Server: the newcomer doesn't read its own join line, as in vanilla

PlayerList.placeNewPlayer calls broadcastSystemMessage before players.add,
so the joining player isn't in the list yet and never gets its own
"joined the game". #4634 sent it to the newcomer too, which the
dedicated_server harness (the real 26.3 server's packets) shows as an
extra system_chat at play start. Back to the others only, at the same
point as before.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

.github/pull_request_template.md

@@ -21,12 +21,6 @@
 <!-- The vanilla classes and methods this follows (tools/rea_vanilla.py), and the harness that checks it.
      "Horizon-only" for a feature vanilla doesn't have; "none" for tooling or docs. -->
 
-## Other projects' code
-
-<!-- "none", or for each project you read or copied from: its link at the commit, its license (only MIT,
-     BSD-2-Clause, BSD-3-Clause, Apache-2.0, ISC, zlib, 0BSD, MIT-0, Unlicense or CC0-1.0), and what you took.
-     CONTRIBUTING.md "Only original code". -->
-
 ## Self-check
 
 <!-- Paste the block `python3 tools/pr_ready.py` prints (`--base upstream/main` from a fork). -->

.github/trusted-reviewers.txt

@@ -7,4 +7,3 @@ kacpherek    # added by Ludovic, 2026-10-27
 rdbtCVS      # added by Ludovic, 2026-10-27
 Online5277   # added by Ludovic, 2026-10-27 (his top three by merged pull requests)
 levzzz5154   # added by Ludovic, 2026-10-28 (Horizon Team; author of horizon-mixins)
-Qwerner88880 # added by Ludovic, 2026-10-31 (Discord vladislav_hagen; native-mod hooks)

.github/workflows/cancel-on-close.yml

@@ -9,9 +9,7 @@ permissions:
   actions: write
 jobs:
   cancel:
-    # One of playhorizon's small runners, out of GitHub's shared pool: no checkout, no code of the pull request
-    # (docs/ci-runners.md). SELF_HOSTED_CI=off: GitHub's runners.
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     steps:
       - name: Cancel the pull request's unfinished runs
         env:

.github/workflows/ci.yml

@@ -24,23 +24,14 @@ env:
   HORIZON_TELEMETRY_URL: "off"
 
 jobs:
-  # One job, not one per check: each job takes a runner from the organisation's shared pool, and with every pull request
-  # and every merge to main starting this workflow, three jobs a run left the pool's queue tens of minutes deep.
-  #
-  # Where: GitHub's runners. With the repository variable SELF_HOSTED_CI=all (for when that pool is full: their 4 CPUs
-  # are about one GitHub runner, docs/ci-runners.md), main's pushes and this repository's own pull requests run on
-  # playhorizon's checks runners (label playhorizon-ci); a fork's pull request never does (and the runners refuse it
-  # themselves). There the build folder persists (CARGO_TARGET_DIR, outside the checkout), so the apt packages,
-  # Python and the Rust cache steps are GitHub's only.
   verify:
-    runs-on: ${{ vars.SELF_HOSTED_CI == 'all' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) && fromJSON('["self-hosted", "linux", "playhorizon-ci"]') || 'ubuntu-latest' }}
-    timeout-minutes: 45
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - uses: actions/setup-python@v5
-        if: runner.environment == 'github-hosted'
         with:
           python-version: '3.12'
       - name: Does this pull request need Rust checks?
@@ -50,33 +41,20 @@ jobs:
           BASE_SHA: ${{ github.event.pull_request.base.sha }}
           HEAD_SHA: ${{ github.event.pull_request.head.sha }}
         run: python3 tools/ci/rust_changes.py "$BASE_SHA" "$HEAD_SHA" >> "$GITHUB_OUTPUT"
-      # A pull request adds only its own commits to main, so it reads those; main's pushes read every ref's history.
       - name: Keep game artifacts out of Git
-        env:
-          EVENT: ${{ github.event_name }}
-          BASE_SHA: ${{ github.event.pull_request.base.sha }}
-          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
         run: |
           python tools/check_public_tree.py
-          if [ "$EVENT" = pull_request ]; then
-            python tools/check_public_tree.py --range "$BASE_SHA..$HEAD_SHA"
-          else
-            python tools/check_public_tree.py --history
-          fi
+          python tools/check_public_tree.py --history
       - name: Test offline research tooling
         run: python -m unittest discover -s tests -v
       - name: Install Rust toolchain and the ALSA and udev headers the client links against
         if: steps.rust.outputs.required != 'false'
-        env:
-          HOSTED: ${{ runner.environment == 'github-hosted' }}
         run: |
-          if [ "$HOSTED" = true ]; then
-            sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
-          fi
+          sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
           rustup toolchain install stable --profile minimal --component rustfmt --component clippy
       # Dependencies and the workspace's own build, saved from main's runs (pull requests read main's cache).
       - uses: Swatinem/rust-cache@v2
-        if: steps.rust.outputs.required != 'false' && runner.environment == 'github-hosted'
+        if: steps.rust.outputs.required != 'false'
         with:
           shared-key: verify
           save-if: ${{ github.ref == 'refs/heads/main' }}
@@ -89,8 +67,6 @@ jobs:
           cargo +stable clippy -p horizon-client --all-targets --no-default-features -- -D warnings
       # Libraries, binaries and integration tests, then doc tests: not the ~275 examples, which clippy above already
       # type-checks and the parity job builds and runs (they were most of this step's build and link time).
-      # cargo test, not nextest: nextest's process per test reloads each binary's shared tables for every test, and on
-      # these 4-core runners it was no faster (#4978).
       - name: Test Rust core and voxel kernel correctness
         if: steps.rust.outputs.required != 'false'
         run: |
@@ -103,8 +79,8 @@ jobs:
   # changes it or a crate it builds is checked here, and so is every push to main: two pull requests can each pass
   # alone and break it together (#2059 and the registry ratings did, 2026-10-26).
   launcher:
-    runs-on: ${{ vars.SELF_HOSTED_CI == 'all' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) && fromJSON('["self-hosted", "linux", "playhorizon-ci"]') || 'ubuntu-latest' }}
-    timeout-minutes: 45
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
         with:
@@ -118,16 +94,12 @@ jobs:
         run: python3 tools/ci/rust_changes.py --launcher "$BASE_SHA" "$HEAD_SHA" >> "$GITHUB_OUTPUT"
       - name: Install Rust and the headers GPUI links against
         if: steps.launcher.outputs.required != 'false'
-        env:
-          HOSTED: ${{ runner.environment == 'github-hosted' }}
         run: |
-          if [ "$HOSTED" = true ]; then
-            sudo apt-get update && sudo apt-get install -y --no-install-recommends libxkbcommon-x11-dev libwayland-dev \
-              libx11-xcb-dev libfontconfig-dev libvulkan-dev libasound2-dev libudev-dev
-          fi
+          sudo apt-get update && sudo apt-get install -y --no-install-recommends libxkbcommon-x11-dev libwayland-dev \
+            libx11-xcb-dev libfontconfig-dev libvulkan-dev libasound2-dev libudev-dev
           rustup toolchain install stable --profile minimal --component rustfmt --component clippy
       - uses: Swatinem/rust-cache@v2
-        if: steps.launcher.outputs.required != 'false' && runner.environment == 'github-hosted'
+        if: steps.launcher.outputs.required != 'false'
         with:
           workspaces: launcher
           shared-key: launcher
@@ -144,8 +116,7 @@ jobs:
   # a harness, an oracle, a probe or the runner, or carries the run-parity label (run-parity.yml, when it is added).
   parity-scope:
     if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
-    # A git diff of this repository's own branch: one of playhorizon's small runners (docs/ci-runners.md).
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     outputs:
       run: ${{ steps.scope.outputs.run }}
     steps:

.github/workflows/claim-command.yml

@@ -29,8 +29,7 @@ jobs:
     # the skipped runs of ordinary comments must not cancel a waiting one.
     concurrency:
       group: claim-${{ github.event.issue.number }}
-    # One of playhorizon's small runners, out of GitHub's shared pool: main's script only (docs/ci-runners.md).
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     timeout-minutes: 5
     permissions:
       contents: read
@@ -56,8 +55,7 @@ jobs:
         run: python3 tools/ci/claim_command.py command
   release:
     if: github.event_name != 'issue_comment' && github.repository == 'horizon-rust/horizon'
-    # One of playhorizon's small runners, out of GitHub's shared pool: main's script only (docs/ci-runners.md).
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     timeout-minutes: 10
     permissions:
       contents: read

.github/workflows/game-build.yml

@@ -1,7 +1,6 @@
 name: game build
 # Builds the game for every platform from `ref`: the Java exporters, then Linux and the Linux server and Windows on
-# GitHub, macOS on the Mac mini's runner with a 1500-frame offscreen run of a new world (smoke-test.json): Apple
-# Silicon, and Intel cross-built there for x86_64-apple-darwin and checked under Rosetta 2 (#1161). Called by
+# GitHub, macOS on the Mac mini's runner with a 1500-frame offscreen run of a new world (smoke-test.json). Called by
 # release.yml (the releases) and nightly-build.yml (the opt-in Nightly), always from main's copy of this file: the
 # caller's commit, never the one being built. It holds no secrets: signing the checksums is the callers' own job,
 # which never runs what this one built. See docs/release-flow.md.
@@ -105,13 +104,6 @@ jobs:
             mac: true
             dir: horizon-macos-arm64
             asset: horizon-macos-arm64.zip
-          # Intel Macs: built on the same runner for another target; its checks and smoke test run the x86_64
-          # programs under Rosetta 2.
-          - name: macos-x64
-            mac: true
-            target: x86_64-apple-darwin
-            dir: horizon-macos-x64
-            asset: horizon-macos-x64.zip
     runs-on: ${{ matrix.mac && (inputs.trusted && vars.MAC_RUNNER || fromJSON('["self-hosted", "macOS", "horizon-nightly"]')) || matrix.os }}
     # Notarizing the zip can take a few minutes.
     timeout-minutes: ${{ matrix.mac && 60 || 40 }}
@@ -122,8 +114,6 @@ jobs:
       HORIZON_VERSION: ${{ inputs.version }}
       # A nightly's date and commit ("2026-10-28 0c02067"), which the game shows; empty for a release.
       HORIZON_NIGHTLY: ${{ inputs.nightly }}
-      # Where cargo puts the programs: target/release, or target/<target>/release for another target.
-      BIN: ${{ matrix.target && format('target/{0}/release', matrix.target) || 'target/release' }}
     defaults:
       run:
         shell: bash
@@ -138,8 +128,6 @@ jobs:
           # keeps its preparations outside the checkout.
           clean: true
       - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.target }}
       - uses: Swatinem/rust-cache@v2
         if: runner.environment == 'github-hosted'
         with:
@@ -150,11 +138,11 @@ jobs:
         if: runner.os == 'Linux'
         run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
       - name: Build the client, horizon-ctl, horizon-prepare and horizon-server
-        run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
+        run: cargo build --release --locked -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
       - name: Every program the release folder takes was built
         run: |
           for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
-            test -f "$BIN/$binary${{ matrix.exe }}" || { echo "::error::$BIN/$binary${{ matrix.exe }} is missing"; exit 1; }
+            test -f "target/release/$binary${{ matrix.exe }}" || { echo "::error::target/release/$binary${{ matrix.exe }} is missing"; exit 1; }
           done
       - name: The signing keychain, unlocked
         if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id
@@ -169,15 +157,15 @@ jobs:
         run: |
           for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
             codesign --force --options runtime --timestamp --keychain "$MACOS_SIGN_KEYCHAIN" \
-              --identifier "dev.horizon.${binary#horizon-}" --sign "$MACOS_SIGN_IDENTITY" "$BIN/$binary"
-            codesign --verify --strict --verbose=2 "$BIN/$binary"
+              --identifier "dev.horizon.${binary#horizon-}" --sign "$MACOS_SIGN_IDENTITY" "target/release/$binary"
+            codesign --verify --strict --verbose=2 "target/release/$binary"
           done
       - name: Only system libraries
         # Windows: no non-system DLL (a "DLL not found" dialog on some players' machines). Linux: the standard
         # loader and libraries every desktop distribution has. macOS: only the system's own libraries.
         run: |
           for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
-            file="$BIN/$binary${{ matrix.exe }}"
+            file="target/release/$binary${{ matrix.exe }}"
             if [[ "$RUNNER_OS" == macOS ]]; then
               others=$(otool -L "$file" | tail -n +2 | awk '{print $1}' | grep -v -E '^(/usr/lib/|/System/Library/)' || true)
               [[ -z "$others" ]] || { echo "::error::$binary links $others"; exit 1; }
@@ -188,7 +176,7 @@ jobs:
       - name: Every program starts
         run: |
           set -euo pipefail
-          bin=$BIN
+          bin=target/release
           "$bin/horizon-client${{ matrix.exe }}" --help | grep -q -- '--resources'
           "$bin/horizon-ctl${{ matrix.exe }}" --help > /dev/null
           "$bin/horizon-prepare${{ matrix.exe }}" --help | grep -q -- '--minecraft-dir'
@@ -214,7 +202,7 @@ jobs:
           home="$RUNNER_TEMP/horizon-smoke"
           rm -rf "$home" && mkdir -p "$home"
           version=$(sed -n 's/.*"version": *"\([^"]*\)".*/\1/p' research-lock.json | head -1)
-          client="$PWD/$BIN/horizon-client"
+          client="$PWD/target/release/horizon-client"
           resources="$PWD/.local/horizon-client/$version"
           (cd "$home" && HORIZON_HOME="$home" HORIZON_NO_AUDIO=1 "$client" --resources "$resources" --offscreen \
             --world smoke --seed 1 --render-distance 4 --world-frames 1500 --timeout-seconds 180 \
@@ -229,9 +217,8 @@ jobs:
           EOF
           # Published with the release; the publish job checks it again before it publishes anything.
           cp "$home/smoke.json" "$RUNNER_TEMP/smoke-test.json"
-      # One smoke-test.json per build, the Apple Silicon one's; the Intel build must pass its own run too.
       - uses: actions/upload-artifact@v4
-        if: runner.environment == 'self-hosted' && !matrix.target
+        if: runner.environment == 'self-hosted'
         with:
           name: smoke-test.json
           path: ${{ runner.temp }}/smoke-test.json
@@ -244,7 +231,7 @@ jobs:
       - name: Package
         run: |
           set -euo pipefail
-          cargo run --locked -p xtask -- package "$BIN/horizon-client${{ matrix.exe }}" "dist/${{ matrix.dir }}"
+          cargo run --locked -p xtask -- package "target/release/horizon-client${{ matrix.exe }}" "dist/${{ matrix.dir }}"
           cd dist
           rm -f "${{ matrix.asset }}"
           case "${{ matrix.asset }}" in

.github/workflows/launcher.yml

@@ -8,11 +8,7 @@ name: launcher
 # feature. The version and the tag are given to the build (HORIZON_LAUNCHER_VERSION, HORIZON_LAUNCHER_TAG): no bump
 # commits.
 # Never marked latest. Pushes to launcher branches only build. RELEASES_PAUSED=1 stops releases.
-# Linux ships two archives of one binary: the .tar.gz the launcher updates itself from, and an
-# AppImage (packaging/linux/appimage.sh) for players without a distribution package, which replaces
-# itself instead (launcher/src/backend.rs).
-# macOS: Apple Silicon, and Intel cross-built for x86_64-apple-darwin on the same runner, its tests and smoke test
-# under Rosetta 2 (#1161). With the repository variable MACOS_SIGN_IDENTITY set, Horizon.app and the .dmg are signed with
+# macOS: with the repository variable MACOS_SIGN_IDENTITY set, Horizon.app and the .dmg are signed with
 # Developer ID, notarized and stapled, from the runner's signing keychain (packaging/macos/README.md);
 # unset (forks), they are signed ad hoc.
 #   gh workflow run launcher --ref <branch>                    # dry run: builds everything, publishes nothing
@@ -22,7 +18,7 @@ on:
   push:
     branches: [main, launcher, 'launcher-*']
     paths:
-      # Everything the launcher is built and packaged from, as tools/release_train.py's LAUNCHER_PATHS.
+      # Every crate the launcher builds in, as tools/release_train.py's LAUNCHER_PATHS.
       - 'launcher/**'
       - 'crates/horizon-bench/**'
       - 'crates/horizon-friends/**'
@@ -32,8 +28,6 @@ on:
       - 'crates/horizon-release-sign/**'
       - 'crates/horizon-telemetry/**'
       - 'crates/horizon-theme/**'
-      - 'packaging/linux/**'
-      - 'packaging/icons/**'
       - '.github/workflows/launcher.yml'
   schedule:
     - cron: '7-59/10 * * * *'
@@ -111,13 +105,6 @@ jobs:
             mac: true
             asset: horizon-launcher-macos-arm64.zip
             binary: horizon-launcher
-            mac_arch: arm64
-          - name: macos-x64
-            mac: true
-            target: x86_64-apple-darwin
-            asset: horizon-launcher-macos-x64.zip
-            binary: horizon-launcher
-            mac_arch: x64
           - name: windows
             os: windows-latest
             asset: horizon-launcher-windows-x64.zip
@@ -130,8 +117,6 @@ jobs:
     timeout-minutes: ${{ matrix.mac && 60 || 40 }}
     env:
       RUSTFLAGS: ${{ matrix.rustflags }}
-      # Where cargo puts the launcher: target/release, or target/<target>/release for another target.
-      BIN: ${{ matrix.target && format('target/{0}/release', matrix.target) || 'target/release' }}
       # Horizon's Azure app for Microsoft sign-in (docs/microsoft-account.md): a repository
       # variable, not a secret. Unset, the launcher says sign-in is not configured.
       HORIZON_MSA_CLIENT_ID: ${{ vars.HORIZON_MSA_CLIENT_ID }}
@@ -155,8 +140,6 @@ jobs:
           # parity jobs, and nothing they leave may end up in a launcher release (target/ is rebuilt from scratch).
           clean: true
       - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.target }}
       - uses: Swatinem/rust-cache@v2
         if: runner.environment == 'github-hosted'
         with:
@@ -166,7 +149,7 @@ jobs:
         if: runner.os == 'Linux'
         run: |
           sudo apt-get update
-          sudo apt-get install -y libxkbcommon-x11-dev libwayland-dev libx11-xcb-dev libfontconfig-dev libvulkan-dev libasound2-dev patchelf
+          sudo apt-get install -y libxkbcommon-x11-dev libwayland-dev libx11-xcb-dev libfontconfig-dev libvulkan-dev libasound2-dev
       - name: Metal shaders compiled now, or at run time without the Metal toolchain
         # GPUI compiles its Metal shaders when it builds; the Mac mini has Xcode without the Metal toolchain
         # (xcodebuild -downloadComponent MetalToolchain), so there they are compiled when the launcher starts.
@@ -177,17 +160,17 @@ jobs:
             echo "LAUNCHER_FEATURES=gpui/runtime_shaders" >> "$GITHUB_ENV"
           fi
       # Every test target (the library, the binary, tests/), on each system the launcher ships for.
-      - run: cargo test --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
-      - run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
+      - run: cargo test --release --locked ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
+      - run: cargo build --release --locked ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
       - name: The version is the release's
         run: |
-          out=$("$BIN/${{ matrix.binary }}" --version)
+          out=$(target/release/${{ matrix.binary }} --version)
           echo "$out"
           expected="${HORIZON_LAUNCHER_VERSION:-$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -1)}"
           [[ "$out" == "horizon-launcher $expected" ]] || { echo "::error::expected horizon-launcher $expected"; exit 1; }
       - name: Only system libraries
         run: |
-          file="$BIN/${{ matrix.binary }}"
+          file=target/release/${{ matrix.binary }}
           case "$RUNNER_OS" in
             Windows) python ../tools/check_imports.py "$file" ;;
             macOS) others=$(otool -L "$file" | tail -n +2 | awk '{print $1}' | grep -v -E '^(/usr/lib/|/System/Library/)' || true)
@@ -202,28 +185,13 @@ jobs:
           export HORIZON_LAUNCHER_HOME="${RUNNER_TEMP//\\//}/horizon-launcher-smoke"
           export HORIZON_HOME="$HORIZON_LAUNCHER_HOME/game"
           rm -rf "$HORIZON_LAUNCHER_HOME"
-          launcher="$PWD/$BIN/${{ matrix.binary }}"
+          launcher="$PWD/target/release/${{ matrix.binary }}"
           # GitHub's API rate-limits shared runner addresses now and then: try a few times.
           retry() { for i in 1 2 3 4; do "$@" && return 0; sleep $((i * 15)); done; return 1; }
           retry "$launcher" versions
-          "$launcher" links --json
-          # The Intel Mac launcher can come out before any game build has its asset (#1161): then there is nothing
-          # to install yet. Only that entry skips, and only on a version list that parsed and had no build here
-          # (exit 3); a launcher or a script that fails still fails the step.
-          if [[ "${{ matrix.name }}" == macos-x64 ]]; then
-            versions=$(retry "$launcher" --json versions)
-            no_build='import json, sys; sys.exit(3 if not any(r["available_here"] for r in json.load(sys.stdin)) else 0)'
-            status=0
-            python3 -c "$no_build" <<<"$versions" || status=$?
-            if [[ $status == 3 ]]; then
-              echo "::warning::No game build has an asset for ${{ matrix.name }} yet: install not tested"
-              rm -rf "$HORIZON_LAUNCHER_HOME"
-              exit 0
-            fi
-            [[ $status == 0 ]] || exit $status
-          fi
           retry "$launcher" install latest
           "$launcher" versions --installed
+          "$launcher" links --json
           # `install latest` is the Nightly since #3342 (versions/nightly-<date>-<commit>), a vX.Y.Z before.
           clients=("$HORIZON_LAUNCHER_HOME"/versions/*/horizon-client*)
           client="${clients[0]}"
@@ -256,18 +224,11 @@ jobs:
             # Developer ID): packaging/macos.
             python3 -m venv "$RUNNER_TEMP/dmg" && "$RUNNER_TEMP/dmg/bin/pip" install --quiet dmgbuild==1.6.5
             version=${HORIZON_LAUNCHER_VERSION:-$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -1)}
-            DMGBUILD="$RUNNER_TEMP/dmg/bin/dmgbuild" ../packaging/macos/package.sh "$BIN/${{ matrix.binary }}" "$version" out ${{ matrix.mac_arch }}
+            DMGBUILD="$RUNNER_TEMP/dmg/bin/dmgbuild" ../packaging/macos/package.sh target/release/${{ matrix.binary }} "$version" out
             rm -rf out/Horizon.app
           else
-            version=${HORIZON_LAUNCHER_VERSION:-$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -1)}
-            if [[ "$RUNNER_OS" == "Linux" ]]; then
-              # The .tar.gz below is what the launcher updates itself from; the AppImage is what a
-              # player downloads and double-clicks, and it replaces itself instead
-              # (packaging/linux/appimage.sh, launcher/src/backend.rs).
-              ../packaging/linux/appimage.sh "$BIN/${{ matrix.binary }}" "$version" out
-            fi
             mkdir -p dist
-            cp "$BIN/${{ matrix.binary }}" dist/
+            cp target/release/${{ matrix.binary }} dist/
             if [[ "${{ matrix.asset }}" == *.tar.gz ]]; then
               (cd dist && tar czf ../out/${{ matrix.asset }} ${{ matrix.binary }})
             else

.github/workflows/native-hook-stamp.yml

@@ -1,55 +0,0 @@
-name: native hook stamp
-# Opens a PR that numbers pending fragments after they merge. Only pushes to
-# main run main's own tool; fragments are read as data, not PR code.
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - 'tools/native-hook-fragments/*.json'
-
-permissions:
-  contents: read
-
-concurrency:
-  group: native-hook-stamp
-  cancel-in-progress: false
-
-jobs:
-  stamp:
-    if: github.repository == 'horizon-rust/horizon'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    timeout-minutes: 10
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: main
-          fetch-depth: 0
-      - name: Open a stamp pull request
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          set -eu
-          branch=automation/native-hook-stamp
-          if [ -n "$(gh pr list --state open --head "$branch" --json number --jq '.[0].number // empty')" ]; then
-            echo "A stamp pull request is already open."
-            exit 0
-          fi
-          python3 tools/stamp_native_hooks.py
-          if git diff --quiet; then
-            echo "No fragments to stamp."
-            exit 0
-          fi
-          git config user.name 'github-actions[bot]'
-          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
-          git checkout -b "$branch"
-          git add -u
-          git commit -m 'Stamp native hook API fragments'
-          if git ls-remote --exit-code --heads origin "$branch" >/dev/null; then
-            git fetch origin "+refs/heads/$branch:refs/remotes/origin/$branch"
-          fi
-          git push --force-with-lease origin "$branch"
-          gh pr create --base main --head "$branch" --title 'Stamp native hook API fragments' --body 'Assign API numbers to the pending native hook fragments. Close and reopen this PR to run CI.'

.github/workflows/nightly-build.yml

@@ -172,8 +172,7 @@ jobs:
           EPHEMERAL: ${{ needs.pick.outputs.dry_run == 'true' && 'yes' || '' }}
         run: |
           bash tools/ci/sign_release.sh nightly dist/horizon-linux-x86_64.tar.gz dist/horizon-windows-x64.zip \
-            dist/horizon-macos-arm64.zip dist/horizon-macos-x64.zip dist/horizon-server-linux-x86_64.tar.gz \
-            dist/horizon-source.tar.gz
+            dist/horizon-macos-arm64.zip dist/horizon-server-linux-x86_64.tar.gz dist/horizon-source.tar.gz
       - uses: actions/upload-artifact@v4
         with:
           name: signature
@@ -236,8 +235,7 @@ jobs:
             --title "Nightly $DATE · ${SHA:0:7}" --notes-file dist/nightly-notes.md \
             "dist/horizon-linux-x86_64.tar.gz#Game files the launcher installs (Nightly): Linux (horizon-linux-x86_64.tar.gz)" \
             "dist/horizon-windows-x64.zip#Game files the launcher installs (Nightly): Windows (horizon-windows-x64.zip)" \
-            "dist/horizon-macos-arm64.zip#Game files the launcher installs (Nightly): macOS on Apple Silicon (horizon-macos-arm64.zip)" \
-            "dist/horizon-macos-x64.zip#Game files the launcher installs (Nightly): macOS on Intel (horizon-macos-x64.zip)" \
+            "dist/horizon-macos-arm64.zip#Game files the launcher installs (Nightly): macOS (horizon-macos-arm64.zip)" \
             "dist/horizon-server-linux-x86_64.tar.gz#Nightly dedicated server for Linux (horizon-server-linux-x86_64.tar.gz)" \
             "dist/horizon-source.tar.gz#Source of this Nightly, commit ${SHA:0:7} (horizon-source.tar.gz; kept for good as the tag $SOURCE_TAG)" \
             dist/SHA256SUMS "${signature[@]}" dist/smoke-test.json

.github/workflows/overlap-note.yml

@@ -19,9 +19,7 @@ jobs:
     concurrency:
       group: overlap-note-${{ github.event.pull_request.number }}
       cancel-in-progress: true
-    # One of playhorizon's small runners, out of GitHub's shared pool: it runs main's script only (above), so a fork's
-    # pull request runs none of its code there (docs/ci-runners.md). SELF_HOSTED_CI=off: GitHub's runners.
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     timeout-minutes: 10
     permissions:
       contents: read

.github/workflows/pr-labels.yml

@@ -16,9 +16,7 @@ jobs:
   label:
     # Title-only edits change nothing: skip them before a runner starts.
     if: github.event.action != 'edited' || github.event.changes.body != null
-    # One of playhorizon's small runners, out of GitHub's shared pool: it runs main's script only (above), so a fork's
-    # pull request runs none of its code there (docs/ci-runners.md). SELF_HOSTED_CI=off: GitHub's runners.
-    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
+    runs-on: ubuntu-latest
     timeout-minutes: 5
     permissions:
       contents: read

.gitignore

@@ -21,7 +21,6 @@
 .DS_Store
 # What the client writes to its working directory when run from the repo root.
 /options.txt
-/debug-profile.json
 /horizon.txt
 /horizon-graphics.txt
 /horizon-controller.txt

AGENTS.md

@@ -68,16 +68,6 @@ unittest discover -s tests`), `mods/horizon/src/test/java/dev/horizonlab/parity/
 `docs/`, `.github/workflows/`. The website (playhorizon.dev) is the private horizon-rust/horizon-site: its build
 reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` and `crates/horizon-theme/tokens.css` from main.
 
-## Write tests with signal
-
-- Test observable behavior, not words in docs, comments or source. Keep checks for machine-consumed contracts.
-- Use independent expected values or a vanilla oracle; do not derive the answer from the code under test.
-- Test outcomes, not only calls to stubs. Use mocks to isolate behavior, not as the behavior itself.
-- Skip tests of trivial constants, derives and getters, or behavior already covered by another test.
-- Avoid pinning implementation details; a harmless refactor should not break a behavior test.
-- Make slow tests faster without removing cases or weakening their coverage.
-- Never delete parity harnesses or tests that pin vanilla behaviour: they are the spec.
-
 ## Build and test fast
 
 ```sh

CONTRIBUTING.md

@@ -2,7 +2,7 @@
 
 Thanks for helping. Horizon is Minecraft: Java Edition 26.3 rewritten in Rust, and the one rule that shapes
 everything is that **it plays exactly like vanilla**. This page is the short version of how we work; questions are
-welcome on [Discord](https://discord.gg/playhorizon).
+welcome on [Discord](https://discord.gg/HcTeMZxe5E).
 
 This repository holds the game and the launcher, plus the tools, tests and docs that build, check and release them.
 The website (playhorizon.dev) is built in a separate repository from this one's README, `docs/api/` and roadmap. Anything else (videos, Discord and other community material) lives elsewhere.
@@ -47,31 +47,14 @@ them (`git config core.hooksPath .githooks` runs it before every commit).
 The pre-push hook checks the full history reachable from the branches and tags being pushed. Run
 `python3 tools/check_public_tree.py --history` to audit the history of all local refs.
 
-## Only original code, or code whose license allows it
+## Only original code
 
-Horizon is MIT. Its code is written from Minecraft 26.3 itself and from public documentation. Since 30 October 2026
-another project's source may also be read and used, **only when that project's license allows it**:
-
-- **Allowed:** MIT, MIT-0, BSD-2-Clause, BSD-3-Clause, 0BSD, ISC, zlib, Apache-2.0, Unlicense, and the CC0-1.0
-  public-domain dedication. That code may be read, copied or adapted.
-- **Everything else is off limits, even to read:** GPL, LGPL (Iris), AGPL, MPL, EPL, Polyform (Sodium), the Creative
-  Commons licenses (CC BY, CC BY-SA, CC BY-NC and the others; CC0 is a public-domain dedication, not one of them),
-  custom or "source available" licenses, all rights reserved (OptiFine), and any project with no license or an
-  unclear one. Don't read, copy, translate or paraphrase their source, and don't send code an AI tool
-  wrote from it. Being able to download a mod or a pack does not give you the right to read its files.
-- **Check the license yourself.** Read the LICENSE file at the commit you use and the header of each file you take:
-  some repositories mix licenses, and a file under another license is off limits. A license that changed: the one
-  at your commit counts. In doubt, don't: ask in #contributors first.
-- **Say it in the pull request:** the project, a link to the commit, its license, and what you read or copied. A
-  pull request that used another project's source without saying so is closed.
-- **Copied or adapted code** keeps its copyright line and license notice at the top of the file, and gets an entry
-  in [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md). Apache-2.0 code also keeps its NOTICE text and says what
-  was changed.
-
-User documentation and file formats are fine to read, and packs and mods are fine to run and observe, whatever
-their license. Shader packs were removed on 24 October 2026 (#1561) because their code had been written from
-another project's source; they come back only as a clean-room rewrite from a written description of the pack
-format.
+Horizon's code is written from Minecraft 26.3 itself and from public documentation, never from another mod, loader
+or renderer. Don't read, copy, translate or paraphrase the source of Iris, OptiFine, Sodium or any other project,
+and don't send code an AI tool wrote from it. Their user documentation and file formats are fine to read, and their
+packs and mods are fine to run and observe. Shader packs were removed on 24 October 2026 (#1561) because their code
+had been written from another project's source; they come back only as a clean-room rewrite from a written
+description of the pack format.
 
 ## Before asking for review
 
@@ -99,8 +82,7 @@ claimed on Discord with Kira's `/claim`): pick another, or ask its holder in the
 enough), then claim it. `/unclaim` gives it back.
 
 A claim with no open pull request linking the issue (`Fixes #123` in the description, or a draft) is released after
-5 days, with a comment: open a draft early. You can hold 8 open issues at a time, not counting the ones your
-pull requests already fix. Agents claim the same way.
+5 days, with a comment: open a draft early. You can hold 5 open issues at a time. Agents claim the same way.
 
 When your pull request changes the same functions as another open one, or closes the same issue, a bot comment names
 it (edited on every push, never repeated): talk to its author in the thread before you both finish the same work.
@@ -113,10 +95,6 @@ it (edited on every push, never repeated): talk to its author in the thread befo
   can see.
 - **Tick "Allow edits by maintainers".** When something small is left (a lint, a rebase, a nit) we push the fixup
   ourselves instead of sending it back to you; only design questions come back.
-- **Once we've pushed to your branch, merge main into it; don't rebase or force-push.** A rebase or force-push
-  replaces our commits with yours and erases the fixes we added (it happened on #5188 and #5203). Tell your agent
-  too: `git merge origin/main`, never `git rebase` or `git push --force` on a branch a maintainer has touched. If
-  our fixes get erased anyway, we finish the work in our own pull request that keeps your commits and credits you.
 - **Tick its kind** in the template: `parity` (Horizon now does what vanilla does), `bug` (a crash or breakage),
   `perf`, `feature` (new for players), `extra` (Horizon-only, off by default), `tooling` or `docs`. A workflow sets
   that label, and area labels (`launcher`, `mobs`, `worldgen`, `rendering`...) from the paths you change.
@@ -140,5 +118,5 @@ new pushes, we add it again.
 
 ## Talk to us
 
-[Discord](https://discord.gg/playhorizon) for questions and ideas, [issues](https://github.com/horizon-rust/horizon/issues)
+[Discord](https://discord.gg/HcTeMZxe5E) for questions and ideas, [issues](https://github.com/horizon-rust/horizon/issues)
 for bugs. To take something on, `/claim` its issue ([above](#claim-before-you-start)).

Cargo.lock

@@ -34,17 +34,6 @@ dependencies = [
  "generic-array",
 ]
 
-[[package]]
-name = "aes"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
-dependencies = [
- "cfg-if",
- "cipher",
- "cpufeatures 0.2.17",
-]
-
 [[package]]
 name = "ahash"
 version = "0.8.12"
@@ -129,6 +118,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "arbitrary"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3bc62ac97cc33321f50863d514c3bc38a453947a8f9e781137e47c7401020aed"
+dependencies = [
+ "derive_arbitrary",
+]
+
 [[package]]
 name = "arboard"
 version = "3.6.1"
@@ -174,45 +172,6 @@ dependencies = [
  "libloading",
 ]
 
-[[package]]
-name = "asn1-rs"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7f43a50ac4fdca5df8e885c21b835997f0a1cdee65494a6847694a98652d9d8"
-dependencies = [
- "asn1-rs-derive",
- "asn1-rs-impl",
- "displaydoc",
- "nom 7.1.3",
- "num-traits",
- "rusticata-macros",
- "thiserror 2.0.21",
- "time",
-]
-
-[[package]]
-name = "asn1-rs-derive"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3109e49b1e4909e9db6515a30c633684d68cdeaa252f215214cb4fa1a5bfee2c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
- "synstructure 0.13.2",
-]
-
-[[package]]
-name = "asn1-rs-impl"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -231,12 +190,6 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
-[[package]]
-name = "base64ct"
-version = "1.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
-
 [[package]]
 name = "bit-set"
 version = "0.10.0"
@@ -251,9 +204,6 @@ name = "bit-vec"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
-dependencies = [
- "serde",
-]
 
 [[package]]
 name = "bitflags"
@@ -276,15 +226,6 @@ dependencies = [
  "generic-array",
 ]
 
-[[package]]
-name = "block-padding"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
-dependencies = [
- "generic-array",
-]
-
 [[package]]
 name = "block2"
 version = "0.5.1"
@@ -369,15 +310,6 @@ dependencies = [
  "serde_json",
 ]
 
-[[package]]
-name = "cbc"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
-dependencies = [
- "cipher",
-]
-
 [[package]]
 name = "cc"
 version = "1.6.0"
@@ -416,18 +348,7 @@ checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
 dependencies = [
  "cfg-if",
  "cipher",
- "cpufeatures 0.2.17",
-]
-
-[[package]]
-name = "chacha20"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
-dependencies = [
- "cfg-if",
- "cpufeatures 0.3.1",
- "rand_core 0.10.1",
+ "cpufeatures",
 ]
 
 [[package]]
@@ -437,7 +358,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
 dependencies = [
  "aead",
- "chacha20 0.9.1",
+ "chacha20",
  "cipher",
  "poly1305",
  "zeroize",
@@ -474,18 +395,6 @@ dependencies = [
  "error-code",
 ]
 
-[[package]]
-name = "cms"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b77c319abfd5219629c45c34c89ba945ed3c5e49fcde9d16b6c3885f118a730"
-dependencies = [
- "const-oid",
- "der",
- "spki",
- "x509-cert",
-]
-
 [[package]]
 name = "cobs"
 version = "0.3.0"
@@ -525,12 +434,6 @@ dependencies = [
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "const-oid"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
-
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@@ -626,15 +529,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "cpufeatures"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "crc32fast"
 version = "1.5.2"
@@ -663,7 +557,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
  "generic-array",
- "rand_core 0.6.4",
+ "rand_core",
  "typenum",
 ]
 
@@ -686,10 +580,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
 dependencies = [
  "cfg-if",
- "cpufeatures 0.2.17",
+ "cpufeatures",
  "curve25519-dalek-derive",
  "fiat-crypto",
- "rand_core 0.6.4",
+ "rand_core",
  "rustc_version",
  "subtle",
 ]
@@ -712,62 +606,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
 
 [[package]]
-name = "data-encoding"
-version = "2.11.1"
+name = "derive_arbitrary"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
-
-[[package]]
-name = "der"
-version = "0.7.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
-dependencies = [
- "const-oid",
- "der_derive",
- "flagset",
- "pem-rfc7468",
- "zeroize",
-]
-
-[[package]]
-name = "der-parser"
-version = "10.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07da5016415d5a3c4dd39b11ed26f915f52fc4e0dc197d87908bc916e51bc1a6"
-dependencies = [
- "asn1-rs",
- "displaydoc",
- "nom 7.1.3",
- "num-bigint",
- "num-traits",
- "rusticata-macros",
-]
-
-[[package]]
-name = "der_derive"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8034092389675178f570469e6c3b0465d3d30b4505c294a6550db47f3c17ad18"
+checksum = "1b034bd7d5f032402a2479444dcc6f74e36a03f31854d41680fb240ef682a1ac"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "deranged"
-version = "0.5.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e9de72ce2ad1f90dc62fa25f0f430ef85eb4b0d8fa0be4f30373bc40a21d28e"
-
-[[package]]
-name = "des"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffdd80ce8ce993de27e9f063a444a4d53ce8e8db4c1f00cc03af5ad5a9867a1e"
-dependencies = [
- "cipher",
+ "syn 3.0.6",
 ]
 
 [[package]]
@@ -919,12 +765,6 @@ version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 
-[[package]]
-name = "flagset"
-version = "0.4.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7ac824320a75a52197e8f2d787f6a38b6718bb6897a35142d749af3c0e8f4fe"
-
 [[package]]
 name = "flate2"
 version = "1.1.10"
@@ -1074,11 +914,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
 dependencies = [
  "cfg-if",
- "js-sys",
  "libc",
  "r-efi 6.0.0",
- "rand_core 0.10.1",
- "wasm-bindgen",
 ]
 
 [[package]]
@@ -1216,12 +1053,6 @@ version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284"
 
-[[package]]
-name = "hex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
-
 [[package]]
 name = "hidapi"
 version = "2.6.7"
@@ -1288,15 +1119,6 @@ dependencies = [
  "serde_json",
 ]
 
-[[package]]
-name = "horizon-chat-filter"
-version = "0.1.0"
-dependencies = [
- "serde",
- "serde_json",
- "toml",
-]
-
 [[package]]
 name = "horizon-client"
 version = "0.1.0"
@@ -1311,7 +1133,6 @@ dependencies = [
  "horizon-anticheat",
  "horizon-assets",
  "horizon-bench",
- "horizon-chat-filter",
  "horizon-client-core",
  "horizon-client-input",
  "horizon-client-render",
@@ -1322,7 +1143,6 @@ dependencies = [
  "horizon-hdr",
  "horizon-items",
  "horizon-mods",
- "horizon-narrator",
  "horizon-protocol",
  "horizon-server-files",
  "horizon-shader-api",
@@ -1381,7 +1201,6 @@ dependencies = [
  "cpal",
  "flate2",
  "glam",
- "half",
  "horizon-assets",
  "horizon-bench",
  "horizon-client-core",
@@ -1390,7 +1209,6 @@ dependencies = [
  "horizon-core",
  "horizon-hdr",
  "horizon-items",
- "horizon-narrator",
  "horizon-protocol",
  "horizon-shader-api",
  "horizon-shaders",
@@ -1408,7 +1226,6 @@ dependencies = [
  "serde_json",
  "sha1",
  "sha2",
- "smallvec",
  "symphonia",
  "unicode-bidi",
  "ureq",
@@ -1494,18 +1311,6 @@ dependencies = [
  "zip",
 ]
 
-[[package]]
-name = "horizon-narrator"
-version = "0.1.0"
-dependencies = [
- "libloading",
- "log",
- "objc2 0.6.5",
- "objc2-app-kit 0.3.2",
- "objc2-foundation 0.3.2",
- "windows 0.62.2",
-]
-
 [[package]]
 name = "horizon-port-pack"
 version = "0.1.0"
@@ -1566,23 +1371,14 @@ dependencies = [
 name = "horizon-server"
 version = "0.1.0"
 dependencies = [
- "ab_glyph",
- "base64",
  "chrono",
  "horizon-anticheat",
  "horizon-bench",
- "horizon-chat-filter",
- "horizon-core",
  "horizon-release-sign",
  "horizon-server-files",
  "libc",
- "p12-keystore",
- "png",
- "rcgen",
- "rustls",
  "serde",
  "serde_json",
- "sha1",
  "sha2",
  "toml",
  "toml_edit",
@@ -1620,10 +1416,8 @@ dependencies = [
 name = "horizon-shaders"
 version = "0.1.0"
 dependencies = [
- "half",
  "horizon-core",
  "naga",
- "png",
  "zip",
 ]
 
@@ -1843,7 +1637,6 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
 dependencies = [
- "block-padding",
  "generic-array",
 ]
 
@@ -2135,12 +1928,6 @@ dependencies = [
  "libmimalloc-sys",
 ]
 
-[[package]]
-name = "minimal-lexical"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
-
 [[package]]
 name = "minisign-verify"
 version = "0.3.0"
@@ -2176,6 +1963,8 @@ checksum = "743fb55ba31b18fb1ecef6bdc9aa2743314978ac084044301a7eee33fb99a20d"
 [[package]]
 name = "naga"
 version = "30.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a616d2fb8c89516ac2723a581f69d6c18576046bed761bd6b305e5618e6ae130"
 dependencies = [
  "arrayvec",
  "bit-set",
@@ -2252,16 +2041,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "nom"
-version = "7.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
-dependencies = [
- "memchr",
- "minimal-lexical",
-]
-
 [[package]]
 name = "nom"
 version = "8.0.0"
@@ -2271,22 +2050,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "num-bigint"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367"
-dependencies = [
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-conv"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
-
 [[package]]
 name = "num-derive"
 version = "0.4.2"
@@ -2298,15 +2061,6 @@ dependencies = [
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "num-integer"
-version = "0.1.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -2683,15 +2437,6 @@ dependencies = [
  "objc2-foundation 0.2.2",
 ]
 
-[[package]]
-name = "oid-registry"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12f40cff3dde1b6087cc5d5f5d4d65712f34016a03ed60e9c08dcc392736b5b7"
-dependencies = [
- "asn1-rs",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -2753,29 +2498,6 @@ dependencies = [
  "ttf-parser",
 ]
 
-[[package]]
-name = "p12-keystore"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffb9bf5222606eb712d3bb30e01bc9420545b00859970897e70c682353a034f2"
-dependencies = [
- "base64",
- "cbc",
- "cms",
- "der",
- "des",
- "hex",
- "hmac",
- "pkcs12",
- "pkcs5",
- "rand",
- "rc2",
- "sha1",
- "sha2",
- "thiserror 2.0.21",
- "x509-parser",
-]
-
 [[package]]
 name = "parking_lot"
 version = "0.12.5"
@@ -2799,25 +2521,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "pbkdf2"
-version = "0.12.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
-dependencies = [
- "digest",
- "hmac",
-]
-
-[[package]]
-name = "pem-rfc7468"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
-dependencies = [
- "base64ct",
-]
-
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
@@ -2861,36 +2564,6 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
-[[package]]
-name = "pkcs12"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "695b3df3d3cc1015f12d70235e35b6b79befc5fa7a9b95b951eab1dd07c9efc2"
-dependencies = [
- "cms",
- "const-oid",
- "der",
- "digest",
- "spki",
- "x509-cert",
- "zeroize",
-]
-
-[[package]]
-name = "pkcs5"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e847e2c91a18bfa887dd028ec33f2fe6f25db77db3619024764914affe8b69a6"
-dependencies = [
- "aes",
- "cbc",
- "der",
- "pbkdf2",
- "scrypt",
- "sha2",
- "spki",
-]
-
 [[package]]
 name = "pkg-config"
 version = "0.3.34"
@@ -2942,7 +2615,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
 dependencies = [
- "cpufeatures 0.2.17",
+ "cpufeatures",
  "opaque-debug",
  "universal-hash",
 ]
@@ -2983,12 +2656,6 @@ dependencies = [
  "zerovec",
 ]
 
-[[package]]
-name = "powerfmt"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a6394b9e965e73d0a289ee54f589087e2c676aedf60885baf52c76b771e4958"
-
 [[package]]
 name = "pp-rs"
 version = "0.2.1"
@@ -3058,17 +2725,6 @@ version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
-[[package]]
-name = "rand"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af"
-dependencies = [
- "chacha20 0.10.2",
- "getrandom 0.4.3",
- "rand_core 0.10.1",
-]
-
 [[package]]
 name = "rand_core"
 version = "0.6.4"
@@ -3078,12 +2734,6 @@ dependencies = [
  "getrandom 0.2.17",
 ]
 
-[[package]]
-name = "rand_core"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
-
 [[package]]
 name = "range-alloc"
 version = "0.1.5"
@@ -3108,28 +2758,6 @@ dependencies = [
  "objc2-quartz-core 0.3.2",
 ]
 
-[[package]]
-name = "rc2"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62c64daa8e9438b84aaae55010a93f396f8e60e3911590fcba770d04643fc1dd"
-dependencies = [
- "cipher",
-]
-
-[[package]]
-name = "rcgen"
-version = "0.14.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8774e05a7d0de114588e6a28fe7e71694b82614ed569d86d8b389dfbc98b8ad8"
-dependencies = [
- "ring",
- "rustls-pki-types",
- "time",
- "x509-parser",
- "yasna",
-]
-
 [[package]]
 name = "redox_syscall"
 version = "0.4.1"
@@ -3221,15 +2849,6 @@ dependencies = [
  "semver",
 ]
 
-[[package]]
-name = "rusticata-macros"
-version = "4.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632"
-dependencies = [
- "nom 7.1.3",
-]
-
 [[package]]
 name = "rustix"
 version = "0.38.44"
@@ -3306,15 +2925,6 @@ dependencies = [
  "twox-hash",
 ]
 
-[[package]]
-name = "salsa20"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
-dependencies = [
- "cipher",
-]
-
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -3336,17 +2946,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
-[[package]]
-name = "scrypt"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
-dependencies = [
- "pbkdf2",
- "salsa20",
- "sha2",
-]
-
 [[package]]
 name = "sctk-adwaita"
 version = "0.10.1"
@@ -3425,7 +3024,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"
 dependencies = [
  "cfg-if",
- "cpufeatures 0.2.17",
+ "cpufeatures",
  "digest",
 ]
 
@@ -3436,7 +3035,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
  "cfg-if",
- "cpufeatures 0.2.17",
+ "cpufeatures",
  "digest",
 ]
 
@@ -3551,7 +3150,7 @@ checksum = "c5482afe85a0b6ce956c945401598dbc527593c77ba51d0a87a586938b1b893a"
 dependencies = [
  "curve25519-dalek",
  "hkdf",
- "rand_core 0.6.4",
+ "rand_core",
  "sha2",
 ]
 
@@ -3564,16 +3163,6 @@ dependencies = [
  "bitflags 2.13.2",
 ]
 
-[[package]]
-name = "spki"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
-dependencies = [
- "base64ct",
- "der",
-]
-
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
@@ -3691,17 +3280,6 @@ dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "synstructure"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "synstructure"
 version = "0.14.0"
@@ -3762,36 +3340,6 @@ dependencies = [
  "syn 3.0.6",
 ]
 
-[[package]]
-name = "time"
-version = "0.3.55"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134"
-dependencies = [
- "deranged",
- "num-conv",
- "powerfmt",
- "serde_core",
- "time-core",
- "time-macros",
-]
-
-[[package]]
-name = "time-core"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109"
-
-[[package]]
-name = "time-macros"
-version = "0.2.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85"
-dependencies = [
- "num-conv",
- "time-core",
-]
-
 [[package]]
 name = "tiny-skia"
 version = "0.11.4"
@@ -3911,7 +3459,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
 dependencies = [
  "memchr",
- "nom 8.0.0",
+ "nom",
  "petgraph",
 ]
 
@@ -3927,12 +3475,6 @@ version = "2.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86a801b3cea342a06d468c8710662aa29e5e05e4f5c0d62f00bbb7f2ad7941c2"
 
-[[package]]
-name = "typed-path"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce898823d8cd0f028662d2f349694b1af0a5cc9be83f1d213a00d3147445e1e"
-
 [[package]]
 name = "typenum"
 version = "1.20.1"
@@ -4981,35 +4523,6 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
 
-[[package]]
-name = "x509-cert"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1301e935010a701ae5f8655edc0ad17c44bad3ac5ce8c39185f75453b720ae94"
-dependencies = [
- "const-oid",
- "der",
- "spki",
-]
-
-[[package]]
-name = "x509-parser"
-version = "0.18.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d43b0f71ce057da06bc0851b23ee24f3f86190b07203dd8f567d0b706a185202"
-dependencies = [
- "asn1-rs",
- "data-encoding",
- "der-parser",
- "lazy_static",
- "nom 7.1.3",
- "oid-registry",
- "ring",
- "rusticata-macros",
- "thiserror 2.0.21",
- "time",
-]
-
 [[package]]
 name = "xcursor"
 version = "0.3.11"
@@ -5054,16 +4567,6 @@ version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7"
 
-[[package]]
-name = "yasna"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5f6765e852b9b4dc8e2a76843e4d64d1cea8e79bcde0b6901aea8e7c7f08282"
-dependencies = [
- "bit-vec",
- "time",
-]
-
 [[package]]
 name = "yoke"
 version = "0.8.3"
@@ -5084,7 +4587,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "syn 3.0.6",
- "synstructure 0.14.0",
+ "synstructure",
 ]
 
 [[package]]
@@ -5125,7 +4628,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "syn 3.0.6",
- "synstructure 0.14.0",
+ "synstructure",
 ]
 
 [[package]]
@@ -5169,18 +4672,18 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "9.1.3"
+version = "2.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1156b39d142a34b999c2310a50455e0cb3760bf7efad0122f796d813bee26ccb"
+checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
 dependencies = [
+ "arbitrary",
  "crc32fast",
+ "crossbeam-utils",
+ "displaydoc",
  "flate2",
- "getrandom 0.4.3",
  "indexmap",
  "memchr",
- "nix",
- "typed-path",
- "windows-sys 0.61.2",
+ "thiserror 2.0.21",
  "zopfli",
 ]
 

Cargo.toml

@@ -1,9 +1,8 @@
 [workspace]
-exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal", "third_party/naga"]
+exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"]
 members = [
     "crates/horizon-core",
     "crates/horizon-dualsense",
-    "crates/horizon-narrator",
     "crates/horizon-threads",
     "crates/horizon-hdr",
     "crates/horizon-world",
@@ -15,7 +14,6 @@ members = [
     "crates/horizon-items",
     "crates/horizon-server-files",
     "crates/horizon-anticheat",
-    "crates/horizon-chat-filter",
     "crates/horizon-server",
     "crates/horizon-bots",
     "crates/horizon-assets",
@@ -61,8 +59,6 @@ large_enum_variant = "allow"
 # Drop this and the folder once a wgpu release has these fixes.
 [patch.crates-io]
 wgpu-hal = { path = "third_party/wgpu-hal" }
-# naga 30.0.1, with the fixes to its GLSL frontend that shader packs need (THIRD_PARTY_NOTICES.md).
-naga = { path = "third_party/naga" }
 
 # Line tables keep file:line in backtraces; full debug info made every
 # example and test binary hundreds of megabytes and slow to link.

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="docs/media/banner.webp" alt="The Horizon website: the game you know, rebuilt in Rust" width="100%">
+  <img src="docs/media/banner.webp" alt="Horizon: Minecraft: Java Edition 26.3, rewritten in Rust and checked against vanilla by more than 300 differential harnesses" width="100%">
 </p>
 
 <p align="center">
@@ -24,32 +24,34 @@
 
 # Horizon
 
-Minecraft: Java Edition 26.3, rewritten in Rust. Same worlds, same rules, same terrain, checked against the Java game by more than 300 differential harnesses. Free, open source and unofficial.
+Horizon is Minecraft: Java Edition 26.3 rewritten in Rust: a native game that reads the same worlds, follows the same rules and generates the same terrain as the Java game, and is checked against it by more than 300 differential harnesses. You play it through a small launcher, on the files from your own copy of Minecraft. It is free, open source and unofficial.
 
-> Not an official Minecraft product, nor approved by or associated with Mojang or Microsoft. Horizon contains no Minecraft code, assets or data: you need your own copy of Java Edition 26.3.
+> Not an official Minecraft product. Not approved by or associated with Mojang or Microsoft. Horizon contains no Minecraft code, assets or data: you need your own legally obtained copy of Minecraft: Java Edition 26.3.
 
 ## Download
 
-Get **the Horizon launcher** from [playhorizon.dev](https://playhorizon.dev) or [the launcher releases](https://github.com/horizon-rust/horizon/releases?q=launcher-v&expanded=true) (Linux x86-64, macOS on Apple Silicon, macOS on Intel from the next Nightly, Windows x64). It installs and updates the game, prepares its files from your copy of Minecraft, and updates itself.
+Horizon is installed through **the Horizon launcher**. Get it from [playhorizon.dev](https://playhorizon.dev) (the Download button picks your system) or from [the launcher releases](https://github.com/horizon-rust/horizon/releases?q=launcher-v&expanded=true), for Linux x86-64, macOS on Apple Silicon or Windows x64. The launcher installs the game and keeps it up to date with each new build (Horizon ships on one channel, the Nightly), prepares its files from your copy of Minecraft (your own install, or downloaded from Mojang for your account), and updates itself.
 
-**You need** a Microsoft account that owns Java Edition ([why](docs/microsoft-account.md)) and a GPU with Vulkan or OpenGL 3.3 (Linux), Vulkan or DirectX 12 (Windows), or a Mac (Apple Silicon, or Intel from the next Nightly). An existing Minecraft install (official launcher, Prism, MultiMC...) is reused; without one, Play downloads 26.3 from Mojang for your account. Step by step: [Install and first launch](https://playhorizon.dev/docs/install).
+**You need** a Microsoft account that owns Minecraft: Java Edition (the launcher signs in with it, as other launchers do; see [Microsoft account](docs/microsoft-account.md)) and a GPU with Vulkan or OpenGL 3.3 on Linux, Vulkan or DirectX 12 on Windows, or any Apple Silicon Mac. Nothing else: with no Minecraft on your computer, Play downloads 26.3 and the Java it needs from Mojang for your account, as the official launcher does, then prepares it once. An install you already have (the official launcher, Prism, MultiMC and other launchers all work) is used instead. Step by step, with macOS's first-open prompt and the first launch: [Install and first launch](https://playhorizon.dev/docs/install).
 
 <table>
   <tr>
-    <td width="50%"><img src="docs/media/launcher-play.webp" alt="The launcher's Home page: the selected instance ready to play, the version picker, Join a friend and the instance's tabs"></td>
-    <td width="50%"><img src="docs/media/launcher-settings.webp" alt="The launcher's Settings page: Microsoft account, offline name, updates, appearance and accent colour"></td>
+    <td width="50%"><img src="docs/media/launcher-play.webp" alt="The launcher's Play page: a version ready to play, its summary, Client and Server, the version picker and Play"></td>
+    <td width="50%"><img src="docs/media/launcher-patch-notes.webp" alt="The launcher's Patch notes page"></td>
   </tr>
 </table>
 
 ## What works today
 
-- **The game:** vanilla world generation, mobs, villagers, raids, redstone, every command, the HUD and the recipe book, on vanilla saves. Worlds from 1.8 to 26.2 are upgraded. [Status](#project-status).
-- **Extras:** new menus, graphics presets, distant terrain up to 1024 chunks, controllers, zoom, minimap and more, off by default where they change the vanilla look. [Settings](https://playhorizon.dev/docs/settings).
-- **Packs:** resource packs, and data packs with functions, predicates, item modifiers and world generation.
-- **Multiplayer:** invite friends with a code, Open to LAN, join servers (online mode included). [Multiplayer](https://playhorizon.dev/docs/multiplayer).
-- **Mods:** content mods (blocks, items, data) and native Rust mods, built by the launcher with nothing to install. Java mod jars do not run. [Mods](https://playhorizon.dev/docs/mods).
+The [documentation](https://playhorizon.dev/docs/) covers each of these.
 
-In the Rust client, with vanilla assets and no mods or shaders:
+- **The game:** singleplayer with vanilla's world generation, mobs, villagers, raids, redstone, every command, the HUD and the recipe book, on saves in vanilla's format. Worlds from 1.8 to 26.2 are upgraded as vanilla does. [Status table](#project-status).
+- **Horizon's own extras:** new menus (vanilla's are one setting away), graphics presets, distant terrain up to 1024 chunks, controller support, optional zoom, minimap and more, all off by default where they would change the vanilla look. See [Settings](https://playhorizon.dev/docs/settings).
+- **Resource packs and data packs:** resource packs work, and data packs load functions, predicates, item modifiers and world generation, taller levels included (vanilla's biomes for now).
+- **Playing with others:** invite friends from the pause menu's Friends button with a code, Open to LAN, and joining servers, online-mode ones with the Microsoft account the launcher signs in with. See [Multiplayer](https://playhorizon.dev/docs/multiplayer).
+- **Mods:** content mods add blocks, items and data, and native mods change the game's own Rust code, built by the launcher on your copy, with no Rust to install. Horizon's own (Zoom, FPS Counter, Keystrokes, Minimap, Recipes and Coordinates HUD) are native mods. Java mod jars do not run in Horizon. See [Mods and data packs](https://playhorizon.dev/docs/mods).
+
+Screenshots, captured in the Rust client itself with vanilla assets and no mods or shaders:
 
 <table>
   <tr>
@@ -67,15 +69,15 @@ In the Rust client, with vanilla assets and no mods or shaders:
 
 ## Host a server
 
-The launcher's **Servers** page creates, starts, backs up and updates a server, and invites friends over Tailscale. On a VPS, `horizon-server` installs with one command and needs no Java. [Host a server](https://playhorizon.dev/docs/hosting) ([reference](docs/hosting.md)).
+The launcher's **Servers** page creates, starts, backs up and updates a Horizon server with buttons, and invites friends over Tailscale. On a VPS, `horizon-server` installs with one command and runs without Java. Guide: [Host a server](https://playhorizon.dev/docs/hosting) ([reference](docs/hosting.md)).
 
 ## Modpacks
 
-The launcher imports Modrinth and CurseForge packs and plays the mods Horizon can carry over: today, content mods made of data and assets, not Java code. [Modpacks](https://playhorizon.dev/docs/modpacks).
+The launcher's **Modpacks** page imports a Modrinth or CurseForge pack, shows which of its mods Horizon can carry over, and plays the ones it can as their own profile. Today that means content mods made of data and assets; mods with Java code are not ported yet. See [Modpacks](https://playhorizon.dev/docs/modpacks).
 
 ## Agent control
 
-AI agents and scripts can play Horizon. `horizon-ctl`, shipped with the game, reads its state as JSON and acts like a player; `horizon-ctl mcp` serves the same commands over MCP.
+AI agents and scripts can play Horizon. `horizon-ctl`, shipped beside the game in every release folder, is a command line that reads the game as JSON and acts like a player; `horizon-ctl mcp` serves the same commands as an MCP server (one tool per command, screenshots returned as images).
 
 ```sh
 horizon-ctl launch --world Survival --seed 5 --wait   # finds the version the launcher installed
@@ -86,14 +88,16 @@ horizon-ctl break -1 65 -3                              # mines it; replies with
 horizon-ctl open-inventory && horizon-ctl click-slot 0  # menus: slots, buttons by label, text fields
 ```
 
-Commands block until done and reply with the result; `horizon-ctl help` lists them all. [Agent control](docs/native-client.md#agent-control-horizon-ctl-and-mcp).
+Commands block until the action is done and reply with what happened; errors are JSON with distinct exit codes, `horizon-ctl help` lists every command and `horizon-ctl COMMAND --help` explains one with examples. It talks to the game over a Unix socket on Linux and macOS and over a token-protected localhost port on Windows. See [Agent control in the native client guide](docs/native-client.md#agent-control-horizon-ctl-and-mcp).
 
 ## Build from source
 
-Needs Rust 1.90+, Python 3.10+, JDK 25, and on Linux `libasound2-dev libudev-dev`. `horizon-prepare` builds the game's resources from **your own copy** of Java Edition 26.3 (checked against `research-lock.json`) and never downloads it:
+For developers. Requirements: Rust 1.90 or newer, Python 3.10 or newer, JDK 25, and on Linux the ALSA and udev development headers (`libasound2-dev libudev-dev` on Debian and Ubuntu). Development and the vanilla harnesses run on Linux.
 
-1. **Client:** play 26.3 once in the official launcher. Horizon reads `~/.minecraft` (or `--minecraft-dir` / `HORIZON_MINECRAFT_DIR`).
-2. **Server jar:** the 26.3 server jar (`downloads.server.url` in `versions/26.3/26.3.json`), passed once with `--server-jar` or `HORIZON_SERVER_JAR`.
+Horizon contains no game files, and `horizon-prepare` never downloads them (the launcher downloads them from Mojang only for a signed-in account that owns the game). It builds its resources from **your own copy** of Minecraft: Java Edition 26.3, verified against the checksums in `research-lock.json`:
+
+1. **Client:** install Java Edition with the official launcher and play 26.3 once. Horizon reads `versions/26.3/`, `libraries/` and `assets/` from the launcher's game directory (`~/.minecraft` on Linux). If yours lives elsewhere, pass `--minecraft-dir` or set `HORIZON_MINECRAFT_DIR`.
+2. **Server jar:** the 26.3 server jar, from the `downloads.server.url` in your launcher's `versions/26.3/26.3.json` (or [minecraft.net/download/server](https://www.minecraft.net/en-us/download/server) while 26.3 is the current release). Pass it with `--server-jar` or set `HORIZON_SERVER_JAR`. It is only needed the first time.
 
 ```sh
 git clone https://github.com/horizon-rust/horizon.git
@@ -103,49 +107,62 @@ cargo run --release -p horizon-prepare -- sounds   # optional: sounds from your
 cargo run --release -p horizon-client
 ```
 
-Prepared files land in the gitignored `.local/`: never commit or share them. Options, controls and architecture: [the native client guide](docs/native-client.md); all developer docs: [docs/README.md](docs/README.md).
+Everything prepared lands in the gitignored `.local/`. It is derived from the game: never commit it or share it.
+
+The client starts on the title screen. Command-line options (`--world`, `--seed`, `--creative`, `--render-distance`, `--dedicated`), controls, scripting through `horizon-ctl` and the architecture are described in [the native client guide](docs/native-client.md). The rest of the developer documentation is indexed in [docs/README.md](docs/README.md), including [the parity workflow](docs/parity-workflow.md).
 
 ## Roadmap
 
-What is in progress, what comes next and where to help: [ROADMAP.md](ROADMAP.md), or [playhorizon.dev/hub](https://playhorizon.dev/hub) with the work board and what shipped.
+What is being done now, what comes next and where you can help, in plain words and in technical detail: [ROADMAP.md](ROADMAP.md). [playhorizon.dev/hub](https://playhorizon.dev/hub) shows it with the work board, the journal of what shipped and how to help.
 
 ## Contributing
 
-Issues and pull requests are welcome: read [CONTRIBUTING.md](CONTRIBUTING.md) (vanilla first, small pull requests). Questions: [Discord](https://discord.gg/playhorizon). Before a pull request, run the self-check and paste its output:
+Issues and pull requests are welcome: see [CONTRIBUTING.md](CONTRIBUTING.md) for how we work (vanilla first, small pull requests, labels), or [the contributing guide](https://playhorizon.dev/docs/contributing) on the site. Questions and ideas: [Discord](https://discord.gg/HcTeMZxe5E). Before opening a pull request, run the self-check and paste the block it prints:
 
 ```sh
 git config core.hooksPath .githooks
 python3 tools/pr_ready.py
 ```
 
-It runs rustfmt, clippy, the touched crates' tests, the Python tests, the public-tree check and the vanilla harnesses your change affects. Never commit game files, decompiled source or prepared resources.
+It runs rustfmt, clippy with warnings denied, the tests of the crates you touched, the Python tests, the public-tree check, and the vanilla harnesses your change can affect. CI runs the same checks on GitHub's Linux runners; the vanilla harnesses need the game, which Horizon never downloads, so they run on a maintainer's computer holding their own copy. Never commit game files, decompiled source or prepared resources: `tools/check_public_tree.py` rejects them, and tracked Java is allowed only under the project's own `dev/horizonlab` namespace.
 
 ## Project status
 
 **Player-visible gaps: 833 open** of the 833 the [port ledger](tools/port_ledger.py) found, reading every vanilla 26.3 method against Horizon's code: vanilla behaviour a player would notice that Horizon doesn't have yet. By area: Screens, HUD and client packets [197](https://github.com/horizon-rust/horizon/issues/3518); Entity and block rendering, models [129](https://github.com/horizon-rust/horizon/issues/3519); Animals [110](https://github.com/horizon-rust/horizon/issues/3512); Server and players on the server [106](https://github.com/horizon-rust/horizon/issues/3520); Blocks, redstone and fluids [86](https://github.com/horizon-rust/horizon/issues/3516); Entities, projectiles, vehicles and decorations [64](https://github.com/horizon-rust/horizon/issues/3514); Monsters and bosses [53](https://github.com/horizon-rust/horizon/issues/3513); Mob AI, villagers and raids [35](https://github.com/horizon-rust/horizon/issues/3521); World, world generation and saves [32](https://github.com/horizon-rust/horizon/issues/3517); Items, enchantments and inventories [21](https://github.com/horizon-rust/horizon/issues/3515). This number goes down as gaps close (`tools/parity_gaps.py`); the harness results below say that what is tested matches.
 
-The table is the project's own audit: every subsystem matches vanilla in every harness that compares it. 100% means 100% of what the harnesses compare, not that nothing else differs.
+The table below is the project's own audit of each subsystem. Every subsystem now matches vanilla in every harness that compares it. 100% means 100% of what the harnesses compare, not proof that nothing else differs. The remaining known differences are listed below.
 
 ### Java parity: 100%
 
-Scores: 0 (absent), 0.25 (started), 0.5 (playable, major features missing), 0.75 (mostly complete) or 1 (complete and verified by differential tests); the percentage is their average. Last audited 2026-10-13: all 281 harnesses pass on Linux and macOS. The [port ledger](tools/port_ledger.py) adds a method-by-method view of what is ported.
+Each subsystem scores 0 (absent), 0.25 (started, not playable), 0.5 (playable,
+major vanilla features missing), 0.75 (playable, mostly complete) or 1 (complete
+and verified against vanilla by differential tests). The percentage is the
+average; `tests/test_parity.py` keeps it in sync with this table. Last audited
+2026-10-13 against the harness results: all 281 harnesses pass on Linux, each
+rerun whenever one of its inputs changed, and the Mac mini now runs every one of
+them too (Rust uses Java's own float maths on each platform).
+
+The harnesses measure behaviour. A second measure is method by method: the [port ledger](tools/port_ledger.py)
+lists every method of vanilla 26.3 next to the Rust functions that port it, with a verdict for each one
+(ported, folded into another function, missing, or needing no port), and the untested ports. Run
+`python3 tools/port_ledger.py build`, then `coverage`, with the vanilla data in `.local/`.
 
 | Subsystem | Score | Main gaps |
 | --- | ---: | --- |
-| Window, input and game loop | 1 | None: game loop, options, camera, auto-jump, toggle sprint/sneak and frame limiter match |
-| Assets and resources | 1 | None: item models match over 196,290 stacks; the resource pack screen over 3,000 sessions |
-| Network protocol and multiplayer | 1 | None: joins vanilla servers; the dedicated server matches vanilla's files, login, configuration, play and command tree; LAN discovery over 462 cases (offline mode only) |
+| Window, input and game loop | 1 | None: the game loop, options, camera, auto-jump, toggle sprint/sneak, local input and the frame limiter match vanilla |
+| Assets and resources | 1 | None: item models match vanilla over 196,290 stacks and the client draws every item through them; the resource pack screen matches vanilla's drawing over 3,000 sessions of clicks, scrolling and searching, its incompatibility confirmation included |
+| Network protocol and multiplayer | 1 | None: joins vanilla servers; the dedicated server (`--dedicated`) matches vanilla's files, status ping, login, configuration, play, chunks, chat, recipes, advancements and command tree, a client built from vanilla's packet code joins it, Horizon joins a vanilla server, and LAN discovery matches over 462 cases (offline mode only) |
 | Chunk storage and palettes | 1 | None: client and saves share paletted containers, identical to vanilla over 266 scenarios |
 | Section meshing | 1 | None: 112 scenes and over a million quads identical to vanilla |
-| Rendering | 1 | None: entity models, block entity renderers (407 cases) and animations (296), HUD overlays (2,200 states), the recipe book (600), player list, subtitles and world border match |
+| Rendering | 1 | None: entity models, block entity renderers (407 cases, End portals, gateways and the loom's banner preview included) and their animations (296 cases, End gateway beams included), the HUD overlays (2,200 states), the recipe book (600 states), the player list, subtitles and the world border match vanilla |
 | Lighting | 1 | None: saved and relit light matches vanilla, slabs and stairs included |
 | World generation | 1 | None: 2,352 whole chunks over 225 structure sites, in all three dimensions, identical to vanilla |
-| Region files and saves | 1 | None: saves round-trip with vanilla; worlds from 1.8 to 26.2 upgrade as vanilla's DataFixers do |
-| Entities and physics | 1 | None: attributes, spawn rules, natural spawning (15,500 cases), raids and patrols (1,900), `finalizeSpawn` (24,000) and mob AI (92 scenarios) match |
-| Interaction and inventory | 1 | None: menu clicks over 8,000 sequences; recipe book placement (6,000), buttons (1,200), saved book (1,500), loom and crafter screens (1,600) |
-| Menus, HUD and chat | 1 | None: every command (758 over 39,685 inputs), scoreboards (81,000 operations), the player list (872,000 draw calls), chat and its suggestions (3,000 sessions) match |
+| Region files and saves | 1 | None: saves round-trip with vanilla, and worlds from 1.8 to 26.2 upgrade as vanilla's DataFixers do, superflat worlds included; old options.txt and hotbar.nbt files are upgraded too |
+| Entities and physics | 1 | None: attributes, dimensions, death loot, spawn rules, natural spawning (15,500 cases), raids and patrols (1,900 cases), spawned mobs' gear, enchantments and state (`finalizeSpawn`, 24,000 cases) and mob AI (92 scenarios: villager breeding and gossip, the warden, ghastlings and copper golems included) match vanilla |
+| Interaction and inventory | 1 | None: menu clicks match over 8,000 click sequences, the loom and the crafter included; recipe book placement (6,000 cases), its buttons (1,200), the saved book (1,500) and the loom and crafter screens (1,600) match vanilla |
+| Menus, HUD and chat | 1 | None: every command runs as vanilla (758 commands over 39,685 parsed inputs), scoreboards and teams match (81,000 operations), the player list matches over 872,000 draw calls with heads drawn from players' skins (authlib's textures, SkinManager's lookup, legacy skin conversion), and the chat matches focused and scrolled; the resource pack screen (selection over 4,000 cases, drawing and its incompatibility confirmation over 3,000 sessions) and the chat input with its command suggestions, usage lines, Tab completion and history (3,000 sessions on vanilla's client command tree) match vanilla |
 | Audio | 1 | None: the sound engine, sound events, music, situational music, ambience and subtitles match vanilla |
-| Block behaviours and ticking | 1 | None: block updates, random ticks, redstone, dispensers (6,000 cases), crafters (4,000), container spills (4,000), copper golems and the sculk family (435 scenarios) match |
+| Block behaviours and ticking | 1 | None: block updates, random ticks, redstone, dispensers (6,000 cases), crafters (4,000 crafts), block entity removal (containers spill, 4,000 cases), copper golem chest sorting and the sculk family (435 scenarios: shrieker warnings and warden summoning included) match vanilla |
 
 ### Known issues
 
@@ -153,7 +170,9 @@ Skins served over https show the default skin unless already cached; pack icons
 
 ## Licence
 
-[MIT](LICENSE), for the project's original work; dependencies keep their own licences ([notices](THIRD_PARTY_NOTICES.md)). Minecraft is a trademark of Mojang Synergies AB; its code and assets belong to Mojang and Microsoft under the [Minecraft EULA](https://www.minecraft.net/en-us/eula).
+[MIT](LICENSE), for the project's original work only. Dependencies keep their own licences. Minecraft is a trademark of Mojang Synergies AB; Minecraft code and assets belong to Mojang and Microsoft and are covered by the [Minecraft EULA](https://www.minecraft.net/en-us/eula). Decompiled game source and prepared resources stay on your machine and are never published.
+
+Third-party credits and licenses: [Third-party notices](THIRD_PARTY_NOTICES.md).
 
 ## Author
 

ROADMAP.md

@@ -326,11 +326,11 @@ A mapping table from intermediary and SRG names so pre-26.1 jars can be classifi
 
 #### A modpack's own resource and shader packs
 
-Imported modpacks carry their resource packs into a profile of their own. Shader-pack conversion is still pending.
+Importing a modpack also brings the resource packs and shader packs it ships with, where Horizon can use them.
 
 <details><summary>Technical</summary>
 
-Resource-pack carry-over is implemented locally: Modrinth common/client overrides, CurseForge's override folder, installed instances (ZIP and directory packs), and hash-checked indexed ZIP downloads. The launcher keeps profile edits and lets resource-only profiles play; packs are enabled in Resource Packs. Synthetic import and profile tests cover the file pipeline; in-game rendering has not been verified. Shader-pack conversion is still pending, so this combined item remains partial ([docs/modpacks.md](docs/modpacks.md)).
+Porting a pack carries data, assets and worldgen today; the resource packs and shader packs bundled with it are left out. Resource packs can be carried as they are; shader packs go through the converter ([docs/modpacks.md](docs/modpacks.md)).
 
 </details>
 
@@ -742,13 +742,13 @@ Open: the GUI Scale is clamped to 2 after a restart under Hyprland, while XWayla
 
 </details>
 
-#### A Nix flake
+#### AppImage and a Nix flake
 
-Install Horizon on NixOS through a Nix flake.
+Install Horizon on any Linux distribution as an AppImage, and on NixOS through a Nix flake.
 
 <details><summary>Technical</summary>
 
-A player's idea (#horizon-ideas). The launcher's AppImage ships with each launcher release ([packaging/linux/appimage.sh](packaging/linux/appimage.sh)): one file with the libraries GPUI needs, which replaces itself when it updates. A flake.nix packaging the release binaries with their runtime libraries (Vulkan loader, X11/Wayland, ALSA) is still missing, the way horizon-parity's NixOS setup runs them today.
+A player's idea (#horizon-ideas). An AppImage of the launcher and game from the release workflow, and a flake.nix packaging the release binaries with their runtime libraries (Vulkan loader, X11/Wayland, ALSA), the way horizon-parity's NixOS setup runs them today.
 
 </details>
 

THIRD_PARTY_NOTICES.md

@@ -8,12 +8,6 @@ developers, with upstream fixes applied
 [gfx-rs/wgpu#10714](https://github.com/gfx-rs/wgpu/pull/10714)). It is licensed under MIT or
 Apache-2.0; both licenses are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).
 
-## naga
-
-`third_party/naga` is [naga](https://github.com/gfx-rs/wgpu) 30.0.1 by the gfx-rs developers, with
-fixes to its GLSL frontend that shader packs need, each applied in the commit that needed it. It is licensed under MIT or Apache-2.0; both licenses
-are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).
-
 ## Pixelify Sans
 
 `crates/horizon-theme/fonts/PixelifySans-*.ttf` is [Pixelify Sans](https://github.com/eifetx/Pixelify-Sans)
@@ -29,14 +23,13 @@ the same grid.
 
 ## AMD FidelityFX SDK (FSR 3.1 frame generation)
 
-`crates/horizon-client-render/src/gfx/frame_gen/optical_flow.wgsl` and `interpolation.wgsl` are
-ports to WGSL of the optical flow and frame interpolation shaders of the
-[AMD FidelityFX SDK](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK) 1.1.4
-(`sdk/include/FidelityFX/gpu/{opticalflow,frameinterpolation}`, at commit
+`crates/horizon-client-render/src/gfx/frame_gen/optical_flow.wgsl` is a port to WGSL of the
+optical flow shaders of the [AMD FidelityFX SDK](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK)
+1.1.4 (`sdk/include/FidelityFX/gpu/opticalflow`, at commit
 [c6efa6bf7f20](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/tree/c6efa6bf7f2027b3ec94f28578bb5965eabb9e55)),
 and `optical_flow.rs` follows the SDK's `sdk/src/components/opticalflow/ffx_opticalflow.cpp`
 (its passes, their order and their dispatch sizes). Copyright (C) 2024 Advanced Micro Devices,
-Inc., under the MIT license, whose text heads each file. AMD and FidelityFX are AMD's
+Inc., under the MIT license, whose text heads both files. AMD and FidelityFX are AMD's
 trademarks; Horizon is not affiliated with AMD.
 
 ## Mod loader logos

bench/bench.py

@@ -1,457 +0,0 @@
-#!/usr/bin/env python3
-"""Server load bench: the same horizon-bots load on Horizon, vanilla 26.3 or Pumpkin.
-
-    python3 bench/bench.py --server horizon --exe target/release/horizon-server --bots 50
-    python3 bench/bench.py --server vanilla --jar ~/mc/server.jar --bots 50 --pre-generated ~/worlds/seed12345
-    python3 bench/bench.py --server pumpkin --exe ./pumpkin --bots 50
-
-Every run uses a fresh scratch folder (bound to 127.0.0.1, offline, creative so the bots can fly), starts the
-server, lets `horizon-bots` join one every --join-every seconds, warms up, then measures for --seconds:
-
-- TPS: `time query gametime` at the start and the end of the window, as game ticks per wall-clock second;
-- MSPT: `tick query` every 5 s (average, P50, P95, P99 over the last 100 ticks), averaged over the window;
-- RSS and CPU of the server's whole process tree, once a second (needs `ps`: Linux and macOS);
-- bandwidth: `bytes_in`/`bytes_out` from the bots' report, per player and second online (each bot's whole time
-  on the server, its join included), when the bots report them (they do not yet: the field is null until S-6); join time: the bots' `joined_after_ms`.
-
-It writes one JSON report (--out) and prints the Markdown table of the design (docs/design.md, section 1).
-
-Vanilla is the owner's own server.jar (--jar): nothing of Mojang's is fetched or committed. Pumpkin is a released
-binary run as a black box (--exe); its Bedrock listeners, LAN broadcast and telemetry are turned off in the
-config this script writes (--pumpkin-config adds a TOML file of your own on top if a release names a key
-differently). `--pre-generated DIR` copies a finished world into every run's scratch folder as `world`, so runs
-repeat on the same terrain. Build the bots first: cargo build --release -p horizon-bots
-"""
-
-import argparse
-import datetime
-import json
-import os
-from pathlib import Path
-import platform
-import re
-import shutil
-import socket
-import statistics
-import subprocess
-import sys
-import tempfile
-import threading
-import time
-
-ROOT = Path(__file__).resolve().parent.parent
-EXE = '.exe' if os.name == 'nt' else ''
-SERVERS = ('horizon', 'vanilla', 'pumpkin')
-
-PROPERTIES = {
-    'level-seed': '12345',
-    'view-distance': '10',
-    'simulation-distance': '10',
-    'online-mode': 'false',
-    'white-list': 'false',
-    'gamemode': 'creative',
-    'force-gamemode': 'true',
-    'spawn-protection': '0',
-    'max-players': '200',
-    'difficulty': 'easy',
-    'server-ip': '127.0.0.1',
-    'enable-query': 'false',
-    'enable-rcon': 'false',
-}
-
-# Pumpkin's two config files. Bedrock, LAN broadcast and telemetry (plugins' included) are off.
-PUMPKIN_CONFIGURATION = '''\
-server_address = "127.0.0.1:{port}"
-seed = "{seed}"
-max_players = 200
-view_distance = {view}
-simulation_distance = {view}
-online_mode = false
-default_difficulty = "Easy"
-allow_chat_reports = false
-encryption = false
-lan_broadcast = false
-
-[networking.bedrock]
-enabled = false
-
-[networking.lan_broadcast]
-enabled = false
-
-[networking.query]
-enabled = false
-
-[networking.rcon]
-enabled = false
-'''
-PUMPKIN_FEATURES = '''\
-[telemetry]
-enabled = false
-
-[plugins]
-enabled = false
-'''
-
-DONE = re.compile(r'Done|listening|Server started', re.IGNORECASE)
-TICK_AVERAGE = re.compile(r'Average time per tick: ([0-9.]+) ?ms')
-TICK_PERCENTILES = re.compile(r'P50: ([0-9.]+) ?ms P95: ([0-9.]+) ?ms P99: ([0-9.]+) ?ms')
-GAMETIME = re.compile(r'The time is (-?\d+)')
-
-
-def free_port():
-    with socket.socket() as s:
-        s.bind(('127.0.0.1', 0))
-        return s.getsockname()[1]
-
-
-def parse_tick_query(lines):
-    """MSPT numbers from the lines `tick query` printed, or None until both lines are there."""
-    average = percentiles = None
-    for line in lines:
-        if (m := TICK_AVERAGE.search(line)) and average is None:
-            average = float(m.group(1))
-        if (m := TICK_PERCENTILES.search(line)) and percentiles is None:
-            percentiles = tuple(float(g) for g in m.groups())
-    if average is None or percentiles is None:
-        return None
-    return {'average': average, 'p50': percentiles[0], 'p95': percentiles[1], 'p99': percentiles[2]}
-
-
-def parse_gametime(lines):
-    """The game time `time query gametime` printed, or None."""
-    for line in lines:
-        if m := GAMETIME.search(line):
-            return int(m.group(1))
-    return None
-
-
-def tps(start_ticks, end_ticks, seconds):
-    """Game ticks per wall-clock second over the window, or None when a query went unanswered."""
-    if start_ticks is None or end_ticks is None or seconds <= 0:
-        return None
-    return round((end_ticks - start_ticks) / seconds, 2)
-
-
-def percentile(values, p):
-    if not values:
-        return None
-    ordered = sorted(values)
-    return ordered[min(len(ordered) - 1, int(p / 100 * len(ordered)))]
-
-
-def cpu_seconds(text):
-    """ps's cumulative CPU time: [[DD-]HH:]MM:SS[.ss]."""
-    days, _, rest = text.rpartition('-')
-    seconds = 0.0
-    for part in rest.split(':'):
-        seconds = seconds * 60 + float(part)
-    return seconds + (float(days) * 86400 if days else 0)
-
-
-def tree_usage(root):
-    """RSS (bytes) and CPU seconds of a process and all its descendants; None without `ps`."""
-    try:
-        out = subprocess.run(['ps', '-A', '-o', 'pid=,ppid=,rss=,time='], capture_output=True, text=True).stdout
-    except OSError:
-        return None
-    rows = {}
-    for line in out.splitlines():
-        parts = line.split()
-        if len(parts) == 4:
-            rows[int(parts[0])] = (int(parts[1]), int(parts[2]) * 1024, cpu_seconds(parts[3]))
-    tree, frontier = {root}, [root]
-    while frontier:
-        parent = frontier.pop()
-        for pid, (ppid, _, _) in rows.items():
-            if ppid == parent and pid not in tree:
-                tree.add(pid)
-                frontier.append(pid)
-    return sum(rows[p][1] for p in tree if p in rows), sum(rows[p][2] for p in tree if p in rows)
-
-
-def prepare(kind, directory, port, args):
-    """Writes the server's settings into its scratch folder and returns the command that starts it."""
-    directory = Path(directory)
-    if args.pre_generated:
-        shutil.copytree(args.pre_generated, directory / 'world')
-    props = dict(PROPERTIES, **{'server-port': str(port), 'level-seed': str(args.seed),
-                                'view-distance': str(args.view_distance),
-                                'simulation-distance': str(args.view_distance)})
-    if kind == 'pumpkin':
-        config = directory / 'config'
-        config.mkdir()
-        (config / 'configuration.toml').write_text(PUMPKIN_CONFIGURATION.format(
-            port=port, seed=args.seed, view=args.view_distance))
-        (config / 'features.toml').write_text(PUMPKIN_FEATURES)
-        if args.pumpkin_config:
-            with (config / 'configuration.toml').open('a') as f:
-                f.write('\n' + Path(args.pumpkin_config).read_text())
-        return [Path(args.exe).resolve()]
-    (directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items()))
-    (directory / 'eula.txt').write_text('eula=true\n')
-    if kind == 'vanilla':
-        return ['java', f'-Xms{args.heap}', f'-Xmx{args.heap}', '-jar', Path(args.jar).resolve(), 'nogui']
-    server = Path(args.exe).resolve()
-    subprocess.run([server, '--dir', directory, 'import', directory / 'server.properties'], check=True,
-                   capture_output=True)
-    toml = directory / 'server.toml'
-    # No web panel in a bench.
-    toml.write_text(re.sub(r'(?m)^bind = "127\.0\.0\.1:8130"', 'bind = ""', toml.read_text()))
-    return [server, '--dir', directory, 'run']
-
-
-class Server:
-    """A server with its console on stdin and its output collected."""
-
-    def __init__(self, command, directory, log_path):
-        self.lines = []
-        self.lock = threading.Lock()
-        self.log = log_path.open('w', encoding='utf-8')
-        env = dict(os.environ, HORIZON_NO_AUDIO='1', HORIZON_HOME=str(directory / 'horizon-home'),
-                   HORIZON_LAUNCHER_NO_SELF_UPDATE='1')
-        self.process = subprocess.Popen([str(c) for c in command], cwd=directory, stdin=subprocess.PIPE,
-                                        stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
-                                        encoding='utf-8', errors='replace', env=env)
-        threading.Thread(target=self._read, daemon=True).start()
-
-    def _read(self):
-        for line in self.process.stdout:
-            with self.lock:
-                self.lines.append(line.rstrip('\n'))
-            self.log.write(line)
-            self.log.flush()
-
-    def count(self):
-        with self.lock:
-            return len(self.lines)
-
-    def since(self, n):
-        with self.lock:
-            return self.lines[n:]
-
-    def wait_for(self, regex, timeout):
-        deadline = time.time() + timeout
-        while time.time() < deadline:
-            if any(regex.search(line) for line in self.since(0)):
-                return
-            if self.process.poll() is not None:
-                raise RuntimeError('the server exited:\n' + '\n'.join(self.since(0)[-20:]))
-            time.sleep(0.1)
-        raise RuntimeError(f'the server was not up within {timeout} s')
-
-    def ask(self, command, parse, timeout=5):
-        """Sends a console command and returns parse(its output lines), or None if nothing parsed in time."""
-        start = self.count()
-        try:
-            self.process.stdin.write(command + '\n')
-            self.process.stdin.flush()
-        except (BrokenPipeError, OSError):
-            return None
-        deadline = time.time() + timeout
-        while time.time() < deadline:
-            if (value := parse(self.since(start))) is not None:
-                return value
-            time.sleep(0.05)
-        return None
-
-    def stop(self):
-        if self.process.poll() is None:
-            try:
-                self.process.stdin.write('stop\n')
-                self.process.stdin.flush()
-                self.process.wait(timeout=60)
-            except (BrokenPipeError, OSError, subprocess.TimeoutExpired):
-                self.process.kill()
-                self.process.wait()
-        self.log.close()
-
-
-def bots_command(args, port, total):
-    return [str(args.bots_bin), '--server', f'127.0.0.1:{port}', '--bots', str(args.bots),
-            '--behaviour', args.behaviour, '--join-every', str(args.join_every), '--seconds', str(int(total)),
-            '--seed', str(args.seed), '--view-distance', str(args.view_distance), '--report', '-']
-
-
-def split_bot_output(lines):
-    """The per-second samples (JSON lines with a `t`) and the final summary the bots printed."""
-    samples, rest = [], []
-    for line in lines:
-        try:
-            sample = json.loads(line)
-        except ValueError:
-            sample = None
-        if isinstance(sample, dict) and 't' in sample:
-            samples.append(sample)
-        else:
-            rest.append(line)
-    text = ''.join(rest)
-    return samples, (json.loads(text) if text.strip() else {})
-
-
-def bytes_per_player_second(per_bot, run_seconds, join_every):
-    """The bots' bytes over the seconds they were connected: bot i connects i * join_every after the first and
-    stays to the end of the run. So it is each bot's average from its login on, its join included, not the
-    measuring window's alone (the bots report one total at the end). None until the bots count bytes (S-6)."""
-    counted = [(i, b) for i, b in enumerate(per_bot) if 'bytes_in' in b and not b.get('error')]
-    online = sum(max(run_seconds - i * join_every, 0) for i, _ in counted)
-    if not counted or online <= 0:
-        return None
-    return {k: round(sum(b.get(k, 0) for _, b in counted) / online) for k in ('bytes_in', 'bytes_out')}
-
-
-def summarize(kind, args, ticks, rss, cpu, gametime, window_seconds, summary, start_seconds, run_seconds):
-    mean = lambda xs: round(statistics.fmean(xs), 2) if xs else None
-    joins = [b['joined_after_ms'] for b in summary.get('per_bot', []) if b.get('joined_after_ms', 0) > 0]
-    bandwidth = bytes_per_player_second(summary.get('per_bot', []), run_seconds, args.join_every)
-    return {
-        'server': kind,
-        'bots': args.bots,
-        'behaviour': args.behaviour,
-        'start_seconds': start_seconds,
-        'tps': tps(*gametime, window_seconds),
-        'mspt': {k: mean([t[k] for t in ticks]) for k in ('average', 'p50', 'p95', 'p99')},
-        'mspt_worst_p99': max((t['p99'] for t in ticks), default=None),
-        'rss_mb': {'mean': mean([r / 1e6 for r in rss]), 'max': round(max(rss) / 1e6, 1) if rss else None},
-        'cpu_percent': mean(cpu),
-        'bytes_per_player_second': bandwidth,
-        'join_ms': {'p50': percentile(joins, 50), 'worst': max(joins, default=None)},
-        'bots_joined': summary.get('joined'),
-        'bots_failed': [b for b in summary.get('per_bot', []) if b.get('error')],
-        'chunks_total': summary.get('chunks'),
-        'tick_queries': len(ticks),
-    }
-
-
-def run_once(kind, args, out):
-    scratch = Path(tempfile.mkdtemp(prefix=f'horizon-bench-{kind}-'))
-    result = {'server': kind, 'bots': args.bots, 'behaviour': args.behaviour}
-    server = None
-    try:
-        port = free_port()
-        command = prepare(kind, scratch, port, args)
-        started = time.time()
-        server = Server(command, scratch, out / f'{kind}-{args.bots}.log')
-        server.wait_for(DONE, args.start_timeout)
-        start_seconds = round(time.time() - started, 2)
-        total = args.bots * args.join_every + args.warmup + args.seconds
-        bot_process = subprocess.Popen(bots_command(args, port, total), stdout=subprocess.PIPE,
-                                       stderr=subprocess.PIPE, text=True)
-        bot_lines = []
-        threading.Thread(target=lambda: bot_lines.extend(bot_process.stdout), daemon=True).start()
-        time.sleep(args.bots * args.join_every + args.warmup)
-        first_time = server.ask('time query gametime', parse_gametime)
-        began = time.time()
-        rss, cpu, ticks = [], [], []
-        usage = tree_usage(server.process.pid)
-        last_cpu, last_time = (usage[1] if usage else 0), time.time()
-        next_query = time.time()
-        while time.time() - began < args.seconds:
-            time.sleep(1)
-            now = time.time()
-            if usage and (u := tree_usage(server.process.pid)):
-                rss.append(u[0])
-                cpu.append((u[1] - last_cpu) / (now - last_time) * 100)
-                last_cpu, last_time = u[1], now
-            if now >= next_query:
-                if (t := server.ask('tick query', parse_tick_query)) is not None:
-                    ticks.append(t)
-                next_query = now + 5
-        window = time.time() - began
-        last = server.ask('time query gametime', parse_gametime)
-        bot_process.wait(timeout=total + 120)
-        time.sleep(0.5)
-        _, summary = split_bot_output(list(bot_lines))
-        result.update(summarize(kind, args, ticks, rss, cpu, (first_time, last), window, summary, start_seconds,
-                                total))
-    except Exception as e:  # a failed run is reported, and the next one still runs
-        result['error'] = str(e)
-    finally:
-        if server:
-            server.stop()
-        shutil.rmtree(scratch, ignore_errors=True)
-    return result
-
-
-def table(runs):
-    """The Markdown table of the design: one column per server, one row per measure."""
-    ok = [r for r in runs if 'error' not in r]
-    head = '| | ' + ' | '.join(r['server'] for r in ok) + ' |\n|---|' + '---|' * len(ok) + '\n'
-    def cell(r, path):
-        value = r
-        for key in path:
-            value = value.get(key) if isinstance(value, dict) else None
-        return '-' if value is None else str(value)
-    rows = [
-        ('Players', ('bots',)),
-        ('TPS', ('tps',)),
-        ('MSPT average', ('mspt', 'average')),
-        ('MSPT p99 (mean of 5 s queries)', ('mspt', 'p99')),
-        ('MSPT p99 (worst query)', ('mspt_worst_p99',)),
-        ('RSS mean MB', ('rss_mb', 'mean')),
-        ('CPU %', ('cpu_percent',)),
-        ('Bytes in per player and s online', ('bytes_per_player_second', 'bytes_in')),
-        ('Join p50 ms', ('join_ms', 'p50')),
-        ('Join worst ms', ('join_ms', 'worst')),
-        ('Start s', ('start_seconds',)),
-    ]
-    body = ''.join(f'| {name} | ' + ' | '.join(cell(r, path) for r in ok) + ' |\n' for name, path in rows)
-    failed = ''.join(f'\n{r["server"]} failed: {r["error"].splitlines()[0]}\n' for r in runs if 'error' in r)
-    return head + body + failed
-
-
-def check(args):
-    for kind in args.server:
-        if kind not in SERVERS:
-            sys.exit(f'--server: {kind!r} is not one of {", ".join(SERVERS)}')
-    if 'vanilla' in args.server and not args.jar:
-        sys.exit('vanilla needs --jar, your own server.jar')
-    if any(k != 'vanilla' for k in args.server) and not args.exe:
-        sys.exit('horizon and pumpkin need --exe, the server binary')
-    if not Path(args.bots_bin).exists():
-        sys.exit(f'{args.bots_bin} is missing: cargo build --release -p horizon-bots')
-    if args.pre_generated and not Path(args.pre_generated).is_dir():
-        sys.exit(f'--pre-generated {args.pre_generated} is not a folder')
-
-
-def main(argv=None):
-    parser = argparse.ArgumentParser(description=__doc__.split('\n\n')[0])
-    parser.add_argument('--server', type=lambda s: s.split(','), default=['horizon'],
-                        help='horizon, vanilla or pumpkin (comma-separated, one run each)')
-    parser.add_argument('--exe', help='the horizon-server or Pumpkin binary')
-    parser.add_argument('--jar', help="vanilla's server.jar (your own copy)")
-    parser.add_argument('--bots-bin', default=str(ROOT / 'target/release' / f'horizon-bots{EXE}'))
-    parser.add_argument('--bots', type=int, default=50)
-    parser.add_argument('--behaviour', default='mixed')
-    parser.add_argument('--join-every', type=float, default=0.5)
-    parser.add_argument('--warmup', type=int, default=30)
-    parser.add_argument('--seconds', type=int, default=60)
-    parser.add_argument('--seed', type=int, default=12345)
-    parser.add_argument('--view-distance', type=int, default=10)
-    parser.add_argument('--heap', default='4g', help='the Java heap for vanilla')
-    parser.add_argument('--pre-generated', help='a finished world folder, copied into every run as `world`')
-    parser.add_argument('--pumpkin-config', help='extra TOML appended to Pumpkin\'s configuration.toml')
-    parser.add_argument('--start-timeout', type=int, default=600)
-    parser.add_argument('--out', type=Path, default=ROOT / '.local/bench', help='the folder for report.json and logs')
-    args = parser.parse_args(argv)
-    check(args)
-    args.out.mkdir(parents=True, exist_ok=True)
-    runs = []
-    for kind in args.server:
-        print(f'{kind}, {args.bots} {args.behaviour} bots...', flush=True)
-        runs.append(run_once(kind, args, args.out))
-        print(json.dumps(runs[-1]), flush=True)
-    report = {
-        'kind': 'horizon-bench',
-        'date': datetime.datetime.now(datetime.timezone.utc).isoformat(timespec='seconds'),
-        'machine': {'system': platform.system(), 'machine': platform.machine(), 'cpus': os.cpu_count()},
-        'settings': {k: str(v) if isinstance(v, Path) else v for k, v in vars(args).items()},
-        'runs': runs,
-    }
-    path = args.out / 'report.json'
-    path.write_text(json.dumps(report, indent=2) + '\n')
-    print('\n' + table(runs) + f'\nWrote {path}')
-    return 1 if any('error' in r for r in runs) else 0
-
-
-if __name__ == '__main__':
-    sys.exit(main())

crates/cargo-horizon-mod/template/content/horizon-mod.toml

@@ -3,8 +3,8 @@ name = "{name}"
 version = "0.1.0"
 description = ""
 authors = []
-# A content mod: blocks, items and mob effects from data/ and assets/, no code (API 0.2).
+# A content mod: blocks and items from data/ and assets/, no code (API 0.2).
 api = "0.2"
 side = "both"
-# registries: "May add blocks, items and mob effects to your worlds".
+# registries: "May add blocks and items to your worlds".
 capabilities = ["registries"]

crates/horizon-anticheat/src/combat.rs

@@ -1,99 +0,0 @@
-//! Combat: attacks vanilla's client can't send (docs/anticheat.md).
-//!
-//! Vanilla's client sends ServerboundAttackPacket from one place only, `Minecraft.startAttack`, run from
-//! `handleKeybinds` once per client tick. It attacks the entity of the tick's `hitResult`, which
-//! `Minecraft.tick` picks once before the keys are handled, so every attack of one client tick is on the
-//! same entity. And each attack swings the arm (ServerboundPunchPacket) in the same call, so a client
-//! tick never has more attacks than swings: a tick that does comes from a kill aura hiding its swing.
-//! The swing is counted before or after the attack, as older clients behind a version proxy swing
-//! first; a swing without an attack (a miss, a block) is fine.
-
-/// What breaks vanilla's way of attacking.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Foul {
-    /// A client tick with more attacks than swings: how many more.
-    NoSwing(u32),
-    /// A second entity attacked in the same client tick: the first one and this one.
-    TwoTargets(i32, i32),
-}
-
-/// The attacks of the client tick being heard.
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct Attacks {
-    /// The entity this tick attacked first.
-    target: Option<i32>,
-    attacks: u32,
-    swings: u32,
-}
-
-impl Attacks {
-    /// ServerboundAttackPacket on entity `target`.
-    pub fn attack(&mut self, target: i32) -> Option<Foul> {
-        self.attacks = self.attacks.saturating_add(1);
-        let first = *self.target.get_or_insert(target);
-        (first != target).then_some(Foul::TwoTargets(first, target))
-    }
-
-    /// ServerboundPunchPacket: the arm swung.
-    pub fn swing(&mut self) {
-        self.swings = self.swings.saturating_add(1);
-    }
-
-    /// ServerboundClientTickEndPacket: the tick's attacks are counted, and the next tick picks its
-    /// target again.
-    pub fn tick_end(&mut self) -> Option<Foul> {
-        let unswung = self.attacks.saturating_sub(self.swings);
-        *self = Self::default();
-        (unswung > 0).then_some(Foul::NoSwing(unswung))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn a_vanilla_tick_is_clean() {
-        let mut a = Attacks::default();
-        // Two clicks in one tick on the same entity, each swung for.
-        for _ in 0..2 {
-            assert_eq!(a.attack(7), None);
-            a.swing();
-        }
-        assert_eq!(a.tick_end(), None);
-        // The next tick may attack another entity, swinging first (an older client).
-        a.swing();
-        assert_eq!(a.attack(8), None);
-        assert_eq!(a.tick_end(), None);
-        // A swing on its own (a miss, a block) is fine.
-        a.swing();
-        assert_eq!(a.tick_end(), None);
-    }
-
-    #[test]
-    fn an_attack_not_swung_for_is_caught() {
-        let mut a = Attacks::default();
-        a.attack(7);
-        assert_eq!(a.tick_end(), Some(Foul::NoSwing(1)));
-        // A swing in the tick before doesn't count for this one.
-        a.swing();
-        a.tick_end();
-        a.attack(7);
-        a.attack(7);
-        a.swing();
-        assert_eq!(a.tick_end(), Some(Foul::NoSwing(1)));
-    }
-
-    #[test]
-    fn two_entities_in_one_tick_are_caught() {
-        let mut a = Attacks::default();
-        a.attack(7);
-        a.swing();
-        assert_eq!(a.attack(8), Some(Foul::TwoTargets(7, 8)));
-        a.swing();
-        // Still against the tick's first target.
-        assert_eq!(a.attack(9), Some(Foul::TwoTargets(7, 9)));
-        a.swing();
-        assert_eq!(a.tick_end(), None);
-    }
-}

crates/horizon-anticheat/src/lib.rs

@@ -2,26 +2,17 @@
 //! `server.toml`, each player's violation levels, and the rules of the checks. The server's hub
 //! (`horizon_client::lan`) feeds it what players send and carries out what it decides.
 //!
-//! It is on by default, and so is every check, but only the checks a vanilla client can't trip act on
-//! their own (`combat`); the others log only until they have shown no false positive with real
-//! players (their `setback`, `alert` and `kick` are 0). `enabled = false` turns the anticheat, or one
-//! check, off. A check that fails *flags* the player: its violation level (VL) rises by the flag's
-//! weight and falls back by `decay` a second. From `setback` on, the move or action is cancelled (the
-//! player is sent back where the server last had them); from `alert` on, online operators and the
-//! console are told; from `kick` on, the player is disconnected. A check's kicks are counted per player
-//! across sessions ([`Strikes`]), and the kick that reaches its `ban_after` bans the player instead
-//! (`banned-players.json`, reason "Horizon anticheat: <check>"). Any threshold at 0 turns that action
-//! off.
+//! It is off unless the owner turns it on. A check that fails *flags* the player: its violation level
+//! (VL) rises by the flag's weight and falls back by `decay` a second. From `setback` on, the move or
+//! action is cancelled (the player is sent back where the server last had them); from `alert` on,
+//! online operators and the console are told; from `kick` on, the player is disconnected. Nothing bans.
+//! Any threshold at 0 turns that action off.
 //!
 //! The checks are written from vanilla 26.3's own rules and from what cheats are publicly described to
 //! do, never from another anticheat's code.
 
-use std::collections::BTreeMap;
-
 use serde::{Deserialize, Serialize};
 
-pub mod combat;
-pub mod prediction;
 pub mod timer;
 
 /// What one check's violation level leads to.
@@ -32,14 +23,12 @@ pub struct Actions {
     pub kick: f32,
     /// Violation level lost each second.
     pub decay: f32,
-    /// The kick, counting this check's earlier ones for the player, that bans instead; 0: never.
-    pub ban_after: u32,
 }
 
 macro_rules! checks {
     ($(
         $(#[$doc:meta])*
-        $field:ident: $Check:ident => $Config:ident [$setback:expr, $alert:expr, $kick:expr, $decay:expr, $ban_after:expr] {
+        $field:ident: $Check:ident => $Config:ident [$setback:expr, $alert:expr, $kick:expr, $decay:expr] {
             $( $(#[$xdoc:meta])* $extra:ident: $ty:ty = $default:expr, )*
         }
     )*) => {
@@ -65,7 +54,6 @@ macro_rules! checks {
                 pub alert: f32,
                 pub kick: f32,
                 pub decay: f32,
-                pub ban_after: u32,
                 $( $(#[$xdoc])* pub $extra: $ty, )*
             }
 
@@ -77,14 +65,13 @@ macro_rules! checks {
                         alert: $alert,
                         kick: $kick,
                         decay: $decay,
-                        ban_after: $ban_after,
                         $($extra: $default,)*
                     }
                 }
             }
         )*
 
-        /// `server.toml`'s `[anticheat]`: on by default.
+        /// `server.toml`'s `[anticheat]`: off by default.
         #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
         #[serde(default, deny_unknown_fields)]
         pub struct Config {
@@ -95,20 +82,16 @@ macro_rules! checks {
             pub alert_level: u8,
             /// Every flag, one line each, relative to the server's folder; empty: no file.
             pub log: String,
-            /// The players' kicks by check ([`Strikes`]), relative to the server's folder; empty: kept
-            /// only while the server runs.
-            pub strikes: String,
             $(pub $field: $Config,)*
         }
 
         impl Default for Config {
             fn default() -> Self {
                 Self {
-                    enabled: true,
+                    enabled: false,
                     alerts: true,
                     alert_level: 2,
                     log: "logs/anticheat.log".into(),
-                    strikes: "anticheat-strikes.json".into(),
                     $($field: $Config::default(),)*
                 }
             }
@@ -124,13 +107,7 @@ macro_rules! checks {
                 match check {
                     $(Check::$Check => {
                         let c = &self.$field;
-                        Actions {
-                            setback: c.setback,
-                            alert: c.alert,
-                            kick: c.kick,
-                            decay: c.decay,
-                            ban_after: c.ban_after,
-                        }
+                        Actions { setback: c.setback, alert: c.alert, kick: c.kick, decay: c.decay }
                     })*
                 }
             }
@@ -142,8 +119,7 @@ checks! {
     /// Timer: more client ticks than the server's clock allows (a sped-up game). Vanilla's client ends
     /// every tick with ServerboundClientTickEndPacket, at the server's tick rate; each one spends a tick's
     /// time from a balance that wall-clock time fills, capped so a pause can't be saved up for a burst.
-    /// It logs only by default; once trusted: `setback = 2`, `alert = 5`, `kick = 20`.
-    timer: Timer => TimerConfig [0.0, 0.0, 0.0, 0.02, 0] {
+    timer: Timer => TimerConfig [2.0, 5.0, 20.0, 0.02] {
         /// How far ahead of the clock, in milliseconds, a client may get before it is flagged.
         tolerance_ms: f64 = 300.0,
         /// The most time, in milliseconds, a quiet connection banks for the ticks that follow (a lag
@@ -152,35 +128,9 @@ checks! {
     }
 
     /// Ground: a move that says it ends on the ground with nothing there to stand on: no-fall (claiming
-    /// the ground to skip fall damage) and walking on water. The claim is dropped, so vanilla's
-    /// fall damage follows (the player is never sent back: `setback = 0` makes the check log only), and
-    /// a player that keeps claiming is kicked, then banned at the second kick (`ban_after = 2`). A claim standing still isn't
-    /// judged (no fall to skip). On the official server's first two hours (67 players), every player who
-    /// wasn't flying or walking on water peaked at level 7 (4 claims standing still in one second); the
-    /// ones who were, at 113 to 3749.
-    ground: Ground => GroundConfig [10.0, 15.0, 30.0, 2.0, 2] {}
-
-    /// Prediction: each move played again from the client's own inputs with vanilla's movement code,
-    /// and compared (speed, step, fly, jesus...). Each player's client ticks are recorded
-    /// (`prediction::Record`), with a ping a tick to place what the server changes, and played again
-    /// (horizon-client's `lan::prediction`). A move that lands farther than `tolerance` from the
-    /// replay flags, by how far it lands (one `tolerance` off weighs 1, at most 5 a tick), and the
-    /// setback puts the player back where its moves last agreed. A tick near what the replay can't
-    /// play yet (another entity, a block change or abilities the client hadn't seen, a moving piston,
-    /// a chunk the client doesn't have, a riptide launch) is excused, and so are the ticks after it
-    /// until the moves agree again. It logs only by default; once trusted: `setback = 5`, `alert = 15`,
-    /// `kick = 60`.
-    prediction: Prediction => PredictionConfig [0.0, 0.0, 0.0, 2.0, 0] {
-        /// How far, in blocks, a move may land from where the replay puts it.
-        tolerance: f64 = 0.03,
-    }
-
-    /// Combat: attacks vanilla's client can't send (`combat`): one with no swing after it (a kill aura
-    /// that hides its swing), or a second entity attacked in the same client tick (vanilla attacks the
-    /// one entity under the crosshair, picked once a tick). Each flags once; from `setback` on the
-    /// player's attacks are dropped. A vanilla client never trips it, so it acts by default: the first
-    /// kick warns, the second bans (`ban_after = 2`).
-    combat: Combat => CombatConfig [2.0, 5.0, 20.0, 0.5, 2] {}
+    /// the ground to skip fall damage) and walking on water. The claim is always dropped, so vanilla's
+    /// fall damage follows; from `setback` on the player is also sent back.
+    ground: Ground => GroundConfig [5.0, 15.0, 60.0, 2.0] {}
 }
 
 /// How many checks there are.
@@ -221,41 +171,10 @@ impl Config {
                 ));
             }
         }
-        let tolerance = self.prediction.tolerance;
-        if !tolerance.is_finite() || tolerance <= 0.0 {
-            return Err("anticheat.prediction: tolerance is a number of blocks above 0".into());
-        }
         Ok(())
     }
 }
 
-/// How many times each check kicked each player, kept across sessions (`strikes`, a JSON object of
-/// players' UUIDs to check names to counts): the kick that reaches a check's `ban_after` is a ban.
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-#[serde(transparent)]
-pub struct Strikes(pub BTreeMap<String, BTreeMap<String, u32>>);
-
-impl Strikes {
-    /// Player `uuid` was kicked by `check`: its kicks by it so far, this one included, and whether this
-    /// one bans. A ban starts the count again, so a player an operator pardons is kicked before the
-    /// next ban.
-    pub fn kick(&mut self, uuid: &str, check: Check, ban_after: u32) -> (u32, bool) {
-        let count = self
-            .0
-            .entry(uuid.to_owned())
-            .or_default()
-            .entry(check.name().to_owned())
-            .or_default();
-        *count = count.saturating_add(1);
-        let kicks = *count;
-        let ban = ban_after > 0 && kicks >= ban_after;
-        if ban {
-            *count = 0;
-        }
-        (kicks, ban)
-    }
-}
-
 /// What a flag leads to.
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct Verdict {
@@ -279,10 +198,6 @@ pub struct Player {
     pub timer: timer::Balance,
     /// The server tick and height where the ground last held the player.
     pub ground: Option<(u64, f64)>,
-    /// The client ticks the prediction plays again (only while it runs).
-    pub record: Option<Box<prediction::Record>>,
-    /// The attacks of the client tick being heard.
-    pub attacks: combat::Attacks,
 }
 
 impl Player {
@@ -326,22 +241,12 @@ mod tests {
     }
 
     #[test]
-    fn on_by_default_but_only_combat_and_ground_act() {
+    fn off_by_default_and_without_a_section() {
+        assert!(!Config::default().enabled);
         let c = Config::from_server_toml("[server]\nport = 25565\n").unwrap();
         assert_eq!(c, Config::default());
-        for &check in Check::ALL {
-            assert!(c.runs(check), "{}", check.name());
-            let a = c.actions(check);
-            let acts = [a.setback, a.alert, a.kick] != [0.0; 3];
-            assert_eq!(
-                acts,
-                matches!(check, Check::Combat | Check::Ground),
-                "{}",
-                check.name()
-            );
-        }
-        let off = Config::from_server_toml("[anticheat]\nenabled = false\n").unwrap();
-        assert!(Check::ALL.iter().all(|&check| !off.runs(check)));
+        assert!(!c.runs(Check::Timer));
+        assert!(!c.runs(Check::Ground));
     }
 
     #[test]
@@ -352,8 +257,6 @@ mod tests {
         assert_eq!(c.timer.kick, 0.0);
         assert_eq!(c.timer.tolerance_ms, 500.0);
         assert_eq!(c.timer.alert, TimerConfig::default().alert);
-        let zero = "[anticheat]\n[anticheat.prediction]\ntolerance = 0\n";
-        assert!(Config::from_server_toml(zero).is_err());
         let off = "[anticheat]\nenabled = true\n[anticheat.timer]\nenabled = false\n";
         assert!(!Config::from_server_toml(off).unwrap().runs(Check::Timer));
     }
@@ -390,25 +293,6 @@ mod tests {
         assert!(v.kick && v.alert);
     }
 
-    #[test]
-    fn the_kick_that_reaches_ban_after_bans() {
-        let c = Config::default();
-        assert_eq!(c.actions(Check::Combat).ban_after, 2);
-        assert_eq!(c.actions(Check::Prediction).ban_after, 0);
-        let mut s = Strikes::default();
-        assert_eq!(s.kick("a", Check::Combat, 2), (1, false));
-        // Another player, another check: their own counts.
-        assert_eq!(s.kick("b", Check::Combat, 2), (1, false));
-        assert_eq!(s.kick("a", Check::Timer, 2), (1, false));
-        assert_eq!(s.kick("a", Check::Combat, 2), (2, true));
-        // Pardoned, the player is kicked once more before the next ban.
-        assert_eq!(s.kick("a", Check::Combat, 2), (1, false));
-        // 0 never bans; 1 bans at the first kick.
-        assert_eq!(s.kick("c", Check::Timer, 0), (1, false));
-        assert_eq!(s.kick("c", Check::Timer, 0), (2, false));
-        assert_eq!(s.kick("d", Check::Ground, 1), (1, true));
-    }
-
     #[test]
     fn zero_turns_an_action_off() {
         let mut c = on();

crates/horizon-anticheat/src/prediction.rs

@@ -1,411 +0,0 @@
-//! The movement prediction's record: each of a player's client ticks as the server heard them, so
-//! the server can play the tick again with vanilla's movement code and compare (docs/anticheat.md).
-//!
-//! A vanilla client ends every tick with ServerboundClientTickEndPacket, after the tick's input
-//! (ServerboundPlayerInputPacket, sent when the keys change) and its move (ServerboundMovePlayerPacket,
-//! when it moved or turned). Those packets arrive in order, so the packets between two tick ends are one
-//! client tick.
-//!
-//! What the server changes about the player (a push, a teleport, an effect) takes effect on the client
-//! when it handles the packet, which is some client ticks after the server sent it. At the end of each of
-//! its ticks the server sends a ClientboundPingPacket whose id is that server tick; the client answers
-//! with ServerboundPongPacket as soon as it handles it, before its next tick runs. A client tick knows
-//! the last server tick it had handled: every change of that server tick or an earlier one was in effect
-//! during the client tick, none of a later one.
-
-use std::collections::VecDeque;
-
-/// Client ticks kept: two seconds at 20 a second.
-pub const KEPT: usize = 40;
-
-/// Server changes kept, the oldest dropped first.
-const CHANGES_KEPT: usize = 64;
-
-/// Changes near the player kept until every kept tick has seen them.
-const NEAR_KEPT: usize = 1024;
-
-/// Something the server sent the player that changes how its client moves. The client applies it when
-/// it handles the packet, before its next tick.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Change {
-    /// ClientboundSetEntityMotionPacket for the player itself: its new velocity, as the client
-    /// decodes it.
-    Velocity([f64; 3]),
-    /// ClientboundExplodePacket's player knockback, added to the velocity.
-    Knockback([f64; 3]),
-    /// ClientboundUpdateAttributesPacket for the player itself: the server's attributes as they
-    /// are when the replay reaches it, but for the movement speed's sprint modifier, which the
-    /// client's sprinting decides: `sprint` is whether the packet had it when it carried the
-    /// movement speed (the client takes the modifiers as sent, so a sprint modifier the packet
-    /// lacks is gone while the client sprints), None when it didn't (the client keeps its own).
-    Attributes { sprint: Option<bool> },
-    /// ClientboundUpdateMobEffectPacket or ClientboundRemoveMobEffectPacket for the player itself:
-    /// the server's effects, as they are when the replay reaches it. (Their attribute modifiers
-    /// are the server's: they reach the client as attributes.)
-    Effects,
-    /// ClientboundPlayerAbilitiesPacket (a game mode, flight given or taken), or the player's chest
-    /// slot (a glider put on or taken off): the replay takes these from the server every tick, so a
-    /// tick played before the client had them may be off.
-    Abilities,
-}
-
-/// A teleport the client accepted: the replay starts again from it.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Restart {
-    /// Where it put the player.
-    pub at: [f64; 3],
-    /// It kept the player's motion (an End gateway's).
-    pub kept_motion: bool,
-    /// Client ticks ended and changes heard before it: the ones after are the replay's.
-    pub ended: u64,
-    pub changed: u64,
-}
-
-/// One client tick.
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct ClientTick {
-    /// The keys held (ServerboundPlayerInputPacket's flags: forward, backward, left, right, jump,
-    /// shift, sprint), as last sent.
-    pub input: u8,
-    /// Sprinting, as the player's commands left it (ServerboundPlayerCommandPacket).
-    pub sprinting: bool,
-    /// The rotation the client last sent.
-    pub yaw: f32,
-    pub pitch: f32,
-    /// Where the tick's move said the player is, if it said: a move with a position.
-    pub position: Option<[f64; 3]>,
-    /// The tick's move packet's flags (1: on the ground, 2: against a wall), if it sent one.
-    pub flags: Option<u8>,
-    /// The last server tick whose packets the client had handled (its pong) before this tick ended.
-    pub seen: Option<u64>,
-}
-
-/// A player's last client ticks.
-#[derive(Clone, Debug, Default)]
-pub struct Record {
-    /// The tick being heard.
-    current: ClientTick,
-    /// The ended ones, oldest first, at most [`KEPT`].
-    ticks: VecDeque<ClientTick>,
-    /// The last server tick the client answered for.
-    seen: Option<u64>,
-    /// Client ticks ended since the record began.
-    ended: u64,
-    /// Where an accepted teleport put the player, until the replay starts again from there.
-    restart: Option<Restart>,
-    /// What the server changed, with the server tick that sent it, oldest first.
-    changes: VecDeque<(u64, Change)>,
-    /// Changes heard since the record began.
-    changed: u64,
-    /// The blocks the server changed near the player (None: an entity it stopped showing the player
-    /// from near it, which counts wherever the player has gone since), with the server tick that sent
-    /// each, until every kept tick has seen them.
-    near: VecDeque<(u64, Option<[i32; 3]>)>,
-    /// The server tick of the last of them dropped early ([`NEAR_KEPT`] came after it).
-    near_dropped: Option<u64>,
-}
-
-impl Record {
-    /// The tick's move: its position if it has one, the rotation if it has one, and its flags.
-    pub fn moved(&mut self, position: Option<[f64; 3]>, rotation: Option<(f32, f32)>, flags: u8) {
-        if position.is_some() {
-            self.current.position = position;
-        }
-        if let Some((yaw, pitch)) = rotation {
-            (self.current.yaw, self.current.pitch) = (yaw, pitch);
-        }
-        self.current.flags = Some(flags);
-    }
-
-    /// ServerboundPongPacket for the ping sent at the end of `server_tick`. False for an answer to a
-    /// ping that was never sent, or one older than an answer already heard: a vanilla client answers
-    /// every ping, once, in order.
-    pub fn pong(&mut self, server_tick: u64, sent_up_to: u64) -> bool {
-        if server_tick > sent_up_to || self.seen.is_some_and(|seen| server_tick <= seen) {
-            return false;
-        }
-        self.seen = Some(server_tick);
-        true
-    }
-
-    /// ServerboundClientTickEndPacket: the tick ends with these keys held and this sprinting. The
-    /// next tick starts with the same keys and rotation, until the client says otherwise.
-    pub fn tick_end(&mut self, input: u8, sprinting: bool) -> &ClientTick {
-        self.current.input = input;
-        self.current.sprinting = sprinting;
-        self.current.seen = self.seen;
-        let next = ClientTick {
-            yaw: self.current.yaw,
-            pitch: self.current.pitch,
-            ..ClientTick::default()
-        };
-        let ended = std::mem::replace(&mut self.current, next);
-        if self.ticks.len() == KEPT {
-            self.ticks.pop_front();
-        }
-        self.ticks.push_back(ended);
-        self.ended += 1;
-        // What the oldest tick kept had seen, every later one had too.
-        if let Some(seen) = self.ticks.front().and_then(|t| t.seen) {
-            while self.near.front().is_some_and(|&(sent, _)| sent <= seen) {
-                self.near.pop_front();
-            }
-            self.near_dropped = self.near_dropped.filter(|&sent| sent > seen);
-        }
-        self.ticks.back().expect("just pushed")
-    }
-
-    /// The ended ticks, oldest first.
-    pub fn ticks(&self) -> impl DoubleEndedIterator<Item = &ClientTick> + ExactSizeIterator {
-        self.ticks.iter()
-    }
-
-    /// The last server tick the client answered for.
-    pub fn seen(&self) -> Option<u64> {
-        self.seen
-    }
-
-    /// Client ticks ended since the record began.
-    pub fn ended(&self) -> u64 {
-        self.ended
-    }
-
-    /// The ticks ended after the first `played`, oldest first; None when some of them are no longer
-    /// kept.
-    pub fn since(&self, played: u64) -> Option<impl Iterator<Item = &ClientTick>> {
-        let new = self.ended.checked_sub(played)?;
-        let new = usize::try_from(new)
-            .ok()
-            .filter(|&n| n <= self.ticks.len())?;
-        Some(self.ticks.iter().skip(self.ticks.len() - new))
-    }
-
-    /// `change`, sent during server tick `server_tick` (before that tick's ping).
-    pub fn changed(&mut self, server_tick: u64, change: Change) {
-        if self.changes.len() == CHANGES_KEPT {
-            self.changes.pop_front();
-        }
-        self.changes.push_back((server_tick, change));
-        self.changed += 1;
-    }
-
-    /// Changes heard since the record began.
-    pub fn changes(&self) -> u64 {
-        self.changed
-    }
-
-    /// The changes after the first `applied`, oldest first; None when some of them are no longer kept.
-    pub fn changes_since(
-        &self,
-        applied: u64,
-    ) -> Option<impl Iterator<Item = &(u64, Change)> + Clone> {
-        let new = self.changed.checked_sub(applied)?;
-        let new = usize::try_from(new)
-            .ok()
-            .filter(|&n| n <= self.changes.len())?;
-        Some(self.changes.iter().skip(self.changes.len() - new))
-    }
-
-    /// During server tick `server_tick` (before that tick's ping) the server sent the client the block
-    /// at `pos`.
-    pub fn changed_near(&mut self, server_tick: u64, pos: [i32; 3]) {
-        self.note_near(server_tick, Some(pos));
-    }
-
-    /// During server tick `server_tick` the server stopped showing the client an entity near it (a
-    /// firework it flew with, a mob that pushed it): the client may still have it, wherever it goes.
-    pub fn entity_gone(&mut self, server_tick: u64) {
-        if self.near.back() != Some(&(server_tick, None)) {
-            self.note_near(server_tick, None);
-        }
-    }
-
-    fn note_near(&mut self, server_tick: u64, pos: Option<[i32; 3]>) {
-        if self.near.len() == NEAR_KEPT {
-            self.near_dropped = self.near.pop_front().map(|(sent, _)| sent);
-        }
-        self.near.push_back((server_tick, pos));
-    }
-
-    /// Whether a client tick that had `seen` up to that server tick (its [`ClientTick::seen`]) may
-    /// not have had a change at a position for which `near` holds: it still had the old block, or the
-    /// entity, where the server no longer has it.
-    pub fn unseen_near(&self, seen: Option<u64>, near: impl Fn([i32; 3]) -> bool) -> bool {
-        let unseen = |sent: u64| seen.is_none_or(|seen| sent > seen);
-        self.near_dropped.is_some_and(unseen)
-            || self
-                .near
-                .iter()
-                .any(|&(sent, pos)| unseen(sent) && pos.is_none_or(&near))
-    }
-
-    /// The client accepted a teleport to `at` (ServerboundAcceptTeleportationPacket): it goes on from
-    /// there, standing still unless the teleport `kept_motion` (an End gateway's). The ticks it ended
-    /// before stay, for a replay that hasn't played them yet; the one under way starts again.
-    pub fn teleported(&mut self, at: [f64; 3], kept_motion: bool) {
-        self.restart_tick();
-        self.restart = Some(Restart {
-            at,
-            kept_motion,
-            ended: self.ended,
-            changed: self.changed,
-        });
-    }
-
-    /// The last teleport the client accepted, once.
-    pub fn take_restart(&mut self) -> Option<Restart> {
-        self.restart.take()
-    }
-
-    /// The ticks before now say nothing about the ones after.
-    pub fn clear(&mut self) {
-        self.ticks.clear();
-        self.restart_tick();
-    }
-
-    fn restart_tick(&mut self) {
-        self.current = ClientTick {
-            yaw: self.current.yaw,
-            pitch: self.current.pitch,
-            ..ClientTick::default()
-        };
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn a_change_near_is_unseen_by_the_ticks_before_its_pong() {
-        let mut r = Record::default();
-        r.changed_near(4, [1, 2, 3]);
-        r.changed_near(5, [7, 2, 3]);
-        let near = |p: [i32; 3]| p[0] < 5;
-        assert!(r.unseen_near(None, near));
-        assert!(r.unseen_near(Some(3), near));
-        assert!(!r.unseen_near(Some(4), near));
-        assert!(r.unseen_near(Some(4), |_| true));
-        // Kept until the oldest tick kept had seen it: one that ended before the pong hadn't.
-        r.tick_end(0, false);
-        assert!(r.pong(5, 5));
-        r.tick_end(0, false);
-        assert!(r.unseen_near(Some(3), near));
-        for _ in 0..KEPT {
-            r.tick_end(0, false);
-        }
-        assert!(!r.unseen_near(None, |_| true));
-        // An entity gone counts anywhere.
-        r.entity_gone(5);
-        r.entity_gone(5);
-        assert!(r.unseen_near(Some(4), |_| false));
-        assert!(!r.unseen_near(Some(5), |_| false));
-        // One dropped early counts for the ticks that hadn't seen it.
-        for i in 0..=NEAR_KEPT as u64 {
-            r.changed_near(6 + i, [100, 0, 0]);
-        }
-        assert!(
-            r.unseen_near(Some(5), near),
-            "a change dropped unseen counts"
-        );
-        assert!(!r.unseen_near(Some(6), near));
-    }
-
-    #[test]
-    fn a_tick_is_the_packets_between_two_tick_ends() {
-        let mut r = Record::default();
-        r.moved(Some([1.0, 2.0, 3.0]), Some((90.0, 10.0)), 1);
-        let t = *r.tick_end(0b1001, true);
-        assert_eq!(t.position, Some([1.0, 2.0, 3.0]));
-        assert_eq!((t.yaw, t.pitch, t.flags), (90.0, 10.0, Some(1)));
-        assert_eq!((t.input, t.sprinting, t.seen), (0b1001, true, None));
-        // A tick without a move keeps the rotation and has no position.
-        let t = *r.tick_end(0, false);
-        assert_eq!((t.position, t.flags, t.yaw), (None, None, 90.0));
-        assert_eq!(r.ticks().len(), 2);
-    }
-
-    #[test]
-    fn pongs_say_which_server_ticks_a_client_tick_had_seen() {
-        let mut r = Record::default();
-        assert!(r.pong(5, 6));
-        r.tick_end(0, false);
-        assert!(r.pong(6, 6));
-        r.tick_end(0, false);
-        r.tick_end(0, false);
-        let seen: Vec<_> = r.ticks().map(|t| t.seen).collect();
-        assert_eq!(seen, [Some(5), Some(6), Some(6)]);
-        // Never sent, answered twice, or out of order.
-        assert!(!r.pong(9, 6));
-        assert!(!r.pong(6, 6));
-        assert!(!r.pong(4, 6));
-        assert_eq!(r.seen(), Some(6));
-    }
-
-    #[test]
-    fn only_the_last_two_seconds_are_kept() {
-        let mut r = Record::default();
-        for i in 0..KEPT + 5 {
-            r.moved(Some([i as f64, 0.0, 0.0]), None, 0);
-            r.tick_end(0, false);
-        }
-        assert_eq!(r.ticks().len(), KEPT);
-        assert_eq!(r.ticks().next().unwrap().position, Some([5.0, 0.0, 0.0]));
-        r.clear();
-        assert_eq!(r.ticks().len(), 0);
-    }
-
-    #[test]
-    fn the_replay_takes_the_ticks_it_has_not_played() {
-        let mut r = Record::default();
-        for i in 0..3 {
-            r.moved(Some([i as f64, 0.0, 0.0]), None, 0);
-            r.tick_end(0, false);
-        }
-        fn x(r: &Record, played: u64) -> Option<Vec<f64>> {
-            r.since(played)
-                .map(|t| t.map(|t| t.position.unwrap()[0]).collect())
-        }
-        assert_eq!(x(&r, 1), Some(vec![1.0, 2.0]));
-        assert_eq!(x(&r, 3), Some(vec![]));
-        // Played ahead of the record, or so far behind the ticks are gone.
-        assert_eq!(x(&r, 4), None);
-        r.clear();
-        assert_eq!(x(&r, 2), None);
-        assert_eq!(x(&r, 3), Some(vec![]));
-        r.moved(Some([8.0, 0.0, 0.0]), None, 0);
-        r.tick_end(0, false);
-        r.moved(Some([9.0, 0.0, 0.0]), None, 0);
-        r.teleported([5.0, 6.0, 7.0], false);
-        // A tick that ends before the replay starts again is still one after the teleport.
-        r.tick_end(0, false);
-        let restart = r.take_restart().unwrap();
-        assert_eq!((restart.at, restart.kept_motion), ([5.0, 6.0, 7.0], false));
-        assert_eq!(r.since(restart.ended).unwrap().count(), 1);
-        // The tick ended before it stays for a replay that hasn't played it; the move of the one
-        // under way is gone.
-        let positions: Vec<_> = r.since(3).unwrap().map(|t| t.position).collect();
-        assert_eq!(positions, [Some([8.0, 0.0, 0.0]), None]);
-        assert_eq!(r.take_restart(), None);
-    }
-
-    #[test]
-    fn changes_keep_the_server_tick_that_sent_them() {
-        let mut r = Record::default();
-        r.changed(3, Change::Velocity([0.0, 0.4, 0.0]));
-        r.changed(5, Change::Effects);
-        let all: Vec<_> = r.changes_since(0).unwrap().copied().collect();
-        assert_eq!(
-            all,
-            [(3, Change::Velocity([0.0, 0.4, 0.0])), (5, Change::Effects)]
-        );
-        assert_eq!(r.changes_since(1).unwrap().count(), 1);
-        assert!(r.changes_since(3).is_none());
-        for i in 0..CHANGES_KEPT as u64 {
-            r.changed(6 + i, Change::Effects);
-        }
-        // The first two are gone.
-        assert!(r.changes_since(1).is_none());
-        assert_eq!(r.changes_since(2).unwrap().count(), CHANGES_KEPT);
-    }
-}

crates/horizon-assets/src/item_model.rs

@@ -16,7 +16,6 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-mod component_predicate;
 mod special;
 pub use special::{SpecialKind, SpecialModel};
 
@@ -629,7 +628,7 @@ pub enum ConditionProperty {
     ExtendedView,
     KeybindDown(String),
     ViewEntity,
-    /// A single `component` predicate; external predicate types use the host.
+    /// A `component` predicate, evaluated by the host.
     Component(Value),
 }
 impl ConditionProperty {
@@ -652,7 +651,13 @@ impl ConditionProperty {
             "minecraft:extended_view" => Self::ExtendedView,
             "minecraft:keybind_down" => Self::KeybindDown(string(required(m, "keybind")?)?),
             "minecraft:view_entity" => Self::ViewEntity,
-            "minecraft:component" => Self::Component(component_predicate::decode(m)?),
+            "minecraft:component" => {
+                let predicate = required(m, "predicate")?;
+                if object(predicate)?.len() != 1 {
+                    return Err(err("a single component predicate is expected"));
+                }
+                Self::Component(predicate.clone())
+            }
             _ => return Err(err("unknown condition property")),
         })
     }
@@ -959,14 +964,10 @@ pub trait ItemEnv {
     fn bundle_fullness(&self, _stack: &StackView, _components: &Components) -> f32 {
         0.0
     }
-    /// Additional component predicate types supplied by the host.
+    /// `ItemStack.getMaxStackSize` when the prototype has no component.
     fn component_matches(&self, _stack: &StackView, _predicate: &Value) -> bool {
         false
     }
-    /// Membership in the level's enchantment registry tags.
-    fn enchantment_in_tag(&self, _enchantment: &str, _tag: &str) -> bool {
-        false
-    }
     fn is_keybind_down(&self, _keybind: &str) -> bool {
         false
     }
@@ -1334,8 +1335,7 @@ impl Resolve<'_> {
             ConditionProperty::KeybindDown(key) => self.env.is_keybind_down(key),
             ConditionProperty::ViewEntity => owner.is_some_and(|o| o.is_view_entity),
             ConditionProperty::Component(predicate) => {
-                component_predicate::matches(predicate, self.components, self.env)
-                    .unwrap_or_else(|| self.env.component_matches(self.stack, predicate))
+                self.env.component_matches(self.stack, predicate)
             }
         }
     }

crates/horizon-assets/src/item_model/component_predicate.rs

@@ -1,177 +0,0 @@
-//! Component conditions used by enchantment-dependent item models.
-use super::*;
-
-/// `DataComponentPredicate.singleCodec`: a single predicate's type discriminator
-/// (`predicate`) and its wrapped codec's separate `value` field.
-pub(super) fn decode(m: &Map<String, Value>) -> Result<Value> {
-    let id = component_type(required(m, "predicate")?)?;
-    let mut value = required(m, "value")?.clone();
-    if matches!(
-        id.as_str(),
-        "minecraft:enchantments" | "minecraft:stored_enchantments"
-    ) {
-        let mut entries = Vec::new();
-        for entry in list(&value)? {
-            let mut entry = object(entry)?.clone();
-            if let Some(selector) = get(&entry, "enchantments") {
-                let selector = match selector {
-                    Value::Array(ids) => Value::Array(
-                        ids.iter()
-                            .map(ident)
-                            .map(|r| r.map(Value::String))
-                            .collect::<Result<_>>()?,
-                    ),
-                    Value::String(name) if name.starts_with('#') => {
-                        Value::String(format!("#{}", identifier(&name[1..])?))
-                    }
-                    _ => Value::String(ident(selector)?),
-                };
-                entry.insert("enchantments".into(), selector);
-            }
-            if let Some(levels) = get(&entry, "levels") {
-                let levels = if levels.is_object() {
-                    let mut bounds = Map::new();
-                    for key in ["min", "max"] {
-                        if let Some(n) = get(object(levels)?, key) {
-                            bounds.insert(key.into(), Value::from(int(n)?));
-                        }
-                    }
-                    // MinMaxBounds.Bounds.validateSwappedBoundsInCodec.
-                    if bounds
-                        .get("min")
-                        .and_then(Value::as_i64)
-                        .zip(bounds.get("max").and_then(Value::as_i64))
-                        .is_some_and(|(min, max)| min > max)
-                    {
-                        return Err(err("minimum exceeds maximum"));
-                    }
-                    Value::Object(bounds)
-                } else {
-                    Value::from(int(levels)?)
-                };
-                entry.insert("levels".into(), levels);
-            }
-            entries.push(Value::Object(entry));
-        }
-        value = Value::Array(entries);
-    }
-    Ok(Value::Object(Map::from_iter([(id, value)])))
-}
-
-/// `EnchantmentsPredicate.matches` and `EnchantmentPredicate.containedIn`:
-/// all entries must match; each entry needs one selected, present enchantment
-/// with a matching level. An empty predicate list still needs the component.
-pub(super) fn matches(
-    predicate: &Value,
-    components: &Components,
-    env: &dyn ItemEnv,
-) -> Option<bool> {
-    let (id, expected) = predicate.as_object()?.iter().next()?;
-    if !matches!(
-        id.as_str(),
-        "minecraft:enchantments" | "minecraft:stored_enchantments"
-    ) {
-        return None;
-    }
-    let Some(have) = components.get(id).and_then(Value::as_object) else {
-        return Some(false);
-    };
-    Some(expected.as_array()?.iter().all(|entry| {
-        let Some(entry) = entry.as_object() else {
-            return false;
-        };
-        have.iter().any(|(id, level)| {
-            let level = level.as_i64().unwrap_or(0);
-            let selector = get(entry, "enchantments");
-            let selected = match selector {
-                None => true,
-                Some(Value::String(s)) => s
-                    .strip_prefix('#')
-                    .map_or(s == id, |tag| env.enchantment_in_tag(id, tag)),
-                Some(Value::Array(ids)) => ids.iter().any(|s| s.as_str() == Some(id)),
-                _ => false,
-            };
-            selected
-                && if selector.is_some() {
-                    matches_enchantment(level, get(entry, "levels"))
-                } else {
-                    level_matches(level, get(entry, "levels"))
-                }
-        })
-    }))
-}
-
-/// `EnchantmentPredicate.matchesEnchantment`: a named enchantment needs a
-/// nonzero level even when its bounds accept zero.
-fn matches_enchantment(level: i64, bounds: Option<&Value>) -> bool {
-    level != 0 && level_matches(level, bounds)
-}
-
-/// `MinMaxBounds.Ints.matches`: inclusive bounds, or an exact integer.
-fn level_matches(level: i64, bounds: Option<&Value>) -> bool {
-    match bounds {
-        None => true,
-        Some(Value::Number(n)) => n.as_i64() == Some(level),
-        Some(Value::Object(bounds)) => {
-            get(bounds, "min")
-                .and_then(Value::as_i64)
-                .is_none_or(|min| level >= min)
-                && get(bounds, "max")
-                    .and_then(Value::as_i64)
-                    .is_none_or(|max| level <= max)
-        }
-        _ => false,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    struct Tags;
-    impl ItemEnv for Tags {
-        fn enchantment_in_tag(&self, enchantment: &str, tag: &str) -> bool {
-            enchantment == "minecraft:density" && tag == "horizon:mace"
-        }
-    }
-
-    #[test]
-    fn unnamed_predicates_inspect_entries_but_named_ones_require_a_nonzero_level() {
-        let components = Components::from_iter([(
-            "minecraft:enchantments".into(),
-            json!({"minecraft:density":0}),
-        )]);
-        assert_eq!(
-            matches(&json!({"minecraft:enchantments":[{}]}), &components, &NoEnv),
-            Some(true)
-        );
-        assert_eq!(
-            matches(
-                &json!({"minecraft:enchantments":[{"enchantments":"minecraft:density"}]}),
-                &components,
-                &NoEnv
-            ),
-            Some(false)
-        );
-    }
-
-    #[test]
-    fn enchantment_selectors_use_the_hosts_registry_tags() {
-        let condition = json!({"predicate":"enchantments", "value":[
-            {"enchantments":"#horizon:mace", "levels":{"min":3}}
-        ]});
-        let predicate = decode(condition.as_object().unwrap()).unwrap();
-        let mut components = Components::from_iter([(
-            "minecraft:enchantments".into(),
-            json!({"minecraft:density":3}),
-        )]);
-        assert_eq!(matches(&predicate, &components, &Tags), Some(true));
-        assert_eq!(matches(&predicate, &components, &NoEnv), Some(false));
-        components.insert(
-            "minecraft:enchantments".into(),
-            json!({"minecraft:density":2}),
-        );
-        assert_eq!(matches(&predicate, &components, &Tags), Some(false));
-    }
-}

crates/horizon-assets/src/math.rs

@@ -335,177 +335,6 @@ pub fn quaternion_from_axis_angle(angle: f32, axis: [f32; 3]) -> [f32; 4] {
     [axis[0] * sin, axis[1] * sin, axis[2] * sin, cos]
 }
 
-/// A JOML `Matrix3f`: `m[column][row]`.
-type Mat3 = [[f32; 3]; 3];
-
-/// `Matrix3f.mul`: `a * b`.
-fn mul3(a: &Mat3, b: &Mat3) -> Mat3 {
-    std::array::from_fn(|c| {
-        std::array::from_fn(|r| fma(a[0][r], b[c][0], fma(a[1][r], b[c][1], a[2][r] * b[c][2])))
-    })
-}
-/// `Matrix3f.transpose`.
-fn transpose3(m: &Mat3) -> Mat3 {
-    std::array::from_fn(|c| std::array::from_fn(|r| m[r][c]))
-}
-/// `Matrix3f.rotate(Quaternionfc)`: `m * R(q)`, without fma.
-fn rotate3(m: &Mat3, q: [f32; 4]) -> Mat3 {
-    let [x, y, z, w] = q;
-    let (w2, x2, y2, z2) = (w * w, x * x, y * y, z * z);
-    let (zw, xy, xz, yw, yz, xw) = (z * w, x * y, x * z, y * w, y * z, x * w);
-    let (zw, xy, xz, yw, yz, xw) = (zw + zw, xy + xy, xz + xz, yw + yw, yz + yz, xw + xw);
-    let rotation = [
-        [w2 + x2 - z2 - y2, xy + zw, xz - yw],
-        [xy - zw, y2 - z2 + w2 - x2, yz + xw],
-        [yw + xz, yz - xw, z2 - y2 - x2 + w2],
-    ];
-    std::array::from_fn(|c| {
-        let rc = rotation[c];
-        std::array::from_fn(|r| m[0][r] * rc[0] + m[1][r] * rc[1] + m[2][r] * rc[2])
-    })
-}
-/// `Quaternionf.mul`: `a * b`.
-fn quaternion_mul(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
-    let ([x, y, z, w], [qx, qy, qz, qw]) = (a, b);
-    [
-        fma(w, qx, fma(x, qw, fma(y, qz, -z * qy))),
-        fma(w, qy, fma(-x, qz, fma(y, qw, z * qx))),
-        fma(w, qz, fma(x, qy, fma(-y, qx, z * qw))),
-        fma(w, qw, fma(-x, qx, fma(-y, qy, -z * qz))),
-    ]
-}
-
-/// `GivensParameters`: the half angle's sine and cosine.
-#[derive(Clone, Copy)]
-struct Givens(f32, f32);
-
-impl Givens {
-    /// `GivensParameters.fromUnnormalized`.
-    fn unnormalized(sin_half: f32, cos_half: f32) -> Self {
-        let inv = 1.0 / (sin_half * sin_half + cos_half * cos_half).sqrt();
-        Self(inv * sin_half, inv * cos_half)
-    }
-    /// `MatrixUtil.PI_4`: `fromPositiveAngle(π / 4)`.
-    fn quarter_pi() -> Self {
-        let half = std::f32::consts::FRAC_PI_4 / 2.0;
-        let sin = joml_sin(half);
-        Self(sin, cos_from_sin(sin, half))
-    }
-    fn inverse(self) -> Self {
-        Self(-self.0, self.1)
-    }
-    fn cos(self) -> f32 {
-        self.1 * self.1 - self.0 * self.0
-    }
-    fn sin(self) -> f32 {
-        2.0 * self.0 * self.1
-    }
-    /// `aroundX/Y/Z(Quaternionf)` (axis 0, 1, 2).
-    fn quaternion(self, axis: usize) -> [f32; 4] {
-        let mut q = [0.0, 0.0, 0.0, self.1];
-        q[axis] = self.0;
-        q
-    }
-    /// `aroundX/Y/Z(Matrix3f)` (axis 0, 1, 2).
-    fn matrix(self, axis: usize) -> Mat3 {
-        let (cos, sin) = (self.cos(), self.sin());
-        let (a, b) = ((axis + 1) % 3, (axis + 2) % 3);
-        let mut m = [[0.0; 3]; 3];
-        m[axis][axis] = 1.0;
-        m[a][a] = cos;
-        m[b][b] = cos;
-        m[a][b] = sin;
-        m[b][a] = -sin;
-        m
-    }
-}
-
-/// `MatrixUtil.approxGivensQuat`.
-fn approx_givens(a11: f32, a12: f32, a22: f32) -> Givens {
-    let g = 3.0 + 2.0 * 2.0f32.sqrt();
-    let (cos_half, sin_half) = (2.0 * (a11 - a22), a12);
-    if g * sin_half * sin_half < cos_half * cos_half {
-        Givens::unnormalized(sin_half, cos_half)
-    } else {
-        Givens::quarter_pi()
-    }
-}
-/// `MatrixUtil.qrGivensQuat`.
-fn qr_givens(a1: f32, a2: f32) -> Givens {
-    let p = f64::from(a1).hypot(f64::from(a2)) as f32;
-    let mut sin_half = if p > 1.0e-6 { a2 } else { 0.0 };
-    let mut cos_half = a1.abs() + if p > 1.0e-6 { p } else { 1.0e-6 };
-    if a1 < 0.0 {
-        std::mem::swap(&mut sin_half, &mut cos_half);
-    }
-    Givens::unnormalized(sin_half, cos_half)
-}
-/// `MatrixUtil.stepJacobi`: the xy, xz then yz pairs, each by
-/// `similarityTransform` (`R^T * m * R`).
-fn step_jacobi(m: &mut Mat3, q: &mut [f32; 4]) {
-    let mut rotate = |m: &mut Mat3, g: Givens, axis: usize| {
-        *q = quaternion_mul(*q, g.quaternion(axis));
-        let r = g.matrix(axis);
-        *m = mul3(&transpose3(&r), &mul3(m, &r));
-    };
-    if m[0][1] * m[0][1] + m[1][0] * m[1][0] > 1.0e-6 {
-        let g = approx_givens(m[0][0], 0.5 * (m[0][1] + m[1][0]), m[1][1]);
-        rotate(m, g, 2);
-    }
-    if m[0][2] * m[0][2] + m[2][0] * m[2][0] > 1.0e-6 {
-        let g = approx_givens(m[0][0], 0.5 * (m[0][2] + m[2][0]), m[2][2]).inverse();
-        rotate(m, g, 1);
-    }
-    if m[1][2] * m[1][2] + m[2][1] * m[2][1] > 1.0e-6 {
-        let g = approx_givens(m[1][1], 0.5 * (m[1][2] + m[2][1]), m[2][2]);
-        rotate(m, g, 0);
-    }
-}
-
-/// `MatrixUtil.svdDecompose(Matrix4fc, ...)`, how `new Transformation(matrix)`
-/// splits a matrix: translation, left rotation, scale, right rotation. The
-/// right rotation diagonalizes `a^T * a` (`eigenvalueJacobi`, 5 steps), then
-/// QR Givens rotations about z, y and x bring `a * R(right)` to the scale.
-pub fn svd_decompose(m: &Mat4) -> ([f32; 3], [f32; 4], [f32; 3], [f32; 4]) {
-    let inv = 1.0 / m.0[3][3];
-    let a: Mat3 = std::array::from_fn(|c| std::array::from_fn(|r| m.0[c][r] * inv));
-    let mut b = mul3(&transpose3(&a), &a);
-    let mut right = [0.0, 0.0, 0.0, 1.0];
-    for _ in 0..5 {
-        step_jacobi(&mut b, &mut right);
-    }
-    right = normalize_quaternion(right);
-    let (x_small, y_small) = (f64::from(b[0][0]) < 1.0e-6, f64::from(b[1][1]) < 1.0e-6);
-    let mut left = [0.0, 0.0, 0.0, 1.0];
-    let mut r = rotate3(&a, right);
-    let mut qr = |r: &mut Mat3, g: Givens, axis: usize| {
-        left = quaternion_mul(left, g.quaternion(axis));
-        *r = mul3(&transpose3(&g.matrix(axis)), r);
-    };
-    let g = if x_small {
-        qr_givens(r[1][1], -r[1][0])
-    } else {
-        qr_givens(r[0][0], r[0][1])
-    };
-    qr(&mut r, g, 2);
-    let g = if x_small {
-        qr_givens(r[2][2], -r[2][0])
-    } else {
-        qr_givens(r[0][0], r[0][2])
-    };
-    qr(&mut r, g.inverse(), 1);
-    let g = if y_small {
-        qr_givens(r[2][2], -r[2][1])
-    } else {
-        qr_givens(r[1][1], r[1][2])
-    };
-    qr(&mut r, g, 0);
-    let scale = [r[0][0], r[1][1], r[2][2]];
-    let translation = std::array::from_fn(|i| m.0[3][i] * inv);
-    let [x, y, z, w] = right;
-    (translation, left, scale, [-x, -y, -z, w])
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -526,51 +355,6 @@ mod tests {
         assert!((m.0[0][1] - 1.0).abs() < 1e-6 && m.0[0][0].abs() < 1e-6);
     }
     #[test]
-    fn svd_decomposes_like_matrix_util() {
-        let bits = |v: &[f32]| v.iter().map(|f| f.to_bits()).collect::<Vec<_>>();
-        let parts = |m: [f32; 16]| {
-            let (t, l, s, r) = svd_decompose(&Mat4::from_row_major(m));
-            [bits(&t), bits(&l), bits(&s), bits(&r)]
-        };
-        // Values from MatrixUtil.svdDecompose on the 26.3 jar.
-        let scaled = [
-            2.0, 0.0, 0.0, 1.0, 0.0, 3.0, 0.0, -2.0, 0.0, 0.0, 0.5, 0.25, 0.0, 0.0, 0.0, 1.0,
-        ];
-        assert_eq!(
-            parts(scaled),
-            [
-                vec![0x3f80_0000u32, 0xc000_0000, 0x3e80_0000],
-                vec![0u32, 0, 0, 0x3f80_0000],
-                vec![0x4000_0000u32, 0x4040_0000, 0x3f00_0000],
-                vec![0x8000_0000u32, 0x8000_0000, 0x8000_0000, 0x3f80_0000],
-            ]
-        );
-        let quarter_turn = [
-            0.0, -1.0, 0.0, 0.5, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
-        ];
-        assert_eq!(
-            parts(quarter_turn),
-            [
-                vec![0x3f00_0000u32, 0, 0],
-                vec![0u32, 0, 0x3f35_04f3, 0x3f35_04f3],
-                vec![0x3f7f_ffffu32, 0x3f7f_ffff, 0x3f80_0000],
-                vec![0x8000_0000u32, 0x8000_0000, 0x8000_0000, 0x3f80_0000],
-            ]
-        );
-        let sheared = [
-            1.0, 0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.25, 0.0, 2.0, 3.0, 0.0, 0.0, 0.0, 2.0,
-        ];
-        assert_eq!(
-            parts(sheared),
-            [
-                vec![0u32, 0, 0x3fc0_0000],
-                vec![0x3c03_7010u32, 0x3d38_d722, 0x3ea8_ef95, 0x3f71_60d9],
-                vec![0x3f23_2630u32, 0x3ec6_bdde, 0x3f81_5b1f],
-                vec![0xbcc5_7e11u32, 0xbda8_1e36, 0xbee2_916d, 0x3f64_860a],
-            ]
-        );
-    }
-    #[test]
     fn half_turn_has_exact_zeros_like_joml() {
         let half_turn = 180.0 * (std::f64::consts::PI / 180.0) as f32;
         assert_eq!(quaternion_xyz(0.0, half_turn, 0.0), [0.0, 1.0, 0.0, 0.0]);

crates/horizon-bots/src/main.rs

@@ -6,12 +6,6 @@
 //! and `force-gamemode=true`): they never touch blocks, so they need no world of their own, and no server
 //! can refuse their moves for walking into terrain. Every behaviour is deterministic from `--seed`.
 //!
-//! `--behaviour fight` is the exception: the bots play in survival (`gamemode=survival`, `force-gamemode=true`,
-//! and `allow-flight=true` because they hold their spawn height instead of standing on terrain they cannot
-//! see). They track the entities the server sends, walk to the nearest living one and attack it at vanilla's
-//! bare-hand cooldown (every 5 ticks). With `--pvp true` (the default) the other bots are targets too, which
-//! hurts only when the server has `pvp=true`.
-//!
 //!   horizon-bots --server 127.0.0.1:25565 --bots 25 --behaviour mixed --seconds 360 --report bots.json
 //!
 //! It prints one JSON line a second (bots online, chunks received) and writes a summary with `--report`.
@@ -21,15 +15,12 @@
 //! entered the view apart from chunks sent again while the bot still held them (`resent`), and counts the
 //! times the server pulled a bot back (`pulled_back`: a teleport after the first, as for "moved too quickly").
 
-//! The report also has wire bytes in and out (`bytes_in`, `bytes_out`, per bot and in total, after
-//! compression) and join-time percentiles (`join_time`: p50, p99 and max in milliseconds).
-
 use horizon_protocol::{
     PROTOCOL_VERSION,
     buf::{Reader, Writer},
-    connection::{ConnWriter, Connection, Counters},
+    connection::{ConnWriter, Connection},
     crypto::offline_uuid,
-    entity_data, ids,
+    ids,
     item::Stack,
     packets::{
         Empty, configuration,
@@ -40,9 +31,9 @@ use horizon_protocol::{
 };
 use serde_json::json;
 use std::{
-    collections::{BTreeMap, HashSet},
+    collections::HashSet,
     sync::{
-        Arc, LazyLock, Mutex, OnceLock,
+        Arc, LazyLock, Mutex,
         atomic::{AtomicBool, AtomicU64, Ordering},
     },
     thread,
@@ -54,8 +45,7 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
 
   --server HOST:PORT     default 127.0.0.1:25565
   --bots N               default 10
-  --behaviour B          idle, walk, explore, fight or mixed (60 % walk, 20 % explore, 20 % idle); default mixed.
-                         fight needs gamemode=survival, force-gamemode=true and allow-flight=true.
+  --behaviour B          idle, walk, explore or mixed (60 % walk, 20 % explore, 20 % idle); default mixed.
                          stand: stays on the ground where the server puts it (/tp), for a survival test.
                          One abusive client, to test a server's limits (run it beside a normal crowd):
                          flood-move (--flood moves a tick, each 64 to 256 blocks away, ignoring chunks),
@@ -70,12 +60,9 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
                          into a writable book), flood-sign (four 384-character lines on the block
                          below), flood-recipe (recipe book placements)
   --flood N              packets a tick for the flood behaviours; default 100
-  --attack NAME          attack the player NAME twice a second, from wherever the bot is (a reach test),
-                         swinging after each attack as vanilla's client does. NAME,NAME...: each of them
-                         in the same tick (a multi-target kill aura, for the anticheat's tests);
+  --attack NAME          attack the player NAME twice a second, from wherever the bot is (a reach test);
                          the report gives each bot's last health
   --attack-after S       start attacking S seconds after joining; default 5
-  --no-swing             attack without swinging (a kill aura hiding its swing, for the anticheat's tests)
   --no-loaded            never say the level is loaded (ServerboundPlayerLoadedPacket): a vanilla server
                          ignores the player's moves and actions for its first 3 seconds
   --no-read              stop reading from the server once spawned (a client that lets the
@@ -85,7 +72,6 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
   --view-distance N      what the bots ask for; default 10
   --seed N               default 12345
   --explore-speed B      blocks a second an explore bot flies; default 22 (as fast as chunks come)
-  --pvp B                fight bots also attack each other (true or false); default true
   --name PREFIX          bot names: PREFIX0, PREFIX1...; default Bot
   --brand B              the client brand sent in configuration (minecraft:brand); default none
   --height H             blocks above spawn the bots fly at (walk, explore, idle); default 24
@@ -95,8 +81,6 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
                          registry id, count), to test what a server takes
   --click X,Y,Z:SLOT:BUTTON:MODE  3 s after joining, open the block at X,Y,Z (a chest), then a second later
                          click SLOT of its window (ServerboundContainerClickPacket), to test what a server takes
-  --raw TICK:ID:HEX,...  raw serverbound play packets (id, body in hex) sent TICK ticks after joining,
-                         to test what a server takes
   --timer F              cheat, to test an anticheat: tick F times as fast as vanilla's client (1.5: 30 Hz)
   --report FILE          a JSON summary at the end (- prints it after the per-second lines)
 ";
@@ -107,7 +91,6 @@ enum Behaviour {
     Stand,
     Walk,
     Explore,
-    Fight,
     FloodMove,
     FloodAcks,
     FloodPackets,
@@ -127,7 +110,6 @@ impl Behaviour {
             Self::Stand => "stand",
             Self::Walk => "walk",
             Self::Explore => "explore",
-            Self::Fight => "fight",
             Self::FloodMove => "flood-move",
             Self::FloodAcks => "flood-acks",
             Self::FloodPackets => "flood-packets",
@@ -152,18 +134,14 @@ struct Options {
     view_distance: i8,
     seed: u64,
     explore_speed: f64,
-    pvp: bool,
     /// The player to attack, and how long after joining to start.
     attack: Option<String>,
     attack_after: f64,
-    no_swing: bool,
     flood: usize,
     no_read: bool,
     no_loaded: bool,
     height: f64,
     ground: bool,
-    /// --raw: (tick after joining, packet id, body).
-    raw: Vec<(u64, i32, Vec<u8>)>,
     /// ServerboundSetCreativeModeSlotPackets to send once joined: (slot, item id, count).
     give: Vec<(i16, i32, i32)>,
     /// --click: the block to open, then the slot, button and click type in its window.
@@ -187,16 +165,13 @@ fn options() -> Result<Options, String> {
         view_distance: 10,
         seed: 12345,
         explore_speed: 22.0,
-        pvp: true,
         attack: None,
         attack_after: 5.0,
-        no_swing: false,
         flood: 100,
         no_read: false,
         no_loaded: false,
         height: 24.0,
         ground: false,
-        raw: Vec::new(),
         give: Vec::new(),
         click: None,
         name: "Bot".into(),
@@ -214,10 +189,6 @@ fn options() -> Result<Options, String> {
             o.no_read = true;
             continue;
         }
-        if arg == "--no-swing" {
-            o.no_swing = true;
-            continue;
-        }
         if arg == "--no-loaded" {
             o.no_loaded = true;
             continue;
@@ -243,7 +214,6 @@ fn options() -> Result<Options, String> {
             "--explore-speed" => {
                 o.explore_speed = value.parse().map_err(|_| number("blocks a second"))?;
             }
-            "--pvp" => o.pvp = value.parse().map_err(|_| number("true or false"))?,
             "--flood" => o.flood = value.parse().map_err(|_| number("packets a tick"))?,
             "--attack" => o.attack = Some(value),
             "--attack-after" => o.attack_after = value.parse().map_err(|_| number("seconds"))?,
@@ -276,27 +246,6 @@ fn options() -> Result<Options, String> {
                 let parse = |s: &str| s.parse::<i32>().map_err(|_| bad());
                 o.click = Some((at, parse(slot)? as i16, parse(button)? as i8, parse(mode)?));
             }
-            "--raw" => {
-                for part in value.split(',') {
-                    let bad = || number("TICK:ID:HEX");
-                    let [tick, id, hex] = part.split(':').collect::<Vec<_>>()[..] else {
-                        return Err(bad());
-                    };
-                    let body = (0..hex.len())
-                        .step_by(2)
-                        .map(|i| {
-                            hex.get(i..i + 2)
-                                .and_then(|b| u8::from_str_radix(b, 16).ok())
-                        })
-                        .collect::<Option<Vec<u8>>>()
-                        .ok_or_else(bad)?;
-                    o.raw.push((
-                        tick.parse().map_err(|_| bad())?,
-                        id.parse().map_err(|_| bad())?,
-                        body,
-                    ));
-                }
-            }
             "--height" => o.height = value.parse().map_err(|_| number("blocks"))?,
             "--timer" => {
                 o.timer = value.parse().map_err(|_| number("a speed, like 1.5"))?;
@@ -307,11 +256,10 @@ fn options() -> Result<Options, String> {
             _ => return Err(format!("unknown option {arg}; --help lists them")),
         }
     }
-    const BEHAVIOURS: [&str; 16] = [
+    const BEHAVIOURS: [&str; 15] = [
         "idle",
         "walk",
         "explore",
-        "fight",
         "mixed",
         "stand",
         "flood-move",
@@ -327,7 +275,7 @@ fn options() -> Result<Options, String> {
     ];
     if !BEHAVIOURS.contains(&o.behaviour.as_str()) {
         return Err(format!(
-            "--behaviour {}: use idle, walk, explore, fight, mixed or a flood behaviour (--help lists them)",
+            "--behaviour {}: use idle, walk, explore, mixed or a flood behaviour (--help lists them)",
             o.behaviour
         ));
     }
@@ -348,59 +296,21 @@ struct Bot {
     pulled_back: AtomicU64,
     /// Ticks the bot couldn't move because it didn't hold its chunk yet.
     waited: AtomicU64,
-    /// Attack packets sent (fight bots and --attack).
-    attacks: AtomicU64,
-    /// The entities the server tells the bot about (fight bots only).
-    entities: Mutex<Entities>,
     /// The chunks the bot holds (ClientChunkCache).
     held: Mutex<HashSet<(i32, i32)>>,
     /// Where the server last put the bot (a teleport), to start from.
     teleport: Mutex<Option<[f64; 3]>>,
     error: Mutex<Option<String>>,
     joined_after_ms: AtomicU64,
-    /// The connection's byte counters (wire bytes, after compression and encryption), set once it is open.
-    counters: OnceLock<Arc<Counters>>,
     /// The bot stopped reading (--no-read).
     deaf: AtomicBool,
-    /// `--attack`: each target's UUID and, once AddEntity showed it, its entity id.
-    target: Mutex<Vec<(u128, Option<i32>)>>,
+    /// `--attack`: the target's UUID and, once AddEntity showed it, its entity id.
+    target: Mutex<(Option<u128>, Option<i32>)>,
+    attacks: AtomicU64,
     /// The last SetHealth.
     health: Mutex<Option<f32>>,
 }
 
-impl Bot {
-    fn bytes_in(&self) -> u64 {
-        self.counters
-            .get()
-            .map_or(0, |c| c.bytes_in.load(Ordering::Relaxed).max(0) as u64)
-    }
-    fn bytes_out(&self) -> u64 {
-        self.counters
-            .get()
-            .map_or(0, |c| c.bytes_out.load(Ordering::Relaxed).max(0) as u64)
-    }
-}
-
-/// Nearest-rank percentile (`p` in 0..=100) of an ascending-sorted slice; 0 when it is empty.
-fn percentile(sorted: &[u64], p: u64) -> u64 {
-    if sorted.is_empty() {
-        return 0;
-    }
-    let rank = (p * sorted.len() as u64).div_ceil(100).max(1) as usize;
-    sorted[rank - 1]
-}
-
-/// Join-time summary in milliseconds over the bots that got in: count, p50, p99 and max.
-fn join_summary(mut times: Vec<u64>) -> serde_json::Value {
-    times.sort_unstable();
-    json!({
-        "count": times.len(),
-        "p50_ms": percentile(&times, 50),
-        "p99_ms": percentile(&times, 99),
-        "max_ms": times.last().copied().unwrap_or(0),
-    })
-}
-
 /// A small deterministic generator (SplitMix64), so every run moves the bots the same way.
 struct Random(u64);
 impl Random {
@@ -416,142 +326,6 @@ impl Random {
     }
 }
 
-/// Vanilla's bare-hand attack speed is 4 a second: a full-strength swing every 20 / 4 ticks.
-const ATTACK_COOLDOWN_TICKS: u32 = 5;
-/// How far, in blocks, a fight bot strikes (the survival entity interaction range is 3).
-const ATTACK_REACH: f64 = 2.5;
-/// A fight bot walks up to this horizontal distance, so it does not stand inside its target.
-const CLOSE_IN: f64 = 1.5;
-/// Walking speed in blocks a tick.
-const FIGHT_STEP: f64 = 0.215;
-/// `LivingEntity.DATA_HEALTH_ID`: only living entities carry it, and it is sent once it differs from 1.
-const HEALTH_DATA: u8 = 9;
-
-/// What a fight bot knows of one entity.
-#[derive(Clone, Debug, PartialEq)]
-struct Tracked {
-    uuid: u128,
-    pos: [f64; 3],
-    /// Set once the server sends the health of the entity, which only living entities have.
-    health: Option<f32>,
-}
-
-/// The entities around a bot, from AddEntity, the move packets, SetEntityData and RemoveEntities.
-/// Ordered by id, so ties between equally near targets always go to the same entity.
-#[derive(Default)]
-struct Entities(BTreeMap<i32, Tracked>);
-
-impl Entities {
-    fn update(&mut self, id: i32, body: &[u8]) {
-        let Ok(packet) = play::Clientbound::decode(id, body) else {
-            return;
-        };
-        match packet {
-            play::Clientbound::AddEntity(p) => {
-                self.0.insert(
-                    p.id,
-                    Tracked {
-                        uuid: p.uuid,
-                        pos: p.position,
-                        health: None,
-                    },
-                );
-            }
-            play::Clientbound::MoveEntityPos(play::MoveEntityPos(m))
-            | play::Clientbound::MoveEntityPosRot(play::MoveEntityPosRot(m)) => {
-                if let (Some(e), Some(delta)) = (self.0.get_mut(&m.id), &m.delta) {
-                    e.pos = delta.end(e.pos);
-                }
-            }
-            play::Clientbound::EntityPositionSync(p) => {
-                if let Some(e) = self.0.get_mut(&p.id) {
-                    e.pos = p.path.end();
-                }
-            }
-            play::Clientbound::SetEntityData(p) => {
-                if let Some(e) = self.0.get_mut(&p.id) {
-                    for (index, _, value) in &p.values {
-                        if *index == HEALTH_DATA
-                            && let entity_data::Value::Float(health) = value
-                        {
-                            e.health = Some(*health);
-                        }
-                    }
-                }
-            }
-            play::Clientbound::RemoveEntities(p) => {
-                for id in p.ids {
-                    self.0.remove(&id);
-                }
-            }
-            _ => {}
-        }
-    }
-
-    /// The nearest living entity that is not dead; other bots only when `pvp`.
-    fn nearest(&self, from: [f64; 3], pvp: bool, bots: &HashSet<u128>) -> Option<(i32, [f64; 3])> {
-        let mut best: Option<(f64, i32, [f64; 3])> = None;
-        for (id, e) in &self.0 {
-            if !e.health.is_some_and(|h| h > 0.0) || (!pvp && bots.contains(&e.uuid)) {
-                continue;
-            }
-            let d = distance(from, e.pos);
-            if best.is_none_or(|(b, ..)| d < b) {
-                best = Some((d, *id, e.pos));
-            }
-        }
-        best.map(|(_, id, pos)| (id, pos))
-    }
-}
-
-fn distance(a: [f64; 3], b: [f64; 3]) -> f64 {
-    ((a[0] - b[0]).powi(2) + (a[1] - b[1]).powi(2) + (a[2] - b[2]).powi(2)).sqrt()
-}
-
-/// One tick of a fighting bot with a target: walk up to it, and strike once the cooldown is over.
-/// Returns the entity to attack. `since_attack` counts ticks since the last swing.
-fn fight_tick(pos: &mut [f64; 3], target: (i32, [f64; 3]), since_attack: &mut u32) -> Option<i32> {
-    *since_attack = since_attack.saturating_add(1);
-    let (id, at) = target;
-    let (dx, dz) = (at[0] - pos[0], at[2] - pos[2]);
-    let horizontal = dx.hypot(dz);
-    if horizontal > CLOSE_IN {
-        let step = FIGHT_STEP.min(horizontal - CLOSE_IN);
-        pos[0] += dx / horizontal * step;
-        pos[2] += dz / horizontal * step;
-    }
-    if *since_attack >= ATTACK_COOLDOWN_TICKS && distance(*pos, at) <= ATTACK_REACH {
-        *since_attack = 0;
-        return Some(id);
-    }
-    None
-}
-
-/// One tick of walking to random points around the spawn, at sprint speed (5.6 blocks a second).
-fn walk_step(
-    pos: &mut [f64; 3],
-    target: &mut [f64; 3],
-    spawn: [f64; 3],
-    cruise: f64,
-    random: &mut Random,
-) {
-    let (dx, dz) = (target[0] - pos[0], target[2] - pos[2]);
-    let distance = dx.hypot(dz);
-    if distance < 1.0 {
-        let angle = random.unit() * std::f64::consts::TAU;
-        let reach = 8.0 + random.unit() * 40.0;
-        *target = [
-            spawn[0] + angle.cos() * reach,
-            cruise,
-            spawn[2] + angle.sin() * reach,
-        ];
-    } else {
-        let step = 0.28_f64.min(distance);
-        pos[0] += dx / distance * step;
-        pos[2] += dz / distance * step;
-    }
-}
-
 /// One bot thread that panics poisons the locks it held; the others and the report go on.
 fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
     m.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
@@ -807,7 +581,6 @@ fn read(
     mut reader: horizon_protocol::connection::ConnReader,
     writer: Arc<Mutex<ConnWriter>>,
     bot: Arc<Bot>,
-    track: bool,
 ) {
     use ids::play::clientbound as cb;
     use ids::play::serverbound as sb;
@@ -864,15 +637,11 @@ fn read(
             }
             cb::ADD_ENTITY => {
                 if let Ok(play::Clientbound::AddEntity(p)) = play::Clientbound::decode(id, &body) {
-                    for target in lock(&bot.target).iter_mut() {
-                        if target.0 == p.uuid {
-                            target.1 = Some(p.id);
-                        }
+                    let mut target = lock(&bot.target);
+                    if target.0 == Some(p.uuid) {
+                        target.1 = Some(p.id);
                     }
                 }
-                if track {
-                    lock(&bot.entities).update(id, &body);
-                }
                 Ok(())
             }
             cb::SET_HEALTH => {
@@ -925,16 +694,6 @@ fn read(
                 }
                 _ => Ok(()),
             },
-            cb::MOVE_ENTITY_POS
-            | cb::MOVE_ENTITY_POS_ROT
-            | cb::ENTITY_POSITION_SYNC
-            | cb::SET_ENTITY_DATA
-            | cb::REMOVE_ENTITIES
-                if track =>
-            {
-                lock(&bot.entities).update(id, &body);
-                Ok(())
-            }
             cb::DISCONNECT | cb::START_CONFIGURATION => {
                 bot.online.store(false, Ordering::SeqCst);
                 *lock(&bot.error) = Some(if id == cb::DISCONNECT {
@@ -964,7 +723,6 @@ fn run_bot(
     o: Arc<Options>,
     index: usize,
     behaviour: Behaviour,
-    bots: Arc<HashSet<u128>>,
     bot: Arc<Bot>,
     until: Arc<Mutex<Option<Instant>>>,
 ) {
@@ -978,19 +736,12 @@ fn run_bot(
         }
     };
     let (reader, writer) = connection.split();
-    let _ = bot.counters.set(reader.counters.clone());
     let writer = Arc::new(Mutex::new(writer));
-    *lock(&bot.target) = o
-        .attack
-        .iter()
-        .flat_map(|names| names.split(','))
-        .map(|name| (offline_uuid(name), None))
-        .collect();
+    lock(&bot.target).0 = o.attack.as_deref().map(offline_uuid);
     bot.online.store(true, Ordering::SeqCst);
     {
         let (writer, bot) = (writer.clone(), bot.clone());
-        let track = behaviour == Behaviour::Fight;
-        thread::spawn(move || read(reader, writer, bot, track));
+        thread::spawn(move || read(reader, writer, bot));
     }
     use ids::play::serverbound as sb;
     // Wait for the spawn position.
@@ -1041,13 +792,7 @@ fn run_bot(
     let mut sequence = 0;
     let mut random = Random(o.seed ^ (index as u64).wrapping_mul(0x2545_F491_4F6C_DD1D));
     let mut pos = spawn;
-    // Fight bots stay at their spawn height; the others climb to fly above the terrain.
-    let cruise = if behaviour == Behaviour::Fight {
-        spawn[1]
-    } else {
-        spawn[1] + o.height
-    };
-    let mut since_attack = ATTACK_COOLDOWN_TICKS;
+    let cruise = spawn[1] + o.height;
     let heading = random.unit() * std::f64::consts::TAU;
     let mut target = pos;
     let mut next = Instant::now();
@@ -1101,22 +846,22 @@ fn run_bot(
         } else {
             match behaviour {
                 Behaviour::Idle | Behaviour::Stand => {}
-                Behaviour::Walk => walk_step(&mut pos, &mut target, spawn, cruise, &mut random),
-                Behaviour::Fight => {
-                    let near = lock(&bot.entities).nearest(pos, o.pvp, &bots);
-                    if let Some(near) = near {
-                        if let Some(victim) = fight_tick(&mut pos, near, &mut since_attack) {
-                            // The client sends the attack, then swings the arm.
-                            let sent = send(
-                                play::Serverbound::Attack(play::Attack { id: victim }).encode(),
-                            ) && send(raw(sb::PUNCH, |w| w.varint(0)));
-                            if sent {
-                                bot.attacks.fetch_add(1, Ordering::Relaxed);
-                            }
-                        }
+                Behaviour::Walk => {
+                    let (dx, dz) = (target[0] - pos[0], target[2] - pos[2]);
+                    let distance = dx.hypot(dz);
+                    if distance < 1.0 {
+                        let angle = random.unit() * std::f64::consts::TAU;
+                        let reach = 8.0 + random.unit() * 40.0;
+                        target = [
+                            spawn[0] + angle.cos() * reach,
+                            cruise,
+                            spawn[2] + angle.sin() * reach,
+                        ];
                     } else {
-                        since_attack = since_attack.saturating_add(1);
-                        walk_step(&mut pos, &mut target, spawn, cruise, &mut random);
+                        // Sprinting: 5.6 blocks a second.
+                        let step = 0.28_f64.min(distance);
+                        pos[0] += dx / distance * step;
+                        pos[2] += dz / distance * step;
                     }
                 }
                 Behaviour::FloodMove
@@ -1190,11 +935,6 @@ fn run_bot(
                 );
             }
         }
-        for (at, id, body) in &o.raw {
-            if *at == tick {
-                send(raw(*id, |w| w.bytes(body)));
-            }
-        }
         // The costly floods go out wherever the bot is, chunks or not (--no-read gets none).
         for i in 0..o.flood {
             sequence += 1;
@@ -1202,16 +942,13 @@ fn run_bot(
                 send(body);
             }
         }
-        if joined.elapsed().as_secs_f64() >= o.attack_after && tick % 10 == 0 {
-            let targets: Vec<i32> = lock(&bot.target).iter().filter_map(|t| t.1).collect();
-            for id in targets {
-                send(play::Serverbound::Attack(play::Attack { id }).encode());
-                // Minecraft.startAttack swings right after the attack.
-                if !o.no_swing {
-                    send(play::Serverbound::Punch(Empty).encode());
-                }
-                bot.attacks.fetch_add(1, Ordering::Relaxed);
-            }
+        let target = lock(&bot.target).1;
+        if let Some(id) = target
+            && joined.elapsed().as_secs_f64() >= o.attack_after
+            && tick % 10 == 0
+        {
+            send(play::Serverbound::Attack(play::Attack { id }).encode());
+            bot.attacks.fetch_add(1, Ordering::Relaxed);
         }
         tick += 1;
         let ok = send(
@@ -1219,10 +956,7 @@ fn run_bot(
                 x: pos[0],
                 y: pos[1],
                 z: pos[2],
-                // Fight bots stand on the ground; the others fly.
-                flags: u8::from(
-                    matches!(behaviour, Behaviour::Fight | Behaviour::Stand) || o.ground,
-                ),
+                flags: u8::from(behaviour == Behaviour::Stand || o.ground),
             })
             .encode(),
         ) && send(raw(sb::CLIENT_TICK_END, |_| {}));
@@ -1249,7 +983,6 @@ fn behaviour_of(mode: &str, index: usize) -> Behaviour {
         "stand" => Behaviour::Stand,
         "walk" => Behaviour::Walk,
         "explore" => Behaviour::Explore,
-        "fight" => Behaviour::Fight,
         "flood-move" => Behaviour::FloodMove,
         "flood-acks" => Behaviour::FloodAcks,
         "flood-packets" => Behaviour::FloodPackets,
@@ -1280,23 +1013,14 @@ fn main() {
     let start = Instant::now();
     let until: Arc<Mutex<Option<Instant>>> = Arc::new(Mutex::new(None));
     let bots: Vec<Arc<Bot>> = (0..o.bots).map(|_| Arc::new(Bot::default())).collect();
-    // The uuids of all bots, so that `--pvp false` leaves them alone.
-    let bot_uuids: Arc<HashSet<u128>> = Arc::new(
-        (0..o.bots)
-            .map(|i| offline_uuid(&format!("{}{i}", o.name)))
-            .collect(),
-    );
     let launcher = {
         let (o, bots, until) = (o.clone(), bots.clone(), until.clone());
-        let bot_uuids = bot_uuids.clone();
         thread::spawn(move || {
             let mut handles = Vec::new();
             for (i, bot) in bots.iter().enumerate() {
                 let (o2, bot, until) = (o.clone(), bot.clone(), until.clone());
-                let (behaviour, uuids) = (behaviour_of(&o.behaviour, i), bot_uuids.clone());
-                handles.push(thread::spawn(move || {
-                    run_bot(o2, i, behaviour, uuids, bot, until);
-                }));
+                let behaviour = behaviour_of(&o.behaviour, i);
+                handles.push(thread::spawn(move || run_bot(o2, i, behaviour, bot, until)));
                 thread::sleep(Duration::from_secs_f64(o.join_every));
             }
             handles
@@ -1333,7 +1057,6 @@ fn main() {
                 "resent": total(|b| &b.resent),
                 "pulled_back": total(|b| &b.pulled_back),
                 "waited_ticks": total(|b| &b.waited),
-                "attacks": total(|b| &b.attacks),
             })
         );
         previous_chunks = chunks;
@@ -1353,7 +1076,6 @@ fn main() {
         "behaviour": o.behaviour,
         "seed": o.seed,
         "explore_speed": o.explore_speed,
-        "pvp": o.pvp,
         "view_distance": o.view_distance,
         "seconds": o.seconds,
         "joined": bots.iter().filter(|b| b.joined_after_ms.load(Ordering::SeqCst) > 0).count(),
@@ -1361,21 +1083,10 @@ fn main() {
         "resent": bots.iter().map(|b| b.resent.load(Ordering::Relaxed)).sum::<u64>(),
         "pulled_back": bots.iter().map(|b| b.pulled_back.load(Ordering::Relaxed)).sum::<u64>(),
         "waited_ticks": bots.iter().map(|b| b.waited.load(Ordering::Relaxed)).sum::<u64>(),
-        "attacks": bots.iter().map(|b| b.attacks.load(Ordering::Relaxed)).sum::<u64>(),
-        "bytes_in": bots.iter().map(|b| b.bytes_in()).sum::<u64>(),
-        "bytes_out": bots.iter().map(|b| b.bytes_out()).sum::<u64>(),
-        "join_time": join_summary(
-            bots.iter()
-                .map(|b| b.joined_after_ms.load(Ordering::SeqCst))
-                .filter(|&ms| ms > 0)
-                .collect(),
-        ),
         "per_bot": bots.iter().enumerate().map(|(i, b)| json!({
             "name": format!("{}{i}", o.name),
             "behaviour": behaviour_of(&o.behaviour, i).name(),
             "joined_after_ms": b.joined_after_ms.load(Ordering::SeqCst),
-            "bytes_in": b.bytes_in(),
-            "bytes_out": b.bytes_out(),
             "chunks": b.chunks.load(Ordering::Relaxed),
             "unique_chunks": b.unique.load(Ordering::Relaxed),
             "resent": b.resent.load(Ordering::Relaxed),
@@ -1410,156 +1121,3 @@ fn main() {
     }
     std::process::exit(if errors.is_empty() { 0 } else { 1 });
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use play::{
-        AddEntity, Clientbound, MoveEntity, MoveEntityPos, RemoveEntities, SetEntityData, VecDelta,
-    };
-
-    fn feed(entities: &mut Entities, packet: &Clientbound) {
-        let bytes = packet.encode();
-        let mut r = Reader::new(&bytes);
-        let id = r.varint().unwrap();
-        entities.update(id, &bytes[bytes.len() - r.remaining()..]);
-    }
-
-    fn add(id: i32, uuid: u128, pos: [f64; 3]) -> Clientbound {
-        Clientbound::AddEntity(AddEntity {
-            id,
-            uuid,
-            kind: 1,
-            position: pos,
-            velocity: [0.0; 3],
-            pitch: 0,
-            yaw: 0,
-            head_yaw: 0,
-            data: 0,
-        })
-    }
-
-    fn health(id: i32, health: f32) -> Clientbound {
-        Clientbound::SetEntityData(SetEntityData {
-            id,
-            values: vec![(HEALTH_DATA, 3, entity_data::Value::Float(health))],
-        })
-    }
-
-    #[test]
-    fn tracks_living_entities_only() {
-        let mut e = Entities::default();
-        feed(&mut e, &add(1, 10, [3.0, 64.0, 0.0]));
-        feed(&mut e, &add(2, 11, [5.0, 64.0, 0.0]));
-        feed(&mut e, &health(2, 20.0));
-        // Entity 1 never sent a health (an item, an arrow), so it is no target.
-        assert_eq!(
-            e.nearest([0.0, 64.0, 0.0], true, &HashSet::new()),
-            Some((2, [5.0, 64.0, 0.0]))
-        );
-        feed(&mut e, &health(2, 0.0));
-        assert_eq!(e.nearest([0.0, 64.0, 0.0], true, &HashSet::new()), None);
-        feed(&mut e, &health(2, 4.0));
-        feed(
-            &mut e,
-            &Clientbound::RemoveEntities(RemoveEntities { ids: vec![2] }),
-        );
-        assert_eq!(e.nearest([0.0, 64.0, 0.0], true, &HashSet::new()), None);
-    }
-
-    #[test]
-    fn moves_follow_the_deltas() {
-        let mut e = Entities::default();
-        feed(&mut e, &add(7, 1, [0.0, 64.0, 0.0]));
-        feed(&mut e, &health(7, 20.0));
-        feed(
-            &mut e,
-            &Clientbound::MoveEntityPos(MoveEntityPos(MoveEntity {
-                id: 7,
-                delta: Some(VecDelta::Linear([4096, 0, -8192])),
-                rotation: None,
-                on_ground: true,
-            })),
-        );
-        assert_eq!(e.0[&7].pos, [1.0, 64.0, -2.0]);
-    }
-
-    #[test]
-    fn pvp_false_spares_the_bots_and_ties_go_to_the_lowest_id() {
-        let mut e = Entities::default();
-        feed(&mut e, &add(9, 100, [2.0, 64.0, 0.0]));
-        feed(&mut e, &add(4, 101, [-2.0, 64.0, 0.0]));
-        feed(&mut e, &add(5, 102, [0.0, 64.0, 6.0]));
-        for id in [9, 4, 5] {
-            feed(&mut e, &health(id, 20.0));
-        }
-        let bots = HashSet::from([100, 101]);
-        let from = [0.0, 64.0, 0.0];
-        assert_eq!(e.nearest(from, true, &bots).map(|t| t.0), Some(4));
-        assert_eq!(e.nearest(from, false, &bots).map(|t| t.0), Some(5));
-    }
-
-    #[test]
-    fn attacks_at_the_vanilla_cooldown() {
-        let mut pos = [0.0, 64.0, 0.0];
-        let target = (3, [1.0, 64.0, 0.0]);
-        let mut since = ATTACK_COOLDOWN_TICKS;
-        let hits: Vec<u32> = (0..40)
-            .filter_map(|tick| fight_tick(&mut pos, target, &mut since).map(|_| tick))
-            .collect();
-        assert_eq!(hits[0], 0, "a bot in reach strikes at once");
-        assert!(
-            hits.windows(2)
-                .all(|w| w[1] - w[0] == ATTACK_COOLDOWN_TICKS)
-        );
-        assert_eq!(hits.len(), 8);
-    }
-
-    #[test]
-    fn walks_into_reach_before_striking() {
-        let mut pos = [0.0, 64.0, 0.0];
-        let target = (3, [10.0, 64.0, 0.0]);
-        let mut since = ATTACK_COOLDOWN_TICKS;
-        let mut first = None;
-        for tick in 0..100 {
-            if fight_tick(&mut pos, target, &mut since).is_some() {
-                first = Some(tick);
-                break;
-            }
-        }
-        assert!(first.is_some_and(|t| t > 30));
-        assert!((target.1[0] - pos[0]).abs() <= ATTACK_REACH);
-        assert!(pos[0] < 10.0 - CLOSE_IN + 1e-9);
-    }
-
-    #[test]
-    fn percentiles_use_nearest_rank() {
-        assert_eq!(percentile(&[], 50), 0);
-        assert_eq!(percentile(&[7], 99), 7);
-        let v: Vec<u64> = (1..=100).collect();
-        assert_eq!(percentile(&v, 50), 50);
-        assert_eq!(percentile(&v, 99), 99);
-        assert_eq!(percentile(&[10, 20, 30, 40], 50), 20);
-    }
-
-    #[test]
-    fn join_summary_sorts_and_reports_max() {
-        let s = join_summary(vec![300, 100, 200]);
-        assert_eq!(s["count"], 3);
-        assert_eq!(s["p50_ms"], 200);
-        assert_eq!(s["p99_ms"], 300);
-        assert_eq!(s["max_ms"], 300);
-        assert_eq!(join_summary(vec![])["count"], 0);
-    }
-
-    #[test]
-    fn bot_bytes_come_from_the_connection_counters() {
-        let bot = Bot::default();
-        assert_eq!((bot.bytes_in(), bot.bytes_out()), (0, 0));
-        let counters = Arc::new(Counters::default());
-        counters.bytes_in.store(1234, Ordering::Relaxed);
-        counters.bytes_out.store(56, Ordering::Relaxed);
-        let _ = bot.counters.set(counters);
-        assert_eq!((bot.bytes_in(), bot.bytes_out()), (1234, 56));
-    }
-}

crates/horizon-chat-filter/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "horizon-chat-filter"
-version = "0.1.0"
-edition.workspace = true
-license.workspace = true
-rust-version = "1.88"
-description = "The dedicated server's chat filter: its [chat_filter] settings, the slur list's matcher and the mutes, with no game state (docs/chat-filter.md)"
-
-[dependencies]
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-toml = "1.1"
-
-[lints]
-workspace = true

crates/horizon-chat-filter/data/slurs.txt

@@ -1,63 +0,0 @@
-# Horizon's chat filter: the hate slurs a server refuses in chat, private messages, /say, /me, team
-# messages, signs, anvil names and book titles (docs/chat-filter.md). This is a moderation list: the
-# words are written here only so the filter can recognise them, because players spammed them on the
-# official server (2026-10-31). Add a word when players find a way around the list; keep insults that
-# aren't slurs out of it (moderators handle those).
-#
-# One entry a line, matched after normalising the text: lower case, accents and look-alike letters
-# (Cyrillic, Greek, full-width, small capitals...), leetspeak (1 i, 3 e, 4 a, 0 o, @ a, $ s, 9 g),
-# separators between letters (n.i.g, n_i_g) and repeated letters. A doubled letter in an entry must be
-# doubled in the text: "niger", the river and the country, isn't "nigger".
-#   word    matches inside a longer word too
-#   =word   only as a whole word ("spic", not "suspicious")
-#   ~word   also when it's spread over several words ("nig ger", "n i g g e r")
-#   !word   never a match: a word that contains an entry ("snigger"); !word* any word starting so
-
-~nigger
-~nigga
-nigguh
-niggah
-niqqa
-niqqer
-nlgger
-nlgga
-kneegrow
-=nig
-=nigs
-=niglet
-=niglets
-=nibba
-=nibbas
-=nibber
-=nibbers
-jigaboo
-porchmonkey
-=coon
-=coons
-~faggot
-=fag
-=fags
-=faggy
-=fagot
-=fagots
-=tranny
-=trannies
-=kike
-=kikes
-=chink
-=chinks
-=gook
-=gooks
-=spic
-=spics
-wetback
-=beaner
-=beaners
-raghead
-towelhead
-zipperhead
-=paki
-=pakis
-
-!snigger*
-!niggard*

crates/horizon-chat-filter/src/lib.rs

@@ -1,472 +0,0 @@
-//! The dedicated server's chat filter (docs/chat-filter.md), without the game: `server.toml`'s
-//! `[chat_filter]`, the matcher for the slur list (`data/slurs.txt`, or the owner's `words_file`), and
-//! the escalation (a refused message, then a mute, then a temporary ban), with the mutes kept in a file
-//! so that they outlive a restart. The server's hub (`horizon_client::lan`) asks it before it relays a
-//! player's text and carries out what it decides.
-
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-
-mod normalise;
-
-pub use normalise::{Run, Text};
-
-/// The list built into the game, used when `words_file` is empty.
-pub const DEFAULT_WORDS: &str = include_str!("../data/slurs.txt");
-
-/// The mutes, beside server.properties.
-pub const MUTES_FILE: &str = "chat-filter-mutes.json";
-
-/// `server.toml`'s `[chat_filter]`: on by default.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct Config {
-    pub enabled: bool,
-    /// The hit, counted within `window_minutes`, that mutes the player; 0: never.
-    pub mute_after: u32,
-    /// The hit that bans the player for `tempban_hours`; 0: never.
-    pub tempban_after: u32,
-    /// How long a hit counts towards the next ones (the time spent muted doesn't count).
-    pub window_minutes: u32,
-    pub mute_minutes: u32,
-    pub tempban_hours: u32,
-    /// The slur list, relative to the server's folder; empty: the list built into the game.
-    pub words_file: String,
-    /// Every refused text with the player and what followed, relative to the server's folder.
-    pub log: String,
-}
-
-impl Default for Config {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            mute_after: 2,
-            tempban_after: 3,
-            window_minutes: 10,
-            mute_minutes: 10,
-            tempban_hours: 24,
-            words_file: String::new(),
-            log: "logs/chat-filter.log".into(),
-        }
-    }
-}
-
-impl Config {
-    /// The `[chat_filter]` section of a whole `server.toml`; the default without it.
-    pub fn from_server_toml(text: &str) -> Result<Self, String> {
-        #[derive(Deserialize)]
-        struct File {
-            #[serde(default)]
-            chat_filter: Config,
-        }
-        // Other sections are the supervisor's to check: only this one is read here.
-        let mut table: toml::Table = toml::from_str(text).map_err(|e| e.to_string())?;
-        let mut only = toml::Table::new();
-        if let Some(section) = table.remove("chat_filter") {
-            only.insert("chat_filter".into(), section);
-        }
-        let file: File = only
-            .try_into()
-            .map_err(|e: toml::de::Error| format!("[chat_filter]: {e}"))?;
-        file.chat_filter.check()?;
-        Ok(file.chat_filter)
-    }
-
-    pub fn check(&self) -> Result<(), String> {
-        if self.window_minutes == 0 {
-            return Err("chat_filter.window_minutes must be 1 or more".into());
-        }
-        Ok(())
-    }
-}
-
-/// How an entry of the list matches.
-#[derive(Clone, Copy, Debug, PartialEq)]
-enum Kind {
-    /// Inside a longer word too.
-    Embedded,
-    /// Only as a whole word.
-    Whole,
-    /// Inside a word, or spread over several words from the start of one.
-    Spread,
-}
-
-#[derive(Debug)]
-struct Entry {
-    runs: Vec<Run>,
-    kind: Kind,
-}
-
-/// The slur list, compiled: each entry's letters as runs, indexed by first letter.
-#[derive(Debug)]
-pub struct Filter {
-    entries: Vec<Entry>,
-    by_first: [Vec<u16>; 27],
-    /// Words never matched: exact (`false`) or as a prefix (`true`).
-    allowed: Vec<(Vec<Run>, bool)>,
-}
-
-impl Filter {
-    /// Compiles a list in `data/slurs.txt`'s format.
-    pub fn new(list: &str) -> Self {
-        let mut f = Filter {
-            entries: Vec::new(),
-            by_first: Default::default(),
-            allowed: Vec::new(),
-        };
-        for line in list.lines() {
-            let line = line.trim();
-            if line.is_empty() || line.starts_with('#') {
-                continue;
-            }
-            if let Some(word) = line.strip_prefix('!') {
-                let (word, prefix) = match word.strip_suffix('*') {
-                    Some(w) => (w, true),
-                    None => (word, false),
-                };
-                f.allowed.push((normalise::word(word), prefix));
-                continue;
-            }
-            let (kind, word) = match line.as_bytes()[0] {
-                b'=' => (Kind::Whole, &line[1..]),
-                b'~' => (Kind::Spread, &line[1..]),
-                _ => (Kind::Embedded, line),
-            };
-            let runs = normalise::word(word);
-            let Some(first) = runs.first() else {
-                continue;
-            };
-            f.by_first[usize::from(first.letter)].push(f.entries.len() as u16);
-            f.entries.push(Entry { runs, kind });
-        }
-        f
-    }
-
-    /// The built-in list.
-    pub fn default_list() -> Self {
-        Self::new(DEFAULT_WORDS)
-    }
-
-    pub fn len(&self) -> usize {
-        self.entries.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.entries.is_empty()
-    }
-
-    /// Whether `text` holds a slur of the list.
-    pub fn matches(&self, text: &str) -> bool {
-        let t = Text::new(text);
-        let runs = &t.runs;
-        for &(start, end) in t.words.iter().chain(&t.spaced) {
-            let word = &runs[start..end];
-            if self.is_allowed(word) {
-                continue;
-            }
-            for at in 0..word.len() {
-                for &e in &self.by_first[usize::from(word[at].letter)] {
-                    let e = &self.entries[usize::from(e)];
-                    let whole = e.kind == Kind::Whole;
-                    if (!whole || at == 0) && fits(&e.runs, &word[at..], whole) {
-                        return true;
-                    }
-                }
-            }
-        }
-        // Spread entries over the whole text, from the start of a word, across at least two.
-        for (w, &at) in t.joined_at.iter().enumerate() {
-            for &e in &self.by_first[usize::from(t.joined[at].letter)] {
-                let e = &self.entries[usize::from(e)];
-                if e.kind == Kind::Spread
-                    && fits(&e.runs, &t.joined[at..], false)
-                    && t.spans_words(w, e.runs.len())
-                {
-                    return true;
-                }
-            }
-        }
-        false
-    }
-
-    fn is_allowed(&self, word: &[Run]) -> bool {
-        self.allowed.iter().any(|(a, prefix)| {
-            if *prefix {
-                // A prefix: its last run may be part of a longer one.
-                word.len() >= a.len() && fits(a, word, false)
-            } else {
-                fits(a, word, true)
-            }
-        })
-    }
-}
-
-/// Whether `entry`'s runs start `runs` (are all of it with `whole`): the same letters, each at least
-/// as many times as the entry has it.
-fn fits(entry: &[Run], runs: &[Run], whole: bool) -> bool {
-    if runs.len() < entry.len() || (whole && runs.len() != entry.len()) {
-        return false;
-    }
-    entry
-        .iter()
-        .zip(runs)
-        .all(|(e, r)| e.letter == r.letter && r.count >= e.count)
-}
-
-/// What a hit leads to.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Action {
-    /// The text is refused, nothing more.
-    Refused,
-    /// Refused, and the player can't chat until then (epoch milliseconds).
-    Muted { until: i64 },
-    /// Refused, and the player is banned until then.
-    Banned { until: i64 },
-}
-
-impl Action {
-    pub fn name(self) -> &'static str {
-        match self {
-            Action::Refused => "refused",
-            Action::Muted { .. } => "muted",
-            Action::Banned { .. } => "banned",
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Mute {
-    pub uuid: String,
-    pub name: String,
-    /// Epoch milliseconds.
-    pub until: i64,
-}
-
-#[derive(Default, Serialize, Deserialize)]
-struct MutesFile {
-    mutes: Vec<Mute>,
-}
-
-/// One player's hits: how many, and when the last one stops counting.
-#[derive(Clone, Copy, Debug)]
-struct Strikes {
-    count: u32,
-    counts_until: i64,
-}
-
-/// The filter, the players' hits and the mutes.
-pub struct Guard {
-    pub config: Config,
-    pub filter: Filter,
-    strikes: HashMap<u128, Strikes>,
-    mutes: HashMap<u128, Mute>,
-    /// Where the mutes are kept; `None` keeps them in memory only (tests).
-    file: Option<PathBuf>,
-}
-
-const MINUTE: i64 = 60_000;
-
-impl Guard {
-    pub fn new(config: Config, filter: Filter, file: Option<PathBuf>) -> Self {
-        let mut mutes = HashMap::new();
-        if let Some(text) = file.as_ref().and_then(|f| std::fs::read_to_string(f).ok())
-            && let Ok(saved) = serde_json::from_str::<MutesFile>(&text)
-        {
-            for m in saved.mutes {
-                if let Some(uuid) = parse_uuid(&m.uuid) {
-                    mutes.insert(uuid, m);
-                }
-            }
-        }
-        Self {
-            config,
-            filter,
-            strikes: HashMap::new(),
-            mutes,
-            file,
-        }
-    }
-
-    /// The server's guard: `words_file` or the built-in list, the mutes in `dir`. An unreadable
-    /// `words_file` falls back to the built-in list, with why.
-    pub fn load(config: Config, dir: &Path) -> (Self, Option<String>) {
-        let mut problem = None;
-        let filter = if config.words_file.is_empty() {
-            Filter::default_list()
-        } else {
-            match std::fs::read_to_string(dir.join(&config.words_file)) {
-                Ok(text) => Filter::new(&text),
-                Err(e) => {
-                    problem = Some(format!(
-                        "chat_filter.words_file {}: {e}; using the built-in list",
-                        config.words_file
-                    ));
-                    Filter::default_list()
-                }
-            }
-        };
-        (
-            Self::new(config, filter, Some(dir.join(MUTES_FILE))),
-            problem,
-        )
-    }
-
-    /// When the player's mute ends, if they are muted at `now`.
-    pub fn muted_until(&self, uuid: u128, now: i64) -> Option<i64> {
-        self.mutes
-            .get(&uuid)
-            .map(|m| m.until)
-            .filter(|&until| until > now)
-    }
-
-    /// A hit by the player at `now`: the hit's number in the window, and what it leads to.
-    pub fn strike(&mut self, uuid: u128, name: &str, now: i64) -> (u32, Action) {
-        let c = &self.config;
-        let window = i64::from(c.window_minutes) * MINUTE;
-        let s = self.strikes.entry(uuid).or_insert(Strikes {
-            count: 0,
-            counts_until: 0,
-        });
-        if now > s.counts_until {
-            s.count = 0;
-        }
-        s.count += 1;
-        s.counts_until = now + window;
-        let count = s.count;
-        let action = if c.tempban_after > 0 && count >= c.tempban_after {
-            self.strikes.remove(&uuid);
-            Action::Banned {
-                until: now + i64::from(c.tempban_hours) * 60 * MINUTE,
-            }
-        } else if c.mute_after > 0 && count >= c.mute_after {
-            let until = now + i64::from(c.mute_minutes) * MINUTE;
-            // The window starts again when the mute ends.
-            s.counts_until = until + window;
-            self.mutes.insert(
-                uuid,
-                Mute {
-                    uuid: uuid_string(uuid),
-                    name: name.to_owned(),
-                    until,
-                },
-            );
-            self.save();
-            Action::Muted { until }
-        } else {
-            Action::Refused
-        };
-        (count, action)
-    }
-
-    /// Lifts a player's mute (and forgets their hits), by name; the name as muted, if they were.
-    pub fn unmute(&mut self, name: &str) -> Option<String> {
-        let uuid = *self
-            .mutes
-            .iter()
-            .find(|(_, m)| m.name.eq_ignore_ascii_case(name))?
-            .0;
-        let mute = self.mutes.remove(&uuid)?;
-        self.strikes.remove(&uuid);
-        self.save();
-        Some(mute.name)
-    }
-
-    fn save(&mut self) {
-        let Some(file) = &self.file else {
-            return;
-        };
-        let now = now_millis();
-        self.mutes.retain(|_, m| m.until > now);
-        let mut mutes: Vec<Mute> = self.mutes.values().cloned().collect();
-        mutes.sort_by(|a, b| a.name.cmp(&b.name));
-        if let Ok(text) = serde_json::to_string_pretty(&MutesFile { mutes }) {
-            let tmp = file.with_extension("json.tmp");
-            if std::fs::write(&tmp, text).is_ok() {
-                let _ = std::fs::rename(&tmp, file);
-            }
-        }
-    }
-}
-
-/// One line of `logs/chat-filter.log`, without its newline.
-pub fn log_line(
-    now: i64,
-    name: &str,
-    uuid: u128,
-    place: &str,
-    count: u32,
-    action: Action,
-    text: &str,
-) -> String {
-    let text: String = text
-        .chars()
-        .map(|c| if c == '\n' { ' ' } else { c })
-        .collect();
-    format!(
-        "{} {name} {} {place} hit {count} {}: {text}",
-        utc(now),
-        uuid_string(uuid),
-        action.name()
-    )
-}
-
-/// Appends a line to the log at `path` (its folder made if needed).
-pub fn append_log(path: &Path, line: &str) -> std::io::Result<()> {
-    use std::io::Write;
-    if let Some(dir) = path.parent() {
-        std::fs::create_dir_all(dir)?;
-    }
-    let mut f = std::fs::OpenOptions::new()
-        .create(true)
-        .append(true)
-        .open(path)?;
-    writeln!(f, "{line}")
-}
-
-pub fn now_millis() -> i64 {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .map_or(0, |d| d.as_millis() as i64)
-}
-
-/// `YYYY-MM-DDTHH:MM:SSZ` for epoch milliseconds.
-pub fn utc(millis: i64) -> String {
-    let secs = millis.div_euclid(1000);
-    let (days, rest) = (secs.div_euclid(86_400), secs.rem_euclid(86_400));
-    // Howard Hinnant's civil_from_days.
-    let z = days + 719_468;
-    let era = z.div_euclid(146_097);
-    let doe = z.rem_euclid(146_097);
-    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
-    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
-    let mp = (5 * doy + 2) / 153;
-    let day = doy - (153 * mp + 2) / 5 + 1;
-    let month = if mp < 10 { mp + 3 } else { mp - 9 };
-    let year = yoe + era * 400 + i64::from(month <= 2);
-    format!(
-        "{year:04}-{month:02}-{day:02}T{:02}:{:02}:{:02}Z",
-        rest / 3600,
-        rest / 60 % 60,
-        rest % 60
-    )
-}
-
-fn uuid_string(u: u128) -> String {
-    let h = format!("{u:032x}");
-    format!(
-        "{}-{}-{}-{}-{}",
-        &h[..8],
-        &h[8..12],
-        &h[12..16],
-        &h[16..20],
-        &h[20..]
-    )
-}
-
-fn parse_uuid(s: &str) -> Option<u128> {
-    u128::from_str_radix(&s.replace('-', ""), 16).ok()
-}
-
-#[cfg(test)]
-mod tests;

crates/horizon-chat-filter/src/normalise.rs

@@ -1,255 +0,0 @@
-//! A text as the filter sees it: words of letters `a`..`z`, each letter with how many times it repeats.
-//! Case, accents, look-alike letters (Cyrillic, Greek, full-width, small capitals, styled mathematical
-//! letters, circled and squared letters), leetspeak and invisible characters are folded away;
-//! separators inside a word are dropped (`n.i.g` is `nig`), and whitespace ends a word.
-
-/// The letter code of anything that is a letter but none of `a`..`z`: it never matches.
-const OTHER: u8 = 26;
-
-/// One letter and how many times it repeats (`gg` is `g` twice).
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Run {
-    /// 0..=25 for `a`..`z`, 26 for any other letter.
-    pub letter: u8,
-    pub count: u8,
-    /// Every one of its characters was punctuation read as a letter (`!` as `i`, `@` as `a`).
-    pub weak: bool,
-}
-
-/// A whole message, normalised.
-#[derive(Debug, Default)]
-pub struct Text {
-    pub runs: Vec<Run>,
-    /// Each word's runs, `runs[start..end]`.
-    pub words: Vec<(usize, usize)>,
-    /// More ranges of `runs` to match as words: letters spaced out (`n i g g a`), joined, and words
-    /// without the punctuation they end with (`fag!`).
-    pub spaced: Vec<(usize, usize)>,
-    /// Every word one after the other, a letter that ends one and starts the next merged.
-    pub joined: Vec<Run>,
-    /// Where each word starts in `joined`.
-    pub joined_at: Vec<usize>,
-    /// The last word each run of `joined` belongs to.
-    joined_last: Vec<usize>,
-}
-
-enum Fold {
-    Letter(u8, bool),
-    Separator,
-    Space,
-    Skip,
-}
-
-impl Text {
-    pub fn new(text: &str) -> Self {
-        let mut t = Text::default();
-        let mut start = 0;
-        for c in text.chars() {
-            match fold(c) {
-                Fold::Letter(letter, weak) => {
-                    let in_word = t.runs.len() > start;
-                    match t.runs.last_mut() {
-                        Some(last) if in_word && last.letter == letter => {
-                            last.count = last.count.saturating_add(1);
-                            last.weak &= weak;
-                        }
-                        _ => t.runs.push(Run {
-                            letter,
-                            count: 1,
-                            weak,
-                        }),
-                    }
-                }
-                Fold::Space => {
-                    t.end_word(start);
-                    start = t.runs.len();
-                }
-                Fold::Separator | Fold::Skip => {}
-            }
-        }
-        t.end_word(start);
-        t.add_spaced();
-        t.join();
-        t
-    }
-
-    fn end_word(&mut self, start: usize) {
-        if self.runs.len() > start {
-            self.words.push((start, self.runs.len()));
-        }
-    }
-
-    /// Spaced-out letters and words without their trailing punctuation, as extra words (their runs
-    /// copied after the real words').
-    fn add_spaced(&mut self) {
-        let words = self.words.len();
-        let mut w = 0;
-        while w < words {
-            let mut end = w;
-            while end < words && self.words[end].1 - self.words[end].0 == 1 {
-                end += 1;
-            }
-            if end - w >= 2 {
-                let first = self.runs.len();
-                for k in w..end {
-                    let run = self.runs[self.words[k].0];
-                    let in_word = self.runs.len() > first;
-                    match self.runs.last_mut() {
-                        Some(last) if in_word && last.letter == run.letter => {
-                            last.count = last.count.saturating_add(run.count);
-                        }
-                        _ => self.runs.push(run),
-                    }
-                }
-                self.spaced.push((first, self.runs.len()));
-                w = end;
-            } else {
-                w += 1;
-            }
-        }
-        for k in 0..words {
-            let (start, mut end) = self.words[k];
-            while end > start + 1 && self.runs[end - 1].weak {
-                end -= 1;
-            }
-            if end < self.words[k].1 {
-                self.spaced.push((start, end));
-            }
-        }
-    }
-
-    fn join(&mut self) {
-        for (w, &(start, end)) in self.words.iter().enumerate() {
-            let mut first = true;
-            for run in &self.runs[start..end] {
-                match self.joined.last_mut() {
-                    Some(last) if first && last.letter == run.letter => {
-                        last.count = last.count.saturating_add(run.count);
-                        self.joined_at.push(self.joined.len() - 1);
-                        *self.joined_last.last_mut().expect("beside joined") = w;
-                    }
-                    _ => {
-                        if first {
-                            self.joined_at.push(self.joined.len());
-                        }
-                        self.joined.push(*run);
-                        self.joined_last.push(w);
-                    }
-                }
-                first = false;
-            }
-        }
-    }
-
-    /// Whether `len` runs of `joined` from word `w`'s start reach into a later word.
-    pub fn spans_words(&self, w: usize, len: usize) -> bool {
-        self.joined_last
-            .get(self.joined_at[w] + len - 1)
-            .is_some_and(|&last| last > w)
-    }
-}
-
-/// An entry of the list, normalised the same way (one word, whitespace ignored).
-pub fn word(text: &str) -> Vec<Run> {
-    let t = Text::new(&text.replace(char::is_whitespace, ""));
-    t.words
-        .first()
-        .map_or_else(Vec::new, |&(s, e)| t.runs[s..e].to_vec())
-}
-
-fn letter(c: char) -> Fold {
-    Fold::Letter(c as u8 - b'a', false)
-}
-
-fn fold(c: char) -> Fold {
-    if c.is_ascii_alphabetic() {
-        return letter(c.to_ascii_lowercase());
-    }
-    if c.is_ascii() {
-        return match c {
-            '0' => letter('o'),
-            '1' => letter('i'),
-            '3' => letter('e'),
-            '4' => letter('a'),
-            '5' => letter('s'),
-            '6' | '9' => letter('g'),
-            '7' => letter('t'),
-            '8' => letter('b'),
-            '!' | '|' => Fold::Letter(b'i' - b'a', true),
-            '@' => Fold::Letter(0, true),
-            '$' => Fold::Letter(b's' - b'a', true),
-            c if c.is_ascii_whitespace() => Fold::Space,
-            _ => Fold::Separator,
-        };
-    }
-    let u = c as u32;
-    let from = |base: u32, span: u32| char::from(b'a' + ((u - base) % span) as u8);
-    let mapped = match u {
-        // Zero-width characters, soft hyphen, combining marks, variation selectors.
-        0xAD | 0x34F | 0x200B..=0x200F | 0x2060..=0x2064 | 0xFEFF | 0x180E => return Fold::Skip,
-        0x300..=0x36F
-        | 0x1AB0..=0x1AFF
-        | 0x1DC0..=0x1DFF
-        | 0x20D0..=0x20FF
-        | 0xFE00..=0xFE0F
-        | 0xFE20..=0xFE2F
-        | 0xE0100..=0xE01EF => return Fold::Skip,
-        // Full-width Latin and digits.
-        0xFF21..=0xFF3A => from(0xFF21, 26),
-        0xFF41..=0xFF5A => from(0xFF41, 26),
-        0xFF10..=0xFF19 => return fold(char::from(b'0' + (u - 0xFF10) as u8)),
-        // Mathematical alphanumerics: 52 letters a style, then digits.
-        0x1D400..=0x1D6A3 => from(0x1D400, 26),
-        0x1D7CE..=0x1D7FF => return fold(char::from(b'0' + ((u - 0x1D7CE) % 10) as u8)),
-        // Circled, parenthesised, squared and negative letters, regional indicators.
-        0x24B6..=0x24CF => from(0x24B6, 26),
-        0x24D0..=0x24E9 => from(0x24D0, 26),
-        0x249C..=0x24B5 => from(0x249C, 26),
-        0x1F130..=0x1F149 => from(0x1F130, 26),
-        0x1F150..=0x1F169 => from(0x1F150, 26),
-        0x1F170..=0x1F189 => from(0x1F170, 26),
-        0x1F1E6..=0x1F1FF => from(0x1F1E6, 26),
-        _ => {
-            if c.is_whitespace() {
-                return Fold::Space;
-            }
-            let lower = c.to_lowercase().next().unwrap_or(c);
-            match LOOK_ALIKES.iter().find(|(_, chars)| chars.contains(lower)) {
-                Some((base, _)) => *base,
-                None if c.is_alphabetic() => return Fold::Letter(OTHER, false),
-                None => return Fold::Separator,
-            }
-        }
-    };
-    letter(mapped)
-}
-
-/// Letters with accents and letters that look like a Latin one, by the letter they read as (lower case).
-const LOOK_ALIKES: &[(char, &str)] = &[
-    ('a', "àáâãäåāăąǎǟǡǻȁȃȧạảấầẩẫậắằẳẵặⱥɐаαᴀᵃª"),
-    ('b', "ƀɓḃḅḇвьъβʙᵇ"),
-    ('c', "çćĉċčƈḉȼсϲᴄᶜ"),
-    ('d', "ďđɗḋḍḏḑḓԁδᴅᵈ"),
-    ('e', "èéêëēĕėęěȅȇȩẹẻẽếềểễệḕḗḙḛḝɇеёєεᴇᵉ€"),
-    ('f', "ƒḟꜰᶠ"),
-    ('g', "ĝğġģǥǧǵɠḡɡɢᵍ"),
-    ('h', "ĥħȟḣḥḧḩḫẖнһʜʰ"),
-    ('i', "ìíîïĩīĭįıǐȉȋḭḯỉịіїιɪⁱ¡ӏ"),
-    ('j', "ĵǰјᴊʲ"),
-    ('k', "ķĸǩḱḳḵкκᴋᵏ"),
-    ('l', "ĺļľŀłḷḹḻḽʟˡ"),
-    ('m', "мᴍᵐ"),
-    ('n', "ñńņňʼnŋǹṅṇṉṋиипηπɴⁿ"),
-    ('o', "òóôõöøōŏőơǒǫǭǿȍȏȫȭȯȱọỏốồổỗộớờởỡợоοσᴏᵒº"),
-    ('p', "ṕṗрρᴘᵖ"),
-    ('q', "ԛ"),
-    ('r', "ŕŗřȑȓṙṛṝṟгʀʳ"),
-    ('s', "śŝşšșṡṣṥṧṩѕꜱˢß"),
-    ('t', "ţťŧțṫṭṯṱẗтτᴛᵗ"),
-    ('u', "ùúûüũūŭůűųưǔǖǘǚǜȕȗụủứừửữựυᴜᵘ"),
-    ('v', "νᴠᵛ"),
-    ('w', "ŵẁẃẅẇẉẘԝωᴡʷ"),
-    ('x', "хχˣ"),
-    ('y', "ýÿŷȳẏẙỳỵỷỹуүγʏʸ"),
-    ('z', "źżžƶẑẓẕᴢᶻ"),
-];

crates/horizon-chat-filter/src/tests.rs

@@ -1,253 +0,0 @@
-// The test texts spell the slurs the filter must refuse: that is what they test.
-use super::*;
-
-fn filter() -> Filter {
-    Filter::default_list()
-}
-
-#[test]
-fn the_list_compiles() {
-    let f = filter();
-    assert!(f.len() > 30, "{} entries", f.len());
-    assert_eq!(f.allowed.len(), 2);
-}
-
-#[test]
-fn normalising_catches_the_usual_disguises() {
-    let f = filter();
-    for text in [
-        "nigger",
-        "NIGGER",
-        "shut up nigga",
-        "Niggers",
-        "n1gg3r",
-        "ni99a",
-        "N!GGA",
-        "nigg@",
-        "n.i.g.g.e.r",
-        "n_i_g_g_a",
-        "n i g g e r",
-        "n i gg a",
-        "nig ger",
-        "nig  gaaa",
-        "niiiiggggggerrrrr",
-        "ñíggér",
-        "ｎｉｇｇｅｒ",
-        "Niggeг",         // Cyrillic ghe for r
-        "nіgger",         // Cyrillic i
-        "nigg\u{0435}r",  // Cyrillic e
-        "n\u{200B}igger", // a zero-width space
-        "n\u{0301}igger", // a combining accent
-        "𝐧𝐢𝐠𝐠𝐞𝐫",
-        "ⓝⓘⓖⓖⓐ",
-        "ɴɪɢɢᴀ",
-        "hi nig",
-        "f a g",
-        "fag!",
-        "you $pic",
-        "FAGGOTINO-CHAN",
-        "sandnigger",
-        "lol kike",
-    ] {
-        assert!(f.matches(text), "{text:?} should be refused");
-    }
-}
-
-#[test]
-fn ordinary_words_pass() {
-    let f = filter();
-    for text in [
-        "hello",
-        "Niger",
-        "I live in Niger",
-        "Nigeria and the Niger river",
-        "nigerian food",
-        "proud2benigerian",
-        "don't snigger",
-        "sniggering at that",
-        "a niggardly offer",
-        "knight",
-        "qKnights",
-        "its still night",
-        "anyone able to boot the latest nightly version?",
-        "i hate nighbours",
-        "can someune give mi night vision",
-        "suspicious stew",
-        "spicy food",
-        "a raccoon in a cocoon",
-        "Scunthorpe",
-        "bigger trigger digger",
-        "gg",
-        "gg ez",
-        "mini gg all",
-        "kniga",
-        "shenanigans",
-        "dignity and signing",
-        "Pakistan",
-        "chinking glasses",
-        "the trannys? no: transmission",
-        "1nicerOli",
-        "ask me evernig",
-        "冰淇淋",
-        "привет",
-        "",
-        "!!!",
-    ] {
-        assert!(!f.matches(text), "{text:?} should pass");
-    }
-}
-
-#[test]
-fn a_custom_list_has_the_same_syntax() {
-    let f = Filter::new("# comment\n=bad\n~worse\nmeh\n!mehish*\n");
-    assert!(f.matches("so bad"));
-    assert!(!f.matches("badly"));
-    assert!(f.matches("wor se"));
-    assert!(f.matches("xxmehxx"));
-    assert!(!f.matches("mehishness"));
-    assert!(!f.matches("me h"));
-}
-
-fn guard(config: Config) -> Guard {
-    Guard::new(config, filter(), None)
-}
-
-const NOW: i64 = 1_793_469_939_000;
-const MIN: i64 = 60_000;
-
-#[test]
-fn the_second_hit_mutes_and_the_third_bans() {
-    let mut g = guard(Config::default());
-    let id = 7;
-    assert_eq!(g.strike(id, "Ann", NOW), (1, Action::Refused));
-    assert_eq!(g.muted_until(id, NOW), None);
-    let until = NOW + 3 * MIN + 10 * MIN;
-    assert_eq!(
-        g.strike(id, "Ann", NOW + 3 * MIN),
-        (2, Action::Muted { until })
-    );
-    assert_eq!(g.muted_until(id, NOW + 4 * MIN), Some(until));
-    assert_eq!(g.muted_until(id, until), None);
-    // The time spent muted doesn't count: 8 minutes after the mute ended is still within the window.
-    assert_eq!(
-        g.strike(id, "Ann", until + 8 * MIN),
-        (
-            3,
-            Action::Banned {
-                until: until + 8 * MIN + 24 * 60 * MIN
-            }
-        )
-    );
-    // Then it starts again.
-    assert_eq!(g.strike(id, "Ann", until + 9 * MIN), (1, Action::Refused));
-}
-
-#[test]
-fn hits_far_apart_dont_add_up() {
-    let mut g = guard(Config::default());
-    assert_eq!(g.strike(1, "Bo", NOW), (1, Action::Refused));
-    assert_eq!(g.strike(1, "Bo", NOW + 11 * MIN), (1, Action::Refused));
-    // Players are counted apart.
-    assert_eq!(g.strike(2, "Cy", NOW + 12 * MIN), (1, Action::Refused));
-}
-
-#[test]
-fn thresholds_are_configurable() {
-    let mut g = guard(Config {
-        mute_after: 0,
-        tempban_after: 2,
-        tempban_hours: 1,
-        ..Config::default()
-    });
-    assert_eq!(g.strike(1, "Bo", NOW), (1, Action::Refused));
-    assert_eq!(
-        g.strike(1, "Bo", NOW + MIN),
-        (
-            2,
-            Action::Banned {
-                until: NOW + MIN + 60 * MIN
-            }
-        )
-    );
-    let mut off = guard(Config {
-        mute_after: 0,
-        tempban_after: 0,
-        ..Config::default()
-    });
-    for k in 1..5 {
-        assert_eq!(off.strike(1, "Bo", NOW + k), (k as u32, Action::Refused));
-    }
-}
-
-#[test]
-fn mutes_survive_a_restart_and_unmute_lifts_them() {
-    let dir = std::env::temp_dir().join(format!("chat-filter-test-{}", std::process::id()));
-    std::fs::create_dir_all(&dir).unwrap();
-    let now = now_millis();
-    let (mut g, problem) = Guard::load(Config::default(), &dir);
-    assert_eq!(problem, None);
-    g.strike(5, "Dee", now);
-    let (_, action) = g.strike(5, "Dee", now);
-    assert!(matches!(action, Action::Muted { .. }));
-    let (mut again, _) = Guard::load(Config::default(), &dir);
-    assert!(again.muted_until(5, now).is_some());
-    assert_eq!(again.unmute("dee").as_deref(), Some("Dee"));
-    assert_eq!(again.unmute("dee"), None);
-    assert_eq!(again.muted_until(5, now), None);
-    let (reloaded, _) = Guard::load(Config::default(), &dir);
-    assert_eq!(reloaded.muted_until(5, now), None);
-    std::fs::remove_dir_all(&dir).unwrap();
-}
-
-#[test]
-fn a_missing_words_file_falls_back_to_the_built_in_list() {
-    let config = Config {
-        words_file: "nope.txt".into(),
-        ..Config::default()
-    };
-    let (g, problem) = Guard::load(config, Path::new("/nonexistent-horizon"));
-    assert!(problem.unwrap().contains("nope.txt"));
-    assert!(g.filter.matches("nigger"));
-}
-
-#[test]
-fn the_section_reads_from_server_toml() {
-    let c = Config::from_server_toml("[server]\nport = 25565\n").unwrap();
-    assert_eq!(c, Config::default());
-    assert!(c.enabled);
-    let c = Config::from_server_toml(
-        "[chat_filter]\nenabled = true\nmute_after = 3\ntempban_after = 5\nwords_file = \"slurs.txt\"\n",
-    )
-    .unwrap();
-    assert_eq!((c.mute_after, c.tempban_after), (3, 5));
-    assert_eq!(c.words_file, "slurs.txt");
-    assert!(
-        !Config::from_server_toml("[chat_filter]\nenabled = false\n")
-            .unwrap()
-            .enabled
-    );
-    assert!(Config::from_server_toml("[chat_filter]\nmute = 2\n").is_err());
-    assert!(Config::from_server_toml("[chat_filter]\nwindow_minutes = 0\n").is_err());
-}
-
-#[test]
-fn log_lines_have_the_time_the_player_and_the_text() {
-    assert_eq!(utc(0), "1970-01-01T00:00:00Z");
-    assert_eq!(utc(951_782_400_000), "2000-02-29T00:00:00Z");
-    assert_eq!(
-        log_line(NOW, "Ann", 1, "chat", 2, Action::Muted { until: 0 }, "a\nb"),
-        "2026-10-31T18:05:39Z Ann 00000000-0000-0000-0000-000000000001 chat hit 2 muted: a b"
-    );
-}
-
-#[test]
-fn a_message_costs_little() {
-    // A long message through the whole list stays far below a tick (debug builds included).
-    let f = filter();
-    let text = "the quick brown fox jumps over the lazy dog ".repeat(6);
-    let start = std::time::Instant::now();
-    for _ in 0..1000 {
-        assert!(!f.matches(&text));
-    }
-    assert!(start.elapsed().as_millis() < 2000, "{:?}", start.elapsed());
-}

crates/horizon-client-core/src/component.rs

@@ -186,73 +186,6 @@ impl Parser<'_> {
         Err("unterminated string".into())
     }
 }
-/// `click_event` / `hover_event`, or the pre-datafixer `clickEvent` /
-/// `hoverEvent` names SNBT and older chat JSON still use.
-fn style_event_object<'a>(
-    o: &'a serde_json::Map<String, Value>,
-    modern: &str,
-    legacy: &str,
-) -> Option<&'a serde_json::Map<String, Value>> {
-    o.get(modern)
-        .or_else(|| o.get(legacy))
-        .and_then(Value::as_object)
-}
-
-/// Style flags from JSON bools, or SNBT `1b`/`0b` which parse as numbers.
-fn style_flag(v: Option<&Value>) -> Option<bool> {
-    match v {
-        Some(Value::Bool(b)) => Some(*b),
-        Some(Value::Number(n)) => n.as_i64().map(|i| i != 0),
-        _ => None,
-    }
-}
-
-fn untrusted_http_url(url: &str) -> bool {
-    // ExtraCodecs.UNTRUSTED_URI / Util.parseAndValidateUntrustedUri: http and
-    // https only, scheme case-insensitive.
-    url.split_once(':').is_some_and(|(scheme, _)| {
-        scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
-    })
-}
-
-/// ClickEvent.CODEC plus the legacy `value` field TextComponentHoverAndClickEventFix
-/// renames (`url` / `command` / `page`).
-fn parse_click_event(e: &serde_json::Map<String, Value>) -> Option<crate::text::ClickEvent> {
-    let text = |k: &str| e.get(k).and_then(Value::as_str).map(str::to_owned);
-    let legacy = || text("value");
-    match e.get("action").and_then(Value::as_str) {
-        Some("open_url") => text("url")
-            .or_else(legacy)
-            .filter(|u| untrusted_http_url(u))
-            .map(crate::text::ClickEvent::OpenUrl),
-        Some("change_page") => e
-            .get("page")
-            .and_then(Value::as_i64)
-            .or_else(|| e.get("value").and_then(Value::as_i64))
-            .or_else(|| {
-                e.get("value")
-                    .and_then(Value::as_str)
-                    .and_then(|s| s.parse().ok())
-            })
-            .and_then(|p| i32::try_from(p).ok())
-            .filter(|p| *p >= 1)
-            .map(crate::text::ClickEvent::ChangePage),
-        Some("suggest_command") => text("command")
-            .or_else(legacy)
-            .map(crate::text::ClickEvent::SuggestCommand),
-        Some("run_command") => text("command")
-            .or_else(legacy)
-            .map(crate::text::ClickEvent::RunCommand),
-        Some("copy_to_clipboard") => text("value").map(crate::text::ClickEvent::CopyToClipboard),
-        // ClickEvent.ShowDialog.CODEC: a `minecraft:dialog` registry id or
-        // the dialog itself; the server may send it (isAllowedFromServer).
-        Some("show_dialog") => e.get("dialog").map(|dialog| {
-            crate::text::ClickEvent::ShowDialog(crate::scoreboard::json_to_tag(dialog))
-        }),
-        _ => None,
-    }
-}
-
 /// The style fields of a component object.
 fn object_style(o: &serde_json::Map<String, Value>) -> Style {
     let mut style = Style::default();
@@ -263,27 +196,52 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
         });
     }
     style.shadow_color = o.get("shadow_color").and_then(shadow_color);
-    style.bold = style_flag(o.get("bold"));
-    style.italic = style_flag(o.get("italic"));
-    style.underlined = style_flag(o.get("underlined"));
-    style.strikethrough = style_flag(o.get("strikethrough"));
-    style.obfuscated = style_flag(o.get("obfuscated"));
+    let flag = |k: &str| o.get(k).and_then(Value::as_bool);
+    style.bold = flag("bold");
+    style.italic = flag("italic");
+    style.underlined = flag("underlined");
+    style.strikethrough = flag("strikethrough");
+    style.obfuscated = flag("obfuscated");
     style.font = o.get("font").and_then(crate::text::font_id);
     // ClickEvent.CODEC: the actions a chat line acts on here. A component
     // from a server never opens a file.
-    if let Some(e) = style_event_object(o, "click_event", "clickEvent") {
-        style.click = parse_click_event(e);
+    if let Some(e) = o.get("click_event").and_then(Value::as_object) {
+        let text = |k: &str| e.get(k).and_then(Value::as_str).map(str::to_owned);
+        style.click = match e.get("action").and_then(Value::as_str) {
+            // ClickEvent.OpenUrl.CODEC: ExtraCodecs.UNTRUSTED_URI allows http and
+            // https only, the scheme in any case (Util.parseAndValidateUntrustedUri).
+            Some("open_url") => text("url")
+                .filter(|u| {
+                    u.split_once(':').is_some_and(|(scheme, _)| {
+                        scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
+                    })
+                })
+                .map(crate::text::ClickEvent::OpenUrl),
+            // ClickEvent.ChangePage.CODEC: ExtraCodecs.POSITIVE_INT.
+            Some("change_page") => e
+                .get("page")
+                .and_then(Value::as_i64)
+                .and_then(|p| i32::try_from(p).ok())
+                .filter(|p| *p >= 1)
+                .map(crate::text::ClickEvent::ChangePage),
+            Some("suggest_command") => text("command").map(crate::text::ClickEvent::SuggestCommand),
+            Some("run_command") => text("command").map(crate::text::ClickEvent::RunCommand),
+            Some("copy_to_clipboard") => {
+                text("value").map(crate::text::ClickEvent::CopyToClipboard)
+            }
+            // ClickEvent.ShowDialog.CODEC: a `minecraft:dialog` registry id or
+            // the dialog itself; the server may send it (isAllowedFromServer).
+            Some("show_dialog") => e.get("dialog").map(|dialog| {
+                crate::text::ClickEvent::ShowDialog(crate::scoreboard::json_to_tag(dialog))
+            }),
+            _ => None,
+        };
     }
     // HoverEvent.ShowText, ShowItem and ShowEntity.
-    if let Some(e) = style_event_object(o, "hover_event", "hoverEvent") {
+    if let Some(e) = o.get("hover_event").and_then(Value::as_object) {
         match e.get("action").and_then(Value::as_str) {
             Some("show_text") => {
-                // Modern `value`, or the older `contents` / nested `text`.
-                let value = e
-                    .get("value")
-                    .or_else(|| e.get("contents"))
-                    .or_else(|| e.get("text"));
-                if let Some(value) = value {
+                if let Some(value) = e.get("value") {
                     style.hover = Some(Box::new(to_text(value, &mut |s| Text::literal(s))));
                 }
             }
@@ -548,43 +506,10 @@ mod tests {
         let t = to_text(&v, &mut |_| Text::empty());
         assert_eq!(t.plain(), "Hi there");
         assert_eq!(t.spans[1].style.color, named_color("red"));
-        // SNBT `1b` is a number in JSON; style flags still take it as true.
-        assert_eq!(t.spans[1].style.bold, Some(true));
         let (v, _) = parse_snbt("[\"a\",{\"text\":\"b\"}]").unwrap();
         assert_eq!(to_text(&v, &mut |_| Text::empty()).plain(), "ab");
     }
 
-    #[test]
-    fn legacy_click_event_open_url_uses_value_field() {
-        use crate::text::ClickEvent;
-        let modern = serde_json::json!({
-            "text": "site",
-            "click_event": {"action": "open_url", "url": "https://example.com"},
-            "underlined": true
-        });
-        let legacy = serde_json::json!({
-            "text": "site",
-            "clickEvent": {"action": "open_url", "value": "https://example.com"},
-            "underlined": 1
-        });
-        for component in [modern, legacy] {
-            let text = to_text(&component, &mut |_| Text::empty());
-            assert_eq!(
-                text.spans[0].style.click,
-                Some(ClickEvent::OpenUrl("https://example.com".into()))
-            );
-            assert_eq!(text.spans[0].style.underlined, Some(true));
-        }
-        let snbt = r#"{text:"site",underlined:1b,clickEvent:{action:open_url,value:"https://example.com"}}"#;
-        let (v, _) = parse_snbt(snbt).unwrap();
-        let text = to_text(&v, &mut |_| Text::empty());
-        assert_eq!(
-            text.spans[0].style.click,
-            Some(ClickEvent::OpenUrl("https://example.com".into()))
-        );
-        assert_eq!(text.spans[0].style.underlined, Some(true));
-    }
-
     #[test]
     fn the_font_is_inherited_and_kept() {
         let (v, _) =

crates/horizon-client-core/src/lang.rs

@@ -57,9 +57,6 @@ impl ResourceSource for Bundled {
             "assets/horizon/lang/en_us.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/en_us.json")
             }
-            "assets/horizon/lang/zh_cn.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/zh_cn.json")
-            }
             "assets/horizon/lang/ru_ru.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/ru_ru.json")
             }
@@ -69,18 +66,6 @@ impl ResourceSource for Bundled {
             "assets/horizon/lang/uk_ua.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/uk_ua.json")
             }
-            "assets/horizon/lang/tr_tr.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/tr_tr.json")
-            }
-            "assets/horizon/lang/es_es.json"
-            | "assets/horizon/lang/es_ar.json"
-            | "assets/horizon/lang/es_cl.json"
-            | "assets/horizon/lang/es_ec.json"
-            | "assets/horizon/lang/es_mx.json"
-            | "assets/horizon/lang/es_uy.json"
-            | "assets/horizon/lang/es_ve.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/es_es.json")
-            }
             _ => return None,
         };
         Some(body.as_bytes().to_vec())
@@ -294,16 +279,6 @@ mod tests {
         }
         assert_eq!(en.get("horizon.pages.mods"), Some("Mods"));
         assert_eq!(ru.get("horizon.pages.mods"), Some("Моды"));
-        let zh = Language::load(&[&empty], "zh_cn");
-        assert_eq!(zh.get("horizon.options.controller"), Some("手柄"));
-        assert_eq!(zh.get("horizon.pages.mods"), Some("模组"));
-        assert_eq!(zh.get("Preset"), Some("预设"));
-        assert_eq!(zh.get("%s chunks"), Some("%s 个区块"));
-        // Not every bundle is complete: the en_us layer is in every map, so a
-        // missing key falls back to English (`horizon.mods.not_built` is not
-        // in ru_ru either).
-        assert_eq!(zh.get("LOD Distance"), Some("LOD 距离"));
-        assert_eq!(ru.get("horizon.mods.not_built"), Some(" (Not built)"));
         let pl = Language::load(&[&empty], "pl_pl");
         assert_eq!(pl.get("horizon.options.controller"), Some("Kontroler"));
         assert_eq!(pl.get("horizon.options.vibration"), Some("Wibracje"));
@@ -312,15 +287,6 @@ mod tests {
             uk.get("horizon.options.on_screen_keyboard"),
             Some("Екранна клавіатура")
         );
-        let tr = Language::load(&[&empty], "tr_tr");
-        assert_eq!(tr.get("horizon.options.controller"), Some("Kontrolcü"));
-        let es = Language::load(&[&empty], "es_es");
-        assert_eq!(es.get("horizon.options.controller"), Some("Mando"));
-        let es_ve = Language::load(&[&empty], "es_ve");
-        assert_eq!(
-            es_ve.get("horizon.options.on_screen_keyboard"),
-            Some("Teclado en pantalla")
-        );
     }
 
     #[test]

crates/horizon-client-core/src/potions.rs

@@ -9,8 +9,7 @@ pub enum Category {
     Harmful,
     Neutral,
 }
-/// A `MobEffect`: id (vanilla's without namespace, a mod's `<ns>:<path>`),
-/// colour, category, instantaneous.
+/// A `MobEffect`: id (without namespace), colour, category, instantaneous.
 #[derive(Clone, Copy, Debug)]
 pub struct EffectDef {
     pub id: &'static str,
@@ -85,80 +84,11 @@ pub const EFFECTS: &[EffectDef] = &[
     fx("infested", 9214860, H),
     fx("breath_of_the_nautilus", 65518, B),
 ];
-/// The effects content mods declare, registered after vanilla's.
-static MOD_EFFECTS: OnceLock<Vec<EffectDef>> = OnceLock::new();
-/// Registers the content mods' effects, `<ns>:<path>` ids in registry order.
-/// The list is set once per process: false when it already was, and the
-/// effects stay those of the first call until the game restarts.
-pub fn register_mod_effects(effects: impl IntoIterator<Item = (String, u32, Category)>) -> bool {
-    if MOD_EFFECTS.get().is_some() {
-        return false;
-    }
-    let defs: Vec<EffectDef> = effects
-        .into_iter()
-        .map(|(id, color, category)| {
-            debug_assert!(id.contains(':'), "{id} has no namespace");
-            fx(Box::leak(id.into_boxed_str()), color, category)
-        })
-        .collect();
-    MOD_EFFECTS.set(defs).is_ok()
-}
-/// The content mods' effects, in registry order.
-pub fn mod_effects() -> &'static [EffectDef] {
-    MOD_EFFECTS.get().map_or(&[], Vec::as_slice)
-}
-/// Every registered effect: vanilla's, then the content mods'.
-pub fn all_effects() -> impl Iterator<Item = &'static EffectDef> {
-    EFFECTS.iter().chain(mod_effects())
-}
 pub fn effect(id: &str) -> Option<&'static EffectDef> {
-    let short = id.trim_start_matches("minecraft:");
-    match EFFECTS.iter().find(|e| e.id == short) {
-        Some(e) => Some(e),
-        None => mod_effect(id),
-    }
+    let id = id.trim_start_matches("minecraft:");
+    EFFECTS.iter().find(|e| e.id == id)
 }
-/// A content mod's effect id (`<ns>:<path>`), not vanilla's with or
-/// without `minecraft:`.
-#[inline]
-pub fn is_mod_effect(id: &str) -> bool {
-    !id.starts_with("minecraft:") && id.bytes().any(|b| b == b':')
-}
-/// Out of line, so vanilla's lookups (every frame, every tick) stay as they were.
-#[cold]
-#[inline(never)]
-fn mod_effect(id: &str) -> Option<&'static EffectDef> {
-    mod_effects().iter().find(|e| e.id == id)
-}
-/// `MobEffect.getDescriptionId` (`Util.makeDescriptionId("effect", key)`):
-/// `effect.<namespace>.<path>`, `/` in the path as `.`.
-pub fn description_id(id: &str) -> String {
-    let (namespace, path) = id.split_once(':').unwrap_or(("minecraft", id));
-    format!("effect.{namespace}.{}", path.replace('/', "."))
-}
-/// The effect's sprite in the GUI atlas (`Hud.getMobEffectSprite`: the key
-/// with `mob_effect/` before its path): `mob_effect/<path>` for vanilla's,
-/// `<ns>:mob_effect/<path>` for a mod's.
-pub fn sprite(id: &str) -> String {
-    let mut out = String::new();
-    push_sprite(&mut out, id);
-    out
-}
-/// [`sprite`], appended to `out`.
-pub fn push_sprite(out: &mut String, id: &str) {
-    let path = match id.split_once(':') {
-        None => id,
-        Some(("minecraft", path)) => path,
-        Some((namespace, path)) => {
-            out.push_str(namespace);
-            out.push(':');
-            path
-        }
-    };
-    out.push_str("mob_effect/");
-    out.push_str(path);
-}
-/// Namespaced effect ids for mob effect storage; a mod's id already is.
+/// Namespaced effect ids for mob effect storage.
 pub fn namespaced(id: &'static str) -> &'static str {
     static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
     let key = id.strip_prefix("minecraft:").unwrap_or(id);
@@ -300,15 +230,10 @@ pub fn potion_color(id: Option<&str>) -> u32 {
     let Some(def) = id.and_then(potion) else {
         return BASE_POTION_COLOR;
     };
-    effects_color(def.effects.iter().map(|(id, _, amp)| (*id, *amp)))
-}
-/// `PotionContents.getColorOptional` of some effects, `(id, amplifier)`, all visible: the mix of
-/// their colours weighted by amplifier + 1, else the base potion colour.
-pub fn effects_color<'a>(effects: impl Iterator<Item = (&'a str, i32)>) -> u32 {
     let (mut r, mut g, mut b, mut total) = (0u32, 0u32, 0u32, 0u32);
-    for (e, amp) in effects {
+    for (e, _, amp) in def.effects {
         let Some(e) = effect(e) else { continue };
-        let w = amp as u32 + 1;
+        let w = *amp as u32 + 1;
         r += w * (e.color >> 16 & 255);
         g += w * (e.color >> 8 & 255);
         b += w * (e.color & 255);
@@ -323,60 +248,3 @@ pub fn effects_color<'a>(effects: impl Iterator<Item = (&'a str, i32)>) -> u32 {
         _ => BASE_POTION_COLOR,
     }
 }
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn description_ids_and_sprites_keep_the_namespace() {
-        assert_eq!(description_id("speed"), "effect.minecraft.speed");
-        assert_eq!(description_id("minecraft:speed"), "effect.minecraft.speed");
-        assert_eq!(description_id("ruby:curse/dark"), "effect.ruby.curse.dark");
-        assert_eq!(sprite("speed"), "mob_effect/speed");
-        assert_eq!(sprite("minecraft:speed"), "mob_effect/speed");
-        assert_eq!(sprite("ruby:curse/dark"), "ruby:mob_effect/curse/dark");
-    }
-
-    /// `PotionContents.getColorOptional`: each visible effect's colour weighted by its
-    /// amplifier + 1, the channels averaged by integer division; none gives the base colour.
-    #[test]
-    fn effects_mix_their_colours_by_amplifier() {
-        let c = |id: &str| effect(id).unwrap().color;
-        assert_eq!(effects_color([("poison", 0)].into_iter()), c("poison"));
-        let (p, s) = (c("poison"), c("speed"));
-        let mix = |shift: u32| (((p >> shift & 255) + 3 * (s >> shift & 255)) / 4) << shift;
-        assert_eq!(
-            effects_color([("poison", 0), ("speed", 2)].into_iter()),
-            mix(16) | mix(8) | mix(0)
-        );
-        assert_eq!(effects_color(std::iter::empty()), BASE_POTION_COLOR);
-    }
-
-    /// The only test that registers: the registry is set once per process.
-    #[test]
-    fn mod_effects_follow_vanilla_once_registered() {
-        assert!(register_mod_effects([(
-            "ruby:glow".to_owned(),
-            0xFF0000,
-            Category::Neutral
-        )]));
-        assert!(!register_mod_effects([(
-            "ruby:late".to_owned(),
-            1,
-            Category::Harmful
-        )]));
-        let glow = effect("ruby:glow").unwrap();
-        assert_eq!(
-            (glow.color, glow.category, glow.instant),
-            (0xFF0000, Category::Neutral, false)
-        );
-        assert!(effect("glow").is_none() && effect("ruby:late").is_none());
-        assert!(is_mod_effect(glow.id) && !is_mod_effect("speed"));
-        assert!(!is_mod_effect(namespaced("speed")));
-        assert_eq!(namespaced(glow.id), "ruby:glow");
-        assert_eq!(effect("minecraft:speed").unwrap().id, "speed");
-        let ids: Vec<_> = all_effects().map(|e| e.id).collect();
-        assert_eq!(ids.len(), EFFECTS.len() + 1);
-        assert_eq!(ids.last(), Some(&"ruby:glow"));
-    }
-}

crates/horizon-client-core/src/registries.rs

@@ -28,12 +28,6 @@ pub struct Registries {
     /// Game rule name -> integer-valued.
     pub game_rules: Vec<(String, bool)>,
     pub players: Vec<String>,
-    /// A dedicated server's lists, for the completions of `/op`, `/deop`, `/pardon`, `/pardon-ip` and
-    /// `/whitelist`: the operators' names, the banned names and addresses, the whitelisted names.
-    pub ops: Vec<String>,
-    pub banned_players: Vec<String>,
-    pub banned_ips: Vec<String>,
-    pub whitelisted: Vec<String>,
     /// `ClientSuggestionProvider.customCompletionSuggestions`: the extra chat
     /// completions the server sent (ClientboundCustomChatCompletionsPacket),
     /// each once.

crates/horizon-client-input/src/interaction_input.rs

@@ -81,19 +81,6 @@ impl InteractionInput {
     }
 }
 
-/// The sentence of `Minecraft.handleKeybinds` that follows a key which opened
-/// a screen: `Gui.setScreen` has already run `KeyMapping.releaseAll()`, so
-/// `key.use` reads up and the same call releases an active use
-/// (`player.isUsingItem() && !keyUse.isDown()` → `MultiPlayerGameMode.releaseUsingItem`).
-/// Only the screens opened from the keybinds do this (the inventory, chat and
-/// advancements); the pause menu, server containers, mount inventories and
-/// dialogs release on the first tick after closing instead, as vanilla does.
-pub fn release_on_screen_open(world: &mut impl InteractionWorld) {
-    if world.using_item() {
-        world.release_using();
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

crates/horizon-client-input/src/lib.rs

@@ -10,6 +10,5 @@ pub mod interaction_input;
 pub mod key_names;
 pub mod keybinds;
 pub mod keymapping;
-pub mod modifiers;
 pub mod mouse;
 pub mod window;

crates/horizon-client-input/src/modifiers.rs

@@ -1,232 +0,0 @@
-//! OS modifier reconciliation and modifiers synthesized by agent control.
-
-use crate::{
-    keybinds::{KeyBinds, key_code},
-    keymapping::{KeyAction, SNEAK, SPRINT, ToggleKeys},
-};
-use std::collections::HashSet;
-use winit::keyboard::{KeyCode, ModifiersState};
-
-const MODIFIERS: [(ModifiersState, [KeyCode; 2]); 4] = [
-    (
-        ModifiersState::SHIFT,
-        [KeyCode::ShiftLeft, KeyCode::ShiftRight],
-    ),
-    (
-        ModifiersState::CONTROL,
-        [KeyCode::ControlLeft, KeyCode::ControlRight],
-    ),
-    (ModifiersState::ALT, [KeyCode::AltLeft, KeyCode::AltRight]),
-    (
-        ModifiersState::SUPER,
-        [KeyCode::SuperLeft, KeyCode::SuperRight],
-    ),
-];
-
-/// A synthesized key updates the same modifier word as window events.
-/// Releasing one side must preserve the other side's hold.
-pub fn set_key(
-    modifiers: &mut ModifiersState,
-    physical: &mut HashSet<KeyCode>,
-    key: KeyCode,
-    down: bool,
-) {
-    let Some((bit, pair)) = MODIFIERS.iter().find(|(_, pair)| pair.contains(&key)) else {
-        return;
-    };
-    if down {
-        physical.insert(key);
-    } else {
-        physical.remove(&key);
-    }
-    modifiers.set(*bit, pair.iter().any(|key| physical.contains(key)));
-}
-
-/// A modifier held for one synthesized click (the pad's Y, an agent's
-/// shift-click): what [`restore`] puts back once the click is done.
-#[derive(Clone, Copy, Debug)]
-pub struct Held {
-    key: KeyCode,
-    was_down: bool,
-    bit: bool,
-}
-
-/// Holds `key` in both the physical keys and the modifier word, which is
-/// what screens read (`InputWithModifiers.hasShiftDown`).
-pub fn hold(modifiers: &mut ModifiersState, physical: &mut HashSet<KeyCode>, key: KeyCode) -> Held {
-    let bit = MODIFIERS
-        .iter()
-        .find(|(_, pair)| pair.contains(&key))
-        .is_some_and(|(bit, _)| modifiers.contains(*bit));
-    let held = Held {
-        key,
-        was_down: physical.contains(&key),
-        bit,
-    };
-    set_key(modifiers, physical, key, true);
-    held
-}
-
-/// Undoes [`hold`]: a key or bit that was already down stays down.
-pub fn restore(modifiers: &mut ModifiersState, physical: &mut HashSet<KeyCode>, held: Held) {
-    if !held.was_down {
-        physical.remove(&held.key);
-    }
-    if let Some((bit, _)) = MODIFIERS.iter().find(|(_, pair)| pair.contains(&held.key)) {
-        modifiers.set(*bit, held.bit);
-    }
-}
-
-/// Recover missing modifier releases without releasing a rebound key or a pad.
-/// ToggleKeyMapping itself preserves keyboard and controller toggles on release.
-pub fn reconcile(
-    modifiers: ModifiersState,
-    physical: &mut HashSet<KeyCode>,
-    bindings: &KeyBinds,
-    toggles: &mut ToggleKeys,
-    options: [bool; 2],
-    pad_held: [bool; 2],
-) {
-    for (bit, pair) in MODIFIERS {
-        if modifiers.contains(bit) {
-            continue;
-        }
-        for key in pair {
-            if !physical.remove(&key) {
-                continue;
-            }
-            for (slot, name) in [(SNEAK, "key.sneak"), (SPRINT, "key.sprint")] {
-                if key_code(bindings.get(name)) == Some(key) && !pad_held[slot] {
-                    toggles.key(slot, KeyAction::Release, false, options[slot]);
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn modifier_taps_release_both_bits() {
-        let mut modifiers = ModifiersState::empty();
-        let mut physical = HashSet::new();
-        for (bit, pair) in MODIFIERS {
-            for key in pair {
-                set_key(&mut modifiers, &mut physical, key, true);
-                assert!(modifiers.contains(bit));
-                set_key(&mut modifiers, &mut physical, key, false);
-                assert!(modifiers.is_empty());
-                assert!(physical.is_empty());
-            }
-        }
-    }
-
-    #[test]
-    fn releasing_one_side_keeps_the_other_modifier_held() {
-        let mut modifiers = ModifiersState::empty();
-        let mut physical = HashSet::new();
-        for (bit, [left, right]) in MODIFIERS {
-            set_key(&mut modifiers, &mut physical, left, true);
-            set_key(&mut modifiers, &mut physical, right, true);
-            set_key(&mut modifiers, &mut physical, left, false);
-            assert!(modifiers.contains(bit));
-            set_key(&mut modifiers, &mut physical, right, false);
-            assert!(modifiers.is_empty());
-        }
-    }
-
-    #[test]
-    fn a_held_click_restores_the_previous_state() {
-        let mut modifiers = ModifiersState::empty();
-        let mut physical = HashSet::new();
-        let held = hold(&mut modifiers, &mut physical, KeyCode::ShiftLeft);
-        assert!(modifiers.shift_key());
-        restore(&mut modifiers, &mut physical, held);
-        assert!(modifiers.is_empty());
-        assert!(physical.is_empty());
-
-        // Right Shift already held, or the OS word set with no physical key.
-        for start in [HashSet::from([KeyCode::ShiftRight]), HashSet::new()] {
-            let mut modifiers = ModifiersState::SHIFT;
-            let mut physical = start.clone();
-            let held = hold(&mut modifiers, &mut physical, KeyCode::ShiftLeft);
-            restore(&mut modifiers, &mut physical, held);
-            assert_eq!(modifiers, ModifiersState::SHIFT);
-            assert_eq!(physical, start);
-        }
-    }
-
-    #[test]
-    fn lost_releases_respect_rebindings_and_pad_holds() {
-        for slot in [SNEAK, SPRINT] {
-            for rebound in [false, true] {
-                for pad in [false, true] {
-                    for toggle in [false, true] {
-                        let mut bindings = KeyBinds::default();
-                        let (name, modifier) = if slot == SNEAK {
-                            ("key.sneak", KeyCode::ShiftLeft)
-                        } else {
-                            ("key.sprint", KeyCode::ControlLeft)
-                        };
-                        if rebound {
-                            bindings.set(name, "key.keyboard.c");
-                        }
-                        let mut physical = HashSet::from([modifier]);
-                        if rebound {
-                            physical.insert(KeyCode::KeyC);
-                        }
-                        let mut toggles = ToggleKeys::default();
-                        toggles.key(slot, KeyAction::Press, false, toggle);
-                        let mut options = [false; 2];
-                        options[slot] = toggle;
-                        let mut pad_held = [false; 2];
-                        pad_held[slot] = pad;
-                        reconcile(
-                            ModifiersState::ALT,
-                            &mut physical,
-                            &bindings,
-                            &mut toggles,
-                            options,
-                            pad_held,
-                        );
-                        assert_eq!(toggles.is_down(slot), rebound || pad || toggle);
-                        assert!(!physical.contains(&modifier));
-                        assert_eq!(physical.contains(&KeyCode::KeyC), rebound);
-                    }
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn unrelated_modifier_change_does_not_release_an_action() {
-        let mut toggles = ToggleKeys::default();
-        toggles.key(SNEAK, KeyAction::Press, false, false);
-        reconcile(
-            ModifiersState::ALT,
-            &mut HashSet::new(),
-            &KeyBinds::default(),
-            &mut toggles,
-            [false; 2],
-            [false; 2],
-        );
-        assert!(toggles.is_down(SNEAK));
-    }
-
-    #[test]
-    fn lost_modifier_release_preserves_a_controller_toggle() {
-        let mut toggles = ToggleKeys::default();
-        toggles.pad_toggle(SNEAK, false);
-        reconcile(
-            ModifiersState::empty(),
-            &mut HashSet::from([KeyCode::ShiftLeft]),
-            &KeyBinds::default(),
-            &mut toggles,
-            [false; 2],
-            [false; 2],
-        );
-        assert!(toggles.is_down(SNEAK));
-    }
-}

crates/horizon-client-input/src/window.rs

@@ -473,37 +473,6 @@ pub fn monitor_video_modes(monitor: &winit::monitor::MonitorHandle) -> Vec<Video
         .collect()
 }
 
-/// The video modes of the window's monitor, listed once per monitor. Listing them takes tens of
-/// milliseconds on Windows, and settings apply at every step of a dragged slider: listing them
-/// each time made the slider stutter.
-#[derive(Debug)]
-pub struct VideoModeList<M = winit::monitor::MonitorHandle> {
-    listed: Option<M>,
-}
-
-impl<M> Default for VideoModeList<M> {
-    fn default() -> Self {
-        Self { listed: None }
-    }
-}
-
-impl<M: PartialEq> VideoModeList<M> {
-    /// The modes of `monitor` when it is not the monitor listed last, else `None` (the list
-    /// stands). No monitor lists none.
-    pub fn refresh(
-        &mut self,
-        monitor: Option<M>,
-        list: impl FnOnce(&M) -> Vec<VideoMode>,
-    ) -> Option<Vec<VideoMode>> {
-        if monitor.is_some() && monitor == self.listed {
-            return None;
-        }
-        let modes = monitor.as_ref().map(list).unwrap_or_default();
-        self.listed = monitor;
-        Some(modes)
-    }
-}
-
 /// `Monitor.currentMode`: the monitor's desktop mode; winit has no such query, so the mode of
 /// the monitor's own size with the highest refresh rate and depth.
 fn monitor_current_mode(
@@ -704,11 +673,6 @@ mod tests {
             vsync_present_mode(&[PresentMode::Fifo], false),
             Some(PresentMode::Fifo)
         );
-        // Regression guard: GLES capabilities report [Fifo, Immediate] without Mailbox.
-        assert_eq!(
-            vsync_present_mode(&[PresentMode::Fifo, PresentMode::Immediate], false),
-            Some(PresentMode::Immediate)
-        );
     }
     #[test]
     fn vsync_on_waits_for_the_display_whatever_the_present_mode() {
@@ -729,28 +693,4 @@ mod tests {
             Some(Immediate)
         );
     }
-
-    #[test]
-    fn video_modes_are_listed_again_only_for_another_monitor() {
-        let mode = |width| VideoMode {
-            width,
-            height: 1080,
-            red_bits: 8,
-            green_bits: 8,
-            blue_bits: 8,
-            refresh_rate: 60.0,
-        };
-        let mut list = VideoModeList::default();
-        let mut listings = 0;
-        let mut modes = |monitor: &i32| {
-            listings += 1;
-            vec![mode(*monitor)]
-        };
-        assert_eq!(list.refresh(Some(1), &mut modes), Some(vec![mode(1)]));
-        assert_eq!(list.refresh(Some(1), &mut modes), None);
-        assert_eq!(list.refresh(Some(2), &mut modes), Some(vec![mode(2)]));
-        assert_eq!(list.refresh(None, &mut modes), Some(vec![]));
-        assert_eq!(list.refresh(Some(2), &mut modes), Some(vec![mode(2)]));
-        assert_eq!(listings, 3);
-    }
 }

crates/horizon-client-render/Cargo.toml

@@ -15,8 +15,6 @@ horizon-command = { path = "../horizon-command" }
 horizon-core = { path = "../horizon-core" }
 horizon-hdr = { path = "../horizon-hdr" }
 horizon-items = { path = "../horizon-items" }
-# The narrator option's status and whether the narrator is there (Options.narrator).
-horizon-narrator = { path = "../horizon-narrator" }
 horizon-protocol = { path = "../horizon-protocol" }
 horizon-shader-api = { path = "../horizon-shader-api" }
 horizon-shaders = { path = "../horizon-shaders" }
@@ -35,20 +33,18 @@ glam = "0.30"
 log = "0.4"
 miniz_oxide = "0.8"
 naga = { version = "30.0.1", features = ["wgsl-in", "glsl-in", "hlsl-out"] }
-half = "2"
 png = "0.18"
 pollster = "0.4"
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1.0.151", features = ["raw_value"] }
 sha1 = "0.10"
 sha2 = "0.10.9"
-smallvec = { version = "1", features = ["const_new"] }
 symphonia = { version = "0.5", default-features = false, features = ["ogg", "vorbis"] }
 unicode-bidi = "0.3.18"
 ureq = { version = "2", default-features = false, features = ["tls"] }
 wgpu = { version = "30.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "metal", "wgsl", "naga-ir"] }
 winit = "0.30.13"
-zip = { version = "9.1.3", default-features = false, features = ["deflate"] }
+zip = { version = "2", default-features = false, features = ["deflate"] }
 
 [target.'cfg(unix)'.dependencies]
 rustix = { version = "1", default-features = false, features = ["std", "time"] }

crates/horizon-client-render/src/assets.rs

@@ -192,8 +192,9 @@ impl Assets {
     pub fn reload(&self, root: &Path) -> Result<RenderAssets> {
         RenderAssets::load(root, self)
     }
-    /// [`Assets::reload`] for a server, which draws nothing: the sprites'
-    /// layers, without the block or item models or the textures' pixels.
+    /// [`Assets::reload`] for a server, which draws nothing: the item models
+    /// and the sprites' layers, without the block models or the textures'
+    /// pixels.
     pub fn reload_for_server(&self, root: &Path) -> Result<RenderAssets> {
         RenderAssets::load_with(root, self, false)
     }
@@ -208,13 +209,8 @@ impl RenderAssets {
         for name in MATERIALS {
             sprites.insert(root, &format!("minecraft:block/{name}"))?;
         }
-        // A server draws no block and no item: its block models (about 24 MB
-        // baked) and item model library (7 MB) stay empty.
-        let parsed = if draws {
-            crate::model_library::ParsedModels::load(root)
-        } else {
-            crate::model_library::ParsedModels::default()
-        };
+        let parsed = crate::model_library::ParsedModels::load(root);
+        // A server draws no block: its models (about 24 MB baked) stay empty.
         let models = if draws {
             crate::models::prepare_with_models(root, registry, &mut sprites, &parsed)?
         } else {
@@ -235,9 +231,6 @@ impl RenderAssets {
         for stage in 0..10 {
             sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
         }
-        if draws {
-            crate::native_emissive::load(root, &mut sprites);
-        }
         sprites.save_disk_cache();
         if draws {
             sprites.finish();

crates/horizon-client-render/src/audio.rs

@@ -39,12 +39,6 @@ struct Channel {
     looping: bool,
     at: [f32; 3],
     relative: bool,
-    /// Whose sounds these are: 0 the game's, another splitscreen player's (`Audio::share`).
-    owner: u8,
-    /// Its world (`Mixer::world_id`; 0 none).
-    world: u32,
-    /// The sound file it started and when, to tell another player's copy of it.
-    started: Option<(String, std::time::Instant)>,
 }
 #[derive(Default)]
 struct Mixer {
@@ -52,15 +46,6 @@ struct Mixer {
     listener: [f64; 3],
     listener_yaw: f32,
     listener_pitch: f32,
-    /// Splitscreen: the other players' cameras (position, yaw, pitch) by owner. A world sound is
-    /// heard from the nearest camera, and panned half as wide while several share the speakers.
-    listeners: HashMap<u8, ([f64; 3], f32, f32)>,
-    /// Each camera's world by owner, as ids: the callback compares and copies integers.
-    worlds: HashMap<u8, u32>,
-    /// World names by id - 1 (`world_id`).
-    world_names: Vec<String>,
-    /// The callback's cameras (position, basis, world), kept to be refilled without allocating.
-    cameras: Vec<([f64; 3], Basis, u32)>,
     limiter_peak: f32,
     /// The output device the stream was opened on (`Library.currentDeviceName`).
     #[cfg(feature = "audio")]
@@ -69,21 +54,6 @@ struct Mixer {
     #[cfg(feature = "audio")]
     device_lost: bool,
 }
-/// A camera's forward, up and right vectors.
-type Basis = ([f64; 3], [f64; 3], [f64; 3]);
-impl Mixer {
-    /// The id of world `name` (1 and up), given once per name.
-    fn world_id(&mut self, name: &str) -> u32 {
-        let i = match self.world_names.iter().position(|w| w == name) {
-            Some(i) => i,
-            None => {
-                self.world_names.push(name.to_owned());
-                self.world_names.len() - 1
-            }
-        };
-        i as u32 + 1
-    }
-}
 /// A sound the player could have heard (`SoundEventListener.onPlaySound`):
 /// what the subtitle overlay needs.
 #[derive(Clone, Debug, PartialEq)]
@@ -105,34 +75,7 @@ pub struct MixerBackend {
     decoder: Option<std::sync::mpsc::Sender<Decode>>,
     next: ChannelId,
     live: bool,
-    /// Whose channels these are (`Channel::owner`).
-    owner: u8,
-    world: u32,
-    /// How many other players share this output: alone, a sound never looks for its copy.
-    shares: Arc<std::sync::atomic::AtomicUsize>,
 }
-/// A splitscreen player's backend leaving: its camera and sounds go with it.
-impl Drop for MixerBackend {
-    fn drop(&mut self) {
-        if self.owner == 0 {
-            return;
-        }
-        self.shares
-            .fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
-        if let Ok(mut m) = self.mixer.lock() {
-            m.listeners.remove(&self.owner);
-            m.worlds.remove(&self.owner);
-            let owner = self.owner;
-            m.channels.retain(|_, c| c.owner != owner);
-        }
-    }
-}
-/// Splitscreen: each shared backend's channel ids start at a block of their own, never handed out
-/// again, so a player in a seat used before never reuses an id a departed one's decoder may
-/// still attach to. The game's own backend counts from 0, as before.
-static SHARED_CHANNELS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
-/// Two players' copies of one sound: started within this of each other.
-const SAME_SOUND: std::time::Duration = std::time::Duration::from_millis(150);
 /// Decoded samples and their rate (`None`: the file did not load).
 type Samples = Option<(Arc<Vec<f32>>, u32)>;
 /// Decoded static sounds (`SoundBufferLibrary`'s buffers), dropped least
@@ -233,11 +176,6 @@ pub struct Audio {
     /// `SoundEngine.lastSeenDevices`: the system default output last seen.
     #[cfg(feature = "audio")]
     default_seen: Option<String>,
-    /// The ALSA cards (Linux) or Core Audio devices (macOS) last seen: listing
-    /// the output devices probes every one, so it waits for these to change
-    /// (`card_fingerprint`).
-    #[cfg(feature = "audio")]
-    cards_seen: Option<String>,
     /// The other half of `lastSeenDevices`: every output device last seen.
     #[cfg(feature = "audio")]
     devices_seen: Vec<String>,
@@ -287,59 +225,7 @@ fn decode(path: &Path) -> Option<(Vec<f32>, u32)> {
     }
     Some((mono, rate))
 }
-/// A sound file without its variant number (`mob/creeper/say2.ogg` is `mob/creeper/say`): each
-/// player's game picks its own variant of the same event.
-// ponytail: variants named by a trailing number, as vanilla's are; the event name if a pack breaks it.
-fn variantless(key: &str) -> &str {
-    key.trim_end_matches(".ogg")
-        .trim_end_matches(|c: char| c.is_ascii_digit())
-}
 impl MixerBackend {
-    /// Splitscreen: another player's game started this same sound here just now (both clients
-    /// heard it); this copy stays stopped, the first is heard from the nearest camera.
-    ///
-    /// A copy is recognised only by its file (without the variant), world, place and time: the
-    /// games pick variants on their own and play many sounds client-side (steps, digging), so
-    /// nothing marks two copies of one event. Two different events alike in all four (two
-    /// players' steps on grass, side by side, within 150 ms) are heard once. That is accepted:
-    /// at that distance and timing they sound like one; a doubled sound is the louder fault.
-    fn duplicate(&self, channel: ChannelId, (namespace, path): (&str, &str)) -> bool {
-        // Alone: nobody else's copy, and no lock taken for it.
-        if self.shares.load(std::sync::atomic::Ordering::Relaxed) == 0 {
-            return false;
-        }
-        let Ok(mut m) = self.mixer.lock() else {
-            return false;
-        };
-        // Alone (no other player's camera), or a sound by the listener (a click, music): its own.
-        let Some(c) = m.channels.get(&channel).filter(|c| !c.relative) else {
-            return false;
-        };
-        if m.listeners.is_empty() {
-            return false;
-        }
-        let key = format!("{namespace}:{path}");
-        let key = variantless(&key);
-        let at = c.at;
-        let world = c.world;
-        let twin = m.channels.values().any(|o| {
-            o.owner != self.owner
-                && o.world == world
-                && !o.relative
-                && o.started
-                    .as_ref()
-                    .is_some_and(|(k, t)| k == key && t.elapsed() < SAME_SOUND)
-                && (0..3).map(|i| (o.at[i] - at[i]).powi(2)).sum::<f32>() < 4.0
-        });
-        if let Some(c) = m.channels.get_mut(&channel) {
-            if twin {
-                c.state = State::Stopped;
-            } else {
-                c.started = Some((key.to_owned(), std::time::Instant::now()));
-            }
-        }
-        twin
-    }
     fn with(&self, channel: ChannelId, f: impl FnOnce(&mut Channel)) {
         if let Ok(mut m) = self.mixer.lock()
             && let Some(c) = m.channels.get_mut(&channel)
@@ -364,9 +250,6 @@ impl Backend for MixerBackend {
                 looping: false,
                 at: [0.0; 3],
                 relative: false,
-                owner: self.owner,
-                world: self.world,
-                started: None,
             },
         );
         Some(id)
@@ -404,10 +287,6 @@ impl Backend for MixerBackend {
         }
         let (namespace, path) = sound.path();
         let file = self.root.join("assets").join(namespace).join(&path);
-        // A looping sound follows its entity in one client's tracking only: each keeps its own.
-        if !looping && self.duplicate(channel, (namespace, &path)) {
-            return;
-        }
         if sound.stream {
             // A streamed sound loops by restarting its stream.
             let mixer = self.mixer.clone();
@@ -516,50 +395,28 @@ fn distance_gain(linear: Option<f32>, distance: f32) -> f32 {
 #[cfg_attr(not(feature = "audio"), allow(dead_code))]
 fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
     data.fill(0.0);
+    let listener = mixer.listener;
     // The camera's forward and up vectors (`Camera.forwardVector`/`upVector`)
     // and OpenAL's right = forward x up.
-    let basis = |yaw: f32, pitch: f32| {
-        let (yaw, pitch) = (f64::from(yaw.to_radians()), f64::from(pitch.to_radians()));
-        let forward = [
-            -yaw.sin() * pitch.cos(),
-            -pitch.sin(),
-            yaw.cos() * pitch.cos(),
-        ];
-        let up = [
-            -yaw.sin() * pitch.sin(),
-            pitch.cos(),
-            yaw.cos() * pitch.sin(),
-        ];
-        let right = [
-            forward[1] * up[2] - forward[2] * up[1],
-            forward[2] * up[0] - forward[0] * up[2],
-            forward[0] * up[1] - forward[1] * up[0],
-        ];
-        (forward, up, right)
-    };
-    // Every camera hearing (splitscreen: the other players' too), in the mixer's own buffer.
-    let mut cameras = std::mem::take(&mut mixer.cameras);
-    cameras.clear();
-    cameras.extend(
-        std::iter::once((
-            0,
-            (mixer.listener, mixer.listener_yaw, mixer.listener_pitch),
-        ))
-        .chain(
-            mixer
-                .listeners
-                .iter()
-                .map(|(&owner, &camera)| (owner, camera)),
-        )
-        .map(|(owner, (at, yaw, pitch))| {
-            (
-                at,
-                basis(yaw, pitch),
-                mixer.worlds.get(&owner).copied().unwrap_or_default(),
-            )
-        }),
+    let (yaw, pitch) = (
+        f64::from(mixer.listener_yaw.to_radians()),
+        f64::from(mixer.listener_pitch.to_radians()),
     );
-    let shared = cameras.len() > 1;
+    let forward = [
+        -yaw.sin() * pitch.cos(),
+        -pitch.sin(),
+        yaw.cos() * pitch.cos(),
+    ];
+    let up = [
+        -yaw.sin() * pitch.sin(),
+        pitch.cos(),
+        yaw.cos() * pitch.sin(),
+    ];
+    let right = [
+        forward[1] * up[2] - forward[2] * up[1],
+        forward[2] * up[0] - forward[0] * up[2],
+        forward[0] * up[1] - forward[1] * up[0],
+    ];
     let dot = |a: [f64; 3], b: [f64; 3]| (a[0] * b[0] + a[1] * b[1] + a[2] * b[2]) as f32;
     // Gains and pans per source for this buffer.
     let mut voices: Vec<(ChannelId, [f32; 3], f64)> = Vec::new();
@@ -570,48 +427,27 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
         if c.state != State::Playing {
             continue;
         }
-        let at = [f64::from(c.at[0]), f64::from(c.at[1]), f64::from(c.at[2])];
-        let away = |listener: [f64; 3]| {
+        let d = if c.relative {
+            [f64::from(c.at[0]), f64::from(c.at[1]), f64::from(c.at[2])]
+        } else {
             [
-                at[0] - listener[0],
-                at[1] - listener[1],
-                at[2] - listener[2],
+                f64::from(c.at[0]) - listener[0],
+                f64::from(c.at[1]) - listener[1],
+                f64::from(c.at[2]) - listener[2],
             ]
         };
-        let length = |d: [f64; 3]| d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
-        // The nearest camera hears it (one camera but in splitscreen).
-        let camera = cameras
-            .iter()
-            .filter(|camera| c.relative || camera.2 == c.world)
-            .min_by(|a, b| length(away(a.0)).total_cmp(&length(away(b.0))))
-            .map(|camera| (camera.0, camera.1));
-        // Unheard sources still advance: returning to a world must not resume stale sounds.
-        let (listener, (forward, up, right)) = camera.unwrap_or(([0.0; 3], basis(0.0, 0.0)));
-        let d = if c.relative { at } else { away(listener) };
         let distance = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt() as f32;
-        let gain = if camera.is_some() {
-            c.gain.clamp(0.0, 1.0) * distance_gain(c.linear, distance)
-        } else {
-            0.0
-        };
+        let gain = c.gain.clamp(0.0, 1.0) * distance_gain(c.linear, distance);
         // Relative sources are already in OpenAL's listener space (-Z ahead).
-        let [mut left, mut right] = if c.relative {
+        let [left, right] = if c.relative {
             stereo_gains(d[0] as f32, d[1] as f32, -d[2] as f32)
         } else {
             stereo_gains(dot(d, right), dot(d, up), dot(d, forward))
-        };
-        if shared {
-            // Several players on the speakers: half the stereo width, as left and right are
-            // nobody's in particular.
-            let middle = (left + right) / 2.0;
-            left = middle + (left - middle) / 2.0;
-            right = middle + (right - middle) / 2.0;
         }
-        let [left, right] = [left, right].map(|pan| gain * pan);
+        .map(|pan| gain * pan);
         let step = f64::from(*source_rate) / f64::from(rate) * f64::from(c.pitch.max(0.0));
         voices.push((*id, [left, right, gain], step));
     }
-    mixer.cameras = cameras;
     for (id, [left, right, gain], step) in voices {
         let Some(c) = mixer.channels.get_mut(&id) else {
             continue;
@@ -702,36 +538,6 @@ fn open_device(
     }
     Ok((stream, config))
 }
-/// Try one output device for `open`: skip it when it was already tried, log it
-/// when it opens, and keep its error when it does not.
-#[cfg(feature = "audio")]
-fn try_open_device(
-    device: &cpal::Device,
-    mixer: Arc<Mutex<Mixer>>,
-    tried: &mut Vec<String>,
-    errors: &mut Vec<String>,
-) -> Option<cpal::Stream> {
-    let name = device.name().unwrap_or_else(|_| "unnamed device".into());
-    if tried.contains(&name) {
-        return None;
-    }
-    tried.push(name.clone());
-    match open_device(device, mixer) {
-        Ok((stream, config)) => {
-            log::info!(
-                "Horizon: audio output {name} ({} Hz, {} channels, {})",
-                config.sample_rate().0,
-                config.channels(),
-                config.sample_format()
-            );
-            Some(stream)
-        }
-        Err(e) => {
-            errors.push(format!("{name}: {e}"));
-            None
-        }
-    }
-}
 /// The name of the system's default output device.
 #[cfg(feature = "audio")]
 fn default_output_name() -> Option<String> {
@@ -739,42 +545,6 @@ fn default_output_name() -> Option<String> {
         .default_output_device()
         .and_then(|d| d.name().ok())
 }
-/// A cheap fingerprint of what `output_devices` can list. On Linux, the ALSA
-/// cards: the rest are `cpal`'s fixed names. On macOS, every Core Audio
-/// device's name, inputs included: telling which of them play opens each one
-/// (about 90 ms a second with twenty devices), naming them takes 2 or 3 ms.
-/// `None` elsewhere, where the list is always looked at.
-#[cfg(feature = "audio")]
-fn card_fingerprint() -> Option<String> {
-    #[cfg(target_os = "linux")]
-    {
-        std::fs::read_to_string("/proc/asound/cards").ok()
-    }
-    #[cfg(target_os = "macos")]
-    {
-        let devices = cpal::default_host().devices().ok()?;
-        Some(
-            devices
-                .filter_map(|d| d.name().ok())
-                .collect::<Vec<_>>()
-                .join("\n"),
-        )
-    }
-    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
-    {
-        None
-    }
-}
-/// Whether the output device list should be looked at again: only the ALSA
-/// cards can add or remove an entry, and `None` means there is no fingerprint,
-/// so the list has to be checked as before.
-#[cfg(any(feature = "audio", test))]
-fn cards_changed(seen: Option<&str>, cards: Option<&str>) -> bool {
-    match (seen, cards) {
-        (Some(seen), Some(cards)) => seen != cards,
-        _ => true,
-    }
-}
 #[cfg(feature = "audio")]
 fn build_stream<T: cpal::SizedSample + cpal::FromSample<f32>>(
     device: &cpal::Device,
@@ -879,17 +649,6 @@ impl Audio {
         };
         let mut engine = SoundEngine::new(registry);
         engine.loaded = live;
-        #[cfg(feature = "audio")]
-        let cards = if live { card_fingerprint() } else { None };
-        // Where the cards gate the list (Linux, macOS), it starts empty: opening the
-        // output does not need it, and listing it probes every device; the first
-        // change fills it. Elsewhere it starts with every device listed, as before.
-        #[cfg(feature = "audio")]
-        let devices = if live && cards.is_none() {
-            output_devices()
-        } else {
-            Vec::new()
-        };
         Self {
             _stream: stream,
             device_name: target_device.to_owned(),
@@ -901,9 +660,6 @@ impl Audio {
                 decoder: None,
                 next: 0,
                 live,
-                owner: 0,
-                world: 0,
-                shares: Arc::default(),
             },
             record_heard: false,
             listener: [0.0; 3],
@@ -918,9 +674,7 @@ impl Audio {
             #[cfg(feature = "audio")]
             default_seen: if live { default_output_name() } else { None },
             #[cfg(feature = "audio")]
-            cards_seen: cards,
-            #[cfg(feature = "audio")]
-            devices_seen: devices,
+            devices_seen: if live { output_devices() } else { Vec::new() },
             #[cfg(feature = "audio")]
             device_ticks: 0,
         }
@@ -987,20 +741,29 @@ impl Audio {
         }
         let host = cpal::default_host();
         let mut errors = Vec::new();
-        // The default device first: it is what plays, and listing the others
-        // probes every PCM, which is slow and prints ALSA's errors for the
-        // plugins this system lacks.
+        // The default device first, then any other output a host lists:
+        // a default that cannot open (busy, or a stale ALSA default) should
+        // not leave the game silent when another device works.
+        let default = host.default_output_device();
+        let others = host.output_devices().into_iter().flatten();
         let mut tried = Vec::new();
-        if let Some(device) = host.default_output_device()
-            && let Some(stream) = try_open_device(&device, mixer.clone(), &mut tried, &mut errors)
-        {
-            return Ok(stream);
-        }
-        // A default that cannot open (busy, or a stale ALSA default) should not
-        // leave the game silent when another device works.
-        for device in host.output_devices().into_iter().flatten() {
-            if let Some(stream) = try_open_device(&device, mixer.clone(), &mut tried, &mut errors) {
-                return Ok(stream);
+        for device in default.into_iter().chain(others) {
+            let name = device.name().unwrap_or_else(|_| "unnamed device".into());
+            if tried.contains(&name) {
+                continue;
+            }
+            tried.push(name.clone());
+            match open_device(&device, mixer.clone()) {
+                Ok((stream, config)) => {
+                    log::info!(
+                        "Horizon: audio output {name} ({} Hz, {} channels, {})",
+                        config.sample_rate().0,
+                        config.channels(),
+                        config.sample_format()
+                    );
+                    return Ok(stream);
+                }
+                Err(e) => errors.push(format!("{name}: {e}")),
             }
         }
         if errors.is_empty() {
@@ -1014,75 +777,15 @@ impl Audio {
             backend: &mut self.backend,
         }
     }
-    /// World identity for this player's sources and camera. Existing channels keep their world.
-    pub fn set_world(&mut self, world: &str) {
-        if let Ok(mut mixer) = self.backend.mixer.lock() {
-            let id = mixer.world_id(world);
-            self.backend.world = id;
-            mixer.worlds.insert(self.backend.owner, id);
-        }
-    }
-
     /// `SoundManager.updateSource`: the camera position and rotation
     /// (`Listener.setTransform` takes its forward and up vectors).
     pub fn set_listener(&mut self, position: [f64; 3], yaw: f32, pitch: f32) {
         self.listener = position;
         self.listener_yaw = yaw;
         if let Ok(mut m) = self.backend.mixer.lock() {
-            if self.backend.owner == 0 {
-                m.listener = position;
-                m.listener_yaw = yaw;
-                m.listener_pitch = pitch;
-            } else {
-                m.listeners
-                    .insert(self.backend.owner, (position, yaw, pitch));
-            }
-        }
-    }
-    /// Splitscreen: another player's sounds on this output, heard from its camera too
-    /// (`owner`: 1 to 255, its own). Dropped, its camera and sounds go.
-    pub fn share(&self, owner: u8) -> Self {
-        assert_ne!(owner, 0, "shared audio owners must be nonzero");
-        self.backend
-            .shares
-            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-        let mut engine = SoundEngine::new(self.engine.registry.clone());
-        engine.loaded = self.backend.live;
-        Self {
-            _stream: None,
-            device_name: self.device_name.clone(),
-            engine,
-            backend: MixerBackend {
-                mixer: self.backend.mixer.clone(),
-                root: self.backend.root.clone(),
-                cache: self.backend.cache.clone(),
-                decoder: None,
-                next: (SHARED_CHANNELS.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1)
-                    << 40,
-                live: self.backend.live,
-                owner,
-                world: self.backend.world,
-                shares: self.backend.shares.clone(),
-            },
-            record_heard: false,
-            listener: [0.0; 3],
-            listener_yaw: 0.0,
-            master: self.master,
-            random: LegacyRandom::new(crate::sound_engine::unique_seed()),
-            source_override: None,
-            capture: None,
-            heard: Default::default(),
-            stopped: Default::default(),
-            preview: Default::default(),
-            // The device belongs to the first player's output, which looks after it.
-            #[cfg(feature = "audio")]
-            default_seen: self.default_seen.clone(),
-            #[cfg(feature = "audio")]
-            cards_seen: self.cards_seen.clone(),
-            #[cfg(feature = "audio")]
-            devices_seen: self.devices_seen.clone(),
-            #[cfg(feature = "audio")]
-            device_ticks: 0,
+            m.listener = position;
+            m.listener_yaw = yaw;
+            m.listener_pitch = pitch;
         }
     }
     /// Sync the volume options, refreshing the categories that changed
@@ -1107,11 +810,6 @@ impl Audio {
     /// at once a second.
     #[cfg(feature = "audio")]
     fn should_change_device(&mut self) -> bool {
-        // A splitscreen share plays through the first player's output: it leaves the device,
-        // and the mixer's lost flag, to that output.
-        if self.backend.owner != 0 {
-            return false;
-        }
         let (current, lost) = match self.backend.mixer.lock() {
             Ok(mut m) => (m.device_name.clone(), std::mem::take(&mut m.device_lost)),
             Err(_) => return false,
@@ -1119,7 +817,6 @@ impl Audio {
         if lost {
             log::info!("Horizon: audio device was lost");
             self.default_seen = default_output_name();
-            self.cards_seen = card_fingerprint();
             self.devices_seen = output_devices();
             return true;
         }
@@ -1129,17 +826,6 @@ impl Audio {
         }
         self.device_ticks = 0;
         let default = default_output_name();
-        let cards = card_fingerprint();
-        // Listing the devices probes every one (on Linux every built-in PCM,
-        // printing ALSA's errors for the plugins this system lacks; on macOS
-        // every Core Audio device, about 90 ms with twenty of them); only the
-        // fingerprint's devices can change the list, and it is cheap.
-        if default == self.default_seen
-            && !cards_changed(self.cards_seen.as_deref(), cards.as_deref())
-        {
-            return false;
-        }
-        self.cards_seen = cards;
         let devices = output_devices();
         // Only a change in the device lists is looked at, as in vanilla: a
         // preferred device that is listed but cannot open is not retried.
@@ -1336,13 +1022,6 @@ impl Audio {
         self.stop_instance(id);
         self.release(id);
     }
-    /// `SoundBufferLibrary.enumerate`: the decoded buffers kept and their bytes.
-    pub fn cache_stats(&self) -> (usize, usize) {
-        self.backend
-            .cache
-            .lock()
-            .map_or((0, 0), |c| (c.entries.len(), c.bytes))
-    }
     /// Every sound event id (for command completion).
     /// The engine's table sizes and the mixer's channels (`status`).
     pub fn census(&self) -> serde_json::Value {
@@ -1461,9 +1140,6 @@ mod tests {
             looping,
             at,
             relative: false,
-            owner: 0,
-            world: 0,
-            started: None,
         }
     }
 
@@ -1621,185 +1297,6 @@ mod tests {
         assert!(close(gains(0.0, 90.0, [0.0, 0.0, 1.0]), [0.5, 0.5]));
     }
 
-    #[test]
-    fn splitscreen_sounds_are_heard_from_the_nearest_camera() {
-        // P1 far away, a second player beside the source: heard at full gain, centred.
-        let mut m = Mixer {
-            listener: [100.0, 0.0, 0.0],
-            ..Mixer::default()
-        };
-        m.listeners.insert(1, ([0.0, 0.0, 1.0], 0.0, 0.0));
-        m.channels
-            .insert(1, channel(vec![1.0; 4], Some(16.0), [0.0, 0.0, 2.0], true));
-        let mut data = [0.0; 2];
-        mix(&mut m, &mut data, 2, 48_000);
-        assert!(
-            data[0] > 0.5 && (data[0] - data[1]).abs() < 1e-4,
-            "{data:?}"
-        );
-        // Alone, P1 would not hear it: 100 blocks past its 16.
-        m.listeners.clear();
-        let mut data = [0.0; 2];
-        mix(&mut m, &mut data, 2, 48_000);
-        assert_eq!(data, [0.0; 2]);
-    }
-
-    #[test]
-    fn a_shared_listener_registers_even_in_the_hosts_world() {
-        let mut host = Audio::silent(Path::new("/nonexistent/horizon-test-audio"));
-        host.set_world("minecraft:overworld");
-        let mut guest = host.share(1);
-        guest.set_world("minecraft:overworld");
-        guest.set_listener([1.0, 2.0, 3.0], 0.0, 0.0);
-        let id = guest.backend.create(false).unwrap();
-        let mixer = host.backend.mixer.lock().unwrap();
-        let overworld = mixer
-            .world_names
-            .iter()
-            .position(|w| w == "minecraft:overworld");
-        let overworld = overworld.map(|i| i as u32 + 1);
-        assert_eq!(mixer.worlds.get(&1).copied(), overworld);
-        assert_eq!(Some(mixer.channels[&id].world), overworld);
-    }
-
-    #[test]
-    fn cameras_in_other_dimensions_cannot_hear_a_source() {
-        let mut m = Mixer {
-            listener: [100.0, 0.0, 0.0],
-            ..Default::default()
-        };
-        m.listeners.insert(1, ([0.0, 0.0, 1.0], 0.0, 0.0));
-        let nether = m.world_id("nether");
-        m.worlds.insert(1, nether);
-        m.channels
-            .insert(1, channel(vec![1.0; 4], Some(16.0), [0.0, 0.0, 2.0], true));
-        let mut data = [0.0; 2];
-        mix(&mut m, &mut data, 2, 48_000);
-        assert_eq!(
-            data, [0.0; 2],
-            "nearby Nether camera must not hear Overworld source"
-        );
-        m.channels.get_mut(&1).unwrap().world = nether;
-        mix(&mut m, &mut data, 2, 48_000);
-        assert!(data[0] > 0.5, "same-world camera must hear source");
-        let end = m.world_id("end");
-        m.worlds.insert(1, end);
-        data.fill(0.0);
-        mix(&mut m, &mut data, 2, 48_000);
-        assert_eq!(data, [0.0; 2], "no listener remains in source's world");
-    }
-
-    #[test]
-    fn sounds_in_a_world_without_listeners_finish_while_inaudible() {
-        let mut mixer = Mixer::default();
-        let mut source = channel(vec![1.0; 4], None, [0.0; 3], false);
-        let nether = mixer.world_id("nether");
-        source.world = nether;
-        mixer.channels.insert(1, source);
-        let mut data = [0.0; 4];
-        mix(&mut mixer, &mut data, 2, 48_000);
-        assert_eq!(data, [0.0; 4]);
-        assert!(mixer.channels[&1].position > 0.0);
-        mix(&mut mixer, &mut data, 2, 48_000);
-        assert_eq!(mixer.channels[&1].state, State::Stopped);
-        mixer.worlds.insert(0, nether);
-        mix(&mut mixer, &mut data, 2, 48_000);
-        assert_eq!(data, [0.0; 4], "returning must not resume the old one-shot");
-    }
-
-    #[test]
-    fn variants_of_one_sound_are_the_same_sound() {
-        assert_eq!(
-            variantless("minecraft:mob/creeper/say1.ogg"),
-            "minecraft:mob/creeper/say"
-        );
-        assert_eq!(
-            variantless("minecraft:step/grass6.ogg"),
-            "minecraft:step/grass"
-        );
-        assert_eq!(
-            variantless("minecraft:random/click.ogg"),
-            "minecraft:random/click"
-        );
-    }
-
-    #[test]
-    fn another_players_copy_of_a_sound_is_dropped() {
-        let mixer = Arc::new(Mutex::new(Mixer::default()));
-        // One other player shares the output.
-        let shares = Arc::new(std::sync::atomic::AtomicUsize::new(1));
-        let backend = |owner| MixerBackend {
-            mixer: mixer.clone(),
-            root: PathBuf::new(),
-            cache: Arc::default(),
-            decoder: None,
-            next: (u64::from(owner)) << 40,
-            live: true,
-            owner,
-            world: 0,
-            shares: shares.clone(),
-        };
-        let (mut p1, mut p2) = (backend(0), backend(1));
-        // P2 is listening (its camera is in the mixer), so two players share the speakers.
-        mixer
-            .lock()
-            .unwrap()
-            .listeners
-            .insert(1, ([0.0; 3], 0.0, 0.0));
-        let started = |b: &mut MixerBackend, at: [f64; 3]| {
-            let id = b.create(false).unwrap();
-            b.set_position(id, at);
-            !b.duplicate(id, ("minecraft", "mob/creeper/say1.ogg"))
-        };
-        assert!(started(&mut p1, [5.0, 64.0, 5.0]));
-        // P2's client got the same sound at the same place: one copy plays.
-        assert!(!started(&mut p2, [5.2, 64.0, 5.0]));
-        // Elsewhere, or P1's own second one, it is a sound of its own.
-        assert!(started(&mut p2, [40.0, 64.0, 5.0]));
-        assert!(started(&mut p1, [5.0, 64.0, 5.0]));
-        // Equal coordinates in another dimension describe a different sound.
-        p2.world = mixer.lock().unwrap().world_id("nether");
-        assert!(started(&mut p2, [5.0, 64.0, 5.0]));
-        // P2 leaving takes its sounds.
-        drop(p2);
-        assert!(
-            mixer
-                .lock()
-                .unwrap()
-                .channels
-                .values()
-                .all(|c| c.owner == 0)
-        );
-    }
-
-    #[test]
-    fn reusing_a_seat_does_not_reuse_its_channels_or_leave_its_camera() {
-        let host = Audio::silent(Path::new("/nonexistent/horizon-test-audio"));
-        let mut guest = host.share(1);
-        guest.set_world("overworld");
-        guest.set_listener([1.0, 0.0, 0.0], 0.0, 0.0);
-        let old = guest.backend.create(false).unwrap();
-        drop(guest);
-        {
-            let mixer = host.backend.mixer.lock().unwrap();
-            assert!(!mixer.channels.contains_key(&old));
-            assert!(!mixer.listeners.contains_key(&1));
-            assert!(!mixer.worlds.contains_key(&1));
-        }
-        let mut replacement = host.share(1);
-        let new = replacement.backend.create(false).unwrap();
-        assert_ne!(old, new);
-        assert!(
-            replacement
-                .backend
-                .mixer
-                .lock()
-                .unwrap()
-                .channels
-                .contains_key(&new)
-        );
-    }
-
     #[test]
     fn a_mono_output_plays_sources_unpanned() {
         let mut m = Mixer::default();
@@ -1809,15 +1306,4 @@ mod tests {
         mix(&mut m, &mut data, 1, 48_000);
         assert_eq!(data, [0.5; 2]);
     }
-
-    #[test]
-    fn output_devices_are_looked_at_again_only_when_the_cards_change() {
-        // No fingerprint (not Linux, or the cards could not be read): the list
-        // has to be looked at as before.
-        assert!(cards_changed(None, None));
-        assert!(cards_changed(Some("0 [PCH ]"), None));
-        // The same cards list the same devices; a card added or removed does not.
-        assert!(!cards_changed(Some("0 [PCH ]"), Some("0 [PCH ]")));
-        assert!(cards_changed(Some("0 [PCH ]"), Some("0 [PCH ]\n 1 [USB ]")));
-    }
 }

crates/horizon-client-render/src/auth.rs

@@ -203,46 +203,6 @@ pub fn endpoint(doc: &serde_json::Value, service: &str, name: &str) -> Option<St
         .map(str::to_owned)
 }
 
-/// `Minecraft`'s constructor futures for the title screen: `UserApiService.fetchProperties`
-/// (the `player` service's `getAttributes`, with the bearer token) and
-/// `SessionService.fetchProfile(uuid, true)` (`getProfileById`). A failed
-/// attributes call falls back to the offline properties, a failed profile call
-/// to no actions, as vanilla does. Blocks: call it off the main thread.
-pub fn fetch_account_status(session: &AuthSession) -> crate::ban_notice::AccountStatus {
-    use crate::ban_notice::{AccountStatus, parse_profile_actions, parse_properties};
-    let Ok(doc) = discovery() else {
-        return AccountStatus::default();
-    };
-    let properties = endpoint(&doc, "player", "getAttributes")
-        .and_then(|url| {
-            agent()
-                .get(&url)
-                .set("Authorization", &format!("Bearer {}", session.access_token))
-                .call()
-                .ok()?
-                .into_string()
-                .ok()
-        })
-        .and_then(|body| parse_properties(&body))
-        .unwrap_or_default();
-    let actions = endpoint(&doc, "session", "getProfileById")
-        .and_then(|url| {
-            let url = url.replace("{profileId}", &format!("{:032x}", session.uuid));
-            agent()
-                .get(&format!("{url}?unsigned=true"))
-                .call()
-                .ok()?
-                .into_string()
-                .ok()
-        })
-        .map(|body| parse_profile_actions(&body))
-        .unwrap_or_default();
-    AccountStatus {
-        properties,
-        actions,
-    }
-}
-
 /// The JoinMinecraftServerRequest body; `selectedProfile` is the undashed UUID.
 pub fn join_request(session: &AuthSession, server_hash: &str) -> String {
     serde_json::json!({
@@ -272,211 +232,6 @@ pub fn join_server(session: &AuthSession, server_hash: &str) -> Result<(), JoinE
     }
 }
 
-/// The account's chat key pair (ProfileKeyPair): the private key that signs
-/// its chat, the public key with the services' signature over it, and when
-/// to fetch a new one (refreshedAfter, epoch milliseconds). Like the access
-/// token it stays in memory: vanilla's profilekeys file is never written.
-pub struct ChatKeyPair {
-    pub private: horizon_protocol::rsa::RsaPrivateKey,
-    pub public: horizon_protocol::secure_chat::ProfileKey,
-    pub refreshed_after: i64,
-}
-impl std::fmt::Debug for ChatKeyPair {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ChatKeyPair")
-            .field("expires_at", &self.public.expires_at)
-            .field("refreshed_after", &self.refreshed_after)
-            .finish_non_exhaustive()
-    }
-}
-impl ChatKeyPair {
-    /// ProfileKeyPair.dueRefresh.
-    pub fn due_refresh(&self, now: i64) -> bool {
-        self.refreshed_after < now
-    }
-}
-
-/// Epoch milliseconds now.
-pub fn now_millis() -> i64 {
-    SystemTime::now()
-        .duration_since(SystemTime::UNIX_EPOCH)
-        .map_or(0, |d| d.as_millis() as i64)
-}
-
-/// Instant.parse for the services' UTC times
-/// (`2022-07-30T23:05:24.548227Z`): epoch milliseconds.
-pub fn parse_instant(text: &str) -> Option<i64> {
-    let text = text.strip_suffix('Z')?;
-    let (date, time) = text.split_once('T')?;
-    let mut date = date.splitn(3, '-').map(|p| p.parse::<i64>().ok());
-    let (y, m, d) = (date.next()??, date.next()??, date.next()??);
-    let (hms, fraction) = time.split_once('.').unwrap_or((time, ""));
-    let mut hms = hms.splitn(3, ':').map(|p| p.parse::<i64>().ok());
-    let (h, min, s) = (hms.next()??, hms.next()??, hms.next()??);
-    if !(1..=12).contains(&m) || !(1..=31).contains(&d) || h > 23 || min > 59 || s > 60 {
-        return None;
-    }
-    if !fraction.bytes().all(|b| b.is_ascii_digit()) {
-        return None;
-    }
-    let millis = format!("{fraction:0<3}")[..3].parse::<i64>().ok()?;
-    // Days from 1970-01-01 (Howard Hinnant's days_from_civil).
-    let y = if m <= 2 { y - 1 } else { y };
-    let era = y.div_euclid(400);
-    let yoe = y - era * 400;
-    let doy = (153 * (m + if m > 2 { -3 } else { 9 }) + 2) / 5 + d - 1;
-    let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
-    let days = era * 146_097 + doe - 719_468;
-    Some(((days * 24 + h) * 60 + min) * 60_000 + s * 1000 + millis)
-}
-
-/// Crypt.stringToPemRsaPrivateKey / stringToRsaPublicKey: the base64
-/// between a PEM block's armour lines.
-fn pem_der(pem: &str) -> Option<Vec<u8>> {
-    let body: String = pem
-        .lines()
-        .filter(|l| !l.starts_with("-----"))
-        .flat_map(|l| l.chars().filter(|c| !c.is_whitespace()))
-        .collect();
-    crate::skins::base64_decode(&body)
-}
-
-/// KeyPairResponse from the certificates endpoint, as
-/// AccountProfileKeyPairManager.fetchProfileKeyPair reads it: the PEM key
-/// pair, publicKeySignatureV2 (the signature over the profile id too),
-/// expiresAt and refreshedAfter. None for anything malformed, or a private
-/// key that isn't the public key's other half.
-pub fn parse_certificates(body: &str) -> Option<ChatKeyPair> {
-    use horizon_protocol::rsa::{RsaPrivateKey, RsaPublicKey};
-    let v: serde_json::Value = serde_json::from_str(body).ok()?;
-    let field = |path: &str| v.pointer(path).and_then(|s| s.as_str());
-    let private = RsaPrivateKey::from_der(&pem_der(field("/keyPair/privateKey")?)?).ok()?;
-    let key = pem_der(field("/keyPair/publicKey")?)?;
-    if RsaPublicKey::from_der(&key).ok()? != private.public {
-        return None;
-    }
-    let signature = crate::skins::base64_decode(field("/publicKeySignatureV2")?)?;
-    Some(ChatKeyPair {
-        private,
-        public: horizon_protocol::secure_chat::ProfileKey {
-            expires_at: parse_instant(field("/expiresAt")?)?,
-            key,
-            signature,
-        },
-        refreshed_after: parse_instant(field("/refreshedAfter")?)?,
-    })
-}
-
-/// UserApiService.getKeyPair: the certificates endpoint, POSTed with the
-/// access token.
-pub fn fetch_chat_keys(session: &AuthSession) -> Result<ChatKeyPair, JoinError> {
-    let doc = discovery()?;
-    let url = endpoint(&doc, "player", "getCertificates").ok_or(JoinError::Unavailable)?;
-    let body = match agent()
-        .post(&url)
-        .set("Authorization", &format!("Bearer {}", session.access_token))
-        .set("Content-Type", "application/json; charset=utf-8")
-        .send_string("")
-    {
-        Ok(response) => response.into_string().unwrap_or_default(),
-        Err(ureq::Error::Status(status, response)) => {
-            return Err(JoinError::from_response(
-                status,
-                &response.into_string().unwrap_or_default(),
-            ));
-        }
-        Err(ureq::Error::Transport(_)) => return Err(JoinError::Unavailable),
-    };
-    parse_certificates(&body)
-        .ok_or_else(|| JoinError::Other("Malformed profile key pair response".to_owned()))
-}
-
-/// AccountProfileKeyPairManager.MINIMUM_PROFILE_KEY_REFRESH_INTERVAL.
-const KEY_RETRY: Duration = Duration::from_secs(60 * 60);
-
-/// The chat key pair as AccountProfileKeyPairManager keeps it: fetched on a
-/// background thread, kept until it is due a refresh, and on a failure kept
-/// as it was (the next try waits an hour, or the next join).
-#[derive(Default)]
-struct ChatKeys {
-    current: Option<Arc<ChatKeyPair>>,
-    fetching: bool,
-    next_try: Option<std::time::Instant>,
-}
-static CHAT_KEYS: Mutex<ChatKeys> = Mutex::new(ChatKeys {
-    current: None,
-    fetching: false,
-    next_try: None,
-});
-
-/// prepareKeyPair (`now`: on a join) or, from a tick, shouldRefreshKeyPair
-/// then prepareKeyPair: start fetching when there is no key pair or it is
-/// due a refresh. Nothing without a signed-in account.
-pub fn prepare_chat_keys(now: bool) {
-    let Some(session) = current() else {
-        return;
-    };
-    let mut keys = CHAT_KEYS.lock().unwrap();
-    let instant = std::time::Instant::now();
-    if keys.fetching || !now && keys.next_try.is_some_and(|t| instant < t) {
-        return;
-    }
-    keys.next_try = Some(instant + KEY_RETRY);
-    if keys
-        .current
-        .as_ref()
-        .is_some_and(|k| !k.due_refresh(now_millis()))
-    {
-        return;
-    }
-    keys.fetching = true;
-    drop(keys);
-    let spawned = std::thread::Builder::new()
-        .name("Profile key fetch".into())
-        .spawn(move || {
-            let result = fetch_chat_keys(&session);
-            let mut keys = CHAT_KEYS.lock().unwrap();
-            keys.fetching = false;
-            match result {
-                Ok(pair) => keys.current = Some(Arc::new(pair)),
-                Err(e) => log::error!("Failed to retrieve profile key pair: {e:?}"),
-            }
-        });
-    if spawned.is_err() {
-        CHAT_KEYS.lock().unwrap().fetching = false;
-    }
-}
-
-/// The chat key pair fetched so far, unless it has expired.
-pub fn chat_keys() -> Option<Arc<ChatKeyPair>> {
-    let now = now_millis();
-    CHAT_KEYS
-        .lock()
-        .unwrap()
-        .current
-        .clone()
-        .filter(|k| !k.public.has_expired(now))
-}
-
-const MINECRAFT_PROFILE: &str = "https://api.minecraftservices.com/minecraft/profile";
-
-/// The signed-in account's active skin and cape from `GET /minecraft/profile`.
-/// Single-player and integrated servers often send no `textures` property, or
-/// one without the equipped cape; the client asks the profile endpoint once.
-pub fn own_textures(session: &AuthSession) -> Option<crate::skins::Textures> {
-    let response = agent()
-        .get(MINECRAFT_PROFILE)
-        .set("Authorization", &format!("Bearer {}", session.access_token))
-        .call()
-        .ok()?;
-    if response.status() != 200 {
-        return None;
-    }
-    let body = response.into_string().ok()?;
-    let profile: serde_json::Value = serde_json::from_str(&body).ok()?;
-    Some(crate::skins::services_profile_textures(&profile))
-}
-
 /// What the session service says about a player joining this server
 /// (MinecraftServicesSessionService.hasJoinedServer).
 #[derive(Clone, Debug, PartialEq)]
@@ -671,104 +426,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn instants_like_java() {
-        assert_eq!(parse_instant("1970-01-01T00:00:00Z"), Some(0));
-        assert_eq!(parse_instant("1970-01-01T00:00:01.5Z"), Some(1500));
-        // Instant.parse("2022-07-30T23:05:24.548227Z").toEpochMilli().
-        assert_eq!(
-            parse_instant("2022-07-30T23:05:24.548227Z"),
-            Some(1_659_222_324_548)
-        );
-        assert_eq!(
-            parse_instant("2024-02-29T12:00:00Z"),
-            Some(1_709_208_000_000)
-        );
-        assert_eq!(parse_instant("1969-12-31T23:59:59Z"), Some(-1000));
-        for bad in [
-            "2022-07-30T23:05:24",
-            "2022-13-01T00:00:00Z",
-            "2022-07-30 23:05:24Z",
-            "2022-07-30T23:05:24.5x1Z",
-            "",
-        ] {
-            assert_eq!(parse_instant(bad), None, "{bad}");
-        }
-    }
-
-    /// A throwaway 1024-bit key (`openssl genrsa`, PKCS#8 as the services
-    /// send it under "RSA PRIVATE KEY") and its public half.
-    const PRIVATE_B64: &str = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKSDqaLOF2Ltt4tzWblkFeNYhdss67BhXTbOMUYjpcPdtf4dzNtgZsTf4WEluvc8pItGWChdpq3xzPC9GL4PZ+Oh1o6VR/wSm20/50QT7V+YcSP1VrVKjDpDSg/UoC1Fmdc/vb9AO8Ip7TxuRYd/uyog/ThQ8aGcWtvvtwPqx4XrAgMBAAECgYA+ZGy2gQDflRZSPeoeZHXkphMF/7BXUWW/vk1zs1tPwEsgV/70iEgRjHL2nA+fapFg/Mm8bWAkghrehmjW1BLq5w8sGdGJCHfE/kauu78jJK0/ME38e9bsSEvv5HMMxyx0mlV8DQu2pzCT71ceT8VD/1pewUbpeZypj5pxtsCIMQJBANXgca/mnAQXTuowI8FqMiald6OuAcAWbOaNrCB5HHWuxH7hFatSqGrgp4YLqHv7bzeodU1y/uxwc+/01khd0rMCQQDE6mPfIdZxHhWkMUAKhMEnrLanfCL0dfyAe+lBpqgPwO3UurCfCaFX5RdYB3fCyvgy5foHN1/I8/Eobp+enrvpAkBgkZnjeXWiZz/Lf/b1AtUoG/g8IHpL2BRNuVQpyWVvQX0ZaNoW5BiFQXCClsr5SBr8f4SPdsfhzBidFOiX/jz/AkBDuk6Bd3T3UR6ma54YQBLjX38vWf330QD4/CV9RCH30Sa8DT4kZT6OKah+yYrCf+cgMoNtqfkS9/xRKMNT3krJAkAaFrAT6HF5Y9b5OLASbbFe7MZ4zNCzuEl6plKNUi+JCHESaU/VCCuYOLoWLeSDFYkZUoSmqiRxH8fVTsBz393x";
-    const PUBLIC_B64: &str = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCkg6mizhdi7beLc1m5ZBXjWIXbLOuwYV02zjFGI6XD3bX+HczbYGbE3+FhJbr3PKSLRlgoXaat8czwvRi+D2fjodaOlUf8EpttP+dEE+1fmHEj9Va1Sow6Q0oP1KAtRZnXP72/QDvCKe08bkWHf7sqIP04UPGhnFrb77cD6seF6wIDAQAB";
-
-    fn pem(label: &str, b64: &str) -> String {
-        let lines: Vec<&str> = b64
-            .as_bytes()
-            .chunks(76)
-            .map(|c| std::str::from_utf8(c).unwrap())
-            .collect();
-        format!(
-            "-----BEGIN {label}-----\n{}\n-----END {label}-----\n",
-            lines.join("\n")
-        )
-    }
-
-    fn certificates(private: &str, public: &str) -> String {
-        serde_json::json!({
-            "keyPair": {
-                "privateKey": pem("RSA PRIVATE KEY", private),
-                "publicKey": pem("RSA PUBLIC KEY", public),
-            },
-            "publicKeySignature": "djE=",
-            "publicKeySignatureV2": "c2ln",
-            "expiresAt": "2022-07-30T23:05:24.548227Z",
-            "refreshedAfter": "2022-07-30T15:05:24.548227Z",
-        })
-        .to_string()
-    }
-
-    #[test]
-    fn certificates_response() {
-        let pair = parse_certificates(&certificates(PRIVATE_B64, PUBLIC_B64)).unwrap();
-        assert_eq!(
-            pair.public.key,
-            crate::skins::base64_decode(PUBLIC_B64).unwrap()
-        );
-        assert_eq!(pair.public.signature, b"sig", "publicKeySignatureV2");
-        assert_eq!(pair.public.expires_at, 1_659_222_324_548);
-        assert_eq!(pair.refreshed_after, 1_659_193_524_548);
-        assert_eq!(pair.private.public_der(), pair.public.key);
-        assert!(pair.due_refresh(1_659_193_524_549));
-        assert!(!pair.due_refresh(1_659_193_524_548));
-        assert!(!format!("{pair:?}").contains("MII"));
-        // A public key that isn't the private key's, and broken fields.
-        let other = horizon_protocol::rsa::RsaPrivateKey::generate(1024).unwrap();
-        let other = base64(&other.public_der());
-        assert!(parse_certificates(&certificates(PRIVATE_B64, &other)).is_none());
-        assert!(parse_certificates(&certificates("bm9wZQ==", PUBLIC_B64)).is_none());
-        assert!(parse_certificates("{}").is_none());
-        assert!(parse_certificates("").is_none());
-    }
-
-    fn base64(bytes: &[u8]) -> String {
-        const A: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-        let mut out = String::new();
-        for c in bytes.chunks(3) {
-            let n = c
-                .iter()
-                .enumerate()
-                .fold(0u32, |n, (i, &b)| n | u32::from(b) << (16 - 8 * i));
-            for i in 0..4 {
-                out.push(if i <= c.len() {
-                    char::from(A[(n >> (18 - 6 * i) & 63) as usize])
-                } else {
-                    '='
-                });
-            }
-        }
-        out
-    }
-
     #[test]
     fn discovery_endpoints() {
         let doc = serde_json::json!({"discovery": {"session": {"endpoints": {"join": {"uri": "https://s/join"}}}}});

crates/horizon-client-render/src/ban_notice.rs

@@ -1,373 +0,0 @@
-//! The ban notices `Gui.addInitialScreens` queues before the title screen:
-//! `Minecraft.multiplayerBan()` (the account's MULTIPLAYER ban from the services
-//! attributes call), the forced name change and the banned skin
-//! (`ProfileResult.actions()`), and the text `BanNoticeScreens` shows for each.
-//! The network calls are in `auth.rs`; this file parses what they return.
-use crate::text::Text;
-
-/// `CommonLinks.SUSPENSION_HELP`.
-pub const SUSPENSION_HELP: &str = "https://aka.ms/mcjavamoderation";
-
-/// authlib's `BanDetails` (the id is never shown).
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct BanDetails {
-    /// Epoch milliseconds the ban ends; `None` is permanent.
-    pub expires_ms: Option<i64>,
-    pub reason: Option<String>,
-    pub reason_message: Option<String>,
-}
-
-/// authlib's `UserProperties`, as far as the title screen reads it.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct UserProperties {
-    /// `UserFlag.SERVERS_ALLOWED` (`privileges.multiplayerServer.enabled`).
-    pub servers_allowed: bool,
-    /// `bannedScopes.get("MULTIPLAYER")`.
-    pub multiplayer_ban: Option<BanDetails>,
-}
-impl Default for UserProperties {
-    /// `UserApiService.OFFLINE_PROPERTIES`: what a failed fetch falls back to.
-    fn default() -> Self {
-        Self {
-            servers_allowed: true,
-            multiplayer_ban: None,
-        }
-    }
-}
-
-/// authlib's `ProfileResult.actions()`.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct ProfileActions {
-    pub forced_name_change: bool,
-    pub using_banned_skin: bool,
-}
-
-/// What the title screen learns about the account.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct AccountStatus {
-    pub properties: UserProperties,
-    pub actions: ProfileActions,
-}
-impl AccountStatus {
-    /// `Minecraft.allowsMultiplayer` (without the `--disableMultiplayer` flag).
-    pub fn allows_multiplayer(&self) -> bool {
-        self.properties.servers_allowed
-            && self.properties.multiplayer_ban.is_none()
-            && !self.actions.forced_name_change
-    }
-}
-
-/// One of the screens `Gui.addInitialScreens` adds.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Notice {
-    /// `BanNoticeScreens.create`.
-    Multiplayer(BanDetails),
-    /// `BanNoticeScreens.createNameBan` with the profile's name.
-    Name(String),
-    /// `BanNoticeScreens.createSkinBan`.
-    Skin,
-}
-
-/// `Gui.addInitialScreens`' ban part, in its order: the multiplayer ban, the
-/// name ban, the skin ban.
-pub fn initial_notices(status: &AccountStatus, profile_name: &str) -> Vec<Notice> {
-    let mut notices = Vec::new();
-    if let Some(ban) = &status.properties.multiplayer_ban {
-        notices.push(Notice::Multiplayer(ban.clone()));
-    }
-    if status.actions.forced_name_change {
-        notices.push(Notice::Name(profile_name.to_owned()));
-    }
-    if status.actions.using_banned_skin {
-        notices.push(Notice::Skin);
-    }
-    notices
-}
-
-impl Notice {
-    /// The screen's title (bold).
-    pub fn title(&self) -> Text {
-        let key = match self {
-            Self::Multiplayer(ban) if ban.expires_ms.is_some() => "gui.banned.title.temporary",
-            Self::Multiplayer(_) => "gui.banned.title.permanent",
-            Self::Name(_) => "gui.banned.name.title",
-            Self::Skin => "gui.banned.skin.title",
-        };
-        Text::translate(key, &[]).bold()
-    }
-    /// The screen's message; `now_ms` is `Instant.now()`.
-    pub fn message(&self, now_ms: i64) -> Text {
-        let link = || Text::literal(SUSPENSION_HELP);
-        match self {
-            Self::Multiplayer(ban) => Text::translate(
-                "gui.banned.description",
-                &[reason_text(ban), status_text(ban, now_ms), link()],
-            ),
-            Self::Name(name) => Text::translate(
-                "gui.banned.name.description",
-                &[Text::colored(name.clone(), YELLOW), link()],
-            ),
-            Self::Skin => Text::translate("gui.banned.skin.description", &[link()]),
-        }
-    }
-}
-
-/// `ChatFormatting.YELLOW`.
-const YELLOW: u32 = 0xFFFF55;
-
-/// `BanReason.byId`: the translation key suffix.
-fn ban_reason(id: i32) -> Option<&'static str> {
-    Some(match id {
-        2 => "false_reporting",
-        5 => "hate_speech",
-        16 | 25 => "hate_terrorism_notorious_figure",
-        17 | 19 | 23 | 31 => "generic_violation",
-        21 => "harassment_or_bullying",
-        27 => "defamation_impersonation_false_information",
-        28 => "drugs",
-        29 => "fraud",
-        30 => "spam_or_advertising",
-        32 => "nudity_or_pornography",
-        33 | 35 | 36 => "sexually_inappropriate",
-        34 => "extreme_violence_or_gore",
-        53 => "imminent_harm_to_person_or_property",
-        _ => return None,
-    })
-}
-
-/// `BanNoticeScreens.getBanReasonText`.
-fn reason_text(ban: &BanDetails) -> Text {
-    let numeric = ban
-        .reason
-        .as_deref()
-        .filter(|r| !r.is_empty() && r.bytes().all(|b| b.is_ascii_digit()));
-    let Some(reason) = numeric else {
-        return Text::translate("gui.banned.description.unknownreason", &[]);
-    };
-    // Integer.parseInt: past i32 the vanilla screen would throw; show the code as is.
-    let id = reason.parse::<i32>().ok();
-    let text = if let Some(key) = id.and_then(ban_reason) {
-        Text::translate(&format!("gui.banned.reason.{key}"), &[]).bold()
-    } else if let Some(message) = &ban.reason_message {
-        Text::translate(
-            "gui.banned.description.reason_id_message",
-            &[Text::literal(reason), Text::literal(message.clone())],
-        )
-        .bold()
-    } else {
-        Text::translate("gui.banned.description.reason_id", &[Text::literal(reason)]).bold()
-    };
-    Text::translate("gui.banned.description.reason", &[text])
-}
-
-/// `BanNoticeScreens.getBanStatusText`.
-fn status_text(ban: &BanDetails, now_ms: i64) -> Text {
-    match ban.expires_ms {
-        Some(expires) => {
-            let duration = Text::translate(
-                "gui.banned.description.temporary.duration",
-                &[duration_text(expires - now_ms)],
-            )
-            .bold();
-            Text::translate("gui.banned.description.temporary", &[duration])
-        }
-        None => Text::translate("gui.banned.description.permanent", &[]).bold(),
-    }
-}
-
-/// `BanNoticeScreens.getBanDurationText`: days past 72 hours, else hours,
-/// else minutes (`Duration.toHours` and friends truncate toward zero).
-fn duration_text(millis: i64) -> Text {
-    let count = |n: i64| Text::literal(n.to_string());
-    let hours = millis / 3_600_000;
-    if hours > 72 {
-        Text::translate("gui.days", &[count(millis / 86_400_000)])
-    } else if hours < 1 {
-        Text::translate("gui.minutes", &[count(millis / 60_000)])
-    } else {
-        Text::translate("gui.hours", &[count(hours)])
-    }
-}
-
-/// `Instant` as authlib's gson adapter reads it: an ISO-8601 string, or epoch milliseconds.
-fn parse_instant(value: &serde_json::Value) -> Option<i64> {
-    match value {
-        serde_json::Value::Number(n) => n.as_i64(),
-        serde_json::Value::String(s) => chrono::DateTime::parse_from_rfc3339(s)
-            .ok()
-            .map(|t| t.timestamp_millis())
-            .or_else(|| s.parse().ok()),
-        _ => None,
-    }
-}
-
-/// `UserAttributesResponse` into `UserProperties` (`fetchProperties`). Bad JSON
-/// is an error, which vanilla answers with the offline properties.
-pub fn parse_properties(body: &str) -> Option<UserProperties> {
-    let v: serde_json::Value = serde_json::from_str(body).ok()?;
-    let servers_allowed = v
-        .pointer("/privileges/multiplayerServer/enabled")
-        .and_then(|e| e.as_bool())
-        .unwrap_or(false);
-    let multiplayer_ban = v
-        .pointer("/banStatus/bannedScopes/MULTIPLAYER")
-        .filter(|b| b.is_object())
-        .map(|b| {
-            let text = |k: &str| b.get(k).and_then(|s| s.as_str()).map(str::to_owned);
-            BanDetails {
-                expires_ms: b.get("expires").and_then(parse_instant),
-                reason: text("reason"),
-                reason_message: text("reasonMessage"),
-            }
-        });
-    Some(UserProperties {
-        servers_allowed,
-        multiplayer_ban,
-    })
-}
-
-/// `MinecraftProfilePropertiesResponse.profileActions` into `ProfileActionType`s.
-pub fn parse_profile_actions(body: &str) -> ProfileActions {
-    let mut actions = ProfileActions::default();
-    let v: serde_json::Value = serde_json::from_str(body).unwrap_or_default();
-    for action in v
-        .get("profileActions")
-        .and_then(|a| a.as_array())
-        .into_iter()
-        .flatten()
-    {
-        match action.get("type").and_then(|t| t.as_str()) {
-            Some("FORCED_NAME_CHANGE") => actions.forced_name_change = true,
-            Some("USING_BANNED_SKIN") => actions.using_banned_skin = true,
-            _ => {}
-        }
-    }
-    actions
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const HOUR: i64 = 3_600_000;
-    /// 2026-11-01T00:00:00Z.
-    const EXPIRES: i64 = 1_793_491_200_000;
-
-    #[test]
-    fn parses_a_multiplayer_ban() {
-        let body = r#"{"privileges":{"multiplayerServer":{"enabled":false}},
-            "banStatus":{"bannedScopes":{"MULTIPLAYER":{"banId":"6b0f0a0e-0000-4000-8000-000000000000",
-            "expires":"2026-11-01T00:00:00Z","reason":"21","reasonMessage":"x"}}}}"#;
-        let p = parse_properties(body).unwrap();
-        assert!(!p.servers_allowed);
-        let ban = p.multiplayer_ban.unwrap();
-        assert_eq!(ban.expires_ms, Some(EXPIRES));
-        assert_eq!(ban.reason.as_deref(), Some("21"));
-        let numeric =
-            parse_properties(r#"{"banStatus":{"bannedScopes":{"MULTIPLAYER":{"expires":5}}}}"#)
-                .unwrap();
-        assert_eq!(numeric.multiplayer_ban.unwrap().expires_ms, Some(5));
-        assert!(parse_properties("nope").is_none());
-        let clean = parse_properties(
-            r#"{"privileges":{"multiplayerServer":{"enabled":true}},"banStatus":{"bannedScopes":{}}}"#,
-        )
-        .unwrap();
-        assert!(clean.servers_allowed && clean.multiplayer_ban.is_none());
-    }
-
-    #[test]
-    fn parses_profile_actions() {
-        let a = parse_profile_actions(
-            r#"{"id":"x","profileActions":[{"type":"FORCED_NAME_CHANGE"},{"type":"OTHER"}]}"#,
-        );
-        assert!(a.forced_name_change && !a.using_banned_skin);
-        let a = parse_profile_actions(r#"{"profileActions":[{"type":"USING_BANNED_SKIN"}]}"#);
-        assert!(!a.forced_name_change && a.using_banned_skin);
-        assert_eq!(parse_profile_actions("{}"), ProfileActions::default());
-    }
-
-    #[test]
-    fn queues_in_vanilla_order() {
-        let ban = BanDetails {
-            expires_ms: None,
-            reason: None,
-            reason_message: None,
-        };
-        let status = AccountStatus {
-            properties: UserProperties {
-                servers_allowed: true,
-                multiplayer_ban: Some(ban.clone()),
-            },
-            actions: ProfileActions {
-                forced_name_change: true,
-                using_banned_skin: true,
-            },
-        };
-        assert_eq!(
-            initial_notices(&status, "Steve"),
-            vec![
-                Notice::Multiplayer(ban),
-                Notice::Name("Steve".into()),
-                Notice::Skin
-            ]
-        );
-        assert!(!status.allows_multiplayer());
-        assert!(initial_notices(&AccountStatus::default(), "Steve").is_empty());
-        assert!(AccountStatus::default().allows_multiplayer());
-        let no_servers = AccountStatus {
-            properties: UserProperties {
-                servers_allowed: false,
-                multiplayer_ban: None,
-            },
-            ..Default::default()
-        };
-        assert!(!no_servers.allows_multiplayer());
-    }
-
-    /// The message's component JSON: the keys and arguments, whatever language is loaded.
-    fn json(notice: &Notice, now: i64) -> String {
-        notice.message(now).component().to_string()
-    }
-
-    #[test]
-    fn ban_text_follows_banned_screens() {
-        let temp = |reason: Option<&str>, message: Option<&str>| {
-            Notice::Multiplayer(BanDetails {
-                expires_ms: Some(100 * HOUR),
-                reason: reason.map(str::to_owned),
-                reason_message: message.map(str::to_owned),
-            })
-        };
-        assert_eq!(
-            temp(None, None).title().translation_key(),
-            Some("gui.banned.title.temporary")
-        );
-        let perm = Notice::Multiplayer(BanDetails {
-            expires_ms: None,
-            reason: Some("5".into()),
-            reason_message: None,
-        });
-        assert_eq!(
-            perm.title().translation_key(),
-            Some("gui.banned.title.permanent")
-        );
-        let text = json(&perm, 0);
-        assert!(text.contains("gui.banned.reason.hate_speech"));
-        assert!(text.contains("gui.banned.description.permanent"));
-        assert!(text.contains(SUSPENSION_HELP));
-        // Unknown ids show their code, with the message when there is one.
-        let with_message = json(&temp(Some("999"), Some("why")), 0);
-        assert!(with_message.contains("gui.banned.description.reason_id_message"));
-        assert!(with_message.contains("why"));
-        assert!(json(&temp(Some("999"), None), 0).contains("gui.banned.description.reason_id\""));
-        assert!(json(&temp(Some("abc"), None), 0).contains("gui.banned.description.unknownreason"));
-        // 100 hours left is past 72: days (4); less is hours; under an hour is minutes.
-        let duration = |now| json(&temp(None, None), now);
-        assert!(duration(0).contains("gui.days") && duration(0).contains("[4]"));
-        assert!(duration(60 * HOUR).contains("gui.hours") && duration(60 * HOUR).contains("[40]"));
-        let minutes = duration(100 * HOUR - 90_000);
-        assert!(minutes.contains("gui.minutes") && minutes.contains("[1]"));
-        assert!(json(&Notice::Name("Bob".into()), 0).contains("Bob"));
-        assert!(json(&Notice::Skin, 0).contains(SUSPENSION_HELP));
-    }
-}

crates/horizon-client-render/src/block_entities.rs

@@ -23,7 +23,7 @@
 //! Which states tick is a table by state id, built by the game from the block
 //! registry; whether a slot is made is decided when the slot is promoted at
 //! the start of the next tick, from the block state then.
-use crate::chunk::block_entity::{BlockEntity, ModContainer, ModFluidTanks};
+use crate::chunk::block_entity::{BlockEntity, ModContainer};
 use crate::fast_hash::{FxHashMap, FxHashSet};
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -73,9 +73,6 @@ pub struct BlockEntities {
     /// The containers of mod blocks' block entities, by block state id;
     /// built with `states`.
     mod_containers: FxHashMap<u32, Arc<ModContainer>>,
-    /// The fluid tanks of mod blocks' block entities, by block state id;
-    /// built with `states`, like the containers.
-    mod_fluids: FxHashMap<u32, Arc<ModFluidTanks>>,
 }
 
 impl std::ops::Deref for BlockEntities {
@@ -165,13 +162,6 @@ impl BlockEntities {
     pub fn mod_container(&self, state: u32) -> Option<&Arc<ModContainer>> {
         self.mod_containers.get(&state)
     }
-    pub fn set_mod_fluids(&mut self, fluids: FxHashMap<u32, Arc<ModFluidTanks>>) {
-        self.mod_fluids = fluids;
-    }
-    /// The fluid tanks of a mod block's block entity in block state `state`.
-    pub fn mod_fluids(&self, state: u32) -> Option<&Arc<ModFluidTanks>> {
-        self.mod_fluids.get(&state)
-    }
 
     fn next(&mut self) -> u32 {
         let n = self.next_slot;

crates/horizon-client-render/src/block_entity_render.rs

@@ -789,8 +789,6 @@ pub struct Scene<'a> {
     pub glyphs: u64,
 }
 
-/// Empty by default (a dedicated server): no state has a block entity model.
-#[derive(Default)]
 pub struct BlockEntityRenderer {
     models: HashMap<&'static str, ModelPart>,
     kinds: Vec<Kind>,
@@ -1118,10 +1116,9 @@ impl BlockEntityRenderer {
     }
     /// `submitCrumblingOverlay` of ChestRenderer.submit, BannerRenderer.submit,
     /// SkullBlockRenderer.submitSkull, ShulkerBoxRenderer.submit,
-    /// BellRenderer.submit, LecternRenderer.submit (the book),
-    /// CopperGolemStatueBlockRenderer.submit, ConduitRenderer.submit (the shell
-    /// or cage) and EnchantTableRenderer.submit (the book): the model drawn
-    /// again under the destroy stage.
+    /// BellRenderer.submit, LecternRenderer.submit (the book) and
+    /// CopperGolemStatueBlockRenderer.submit: the model drawn again under the
+    /// destroy stage.
     pub fn render_breaking(
         &self,
         scene: &Scene,
@@ -1139,8 +1136,6 @@ impl BlockEntityRenderer {
                 | Kind::Bell
                 | Kind::Lectern { .. }
                 | Kind::CopperGolem { .. }
-                | Kind::Conduit
-                | Kind::EnchantingTable
         ) {
             return;
         }
@@ -1495,7 +1490,6 @@ impl BlockEntityRenderer {
                 } else {
                     None
                 };
-                let has_profile = skin.is_some();
                 let texture = skin.as_deref().unwrap_or(texture);
                 let (Some(model), Some(paint)) =
                     (self.models.get(model), paint(texture, 0xFFFFFF, packed))
@@ -1530,13 +1524,7 @@ impl BlockEntityRenderer {
                     "right_ear" => p[5] = (f64::from(t * PI * 0.2).cos() + 2.5) as f32 * 0.2,
                     _ => {}
                 };
-                let start = out.len();
                 draw_part(model, "root", m, &anim, paint, out);
-                // `SkullBlockRenderer.resolveSkullRenderType`: a head with a profile takes
-                // the player skin's `entityTranslucent` render type.
-                if has_profile {
-                    crate::gfx::mark_oit(&mut out[start..]);
-                }
             }
             Kind::Bell => {
                 let (Some(model), Some(paint)) = (
@@ -1686,10 +1674,6 @@ impl BlockEntityRenderer {
                         * Mat4::from_quat(Quat::from_axis_angle(axis, degrees * (PI / 180.0)));
                     draw_part(model, "root", m, &none, paint, out);
                 }
-                // The crumbling overlay covers the shell and the cage only.
-                if crumbling {
-                    return;
-                }
                 let wind = if phase == 1 {
                     "entity/conduit/wind_vertical"
                 } else {

crates/horizon-client-render/src/brewing.rs

@@ -12,9 +12,8 @@ use serde_json::Value;
 use std::{collections::HashSet, fs, path::Path};
 
 pub use horizon_client_core::potions::{
-    BASE_POTION_COLOR, Category, EFFECTS, EffectDef, POTIONS, PotionDef, all_effects,
-    description_id, effect, is_mod_effect, mod_effects, namespaced, potion, potion_color,
-    register_mod_effects,
+    BASE_POTION_COLOR, Category, EFFECTS, EffectDef, POTIONS, PotionDef, effect, namespaced,
+    potion, potion_color,
 };
 /// `MobEffectUtil.formatDuration` at 20 TPS.
 pub fn format_duration(ticks: i32) -> String {
@@ -81,7 +80,8 @@ pub fn effect_lines<'a>(
         .into_iter()
         .map(|(e, duration, amp)| {
             let e = e.trim_start_matches("minecraft:");
-            let mut line = translate(&description_id(e)).unwrap_or_else(|| e.to_owned());
+            let mut line =
+                translate(&format!("effect.minecraft.{e}")).unwrap_or_else(|| e.to_owned());
             if amp > 0 {
                 line.push(' ');
                 line.push_str(

crates/horizon-client-render/src/camera.rs

@@ -434,10 +434,6 @@ pub struct Camera {
     pub up: [f32; 3],
     pub left: [f32; 3],
     pub detached: bool,
-    /// The entity's eye and view rotation (yaw, pitch), where a detached camera backs off
-    /// from.
-    pub eye: [f64; 3],
-    pub eye_rotation: [f32; 2],
 }
 impl Default for Camera {
     fn default() -> Self {
@@ -454,8 +450,6 @@ impl Default for Camera {
             up: [0.0, 1.0, 0.0],
             left: [-1.0, 0.0, 0.0],
             detached: false,
-            eye: [0.0; 3],
-            eye_rotation: [0.0; 2],
         }
     }
 }
@@ -511,8 +505,6 @@ impl Camera {
                 + f64::from(lerp(partial, self.eye_height_old, self.eye_height)),
             lerp_d(p, entity.previous[2], entity.position[2]),
         ];
-        self.eye = self.position;
-        self.eye_rotation = [self.y_rot, self.x_rot];
         self.detached = !camera_type.is_first_person();
         if self.detached {
             if camera_type.is_mirrored() {

crates/horizon-client-render/src/chat.rs

@@ -210,14 +210,6 @@ impl Tag {
             text: Text::translate("chat.tag.not_secure", &[]),
         }
     }
-    /// `GuiMessageTag.chatError`: red (`CHAT_ERROR`, 16733525), the tooltip `chat.tag.error`.
-    pub fn chat_error() -> Self {
-        Self {
-            color: 0xFF_5555,
-            icon: false,
-            text: Text::translate("chat.tag.error", &[]),
-        }
-    }
     /// `GuiMessageTag.chatModified`: the tooltip adds the original content in grey.
     pub fn modified(original_content: &str) -> Self {
         Self {
@@ -878,22 +870,6 @@ impl Chat {
     }
 }
 
-/// `SuggestionsList.getNarrationMessage` for entry `index` of `count`.
-fn suggestion_narration(index: usize, count: usize, text: &str, tooltip: Option<&str>) -> Text {
-    let mut args = vec![
-        Text::literal((index + 1).to_string()),
-        Text::literal(count.to_string()),
-        Text::literal(text),
-    ];
-    match tooltip {
-        Some(tooltip) => {
-            args.push(Text::literal(tooltip));
-            Text::translate("narration.suggestion.tooltip", &args)
-        }
-        None => Text::translate("narration.suggestion", &args),
-    }
-}
-
 /// `CommandSuggestions.SuggestionsList`.
 #[derive(Clone, Debug)]
 struct SuggestionList {
@@ -905,17 +881,8 @@ struct SuggestionList {
     current: usize,
     last_mouse: (i32, i32),
     tab_cycles: bool,
-    /// `lastNarratedEntry`: the entry the narrator last said (-1: none yet).
-    last_narrated: isize,
 }
 impl SuggestionList {
-    /// `getNarrationMessage`: "Selected suggestion 2 out of 5: …", with its
-    /// tooltip when it has one. It marks the entry said.
-    fn narration_message(&mut self) -> Text {
-        self.last_narrated = self.current as isize;
-        let s = &self.list[self.current];
-        suggestion_narration(self.current, self.list.len(), &s.text, s.tooltip.as_deref())
-    }
     fn contains(&self, x: i32, y: i32) -> bool {
         let [rx, ry, w, h] = self.rect;
         x >= rx && x <= rx + w && y >= ry && y <= ry + h
@@ -1038,53 +1005,6 @@ fn last_word_index(s: &str) -> usize {
     }
     if prev_space { s.len() } else { out }
 }
-/// `ChatScreen.normalizeChatMessage`: `String.trim`, then
-/// `StringUtils.normalizeSpace` (one space for every run of whitespace), then
-/// `StringUtil.trimChatMessage` (the first 256 UTF-16 code units, the length
-/// `ServerboundChatPacket`'s `stringUtf8(256)` decodes). The chat screen sends
-/// this, not what was typed: a line of spaces sends nothing, and a message the
-/// packet cannot hold is cut on the client, as vanilla's is, instead of by the
-/// server.
-pub fn normalize_chat_message(message: &str) -> String {
-    // String.trim: the code points up to U+0020, which is not `str::trim`'s
-    // Unicode whitespace (U+00A0 is not Java whitespace and stays).
-    let trimmed = message.trim_matches(|c: char| c <= ' ');
-    truncate_utf16(&normalize_space(trimmed), 256)
-}
-/// `StringUtils.normalizeSpace`: one space for every run of
-/// `Character.isWhitespace`, and none at either end.
-fn normalize_space(s: &str) -> String {
-    let mut out = String::with_capacity(s.len());
-    let mut space = false;
-    for c in s.chars() {
-        if crate::ui::java_whitespace(c) {
-            space = !out.is_empty();
-        } else {
-            if space {
-                out.push(' ');
-                space = false;
-            }
-            out.push(c);
-        }
-    }
-    out
-}
-/// `StringUtil.truncateStringIfNecessary(s, 256, false)`: Java counts UTF-16
-/// code units (`String.length`), so 129 emoji are cut to 128 of them, where
-/// `chars().take(256)` would keep all 129 (258 units) for the server to
-/// reject. A cut between the halves of a surrogate pair keeps the character
-/// below it: vanilla's `substring` leaves half a pair, which a Java `String`
-/// may hold and a Rust `String` may not.
-fn truncate_utf16(s: &str, max_units: usize) -> String {
-    let mut units = 0;
-    for (byte, c) in s.char_indices() {
-        units += c.len_utf16();
-        if units > max_units {
-            return s[..byte].to_owned();
-        }
-    }
-    s.to_owned()
-}
 impl ChatScreen {
     /// `ChatScreen.init`: the input at the bottom, focused, holding `initial`.
     pub fn new(
@@ -1174,14 +1094,12 @@ impl ChatScreen {
             let value = self.input.value.clone();
             let auto = self.auto_suggestions;
             let abilities = self.abilities;
-            let message = std::mem::take(&mut self.input.message);
             *self = if self.layout == SuggestLayout::CHAT {
                 Self::new(m, c, &value, self.history_pos, width, height, abilities)
             } else {
                 Self::command_block(m, c, &value, width, height)
             };
             self.auto_suggestions = auto;
-            self.input.message = message;
         }
     }
     /// `ChatScreen.onEdited`.
@@ -1405,12 +1323,11 @@ impl ChatScreen {
         };
         self.suggestions = None;
         if self.allow_suggestions && self.auto_suggestions {
-            self.show_suggestions(m, false);
+            self.show_suggestions(m);
         }
     }
-    /// `CommandSuggestions.showSuggestions`: `immediate` (Tab asked for
-    /// them) has the narrator say the first one at once.
-    fn show_suggestions(&mut self, m: &Measure, immediate: bool) {
+    /// `CommandSuggestions.showSuggestions`.
+    fn show_suggestions(&mut self, m: &Measure) {
         let Some((start, list)) = self.pending.clone() else {
             return;
         };
@@ -1453,7 +1370,6 @@ impl ChatScreen {
             current: 0,
             last_mouse: (0, 0),
             tab_cycles: false,
-            last_narrated: if immediate { -1 } else { 0 },
         };
         self.select(&mut l, 0);
         self.suggestions = Some(l);
@@ -1473,9 +1389,6 @@ impl ChatScreen {
         self.input.suggestion = applied
             .strip_prefix(self.input.value.as_str())
             .map(str::to_owned);
-        if l.last_narrated != l.current as isize {
-            horizon_narrator::say_system_now(&l.narration_message().plain());
-        }
     }
     fn cycle(&mut self, l: &mut SuggestionList, dir: isize) {
         self.select(l, l.current as isize + dir);
@@ -1586,7 +1499,7 @@ impl ChatScreen {
             self.suggestions = Some(l);
             handled
         } else if key == K::Tab {
-            self.show_suggestions(m, true);
+            self.show_suggestions(m);
             true
         } else {
             false
@@ -1819,18 +1732,4 @@ impl ChatScreen {
     pub fn suggestions_visible(&self) -> bool {
         self.suggestions.is_some()
     }
-    /// `CommandSuggestions.getUsageNarration` while the list shows
-    /// (`isVisible`): whether Tab cycles it or fills the input in, and
-    /// whether Escape hides it (`allowHiding`, which only the chat's turns
-    /// off).
-    pub fn suggestions_usage(&self) -> Option<&'static str> {
-        let list = self.suggestions.as_ref()?;
-        let hidable = self.layout != SuggestLayout::CHAT;
-        Some(match (list.tab_cycles, hidable) {
-            (true, true) => "narration.suggestion.usage.cycle.hidable",
-            (true, false) => "narration.suggestion.usage.cycle.fixed",
-            (false, true) => "narration.suggestion.usage.fill.hidable",
-            (false, false) => "narration.suggestion.usage.fill.fixed",
-        })
-    }
 }

crates/horizon-client-render/src/chat_tests.rs

@@ -578,71 +578,3 @@ fn a_deleted_message_shows_60_ticks_then_becomes_the_marker() {
     assert_eq!(lines(&chat), [marker.clone(), marker]);
     assert!(chat.deletions.is_empty());
 }
-
-/// `SuggestionsList.select` says an entry once (`lastNarratedEntry`), as
-/// "suggestion N out of M", with its tooltip when it has one.
-#[test]
-fn a_suggestion_is_narrated_by_its_place_once() {
-    let suggestion = |text: &str, tooltip: Option<&str>| Suggestion {
-        range: (1, 1),
-        text: text.into(),
-        tooltip: tooltip.map(str::to_owned),
-        int_value: None,
-    };
-    let mut l = SuggestionList {
-        rect: [0; 4],
-        original: "/".into(),
-        list: vec![
-            suggestion("give", None),
-            suggestion("gamemode", Some("Mode")),
-        ],
-        offset: 0,
-        current: 1,
-        last_mouse: (0, 0),
-        tab_cycles: false,
-        last_narrated: 0,
-    };
-    let said = l.narration_message().component();
-    assert_eq!(l.last_narrated, 1);
-    assert_eq!(said["translate"], "narration.suggestion.tooltip");
-    assert_eq!(said["with"].as_array().map(Vec::len), Some(4));
-    l.current = 0;
-    let said = l.narration_message().component();
-    assert_eq!(said["translate"], "narration.suggestion");
-    assert_eq!(said["with"].as_array().map(Vec::len), Some(3));
-}
-
-#[test]
-fn a_chat_message_is_trimmed_and_its_whitespace_runs_collapsed() {
-    // ChatScreen.normalizeChatMessage: String.trim, then StringUtils
-    // .normalizeSpace, so a command gets the arguments the player meant.
-    assert_eq!(normalize_chat_message("  hello   there  "), "hello there");
-    assert_eq!(normalize_chat_message("/msg  Alex\thi"), "/msg Alex hi");
-    assert_eq!(normalize_chat_message("a\n\nb\r\nc"), "a b c");
-    assert_eq!(normalize_chat_message("\t \n"), "");
-    assert_eq!(normalize_chat_message(""), "");
-    // Character.isWhitespace is not str::trim's Unicode whitespace: U+00A0 is
-    // no Java whitespace, so it is neither trimmed nor collapsed, while the
-    // ideographic space U+3000 and Java's U+001C separators are.
-    assert_eq!(normalize_chat_message(" \u{a0} hi"), "\u{a0} hi");
-    assert_eq!(normalize_chat_message("a\u{a0}\u{a0}b"), "a\u{a0}\u{a0}b");
-    assert_eq!(normalize_chat_message("a\u{3000}\u{3000}b"), "a b");
-    assert_eq!(normalize_chat_message("a\u{1c}b"), "a b");
-}
-
-#[test]
-fn a_chat_message_is_cut_to_the_256_utf16_units_the_packet_holds() {
-    // StringUtil.trimChatMessage counts String.length(), UTF-16 code units:
-    // 256 ASCII characters are all kept, 257 are cut to 256.
-    assert_eq!(normalize_chat_message(&"a".repeat(256)).len(), 256);
-    assert_eq!(normalize_chat_message(&"a".repeat(300)).len(), 256);
-    // An emoji is two units, so 128 of them fill the packet and the 129th is
-    // dropped: chars().take(256) would keep all 129 and the server would
-    // reject the message.
-    let emoji = normalize_chat_message(&"\u{1f600}".repeat(129));
-    assert_eq!(emoji, "\u{1f600}".repeat(128));
-    assert_eq!(emoji.encode_utf16().count(), 256);
-    // A cut between the halves of a pair keeps the character below it.
-    let mixed = format!("{}\u{1f600}", "b".repeat(255));
-    assert_eq!(normalize_chat_message(&mixed), "b".repeat(255));
-}

crates/horizon-client-render/src/chunk.rs

@@ -212,7 +212,7 @@ impl Default for ColumnLayout {
 
 /// Biomes are 4x4x4 containers over the biome table (67 entries: a 7-bit
 /// global palette).
-pub const BIOME_STRATEGY: Strategy = Strategy::biomes(8);
+pub const BIOME_STRATEGY: Strategy = Strategy::biomes(7);
 
 /// Bits of the block states' global palette: 16 for vanilla's 35,723 states
 /// (what vanilla servers and clients send), more when content mods add states
@@ -391,9 +391,6 @@ pub struct Chunk {
     pub light_loaded: bool,
     /// Newly generated (not loaded from a save): eligible for generation-time spawns.
     pub fresh: bool,
-    /// Finished from a proto chunk just now, in any kind of world, not read
-    /// from a save (`ChunkEvent.Load`'s `isNewChunk`).
-    pub generated: bool,
     /// Block entities read from a save, moved into the world on arrival.
     pub block_entities: Vec<((i32, i32, i32), block_entity::BlockEntity)>,
     /// `CustomName` of the container block entities (shown as the screen title).
@@ -431,7 +428,6 @@ impl Chunk {
             lit: false,
             light_loaded: false,
             fresh: false,
-            generated: false,
             block_entities: Vec::new(),
             block_names: Vec::new(),
             structure_refs: Vec::new(),

crates/horizon-client-render/src/chunk/block_entity.rs

@@ -120,21 +120,6 @@ pub struct ModContainer {
     pub outputs: Vec<usize>,
     pub menu: Option<String>,
 }
-/// The fluid tanks of a mod block's block entity, in the container's shape:
-/// each tank's capacity in millibuckets, the tanks each face reaches, and
-/// the tanks a fill may reach and a drain may take. The tanks' contents are
-/// not here: they live in the entity's saved compound, under `fluids`, so
-/// they survive restarts and the block's own tick reads them.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct ModFluidTanks {
-    /// Each tank's capacity in millibuckets, in tank order.
-    pub tanks: Vec<i32>,
-    pub faces: [Vec<usize>; 6],
-    /// The tanks a fill may reach (`canPlaceItemThroughFace`).
-    pub inputs: Vec<usize>,
-    /// The tanks a drain may take from (`canTakeItemThroughFace`).
-    pub outputs: Vec<usize>,
-}
 /// The vanilla menus a mod container can open, with the slot count each
 /// shows: slot grids, and the furnaces' (input, fuel, result), whose four
 /// data slots draw the flame (`data[0]` of `data[1]`) and the arrow
@@ -291,19 +276,11 @@ pub struct Beacon {
 }
 #[derive(Clone, Debug, Default)]
 pub struct Jukebox {
-    /// `JukeboxBlockEntity`'s one slot (`ContainerSingleItem`), so a hopper or
-    /// a dropper reaches it as it reaches any container.
-    pub items: [Option<ItemStack>; 1],
+    pub record: Option<ItemStack>,
     /// `ticks_since_song_started`, while a song plays.
     pub ticks: i64,
     pub playing: bool,
 }
-impl Jukebox {
-    /// `JukeboxBlockEntity.getTheItem`: the disc it holds.
-    pub fn record(&self) -> Option<&ItemStack> {
-        self.items[0].as_ref()
-    }
-}
 /// `BrewingStandBlockEntity` state. Slots: 0-2 bottles, 3 ingredient, 4 fuel.
 #[derive(Clone, Debug, Default)]
 pub struct BrewingStand {

crates/horizon-client-render/src/chunk_map.rs

@@ -1,13 +1,7 @@
 //! Resident chunk membership, with a token for consumers that cache its keys.
-use crate::{
-    chunk::Chunk,
-    fast_hash::{FxHashMap, FxHashSet},
-};
+use crate::{chunk::Chunk, fast_hash::FxHashMap};
 use std::{
-    collections::{
-        VecDeque,
-        hash_map::{Iter, ValuesMut},
-    },
+    collections::hash_map::{Iter, ValuesMut},
     ops::Deref,
     sync::{
         Arc,
@@ -22,46 +16,18 @@ fn next_revision() -> u64 {
     NEXT_REVISION.fetch_add(1, Ordering::Relaxed)
 }
 
-/// The membership changes one map keeps for the consumers that read them
-/// every tick (`TickChunkMembership.synchronize`); older ones are dropped.
-const MAX_RECENT_DELTAS: usize = 256;
-
-/// One membership change of one `ChunkMap`, stamped with the revision it
-/// brought the map to.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum ChunkMembershipDelta {
-    Added(Key),
-    Removed(Key),
-    Reset,
-}
-
 /// Read access behaves like a map. Structural writes are explicit so edits to
 /// blocks or light don't invalidate consumers of the loaded chunk key set.
 /// Tokens are process-wide: replacing the entire map also invalidates caches.
 pub struct ChunkMap {
     columns: Columns,
     revision: u64,
-    /// The oldest revision `recent_deltas` still answers for: the revision of
-    /// the change it last dropped, or the revision that cleared them. A
-    /// consumer holding an older one rebuilds, it does not replay.
-    min_valid_revision: u64,
-    /// This map's recent membership changes, in revision order.
-    /// Revisions are process-wide: the numbers missing in between belong to
-    /// the other maps (a server thread's, another dimension's), which say
-    /// nothing about this one's keys.
-    recent_deltas: VecDeque<(u64, ChunkMembershipDelta)>,
-    /// The resident chunks generation has not placed its animals in yet.
-    fresh: FxHashSet<Key>,
 }
 impl Default for ChunkMap {
     fn default() -> Self {
-        let revision = next_revision();
         Self {
             columns: Columns::default(),
-            revision,
-            min_valid_revision: revision,
-            recent_deltas: VecDeque::new(),
-            fresh: FxHashSet::default(),
+            revision: next_revision(),
         }
     }
 }
@@ -69,107 +35,26 @@ impl ChunkMap {
     pub fn membership_revision(&self) -> u64 {
         self.revision
     }
-    fn record_delta(&mut self, delta: ChunkMembershipDelta) {
-        if self.recent_deltas.len() >= MAX_RECENT_DELTAS
-            && let Some((evicted, _)) = self.recent_deltas.pop_front()
-        {
-            self.min_valid_revision = evicted;
-        }
-        self.recent_deltas.push_back((self.revision, delta));
-    }
-    /// This map's membership changes since `last_revision`, one of its own
-    /// earlier `membership_revision`s, or `None` when they can no longer be
-    /// answered: the consumer's revision predates what the ring kept, the map
-    /// was cleared since (a reset rebuilds everything), or the revision is not
-    /// this map's, which its own revisions give away: every one of them in the
-    /// answered range is the opening revision or a change the ring still
-    /// holds, so a revision another map took in between is refused, not
-    /// replayed.
-    pub fn deltas_since(
-        &self,
-        last_revision: u64,
-    ) -> Option<impl Iterator<Item = (u64, ChunkMembershipDelta)> + '_> {
-        if last_revision == 0
-            || last_revision < self.min_valid_revision
-            || last_revision > self.revision
-            || self.recent_deltas.is_empty()
-        {
-            return None;
-        }
-        let pos = self
-            .recent_deltas
-            .partition_point(|(rev, _)| *rev <= last_revision);
-        // A revision this map never took: another map's, drawing on the same
-        // process-wide counter. Only the opening revision and the ones the
-        // ring still holds are this map's.
-        let is_own_revision = last_revision == self.min_valid_revision
-            || (pos > 0 && self.recent_deltas[pos - 1].0 == last_revision);
-        if !is_own_revision {
-            return None;
-        }
-        let slice = self.recent_deltas.range(pos..);
-        if slice
-            .clone()
-            .any(|(_, d)| *d == ChunkMembershipDelta::Reset)
-        {
-            return None;
-        }
-        Some(slice.copied())
-    }
     pub fn insert(&mut self, key: Key, chunk: Arc<Chunk>) -> Option<Arc<Chunk>> {
-        if chunk.fresh {
-            self.fresh.insert(key);
-        } else {
-            self.fresh.remove(&key);
-        }
         let previous = self.columns.insert(key, chunk);
         if previous.is_none() {
             self.revision = next_revision();
-            self.record_delta(ChunkMembershipDelta::Added(key));
         }
         previous
     }
     pub fn remove(&mut self, key: &Key) -> Option<Arc<Chunk>> {
-        self.fresh.remove(key);
         let previous = self.columns.remove(key);
         if previous.is_some() {
             self.revision = next_revision();
-            self.record_delta(ChunkMembershipDelta::Removed(*key));
         }
         previous
     }
     pub fn clear(&mut self) {
         if !self.columns.is_empty() {
             self.columns.clear();
-            self.fresh.clear();
             self.revision = next_revision();
-            self.recent_deltas.clear();
-            self.recent_deltas
-                .push_back((self.revision, ChunkMembershipDelta::Reset));
-            self.min_valid_revision = self.revision;
         }
     }
-    pub fn has_fresh(&self) -> bool {
-        !self.fresh.is_empty()
-    }
-    /// The fresh keys in the chunk map's own iteration order, so the spawns
-    /// they drive run in the order a scan of the columns gave.
-    pub fn fresh_keys_ordered(&self) -> Vec<Key> {
-        if self.fresh.is_empty() {
-            Vec::new()
-        } else if self.fresh.len() == 1 {
-            self.fresh.iter().copied().collect()
-        } else {
-            self.columns
-                .keys()
-                .filter(|k| self.fresh.contains(k))
-                .copied()
-                .collect()
-        }
-    }
-    pub fn remove_fresh(&mut self, key: &Key) {
-        self.fresh.remove(key);
-    }
     pub fn get_mut(&mut self, key: &Key) -> Option<&mut Arc<Chunk>> {
         self.columns.get_mut(key)
     }
@@ -240,146 +125,4 @@ mod tests {
         map = ChunkMap::default();
         assert_ne!(cleared, map.membership_revision());
     }
-
-    /// The deltas' kinds, checking the ring answers in revision order.
-    fn kinds(deltas: Vec<(u64, ChunkMembershipDelta)>) -> Vec<ChunkMembershipDelta> {
-        let mut last = 0;
-        for (rev, _) in &deltas {
-            assert!(*rev > last, "the ring answers in revision order");
-            last = *rev;
-        }
-        deltas.into_iter().map(|(_, d)| d).collect()
-    }
-
-    /// Revision numbers are process-wide: the ones another map takes in
-    /// between, and a payload-only rewrite that takes none at all, say nothing
-    /// about this map's keys.
-    #[test]
-    fn deltas_since_ignores_revisions_other_maps_take() {
-        let mut map = ChunkMap::default();
-        let mut other = ChunkMap::default();
-        let chunk = Arc::new(Chunk::empty(0, 0));
-        map.insert((0, 0), chunk.clone());
-        let seen = map.membership_revision();
-        for key in [(1, 0), (2, 0), (3, 0)] {
-            other.insert(key, chunk.clone());
-        }
-        map.insert((0, 0), Arc::new(Chunk::empty(0, 0))); // Payload only.
-        map.insert((4, 0), chunk.clone());
-        map.remove(&(0, 0));
-        assert_eq!(
-            kinds(map.deltas_since(seen).unwrap().collect()),
-            [
-                ChunkMembershipDelta::Added((4, 0)),
-                ChunkMembershipDelta::Removed((0, 0)),
-            ]
-        );
-        // The consumer's own revision answers, with nothing new since.
-        assert!(
-            map.deltas_since(map.membership_revision())
-                .unwrap()
-                .next()
-                .is_none()
-        );
-        // A revision another map took in between: refused, not replayed.
-        assert!(map.deltas_since(other.membership_revision()).is_none());
-    }
-
-    /// A map built ahead of the live one, its revisions interleaved with it,
-    /// answering for a revision it never took: refused, so the consumer
-    /// rebuilds rather than replay another map's changes.
-    #[test]
-    fn deltas_since_none_for_interleaved_revision_from_another_map() {
-        let mut map = ChunkMap::default();
-        let mut other = ChunkMap::default();
-        let chunk = Arc::new(Chunk::empty(0, 0));
-        map.insert((0, 0), chunk.clone());
-        let seen = map.membership_revision();
-        other.insert((1, 0), chunk.clone());
-        let foreign = other.membership_revision();
-        map.insert((2, 0), chunk.clone());
-        assert!(map.deltas_since(foreign).is_none());
-        assert_eq!(
-            kinds(map.deltas_since(seen).unwrap().collect()),
-            [ChunkMembershipDelta::Added((2, 0))]
-        );
-    }
-
-    /// The ring answers for the changes it kept, and only those.
-    #[test]
-    fn deltas_since_none_for_a_revision_the_ring_dropped() {
-        let mut map = ChunkMap::default();
-        let chunk = Arc::new(Chunk::empty(0, 0));
-        let created = map.membership_revision();
-        let mut revisions = Vec::new();
-        let changes = MAX_RECENT_DELTAS as i32 + 1;
-        for i in 0..changes {
-            map.insert((i, 0), chunk.clone());
-            revisions.push(map.membership_revision());
-        }
-        let (first, kept) = revisions.split_first().unwrap();
-        // The oldest change fell out with the consumer's revision: rebuild.
-        assert!(map.deltas_since(created).is_none());
-        assert_eq!(map.deltas_since(*first).unwrap().count(), kept.len());
-    }
-
-    /// A reset rebuilds whatever the consumer last saw, and the ring answers
-    /// for what follows it.
-    #[test]
-    fn deltas_since_none_across_a_clear() {
-        let mut map = ChunkMap::default();
-        let chunk = Arc::new(Chunk::empty(0, 0));
-        map.insert((0, 0), chunk.clone());
-        let before = map.membership_revision();
-        map.clear();
-        assert!(map.deltas_since(before).is_none());
-        let cleared = map.membership_revision();
-        map.insert((1, 0), chunk);
-        assert_eq!(
-            kinds(map.deltas_since(cleared).unwrap().collect()),
-            [ChunkMembershipDelta::Added((1, 0))]
-        );
-    }
-
-    #[test]
-    fn fresh_chunks_tracking() {
-        let mut map = ChunkMap::default();
-        assert!(!map.has_fresh());
-        let mut chunk = Chunk::empty(1, 2);
-        chunk.fresh = true;
-        map.insert((1, 2), Arc::new(chunk));
-        assert!(map.has_fresh());
-        assert_eq!(map.fresh_keys_ordered(), vec![(1, 2)]);
-
-        map.remove_fresh(&(1, 2));
-        assert!(!map.has_fresh());
-
-        let mut chunk2 = Chunk::empty(3, 4);
-        chunk2.fresh = true;
-        map.insert((3, 4), Arc::new(chunk2));
-        assert!(map.has_fresh());
-
-        map.remove(&(3, 4));
-        assert!(!map.has_fresh());
-    }
-
-    #[test]
-    fn fresh_keys_ordered_matches_chunk_map_iteration_order() {
-        let mut map = ChunkMap::default();
-        let keys = [(-5, 10), (12, -3), (0, 0), (7, 8), (-1, -1), (4, 4)];
-        for (i, &key) in keys.iter().enumerate() {
-            let mut chunk = Chunk::empty(key.0, key.1);
-            chunk.fresh = i % 2 == 0;
-            map.insert(key, Arc::new(chunk));
-        }
-
-        let ordered = map.fresh_keys_ordered();
-        let expected: Vec<Key> = map
-            .keys()
-            .copied()
-            .filter(|k| map.fresh.contains(k))
-            .collect();
-        assert_eq!(ordered, expected);
-        assert_eq!(ordered.len(), 3);
-    }
 }

crates/horizon-client-render/src/clouds.rs

@@ -169,13 +169,11 @@ impl Mesh {
             let x0 = dx as f32 * 12.0;
             let z0 = dz as f32 * 12.0;
             let (x1, z1, y0, y1) = (x0 + 12.0, z0 + 12.0, 0.0, 4.0);
-            // The face's normal is for shader packs (`gl_Normal`); the game's clouds shade by
-            // `shade`.
-            let mut quad = |p: [[f32; 3]; 4], shade: u32, normal: [i8; 4]| {
+            let mut quad = |p: [[f32; 3]; 4], shade: u32| {
                 for v in p {
                     // Overlay 4: clouds (unlit, faded by the cloud fog end).
                     self.vertices.push(crate::mesher::Vertex {
-                        normal,
+                        normal: [0; 4],
                         pos: v,
                         uv,
                         layer: 4,
@@ -188,41 +186,17 @@ impl Mesh {
             };
             if input.fast {
                 for p in flat_cell(x0, z0, 0.0) {
-                    quad(p, 0, [0; 4]);
+                    quad(p, 0);
                 }
                 continue;
             }
             let quads = [
-                (
-                    [[x1, y0, z0], [x1, y0, z1], [x0, y0, z1], [x0, y0, z0]],
-                    1,
-                    [0, -127, 0, 0],
-                ),
-                (
-                    [[x0, y1, z0], [x0, y1, z1], [x1, y1, z1], [x1, y1, z0]],
-                    0,
-                    [0, 127, 0, 0],
-                ),
-                (
-                    [[x0, y0, z0], [x0, y1, z0], [x1, y1, z0], [x1, y0, z0]],
-                    2,
-                    [0, 0, -127, 0],
-                ),
-                (
-                    [[x1, y0, z1], [x1, y1, z1], [x0, y1, z1], [x0, y0, z1]],
-                    2,
-                    [0, 0, 127, 0],
-                ),
-                (
-                    [[x0, y0, z1], [x0, y1, z1], [x0, y1, z0], [x0, y0, z0]],
-                    3,
-                    [-127, 0, 0, 0],
-                ),
-                (
-                    [[x1, y0, z0], [x1, y1, z0], [x1, y1, z1], [x1, y0, z1]],
-                    3,
-                    [127, 0, 0, 0],
-                ),
+                ([[x1, y0, z0], [x1, y0, z1], [x0, y0, z1], [x0, y0, z0]], 1),
+                ([[x0, y1, z0], [x0, y1, z1], [x1, y1, z1], [x1, y1, z0]], 0),
+                ([[x0, y0, z0], [x0, y1, z0], [x1, y1, z0], [x1, y0, z0]], 2),
+                ([[x1, y0, z1], [x1, y1, z1], [x0, y1, z1], [x0, y0, z1]], 2),
+                ([[x0, y0, z1], [x0, y1, z1], [x0, y1, z0], [x0, y0, z0]], 3),
+                ([[x1, y0, z0], [x1, y1, z0], [x1, y1, z1], [x1, y0, z1]], 3),
             ];
             let mask = face_mask(
                 dx as i32,
@@ -236,12 +210,8 @@ impl Mesh {
                 ],
             );
             for (direction, inside) in faces(mask) {
-                let (p, shade, n) = quads[usize::from(direction)];
-                if inside {
-                    quad([p[3], p[2], p[1], p[0]], shade, n.map(|c| -c));
-                } else {
-                    quad(p, shade, n);
-                }
+                let (p, shade) = quads[usize::from(direction)];
+                quad(if inside { [p[3], p[2], p[1], p[0]] } else { p }, shade);
             }
         }
         self.key = Some(key);

crates/horizon-client-render/src/collisions.rs

@@ -343,15 +343,8 @@ impl EntityMovementWorld for SceneCollisions<'_, '_> {
 }
 impl DynamicSupportWorld for SceneCollisions<'_, '_> {
     type Error = io::Error;
-    /// `ShulkerBoxBlockEntity.isClosed`: whether the lid is still shut. A
-    /// closed box collides as its plain block (`ShulkerBoxBlock.getShape`
-    /// asks the block entity, which has grown once the lid starts to open).
-    fn shulker_is_closed(&mut self, p: [i32; 3]) -> io::Result<Option<bool>> {
-        Ok(self
-            .world
-            .shulkers
-            .get(&p)
-            .map(|s| s.status == crate::block_entity_anim::ShulkerStatus::Closed))
+    fn shulker_is_closed(&mut self, _: [i32; 3]) -> io::Result<Option<bool>> {
+        Ok(None)
     }
     /// `MovingPistonBlock.getCollisionShape`: the block entity's moving shape
     /// (`PistonMovingBlockEntity.getCollisionShape`), outside any push.
@@ -380,17 +373,11 @@ impl PistonCollisionWorld for SceneCollisions<'_, '_> {
     }
 }
 impl DynamicCollisionWorld for SceneCollisions<'_, '_> {
-    /// `ShulkerBoxBlockEntity.getBoundingBox`: the box's collision shape
-    /// (`getShape`) is the free shape grown by the lid's progress, which is
-    /// what lets an entity sink into an opening box. None: no such box here.
     fn shulker_collision_state(
         &mut self,
-        p: [i32; 3],
+        _: [i32; 3],
     ) -> io::Result<Option<ShulkerCollisionState>> {
-        Ok(self.world.shulkers.get(&p).map(|s| ShulkerCollisionState {
-            previous_progress: s.progress_old,
-            progress: s.progress,
-        }))
+        Ok(None)
     }
 }
 impl LiquidCollisionWorld for SceneCollisions<'_, '_> {
@@ -510,8 +497,6 @@ impl EntityMovementWorld for LookupCollisions<'_, '_> {
 }
 impl DynamicSupportWorld for LookupCollisions<'_, '_> {
     type Error = io::Error;
-    /// No block-entity data: a lookup world has no shulker box to ask, so the
-    /// box collides as a shut one (`VoxelShape::block()`).
     fn shulker_is_closed(&mut self, _: [i32; 3]) -> io::Result<Option<bool>> {
         Ok(None)
     }
@@ -520,8 +505,6 @@ impl DynamicSupportWorld for LookupCollisions<'_, '_> {
     }
 }
 impl DynamicCollisionWorld for LookupCollisions<'_, '_> {
-    /// No block-entity data: the block table's own shape stands in for the lid
-    /// (`ShulkerBoxBlockEntity.getBoundingBox` needs a block entity).
     fn shulker_collision_state(
         &mut self,
         _: [i32; 3],
@@ -628,140 +611,3 @@ mod border_movement_tests {
         );
     }
 }
-
-#[cfg(test)]
-mod shulker_collision_tests {
-    use super::*;
-    use crate::block_entity_anim::{Shulker, ShulkerStatus, progress_delta_aabb};
-    use horizon_core::geometry::{Aabb, Axis, Direction, Vec3, VoxelShape};
-
-    /// A shulker box facing up at progress 0.0 (closed): collision is a 1x1x1 block.
-    #[test]
-    fn shulker_closed_collision_is_full_block() {
-        let shulker = Shulker {
-            status: ShulkerStatus::Closed,
-            progress: 0.0,
-            progress_old: 0.0,
-            ..Shulker::default()
-        };
-
-        let state = ShulkerCollisionState {
-            previous_progress: shulker.progress_old,
-            progress: shulker.progress,
-        };
-        let aabb = state.bounding_box(Direction::Up);
-
-        // Closed box: height 1.0
-        assert!((aabb.min(Axis::Y) - 0.0).abs() < 1.0e-9);
-        assert!((aabb.max(Axis::Y) - 1.0).abs() < 1.0e-9);
-        // Full horizontal extent
-        assert!((aabb.min(Axis::X) - 0.0).abs() < 1.0e-9);
-        assert!((aabb.max(Axis::X) - 1.0).abs() < 1.0e-9);
-    }
-
-    /// A shulker box facing up at progress 1.0 (fully open): collision is 1.5 tall.
-    #[test]
-    fn shulker_open_collision_grows_upward() {
-        let shulker = Shulker {
-            status: ShulkerStatus::Opened,
-            progress: 1.0,
-            progress_old: 1.0,
-            ..Shulker::default()
-        };
-
-        let state = ShulkerCollisionState {
-            previous_progress: shulker.progress_old,
-            progress: shulker.progress,
-        };
-        let aabb = state.bounding_box(Direction::Up);
-
-        // Fully open: height 1.5 (lid extends 0.5 above the block)
-        assert!((aabb.min(Axis::Y) - 0.0).abs() < 1.0e-9);
-        assert!((aabb.max(Axis::Y) - 1.5).abs() < 1.0e-9);
-    }
-
-    /// A shulker box halfway open: collision height is 1.25.
-    #[test]
-    fn shulker_half_open_collision_height() {
-        let shulker = Shulker {
-            status: ShulkerStatus::Opening,
-            progress: 0.5,
-            progress_old: 0.5,
-            ..Shulker::default()
-        };
-
-        let state = ShulkerCollisionState {
-            previous_progress: shulker.progress_old,
-            progress: shulker.progress,
-        };
-        let aabb = state.bounding_box(Direction::Up);
-
-        // Half open: height 1.25
-        assert!((aabb.min(Axis::Y) - 0.0).abs() < 1.0e-9);
-        assert!((aabb.max(Axis::Y) - 1.25).abs() < 1.0e-9);
-    }
-
-    /// Vanilla clip quirk: an entity whose feet are *inside* the grown lid box
-    /// moving DOWN is not stopped by the box (collision only triggers when
-    /// approaching from outside). An entity ABOVE the box moving DOWN is stopped.
-    #[test]
-    fn shulker_grown_box_allows_clip_when_inside() {
-        // Box at progress 1.0: spans y=0..1.5
-        let shulker = Shulker {
-            status: ShulkerStatus::Opened,
-            progress: 1.0,
-            progress_old: 1.0,
-            ..Shulker::default()
-        };
-        let state = ShulkerCollisionState {
-            previous_progress: shulker.progress_old,
-            progress: shulker.progress,
-        };
-        let aabb = state.bounding_box(Direction::Up);
-        let box_shape = VoxelShape::from_box(aabb).expect("shulker box is a valid shape");
-
-        // Entity box whose feet are at y=0.5 (inside the grown box), height 1.8
-        let entity = Aabb::new(Vec3::new(0.2, 0.5, 0.2), Vec3::new(0.8, 2.3, 0.8));
-
-        // Moving DOWN from inside the box: collide() should NOT stop it
-        // (the entity is already intersecting the box, so the downward movement
-        // sees no face to hit from above).
-        let down = -0.1;
-        let moved_down = box_shape.collide(Axis::Y, entity, down);
-        assert!(
-            (moved_down - down).abs() < 1.0e-9,
-            "entity inside grown box should fall through (clip): moved_down={moved_down}, expected={down}"
-        );
-
-        // Entity box whose feet are at y=1.6 (just ABOVE the grown box)
-        let entity_above = Aabb::new(Vec3::new(0.2, 1.6, 0.2), Vec3::new(0.8, 3.4, 0.8));
-
-        // Moving DOWN from above: collide() SHOULD stop it at y=1.5
-        let moved_down_above = box_shape.collide(Axis::Y, entity_above, -0.2);
-        // The box's top is at y=1.5, entity bottom at 1.6, so max down is -0.1
-        assert!(
-            (moved_down_above - (-0.1)).abs() < 1.0e-9,
-            "entity above grown box should be stopped: moved_down_above={moved_down_above}, expected=-0.1"
-        );
-    }
-
-    /// An entity standing on the lid (y=1.0 when closed, y=1.5 when open)
-    /// and pushed up by the lid: the lid's swept AABB pushes it along the facing.
-    /// This is tested at the integration level via `push_shulker_entities`;
-    /// here we only verify the swept box geometry matches vanilla's
-    /// `Shulker.getProgressDeltaAabb`.
-    #[test]
-    fn shulker_swept_box_matches_vanilla_delta() {
-        // From closed (0.0) to progress 0.5: the lid sweeps from y=0..1 (closed box)
-        // to y=0..1.5 (half open), so the swept volume in world coords at position
-        // [0.5, 0.0, 0.5] (bottom center of block at y=0) is y=1.0..1.5.
-        let delta = progress_delta_aabb(1.0, Direction::Up as u8, 0.0, 0.5, [0.5, 0.0, 0.5]);
-        assert!((delta[1] - 1.0).abs() < 1.0e-9); // minY
-        assert!((delta[4] - 1.5).abs() < 1.0e-9); // maxY
-
-        // From progress 0.5 to 1.0: swept y=1.5..2.0 in world coords
-        let delta2 = progress_delta_aabb(1.0, Direction::Up as u8, 0.5, 1.0, [0.5, 0.0, 0.5]);
-        assert!((delta2[1] - 1.5).abs() < 1.0e-9);
-        assert!((delta2[4] - 2.0).abs() < 1.0e-9);
-    }
-}

crates/horizon-client-render/src/containers.rs

@@ -4,7 +4,7 @@
 pub use crate::chunk::block_entity::{
     Banner, Beacon, BlockEntity, Brushable, Campfire, ChiseledBookshelf, Crafter, CreakingHeart,
     EndGateway, Furnace, FurnaceKind, Jukebox, Lectern, MOD_MENUS, ModBlockEntity, ModContainer,
-    ModFluidTanks, PotentSulfur, Shelf, Skull, SkullSkin,
+    PotentSulfur, Shelf, Skull, SkullSkin,
 };
 use crate::items::ItemStack;
 use std::collections::HashMap;
@@ -82,39 +82,6 @@ pub fn double_chest_name(first: Option<&str>, second: Option<&str>) -> horizon_w
     display_name(first.or(second), "container.chestDouble")
 }
 
-/// `BaseContainerBlockEntity.sendChestLockedNotifications`: the action bar
-/// message of a container that refuses to open, `container.isLocked` naming it
-/// by its display name.
-pub fn locked_message(title: &horizon_world::nbt::Tag) -> horizon_world::nbt::Tag {
-    use horizon_world::nbt::Tag;
-    Tag::compound([
-        ("translate", Tag::String("container.isLocked".into())),
-        ("with", Tag::List(vec![title.clone()])),
-    ])
-}
-
-/// The menu a container vehicle's `createMenu` builds (`ContainerEntity`):
-/// `AbstractChestBoat.createMenu` and `MinecartChest.createMenu` are
-/// `ChestMenu.threeRows` (a 9x3 menu), `MinecartHopper.createMenu` is a
-/// `HopperMenu` (five slots). `None` for any other entity type.
-pub fn vehicle_menu(entity_type: &str) -> Option<(&'static str, usize)> {
-    match entity_type {
-        "minecraft:chest_minecart" => Some(("minecraft:generic_9x3", 27)),
-        "minecraft:hopper_minecart" => Some(("minecraft:hopper", HOPPER_SLOTS)),
-        n if n.ends_with("_chest_boat") || n.ends_with("_chest_raft") => {
-            Some(("minecraft:generic_9x3", 27))
-        }
-        _ => None,
-    }
-}
-
-/// `MenuProvider.getDisplayName` for a container vehicle: `Entity.getDisplayName`
-/// is its custom name, else `getName`, the entity type's name key. Horizon's
-/// vehicles keep no custom name, so this is the type's name key.
-pub fn vehicle_menu_name(entity_type: &str) -> String {
-    format!("entity.{}", entity_type.replacen(':', ".", 1))
-}
-
 impl Campfire {
     /// `placeFood`'s slot: the first empty one, given the item's
     /// `campfire_cooking` time; it takes one item of `held`.
@@ -421,7 +388,7 @@ impl BlockEntity {
             Self::Furnace(f) => f.items.iter().flatten().cloned().collect(),
             Self::Brewing(b) => b.items.iter().flatten().cloned().collect(),
             Self::Sign(_) => Vec::new(),
-            Self::Jukebox(j) => j.items.iter().flatten().cloned().collect(),
+            Self::Jukebox(j) => j.record.iter().cloned().collect(),
             Self::Beacon(_)
             | Self::CreakingHeart(_)
             | Self::Spawner(_)
@@ -454,6 +421,7 @@ impl BlockEntity {
             Self::Furnace(f) => &f.items,
             Self::Brewing(b) => &b.items,
             Self::Sign(_)
+            | Self::Jukebox(_)
             | Self::Beacon(_)
             | Self::Lectern(_)
             | Self::Sculk(_)
@@ -467,7 +435,6 @@ impl BlockEntity {
             | Self::TestInstanceBlock(_)
             | Self::DaylightDetector
             | Self::Brushable(_) => &[],
-            Self::Jukebox(j) => &j.items,
             Self::Crafter(c) => &c.items,
             Self::ChiseledBookshelf(b) => &b.items,
             Self::Shelf(b) => &b.items,
@@ -488,6 +455,7 @@ impl BlockEntity {
             Self::Furnace(f) => &mut f.items,
             Self::Brewing(b) => &mut b.items,
             Self::Sign(_)
+            | Self::Jukebox(_)
             | Self::Beacon(_)
             | Self::Lectern(_)
             | Self::Sculk(_)
@@ -501,7 +469,6 @@ impl BlockEntity {
             | Self::TestInstanceBlock(_)
             | Self::DaylightDetector
             | Self::Brushable(_) => &mut [],
-            Self::Jukebox(j) => &mut j.items,
             Self::Crafter(c) => &mut c.items,
             Self::ChiseledBookshelf(b) => &mut b.items,
             Self::Shelf(b) => &mut b.items,
@@ -645,26 +612,6 @@ mod tests {
         assert_eq!(fifth.count, 1);
     }
 
-    /// `JukeboxBlockEntity`'s single slot is a `Container` slot, so a hopper
-    /// (`HopperBlockEntity.getContainerAt`) can reach the disc in it.
-    #[test]
-    fn a_jukebox_offers_its_record_as_its_one_container_slot() {
-        let mut entity = BlockEntity::Jukebox(Jukebox::default());
-        assert_eq!(entity.slots().len(), 1);
-        assert!(entity.slots()[0].is_none(), "empty until a disc lands");
-        let disc = ItemStack::new("minecraft:cat", 1);
-        entity.slots_mut()[0] = Some(disc.clone());
-        let slots = entity.slots();
-        assert_eq!(slots[0].as_ref().map(|s| &*s.item), Some("minecraft:cat"));
-        match &entity {
-            BlockEntity::Jukebox(j) => {
-                assert_eq!(j.record().map(|s| &*s.item), Some("minecraft:cat"));
-            }
-            _ => panic!("a jukebox"),
-        }
-        assert_eq!(entity.contents().len(), 1);
-    }
-
     /// A whole amount pays itself without a draw; a fraction is a chance of one more.
     #[test]
     fn create_experience_rounds_the_fraction_by_chance() {

crates/horizon-client-render/src/datapack.rs

@@ -23,7 +23,7 @@ enum Source {
 }
 impl DataPack {
     /// Every file path under `prefix` (relative to the pack root).
-    pub fn list(&self, prefix: &str) -> Vec<String> {
+    fn list(&self, prefix: &str) -> Vec<String> {
         match &self.source {
             Source::Zip(z) => z
                 .names()
@@ -58,13 +58,12 @@ impl DataPack {
         }
         out
     }
-    pub fn read(&self, path: &str) -> Option<Vec<u8>> {
+    fn read(&self, path: &str) -> Option<Vec<u8>> {
         match &self.source {
             Source::Zip(z) => z.read(path).ok(),
             Source::Dir(root) => std::fs::read(root.join(path)).ok(),
         }
     }
-
     /// The `description` of `pack.mcmeta`, as text.
     pub fn description(&self) -> String {
         let Some(bytes) = self.read("pack.mcmeta") else {
@@ -76,24 +75,6 @@ impl DataPack {
             other => other["text"].as_str().unwrap_or_default().to_owned(),
         }
     }
-    /// The `features.enabled` flag ids of `pack.mcmeta`
-    /// (`FeatureFlagsMetadataSection`): the flags the pack asks to turn on.
-    pub fn features(&self) -> Vec<String> {
-        self.mcmeta()["features"]["enabled"]
-            .as_array()
-            .map(|a| {
-                a.iter()
-                    .filter_map(|f| f.as_str().map(str::to_owned))
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-    /// The `pack.mcmeta` as JSON, empty when it is missing or unreadable.
-    fn mcmeta(&self) -> serde_json::Value {
-        self.read("pack.mcmeta")
-            .and_then(|b| serde_json::from_slice(&b).ok())
-            .unwrap_or_default()
-    }
 }
 fn walk(root: &Path, dir: &Path, out: &mut Vec<String>) {
     let Ok(entries) = std::fs::read_dir(dir) else {
@@ -146,43 +127,14 @@ pub fn discover(world: &Path) -> Vec<DataPack> {
     packs.sort_by(|a, b| a.id.cmp(&b.id));
     packs
 }
-/// The resources root's built-in feature packs (`ServerPacksSource`
-/// scanning the game's `data/minecraft/datapacks`): every folder with a
-/// `pack.mcmeta`, a feature pack (`PackSource.FEATURE`). Off until a world
-/// selects them.
-pub fn feature_packs(resources: &Path) -> Vec<DataPack> {
-    let Ok(entries) = std::fs::read_dir(resources.join("data").join("minecraft").join("datapacks"))
-    else {
-        return Vec::new();
-    };
-    let mut packs = Vec::new();
-    for e in entries.flatten() {
-        let path = e.path();
-        if path.join("pack.mcmeta").exists() {
-            packs.push(DataPack {
-                id: e.file_name().to_string_lossy().into_owned(),
-                source: Source::Dir(path),
-            });
-        }
-    }
-    packs.sort_by(|a, b| a.id.cmp(&b.id));
-    packs
-}
-/// The packs of `<world>/datapacks` plus the resources root's feature packs:
-/// the world's whole repository, as `PackRepository.reload` sees it.
-pub fn discover_with_features(world_root: &Path, resources: &Path) -> Vec<DataPack> {
-    let mut packs = discover(world_root);
-    packs.extend(feature_packs(resources));
-    packs
-}
 
 // ---- Create World ------------------------------------------------------------
 
 /// Create World's Data Packs screen (`PackSelectionScreen` on vanilla's
-/// `mcworld-` folder): the folder's packs (`PackSource.WORLD`), the
-/// built-in one (`resources` holds its `pack.png`), and the feature packs
-/// of `resources` (`PackSource.FEATURE`), available at the bottom and off
-/// until picked — the Experiments.
+/// `mcworld-` folder): the folder's packs (`PackSource.WORLD`) and the
+/// built-in one (`resources` holds its `pack.png`), which can be unselected
+/// and stays at the bottom. Horizon has no experiments, so their feature
+/// packs are not offered.
 pub fn screen_packs(dir: &Path, resources: &Path) -> Vec<crate::pack_screen::PackInfo> {
     use crate::{
         pack_screen::{Compat, PackInfo, Source, load_icon},
@@ -220,23 +172,6 @@ pub fn screen_packs(dir: &Path, resources: &Path) -> Vec<crate::pack_screen::Pac
         position: Position::Bottom,
         fixed: false,
     });
-    for p in feature_packs(resources) {
-        let meta = p.mcmeta();
-        let (description, description_style) =
-            crate::packs::component_root(&meta["pack"]["description"]);
-        infos.push(PackInfo {
-            icon: None,
-            id: p.id.clone(),
-            title: Text::translate(&format!("dataPack.{}.name", p.id), &[]),
-            description,
-            description_style,
-            source: Source::Feature,
-            compat: crate::packs::compatibility_for(&meta, format),
-            required: false,
-            position: Position::Bottom,
-            fixed: false,
-        });
-    }
     infos
 }
 /// A new empty folder for Create World's packs
@@ -250,59 +185,6 @@ pub fn temp_folder() -> std::io::Result<PathBuf> {
     std::fs::create_dir_all(&dir)?;
     Ok(dir)
 }
-/// `PackSelectionScreen.onFilesDrop`'s `PackDetector`: a zip is a pack; a
-/// folder is one when it holds a `pack.mcmeta`, or exactly one folder that
-/// does (a folder zipped by the system, which adds a wrapper). Copied into
-/// `dir`; false when `path` is no pack.
-pub fn copy_pack(path: &Path, dir: &Path) -> bool {
-    fn copy_dir(from: &Path, at: &Path) {
-        let _ = std::fs::create_dir_all(at);
-        for entry in std::fs::read_dir(from).into_iter().flatten().flatten() {
-            let path = entry.path();
-            let to = at.join(entry.file_name());
-            if path.is_dir() {
-                copy_dir(&path, &to);
-            } else {
-                let _ = std::fs::copy(&path, &to);
-            }
-        }
-    }
-    let name = || {
-        path.file_name()
-            .map(|n| n.to_string_lossy().into_owned())
-            .unwrap_or_default()
-    };
-    if path.is_file() {
-        return path
-            .extension()
-            .is_some_and(|e| e.eq_ignore_ascii_case("zip"))
-            && {
-                let _ = std::fs::create_dir_all(dir);
-                std::fs::copy(path, dir.join(name())).is_ok()
-            };
-    }
-    if !path.is_dir() {
-        return false;
-    }
-    if path.join("pack.mcmeta").is_file() {
-        copy_dir(path, &dir.join(name()));
-        return true;
-    }
-    let own: Vec<PathBuf> = std::fs::read_dir(path)
-        .into_iter()
-        .flatten()
-        .flatten()
-        .map(|e| e.path())
-        .filter(|p| p.is_dir() && p.join("pack.mcmeta").is_file())
-        .collect();
-    match own.as_slice() {
-        [one] => {
-            copy_dir(one, &dir.join(one.file_name().unwrap_or_default()));
-            true
-        }
-        _ => false,
-    }
-}
 /// What's in a folder of packs, to notice packs added or removed while the
 /// screen shows it (`PackSelectionScreen.Watcher`).
 pub fn folder_stamp(dir: &Path) -> Vec<(String, Option<std::time::SystemTime>)> {
@@ -348,11 +230,7 @@ pub fn install(dir: &Path, world: &Path, selected: &[String]) -> Result<(), Stri
 /// The built-in pack is selected unless the world turned it off.
 pub fn for_recreate(world: &Path) -> (Option<PathBuf>, Vec<String>) {
     let packs = discover(world);
-    // No flags here: the recreated world keeps the original's
-    // `enabled_features`, and the flag-aware load re-adds the feature packs
-    // it asks for (`for_recreate`'s selection only seeds the new world's
-    // `datapacks.json`).
-    let mut selected = enabled_ids(world, &packs, &[]);
+    let mut selected = enabled_ids(world, &packs);
     let vanilla_off = std::fs::read(world.join("datapacks.json"))
         .ok()
         .and_then(|b| serde_json::from_slice::<serde_json::Value>(&b).ok())
@@ -575,7 +453,7 @@ pub struct DataStore {
     /// `item_modifier` files, for `/item modify`.
     pub item_modifiers: BTreeMap<String, serde_json::Value>,
     /// The content tables' raw files from the packs after the built-in one:
-    /// `recipe/`, `loot_table/`, `advancement/`, `dialog/` and `tags/…/` files, by
+    /// `recipe/`, `loot_table/`, `advancement/` and `tags/…/` files, by
     /// `<kind-dir>/<ns>:<path>`, each id's files in pack order. The tables
     /// merge them over what they read from the resource root.
     pub files: BTreeMap<String, Vec<Vec<u8>>>,
@@ -583,20 +461,17 @@ pub struct DataStore {
     pub errors: Vec<(String, String)>,
 }
 /// `<kind-dir>/<ns>:<path>` for a pack file the content tables read:
-/// `recipe/`, `loot_table/`, `advancement/`, `trade_set/`,
-/// `villager_trade/`, `dialog/` or `tags/<sub>/`, where the id keeps the sub
-/// path so a nested tag kind stays addressable.
+/// `recipe/`, `loot_table/`, `advancement/` or `tags/<sub>/`, where the id
+/// keeps the sub path so a nested tag kind stays addressable.
 fn content_id(file: &str) -> Option<String> {
     let rest = file.strip_prefix("data/")?;
     let (ns, rest) = rest.split_once('/')?;
     let (kind, rest) = rest.split_once('/')?;
     let kind = match kind {
-        "recipe" | "loot_table" | "advancement" | "trade_set" | "villager_trade" | "dialog" => kind,
-        // A tag id is `{ns}:{path-under-tags}` (`tags/worldgen/biome/
-        // test:sub/mytag`), the whole path after the namespace, so nested
-        // registries keep their directory (`TagLoader`'s id shape).
+        "recipe" | "loot_table" | "advancement" => kind,
         "tags" => {
-            return Some(format!("tags/{ns}:{}", rest.strip_suffix(".json")?));
+            let (sub, name) = rest.rsplit_once('/')?;
+            return Some(format!("tags/{sub}/{ns}:{}", name.strip_suffix(".json")?));
         }
         _ => return None,
     };
@@ -622,15 +497,12 @@ impl DataStore {
             let builtin = pack.id == "vanilla";
             for f in pack.list_kinds(&[
                 "advancement",
-                "dialog",
                 "function",
                 "item_modifier",
                 "loot_table",
                 "predicate",
                 "recipe",
                 "tags",
-                "trade_set",
-                "villager_trade",
             ]) {
                 if !seen.insert(f.clone()) {
                     continue;
@@ -744,25 +616,10 @@ fn hash_normalize(s: &str) -> String {
     }
 }
 
-/// Whether every flag `pack` asks for (`Pack.getRequestedFeatures`) is among
-/// the world's `enabled_features`.
-fn features_enabled(pack: &DataPack, enabled_features: &[String]) -> bool {
-    pack.features()
-        .iter()
-        .all(|f| enabled_features.iter().any(|e| e == f))
-}
-
 /// The ids of `packs` (a world's, from `discover`) that are enabled, lowest
 /// priority first: those `<world>/datapacks.json` lists as enabled, in its
 /// order, then every pack it lists neither way, in name order.
-///
-/// `enabled_features` are the world's feature flags
-/// (`WorldDataConfiguration.enabledFeatures`): a pack a pack file selected
-/// while asking for missing features comes off
-/// (`MinecraftServer.configurePackRepository`), and a feature pack whose
-/// features the world enables is forced on however the world's selection
-/// feels about it (`MinecraftServer.enableForcedFeaturePacks`).
-pub fn enabled_ids(world: &Path, packs: &[DataPack], enabled_features: &[String]) -> Vec<String> {
+pub fn enabled_ids(world: &Path, packs: &[DataPack]) -> Vec<String> {
     let saved: Option<serde_json::Value> = std::fs::read(world.join("datapacks.json"))
         .ok()
         .and_then(|b| serde_json::from_slice(&b).ok());
@@ -781,32 +638,9 @@ pub fn enabled_ids(world: &Path, packs: &[DataPack], enabled_features: &[String]
     let mut enabled: Vec<String> = list("enabled")
         .into_iter()
         .filter(|id| packs.iter().any(|p| &p.id == id))
-        .filter(|id| {
-            packs
-                .iter()
-                .find(|p| &p.id == id)
-                .is_none_or(|p| features_enabled(p, enabled_features))
-        })
         .collect();
     for p in packs {
-        // A pack nobody mentions comes on (`PackRepository.reload` selects
-        // every new pack), but a feature pack stays off until the world
-        // enabled its flag (`PackSource.FEATURE` starts unselected).
-        if !enabled.contains(&p.id)
-            && !disabled.contains(&p.id)
-            && p.id.starts_with("file/")
-            && features_enabled(p, enabled_features)
-        {
-            enabled.push(p.id.clone());
-        }
-    }
-    for p in packs {
-        let feature_pack = !p.id.starts_with("file/") && p.id != "vanilla";
-        if feature_pack
-            && !p.features().is_empty()
-            && features_enabled(p, enabled_features)
-            && !enabled.contains(&p.id)
-        {
+        if !enabled.contains(&p.id) && !disabled.contains(&p.id) {
             enabled.push(p.id.clone());
         }
     }
@@ -917,7 +751,7 @@ mod tests {
         )
         .unwrap();
         let packs = discover(&dir);
-        let enabled = enabled_ids(&dir, &packs, &[]);
+        let enabled = enabled_ids(&dir, &packs);
         assert_eq!(enabled, ["file/b", "file/a"]);
         let enabled: Vec<&DataPack> = enabled
             .iter()
@@ -1031,10 +865,6 @@ mod tests {
             "data/mine/predicate/p.json",
             "{\"condition\":\"minecraft:random_chance\",\"chance\":1}",
         );
-        write(
-            "data/mine/dialog/config/points.json",
-            "{\"type\":\"minecraft:notice\",\"title\":\"Points\"}",
-        );
         let packs = discover(&dir);
         assert_eq!(packs.len(), 1);
         assert_eq!(packs[0].id, "file/mypack");
@@ -1047,11 +877,6 @@ mod tests {
             ["mine:a", "mine:sub/b"]
         );
         assert!(store.predicates.contains_key("mine:p"));
-        // Dialogs reach the synchronized registry through the content files.
-        assert_eq!(
-            store.files["dialog/mine:config/points"],
-            [b"{\"type\":\"minecraft:notice\",\"title\":\"Points\"}".to_vec()]
-        );
         let _ = std::fs::remove_dir_all(&dir);
     }
 

crates/horizon-client-render/src/dynamic_light.rs

@@ -13,37 +13,6 @@ use std::collections::HashMap;
 
 /// Lights the shaders read: `Globals.dynamic_lights` in gfx.rs, terrain.wgsl and entity.wgsl.
 pub const MAX: usize = 16;
-/// Camera-relative position and radius; RGB intensity in a second vec4.
-pub type Colored = [[f32; 4]; 2];
-
-/// Nearest validated native visual lights; never enters gameplay lighting.
-pub fn select_colored(
-    sources: impl Iterator<Item = ([f64; 3], u32, f32, f32)>,
-    camera: DVec3,
-) -> Vec<Colored> {
-    let mut nearest: Vec<_> = sources.collect();
-    nearest.sort_by(|a, b| {
-        (DVec3::from(a.0) - camera)
-            .length_squared()
-            .total_cmp(&(DVec3::from(b.0) - camera).length_squared())
-    });
-    nearest
-        .into_iter()
-        .take(MAX)
-        .map(|(at, rgb, radius, intensity)| {
-            let at = (DVec3::from(at) - camera).as_vec3();
-            [
-                [at.x, at.y, at.z, radius],
-                [
-                    ((rgb >> 16) & 255) as f32 / 255.0,
-                    ((rgb >> 8) & 255) as f32 / 255.0,
-                    (rgb & 255) as f32 / 255.0,
-                    intensity,
-                ],
-            ]
-        })
-        .collect()
-}
 /// What an entity on fire gives off, as a lit campfire or fire block does.
 pub const BURNING: u8 = 15;
 /// Sources farther than this from the camera light nothing it can see well.
@@ -118,17 +87,6 @@ pub fn level_at(pos: [f32; 3], lights: &[[f32; 4]]) -> f32 {
 mod tests {
     use super::*;
 
-    #[test]
-    fn colored_sources_are_camera_relative_and_bounded() {
-        let lights = select_colored(
-            (0..20).map(|x| ([x as f64, 64.0, 0.0], 0xff8040, 5.0, 0.5)),
-            DVec3::new(2.0, 64.0, 0.0),
-        );
-        assert_eq!(lights.len(), MAX);
-        assert_eq!(lights[0][0][0], 0.0);
-        assert_eq!(lights[0][1], [1.0, 128.0 / 255.0, 64.0 / 255.0, 0.5]);
-    }
-
     #[test]
     fn nearest_sources_win() {
         let camera = DVec3::new(100.0, 64.0, 100.0);

crates/horizon-client-render/src/effects.rs

@@ -6,8 +6,7 @@ use horizon_client_core::potions;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct EffectInstance {
-    /// Effect id: vanilla's without namespace (`speed`, `poison`, ...), a
-    /// content mod's `<ns>:<path>`.
+    /// Effect id without namespace (`speed`, `poison`, ...).
     pub id: &'static str,
     /// Remaining ticks; -1 is infinite.
     pub duration: i32,
@@ -220,7 +219,7 @@ impl PlayerEffects {
             .iter()
             .map(|e| {
                 (
-                    potions::namespaced(e.id).to_owned(),
+                    format!("minecraft:{}", e.id),
                     e.duration,
                     e.amplifier,
                     e.ambient,
@@ -235,12 +234,10 @@ impl PlayerEffects {
         i8::from(e.ambient) | i8::from(e.visible) << 1 | 4
     }
     /// `LivingEntity.tickEffects` (server part) with the omens' effect ticks:
-    /// `omen` answers `BadOmenMobEffect` (every tick), `RaidOmenMobEffect`
-    /// (on its last tick) and a content mod's effect (every tick, with the
-    /// tick count `shouldApplyEffectTickThisTick` takes); `absorption_empty`
-    /// is `AbsorptionMobEffect`'s answer: the effect ends once the
-    /// absorption is used up. Returns the actions to apply, in order, and
-    /// whether Raid Omen was newly added.
+    /// `omen` answers `BadOmenMobEffect` (every tick) and `RaidOmenMobEffect`
+    /// (on its last tick); `absorption_empty` is `AbsorptionMobEffect`'s
+    /// answer: the effect ends once the absorption is used up. Returns the
+    /// actions to apply, in order, and whether Raid Omen was newly added.
     ///
     /// Bad Omen turning into a new Raid Omen adds an entry to the map being
     /// iterated: vanilla's iterator then throws a
@@ -249,7 +246,7 @@ impl PlayerEffects {
     /// ticked; the next tick refreshes Raid Omen and drops Bad Omen.
     pub fn tick_with(
         &mut self,
-        omen: &mut dyn FnMut(&EffectInstance, i32) -> OmenTick,
+        omen: &mut dyn FnMut(&EffectInstance) -> OmenTick,
         absorption_empty: bool,
     ) -> (Vec<EffectAction>, bool) {
         self.tick_count = self.tick_count.wrapping_add(1);
@@ -271,9 +268,8 @@ impl PlayerEffects {
                 actions.push(a);
             }
             let answer = match e.id {
-                "bad_omen" => omen(e, t),
-                "raid_omen" if t == 1 => omen(e, t),
-                id if potions::is_mod_effect(id) => omen(e, t),
+                "bad_omen" => omen(e),
+                "raid_omen" if t == 1 => omen(e),
                 "absorption" if absorption_empty => OmenTick::Remove,
                 _ => OmenTick::Continue,
             };
@@ -511,7 +507,7 @@ mod tests {
         let mut fx = PlayerEffects::default();
         fx.add(EffectInstance::new("bad_omen", 100, 1));
         fx.add(EffectInstance::new("speed", 50, 0));
-        let mut convert = |e: &EffectInstance, _: i32| match e.id {
+        let mut convert = |e: &EffectInstance| match e.id {
             "bad_omen" => OmenTick::Add(EffectInstance::new("raid_omen", 600, e.amplifier)),
             _ => OmenTick::Continue,
         };
@@ -529,63 +525,12 @@ mod tests {
         assert_eq!(fx.get("speed").unwrap().duration, 49);
         assert_eq!(fx.get("raid_omen").unwrap().amplifier, 1);
     }
-    /// The only test here that registers mod effects (once per process).
-    #[test]
-    fn a_mod_effect_saves_under_its_namespace() {
-        potions::register_mod_effects([(
-            "ruby:glow".to_owned(),
-            0xFF0000,
-            potions::Category::Neutral,
-        )]);
-        let mut fx = PlayerEffects::default();
-        fx.add(EffectInstance::new(
-            potions::effect("ruby:glow").unwrap().id,
-            600,
-            1,
-        ));
-        let saved = fx.saved();
-        assert_eq!(saved, [("ruby:glow".to_owned(), 600, 1, false, true)]);
-        assert_eq!(PlayerEffects::from_saved(&saved).list, fx.list);
-        // Without its mod the saved effect is dropped, as an unknown id is.
-        assert!(
-            PlayerEffects::from_saved(&[("gone:glow".into(), 600, 1, false, true)])
-                .list
-                .is_empty()
-        );
-    }
-    /// A content mod's effect answers each tick before it counts down (an
-    /// infinite one with the tick count), and goes at once on Remove.
-    #[test]
-    fn a_mod_effect_answers_before_it_counts_down() {
-        let mut fx = PlayerEffects::default();
-        fx.add(EffectInstance::new("ruby:glow", 3, 1));
-        fx.add(EffectInstance::new("ruby:bleed", -1, 0));
-        let mut seen = Vec::new();
-        let mut answer = |e: &EffectInstance, t: i32| {
-            seen.push((e.id, t));
-            match (e.id, t) {
-                ("ruby:glow", 2) => OmenTick::Remove,
-                _ => OmenTick::Continue,
-            }
-        };
-        fx.tick_with(&mut answer, false);
-        fx.tick_with(&mut answer, false);
-        let ticks = [
-            ("ruby:glow", 3),
-            ("ruby:bleed", 1),
-            ("ruby:glow", 2),
-            ("ruby:bleed", 2),
-        ];
-        assert_eq!(seen, ticks);
-        assert!(fx.get("ruby:glow").is_none());
-        assert_eq!(fx.get("ruby:bleed").unwrap().duration, -1);
-    }
     #[test]
     fn raid_omen_acts_on_its_last_tick() {
         let mut fx = PlayerEffects::default();
         fx.add(EffectInstance::new("raid_omen", 2, 0));
         let mut seen = Vec::new();
-        let mut watch = |e: &EffectInstance, _: i32| {
+        let mut watch = |e: &EffectInstance| {
             seen.push(e.duration);
             OmenTick::Remove
         };

crates/horizon-client-render/src/entity.wgsl

@@ -22,10 +22,6 @@ struct Globals {
     outline_params: vec4<f32>,
     // Horizon Extras' dynamic lights: camera-relative position and level (dynamic_light.rs).
     dynamic_lights: array<vec4<f32>, 16>,
-    colored_lights: array<array<vec4<f32>, 2>, 16>,
-    colored_count: vec4<u32>,
-    emissive_layers: array<vec4<u32>, 32>,
-    emissive_count: vec4<u32>,
     sunrise_fan: array<vec4<f32>, 32>,
     filtering: vec4<f32>,
 }
@@ -94,15 +90,6 @@ fn dynamic_block_light(pos: vec3<f32>) -> f32 {
     }
     return level * 16.0;
 }
-fn native_colored_light(pos: vec3<f32>) -> vec3<f32> {
-    var rgb = vec3(0.0);
-    for (var i = 0u; i < min(globals.colored_count.x, 16u); i++) {
-        let at = globals.colored_lights[i][0];
-        let color = globals.colored_lights[i][1];
-        rgb += color.rgb * max(0.0, 1.0 - distance(pos, at.xyz) / at.w) * color.a;
-    }
-    return min(rgb, vec3(1.0));
-}
 fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
     overlay: u32, color: vec4<f32>, light: vec4<u32>, normal: vec4<f32>) -> Out {
     var out: Out;
@@ -116,9 +103,6 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
     let unlit = overlay == 2u || overlay == 4u || overlay == 6u || overlay == 9u || overlay == 10u
         || overlay == 11u || overlay == 12u;
     out.light_color = select(lm, vec4(1.0), unlit);
-    if globals.colored_count.x > 0u && !unlit {
-        out.light_color = vec4(min(out.light_color.rgb + native_colored_light(position), vec3(1.0)), out.light_color.a);
-    }
     // Overlay 6 (beacon beams): the light bytes carry the sprite's v range; 11 and 12
     // (cracks): the destroy stage sprite's origin.
     out.wrap = vec2(f32(light.x | (light.y << 8u)), f32(light.z | (light.w << 8u))) / 65535.0;
@@ -157,9 +141,7 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
 @vertex fn vs_lightning(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
     @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>, @location(5) normal: vec4<f32>,
     @location(7) offset: vec3<f32>) -> Out {
-    var out = entity_vertex(offset + position, uv, overlay & 0xffffu, color, light, normal);
-    out.tier = (overlay >> 16u) & 0xffu;
-    return out;
+    return entity_vertex(offset + position, uv, overlay, color, light, normal);
 }
 struct CloudInfo {
     offset: vec4<f32>,
@@ -312,10 +294,7 @@ fn shadow_color(in: Out) -> vec4<f32> {
 // way terrain.wgsl marks a light source's, drawn again after the entities with
 // only alpha written, so its colour stays as blended.
 @fragment fn fs_hdr_mark(in: Out) -> @location(0) vec4<f32> {
-    // Beams wrap their v in the sprite as fs_entity does: sample where they draw.
-    var uv = in.uv;
-    if in.overlay == 6u { uv.y = in.wrap.x + fract(in.uv.y) * in.wrap.y; }
-    if in.tier == 0u || textureSample(atlas, atlas_sampler, uv).a < 0.1 { discard; }
+    if in.tier == 0u || textureSample(atlas, atlas_sampler, in.uv).a < 0.1 { discard; }
     return vec4(0.0, 0.0, 0.0, 0.7 * f32(4u - min(in.tier, 4u)) / 4.0);
 }
 
@@ -335,10 +314,8 @@ fn celestial_color(in: Out) -> vec4<f32> {
     let color = celestial_color(in);
     let added = color.rgb * color.a;
     // The sky under the disc keeps alpha 1 less this: 0 for the brightest tier
-    // (the sun), terrain.wgsl's mark for the lower ones (the moon). Tier 0 is
-    // geometry that sets none (the End sky, the End flash): it stays brightest.
-    let tier = select(4u, min(in.tier, 4u), in.tier > 0u);
-    let mark = 1.0 - 0.7 * f32(4u - tier) / 4.0;
+    // (the sun), terrain.wgsl's mark for the lower ones (the moon).
+    let mark = 1.0 - 0.7 * f32(4u - min(in.tier, 4u)) / 4.0;
     return vec4(added, mark * smoothstep(0.1, 0.3, max(added.r, max(added.g, added.b))));
 }
 

crates/horizon-client-render/src/gfx/animate.rs

@@ -72,8 +72,6 @@ pub(super) struct SpriteAnimator {
     size: u32,
     /// The layers the last `animate` rewrote, counted over all arrays.
     changed: Vec<u32>,
-    /// Whether each sprite layer has an animation.
-    is_animated: Vec<bool>,
 }
 
 impl SpriteAnimator {
@@ -149,11 +147,6 @@ impl SpriteAnimator {
                 group,
             });
         }
-        let max_layer = animations.iter().map(|a| a.layer).max().unwrap_or(0);
-        let mut is_animated = vec![false; (max_layer + 1) as usize];
-        for a in animations {
-            is_animated[a.layer as usize] = true;
-        }
         let Some((pipeline, layout)) = pipeline else {
             let groups = keys
                 .iter()
@@ -175,7 +168,6 @@ impl SpriteAnimator {
                 },
                 size,
                 changed: Vec::new(),
-                is_animated,
             };
         };
         let frames: Vec<_> = frames
@@ -255,23 +247,9 @@ impl SpriteAnimator {
             writer: Writer::Gpu { jobs, pipeline },
             size,
             changed: Vec::new(),
-            is_animated,
         }
     }
 
-    /// Whether the sprite layer has an animation.
-    pub fn is_animated(&self, layer: u16) -> bool {
-        self.is_animated
-            .get(layer as usize)
-            .copied()
-            .unwrap_or(false)
-    }
-
-    /// Number of words needed to mark the animated layers visible this frame.
-    pub fn active_layer_words(&self) -> usize {
-        self.is_animated.len().div_ceil(u64::BITS as usize)
-    }
-
     /// Whether the jobs can run on the GPU: compute shaders writing a
     /// storage texture and reading two storage buffers (not OpenGL before
     /// 4.3).
@@ -291,16 +269,14 @@ impl SpriteAnimator {
     }
 
     /// Show every sprite's frame at `tick`, rewriting only the sprites whose
-    /// frame or mix changed (`SpriteContents.AnimationState.tick`), skipping
-    /// sprites not present in `active` when provided.
+    /// frame or mix changed (`SpriteContents.AnimationState.tick`).
     pub fn animate(
         &mut self,
         encoder: &mut wgpu::CommandEncoder,
         uploads: &mut Uploads,
         tick: u64,
-        active: Option<&[u64]>,
     ) {
-        if self.collect(tick, active) == 0 {
+        if self.collect(tick) == 0 {
             return;
         }
         let (jobs, pipeline) = match &self.writer {
@@ -360,18 +336,10 @@ impl SpriteAnimator {
 
     /// Queue a job for every sprite whose blend at `tick` differs from what
     /// its layer shows; the number of jobs.
-    fn collect(&mut self, tick: u64, active: Option<&[u64]>) -> usize {
+    fn collect(&mut self, tick: u64) -> usize {
         let mut count = 0;
         self.changed.clear();
         for sprite in &mut self.sprites {
-            if let Some(active) = active {
-                let layer = sprite.animation.layer as usize;
-                let word = layer / u64::BITS as usize;
-                let bit = 1_u64 << (layer % u64::BITS as usize);
-                if active.get(word).is_none_or(|active| active & bit == 0) {
-                    continue;
-                }
-            }
             let blend = sprite.animation.blend(tick);
             if sprite.shown == Some(blend) {
                 continue;
@@ -859,7 +827,7 @@ mod tests {
         for tick in [0, 0, 1, 2, 3, 4, 7, 7, 12, 30] {
             let mut encoder = device.create_command_encoder(&Default::default());
             let shown: Vec<_> = animator.sprites.iter().map(|s| s.shown).collect();
-            animator.animate(&mut encoder, &mut uploads, tick, None);
+            animator.animate(&mut encoder, &mut uploads, tick);
             writes.push(
                 animator
                     .sprites
@@ -896,56 +864,4 @@ mod tests {
         // its frame turns over (every 2 ticks, but 12 shows 7's frame).
         assert_eq!(writes, [3, 0, 2, 3, 2, 3, 3, 0, 2, 1]);
     }
-
-    #[test]
-    fn inactive_sprites_are_skipped_by_collect() {
-        let Some((device, _)) = device() else {
-            return;
-        };
-        let size = 16;
-        let clips = [
-            (1, 16, r#"{"frametime":1}"#),
-            (3, 16, r#"{"frametime":1}"#),
-            (5, 16, r#"{"frametime":1}"#),
-        ];
-        let mut mips = vec![Settings::default(); 6];
-        let animations: Vec<_> = clips
-            .iter()
-            .map(|&(layer, native, metadata)| {
-                mips[layer as usize] = settings(native, Strategy::Cutout);
-                let frames = (0..3)
-                    .map(|f| crate::sprites::resample(&frame(native, layer * 7 + f), native, size))
-                    .collect();
-                crate::sprites::test_frames(layer, frames, metadata)
-            })
-            .collect();
-        // Construct with CPU writer (empty textures is fine for collect testing)
-        let mut animator = SpriteAnimator::new(&device, &animations, size, &mips, &[], 2, false);
-        assert!(animator.is_animated(1));
-        assert!(!animator.is_animated(2));
-        assert!(animator.is_animated(3));
-        assert!(animator.is_animated(5));
-
-        // When active layer is [1], only sprite 1 is collected
-        let active = [1_u64 << 1];
-        let count = animator.collect(1, Some(&active));
-        assert_eq!(count, 1);
-        assert_eq!(animator.changed, vec![1]);
-
-        // When active is empty, 0 are collected
-        let count = animator.collect(2, Some(&[0]));
-        assert_eq!(count, 0);
-        assert!(animator.changed.is_empty());
-
-        // When active is [3, 5], both 3 and 5 are collected
-        let active = [1_u64 << 3 | 1_u64 << 5];
-        let count = animator.collect(3, Some(&active));
-        assert_eq!(count, 2);
-        assert_eq!(animator.changed, vec![3, 5]);
-
-        // When active is None, all out-of-date sprites update
-        let count = animator.collect(5, None);
-        assert_eq!(count, 3);
-        assert_eq!(animator.changed, vec![1, 3, 5]);
-    }
 }

crates/horizon-client-render/src/gfx/arena.rs

@@ -76,22 +76,8 @@ struct Page {
     /// Capacity in vertices.
     capacity: u64,
     free: FreeList,
-    /// The buffer went to system memory (`Arena::create`'s fallback): meshes
-    /// are never moved into it, and it is the first to empty.
-    host: bool,
 }
 
-impl Page {
-    /// Vertices in the page's free ranges.
-    fn free_vertices(&self) -> u64 {
-        self.free.0.values().sum()
-    }
-}
-
-/// An arena with this many bytes in free ranges, at least half of its pages,
-/// has a page worth emptying (`Arena::sparsest`).
-const COMPACT_MIN_FREE: u64 = 128 << 20;
-
 /// Terrain vertices in pages of at most `page_limit` vertices (devices cap
 /// buffer sizes): a section's vertices sit in one page.
 pub struct Arena {
@@ -100,8 +86,6 @@ pub struct Arena {
     page_limit: u64,
     initial_capacity: u64,
     usage: wgpu::BufferUsages,
-    /// A page being emptied (`Arena::close`): nothing is placed in it.
-    closing: Option<u32>,
     /// A page had to go to system memory (logged once).
     spilled: bool,
     /// Tests: GPU-local pages fail as if video memory were full.
@@ -145,7 +129,6 @@ impl Arena {
             page_limit,
             initial_capacity: capacity,
             usage,
-            closing: None,
             spilled: false,
             #[cfg(test)]
             video_memory_full: false,
@@ -155,7 +138,7 @@ impl Arena {
     /// and the device allows it, in system memory: Vulkan drivers fail an
     /// allocation rather than page like OpenGL ones, and wgpu's default error
     /// handler panics. `None` when neither has room.
-    fn create(&mut self, device: &wgpu::Device, capacity: u64) -> Option<(wgpu::Buffer, bool)> {
+    fn create(&mut self, device: &wgpu::Device, capacity: u64) -> Option<wgpu::Buffer> {
         let usage = self.usage | wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::COPY_SRC;
         #[cfg(test)]
         let local = (!self.video_memory_full)
@@ -163,7 +146,6 @@ impl Arena {
             .flatten();
         #[cfg(not(test))]
         let local = try_create(device, capacity * self.stride, usage);
-        let local = local.map(|buffer| (buffer, false));
         local.or_else(|| {
             // Mappable buffers are placed in host-visible memory, which the
             // allocator takes from system memory once video memory is full.
@@ -184,7 +166,7 @@ impl Arena {
                      (lower the render distance if frames slow down)"
                 );
             }
-            Some((buffer, true))
+            Some(buffer)
         })
     }
     /// The rounded length a request of `vertices` occupies.
@@ -225,13 +207,16 @@ impl Arena {
         vertices: u64,
     ) -> Option<(u32, u64)> {
         let len = Self::span(vertices).min(self.page_limit);
-        if let Some(found) = self.alloc_existing(len) {
-            return Some(found);
+        for (i, page) in self.pages.iter_mut().enumerate() {
+            if let Some(page) = page
+                && let Some(start) = page.free.take(len)
+            {
+                return Some((i as u32, start));
+            }
         }
         let last = self.pages.len().saturating_sub(1);
         if let Some(page) = self.pages.last().and_then(Option::as_ref)
             && page.capacity < self.page_limit
-            && self.closing != Some(last as u32)
         {
             let current = page.capacity;
             let grown = (current * 2).max(current + len).min(self.page_limit);
@@ -250,7 +235,7 @@ impl Arena {
         .max(len)
         .min(self.page_limit);
         // A page just large enough when memory is short.
-        let ((buffer, host), capacity) = match self.create(device, capacity) {
+        let (buffer, capacity) = match self.create(device, capacity) {
             Some(buffer) => (buffer, capacity),
             None if capacity > len => (self.create(device, len)?, len),
             None => return None,
@@ -261,7 +246,6 @@ impl Arena {
             buffer,
             capacity,
             free,
-            host,
         };
         let index = self
             .pages
@@ -274,96 +258,6 @@ impl Arena {
         self.pages[index] = Some(page);
         Some((index as u32, start))
     }
-    /// A range of `vertices` in a page that exists already and is not being
-    /// emptied: never grows the arena.
-    pub fn alloc_existing(&mut self, vertices: u64) -> Option<(u32, u64)> {
-        let len = Self::span(vertices).min(self.page_limit);
-        let closing = self.closing;
-        self.pages
-            .iter_mut()
-            .enumerate()
-            .filter(|(i, _)| closing != Some(*i as u32))
-            .find_map(|(i, page)| Some((i as u32, page.as_mut()?.free.take(len)?)))
-    }
-    /// `alloc_existing` for a mesh moved off the closing page: only pages in
-    /// video memory, so compaction never pushes terrain into system memory.
-    pub fn alloc_moved(&mut self, vertices: u64) -> Option<(u32, u64)> {
-        let len = Self::span(vertices).min(self.page_limit);
-        let closing = self.closing;
-        self.pages
-            .iter_mut()
-            .enumerate()
-            .filter(|(i, p)| closing != Some(*i as u32) && p.as_ref().is_some_and(|p| !p.host))
-            .find_map(|(i, page)| Some((i as u32, page.as_mut()?.free.take(len)?)))
-    }
-    /// The page to empty when much of the arena is free ranges (video memory
-    /// that fragmentation keeps: a page goes back only once all of it is free):
-    /// the one with the fewest vertices in use that the other pages' free
-    /// ranges can take. `None` when the arena is dense enough or already
-    /// emptying a page.
-    pub fn sparsest(&self) -> Option<u32> {
-        self.sparsest_from(COMPACT_MIN_FREE)
-    }
-    /// `sparsest` for an arena with at least `min_free` bytes in free ranges.
-    fn sparsest_from(&self, min_free: u64) -> Option<u32> {
-        if self.closing.is_some() {
-            return None;
-        }
-        let pages = || {
-            self.pages
-                .iter()
-                .enumerate()
-                .filter_map(|(i, p)| Some((i, p.as_ref()?)))
-        };
-        let free: u64 = pages().map(|(_, p)| p.free_vertices()).sum();
-        let capacity: u64 = pages().map(|(_, p)| p.capacity).sum();
-        if free * self.stride < min_free || free * 2 < capacity {
-            return None;
-        }
-        // Moves only go to video-memory pages (`alloc_moved`).
-        let local_free: u64 = pages()
-            .filter(|(_, p)| !p.host)
-            .map(|(_, p)| p.free_vertices())
-            .sum();
-        pages()
-            .filter_map(|(i, p)| {
-                let used = p.capacity - p.free_vertices();
-                let own = if p.host { 0 } else { p.free_vertices() };
-                // The room elsewhere, less a quarter for first fit's gaps.
-                let elsewhere = (local_free - own) / 4 * 3;
-                // A page in system memory is emptied first.
-                (used > 0 && used <= elsewhere).then_some((!p.host, used, i as u32))
-            })
-            .min()
-            .map(|(_, _, i)| i)
-    }
-    /// Stops placing vertices in `page` until `reopen`.
-    pub fn close(&mut self, page: u32) {
-        self.closing = Some(page);
-    }
-    pub fn reopen(&mut self) {
-        self.closing = None;
-    }
-    pub fn closing(&self) -> Option<u32> {
-        self.closing
-    }
-    /// Records the copy of `vertices` from one range to another of other pages.
-    pub fn copy(
-        &self,
-        encoder: &mut wgpu::CommandEncoder,
-        from: (u32, u64),
-        to: (u32, u64),
-        vertices: u64,
-    ) {
-        debug_assert_ne!(from.0, to.0);
-        encoder.copy_buffer_to_buffer(
-            self.buffer(from.0),
-            from.1 * self.stride,
-            self.buffer(to.0),
-            to.1 * self.stride,
-            vertices * self.stride,
-        );
-    }
     pub fn release(&mut self, page: u32, start: u64, vertices: u64) {
         let len = Self::span(vertices).min(self.page_limit);
         self.pages[page as usize]
@@ -402,7 +296,7 @@ impl Arena {
         capacity: u64,
     ) -> bool {
         let capacity = capacity.next_multiple_of(GRAIN).min(self.page_limit);
-        let Some((buffer, host)) = self.create(device, capacity) else {
+        let Some(buffer) = self.create(device, capacity) else {
             return false;
         };
         let old = self.pages[page].as_mut().expect("live arena page");
@@ -410,7 +304,6 @@ impl Arena {
         encoder.copy_buffer_to_buffer(&old.buffer, 0, &buffer, 0, old.capacity * self.stride);
         let previous = old.capacity;
         old.buffer = buffer;
-        old.host = host;
         old.capacity = capacity;
         old.free.give(previous, capacity - previous);
         true
@@ -425,9 +318,6 @@ impl Arena {
                 *page = None;
             }
         }
-        if self.closing.is_some_and(|page| !self.has_page(page)) {
-            self.closing = None;
-        }
         // Keep live page indices stable; later allocations reuse interior holes.
         while self.pages.last().is_some_and(Option::is_none) {
             self.pages.pop();
@@ -435,7 +325,6 @@ impl Arena {
     }
     pub fn clear(&mut self) {
         self.pages.clear();
-        self.closing = None;
     }
 }
 
@@ -518,76 +407,6 @@ mod tests {
         assert_eq!(read(&device, &queue, arena.buffer(page), next * 4), 9);
     }
 
-    #[test]
-    fn a_sparse_page_empties_into_the_others_and_is_reclaimed() {
-        let Some((device, queue)) = device() else {
-            eprintln!("no GPU adapter: skipped");
-            return;
-        };
-        let mut arena = Arena::new(&device, 4, GRAIN, false);
-        arena.page_limit = 4 * GRAIN;
-        // Eight ranges fill two pages, each holding its own number.
-        let ranges: Vec<(u32, u64)> = (0..8)
-            .map(|i| {
-                let range = alloc(&mut arena, &device, &queue, GRAIN).unwrap();
-                queue.write_buffer(
-                    arena.buffer(range.0),
-                    range.1 * 4,
-                    &(100 + i as u32).to_le_bytes(),
-                );
-                range
-            })
-            .collect();
-        assert_eq!(arena.pages.iter().flatten().count(), 2);
-        let (first, second) = (ranges[0].0, ranges[7].0);
-        assert_ne!(first, second);
-        // Fragmented: one range live in the first page, two in the second.
-        for (i, &(page, start)) in ranges.iter().enumerate() {
-            if ![0, 6, 7].contains(&i) {
-                arena.release(page, start, GRAIN);
-            }
-        }
-        // Dense enough arenas, and ones without room elsewhere, are left alone.
-        assert_eq!(arena.sparsest_from(u64::MAX), None);
-        assert_eq!(arena.sparsest_from(0), Some(first));
-        arena.close(first);
-        assert_eq!(
-            arena.sparsest_from(0),
-            None,
-            "one page is emptied at a time"
-        );
-        // New ranges avoid the closing page though it has room.
-        let (page, extra) = alloc(&mut arena, &device, &queue, GRAIN).unwrap();
-        assert_eq!(page, second);
-        arena.release(page, extra, GRAIN);
-        // Its live range moves, data included, and the page goes back.
-        let (page, start) = ranges[0];
-        let to = arena.alloc_existing(GRAIN).unwrap();
-        assert_eq!(to.0, second);
-        let mut encoder = device.create_command_encoder(&Default::default());
-        arena.copy(&mut encoder, (page, start), to, GRAIN);
-        queue.submit([encoder.finish()]);
-        arena.release(page, start, GRAIN);
-        assert_eq!(read(&device, &queue, arena.buffer(to.0), to.1 * 4), 100);
-        // Emptied but not trimmed yet: it stays closed, so uploads can't refill it.
-        assert_eq!(arena.closing(), Some(page));
-        let refill = alloc(&mut arena, &device, &queue, GRAIN).unwrap();
-        assert_ne!(refill.0, page);
-        arena.release(refill.0, refill.1, GRAIN);
-        let before = arena.bytes();
-        arena.trim();
-        assert_eq!(arena.bytes(), before - 4 * GRAIN * 4);
-        assert_eq!(arena.closing(), None);
-        // The others kept their ranges.
-        for i in [6, 7] {
-            let (page, start) = ranges[i];
-            assert_eq!(
-                read(&device, &queue, arena.buffer(page), start * 4),
-                100 + i as u32
-            );
-        }
-    }
-
     #[test]
     fn empty_pages_are_reclaimed_without_moving_live_ranges() {
         let Some((device, queue)) = device() else {
@@ -753,9 +572,6 @@ mod tests {
         queue.write_buffer(arena.buffer(grown), next * 4, &9u32.to_le_bytes());
         assert_eq!(read(&device, &queue, arena.buffer(page), start * 4), 7);
         assert_eq!(read(&device, &queue, arena.buffer(grown), next * 4), 9);
-        // Compaction never moves terrain into a page in system memory.
-        assert!(arena.pages[page as usize].as_ref().unwrap().host);
-        assert_eq!(arena.alloc_moved(GRAIN), None);
     }
 
     #[test]

crates/horizon-client-render/src/gfx/entity_batch.rs

@@ -20,13 +20,6 @@ const MATERIALS: usize = 10;
 /// (`RenderTypes.entityTranslucent`, `entityTranslucentEmissive`, `eyes`,
 /// `breezeWind`). Only the improved transparency path reads it.
 pub const OIT_ENTITY: u32 = 1 << 24;
-/// Tags quads as drawn by a render type vanilla gives an `OitPipelineSet`
-/// (`OIT_ENTITY`): improved transparency draws them in its stages.
-pub fn mark_oit(quads: &mut [Vertex]) {
-    for vertex in quads {
-        vertex.layer |= OIT_ENTITY;
-    }
-}
 /// The overlay of depth-only quads that hide water (`RenderTypes.waterMask`).
 pub const WATER_MASK_OVERLAY: u32 = 13;
 /// The overlay of energy swirl quads (`RenderTypes.energySwirl`: the charged creeper's and the
@@ -46,13 +39,12 @@ pub const TRANSLUCENT_GLINT_ITEM_OVERLAY: u32 = 33;
 /// drawn like an ordinary entity, pulled toward the camera.
 pub const TEXT_POLYGON_OFFSET_OVERLAY: u32 = 35;
 
-/// The material of a quad by its overlay (`MATERIALS` order): the overlay is the layer's low 16
-/// bits, as entity.wgsl reads it; HDR output's tier rides in the high ones.
+/// The material of a quad by its overlay (`MATERIALS` order).
 fn material(layer: u32, oit: bool) -> usize {
     if oit && layer & OIT_ENTITY != 0 {
         return 9;
     }
-    match layer & 0xffff {
+    match layer {
         TEXT_POLYGON_OFFSET_OVERLAY => 1,
         11 => 2,
         12 => 3,
@@ -72,10 +64,6 @@ pub(super) struct EntityBatch {
     // frame, keeping their storage.
     runs: [Vec<(usize, usize)>; MATERIALS],
     pub(super) combined: Vec<Vertex>,
-    /// Additive quads tagged `OIT_ENTITY` that the last `update` moved into the
-    /// last material (improved transparency on): the dragon's eyes, which share
-    /// the additive buffer with its rays.
-    pub(super) moved_additive: u32,
 }
 
 impl EntityBatch {
@@ -113,32 +101,7 @@ impl EntityBatch {
                     .extend_from_slice(&entities[first * 4..(first + count) * 4]);
             }
         }
-        // `RenderTypes.eyes` is blended like the other entities, not added: with
-        // improved transparency on, tagged additive quads join the last
-        // material, drawn without the additive overlay and the baked shading.
-        self.moved_additive = 0;
-        if oit {
-            for quad in additive.as_chunks::<4>().0 {
-                if quad[0].layer & OIT_ENTITY != 0 {
-                    self.combined.extend(quad.iter().map(|v| Vertex {
-                        layer: v.layer & !0xffff,
-                        normal: [0; 4],
-                        ..*v
-                    }));
-                    counts[9] += 1;
-                    self.moved_additive += 1;
-                }
-            }
-        }
-        if self.moved_additive == 0 {
-            self.combined.extend_from_slice(additive);
-        } else {
-            for quad in additive.as_chunks::<4>().0 {
-                if quad[0].layer & OIT_ENTITY == 0 {
-                    self.combined.extend_from_slice(quad);
-                }
-            }
-        }
+        self.combined.extend_from_slice(additive);
         self.combined.extend_from_slice(hand);
         self.combined.extend_from_slice(see_through);
         counts.map(|count| count as u32)
@@ -214,15 +177,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn a_tier_in_the_high_bits_keeps_the_material() {
-        for layer in [0u32, 11, 12, 15, 32, 33, 35, OIT_ENTITY] {
-            for oit in [false, true] {
-                assert_eq!(material(layer | 4 << 16, oit), material(layer, oit));
-            }
-        }
-    }
-
     #[test]
     fn oit_entity_quads_are_a_last_material_only_when_on() {
         let quad = |layer: u32, x: f32| {
@@ -256,38 +210,6 @@ mod tests {
         assert_eq!(xs, [0.0, 2.0, 3.0, 1.0, 4.0]);
     }
 
-    #[test]
-    fn tagged_additive_quads_join_the_last_material_only_when_on() {
-        let quad = |layer: u32, x: f32| {
-            (0..4).map(move |_| Vertex {
-                pos: [x, 0.0, 0.0],
-                layer,
-                normal: [1, 2, 3, 4],
-                ..geometry(1, false)[0]
-            })
-        };
-        // The dragon's eyes (tagged, overlay 2) and a ray (plain).
-        let additive: Vec<Vertex> = [(2 | OIT_ENTITY | 3 << 16, 1.0), (2, 2.0)]
-            .into_iter()
-            .flat_map(|(layer, x)| quad(layer, x))
-            .collect();
-        let entities: Vec<Vertex> = quad(0, 0.0).collect();
-        let mut batch = EntityBatch::default();
-        // Off: untouched.
-        let counts = batch.update(&entities, &additive, &[], &[], false);
-        assert_eq!((counts[9], batch.moved_additive), (0, 0));
-        assert_eq!(batch.combined.len(), 12);
-        assert_eq!(batch.combined[4].layer, 2 | OIT_ENTITY | 3 << 16);
-        // On: the eyes are an entity quad without the additive overlay, the ray stays.
-        let counts = batch.update(&entities, &additive, &[], &[], true);
-        assert_eq!((counts[0], counts[9], batch.moved_additive), (1, 1, 1));
-        let xs: Vec<f32> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
-        assert_eq!(xs, [0.0, 1.0, 2.0]);
-        assert_eq!(batch.combined[4].layer, OIT_ENTITY | 3 << 16);
-        assert_eq!(batch.combined[4].normal, [0; 4]);
-        assert_eq!(batch.combined[8].layer, 2);
-    }
-
     #[test]
     fn stable_material_order_tails_and_reuse() {
         let mut batch = EntityBatch::default();

crates/horizon-client-render/src/gfx/flat.rs

@@ -63,8 +63,6 @@ pub struct Call {
 
 pub struct Flat {
     pub solid: wgpu::RenderPipeline,
-    /// The solid draws as the water mirror's camera draws them (`fs_solid_mirror`).
-    pub solid_mirror: wgpu::RenderPipeline,
     pub translucent: wgpu::RenderPipeline,
     flatten: wgpu::ComputePipeline,
     compute_layout: wgpu::BindGroupLayout,
@@ -119,52 +117,29 @@ pub struct Flat {
 /// sides it shows the eye (`mesher::Sides`), so it counts sections.
 pub const MIN_SECTIONS: usize = 1600;
 
-/// Whether flat draws exist: vertex shaders can read storage buffers large
-/// enough for an index page. A shader pack's terrain draws flat wherever they
-/// do, since only there does it read each quad's face normal and `mc_Entity`;
-/// frames without one draw flat only where `for_vanilla` says.
+/// Whether flat draws apply: the backend emulates multi-draw, and vertex
+/// shaders can read storage buffers large enough for an index page.
 /// `HORIZON_FLAT_DRAWS=1` draws every frame flat, `0` none.
 pub fn wanted(adapter: &wgpu::Adapter, device: &wgpu::Device) -> bool {
-    std::env::var("HORIZON_FLAT_DRAWS").as_deref() != Ok("0") && supported(adapter, device)
+    match std::env::var("HORIZON_FLAT_DRAWS").as_deref() {
+        Ok("0") => return false,
+        Ok("1") => return supported(adapter, device),
+        _ => {}
+    }
+    let info = adapter.get_info();
+    (info.backend == wgpu::Backend::Metal || is_broken_intel_vulkan(&info))
+        && supported(adapter, device)
 }
 
-/// Whether frames without a shader pack's terrain draw flat: where the backend
-/// emulates multi-draw (Metal, past `MIN_SECTIONS`), on Intel Gen11/Gen12's Vulkan
-/// driver, or with `HORIZON_FLAT_DRAWS=1`. Elsewhere per-section draws stay.
-pub fn for_vanilla(info: &wgpu::AdapterInfo) -> bool {
-    std::env::var("HORIZON_FLAT_DRAWS").as_deref() == Ok("1")
-        || info.backend == wgpu::Backend::Metal
-        || is_broken_intel_vulkan(info)
-}
-
-/// Intel Gen11 (Ice Lake) and Gen12 (Tiger Lake, Rocket Lake, Alder Lake,
-/// Raptor Lake) ANV Vulkan drivers have broken `first_instance` for
-/// instance-step vertex attributes (#3529, #4599), causing terrain sections to
-/// be drawn with another section's origin and flicker.
+/// Intel Gen11 (Ice Lake) ANV Vulkan driver has broken `first_instance` for instance-step
+/// vertex attributes (#3529), causing terrain sections to be drawn with another section's origin
+/// and flicker.
 pub fn is_broken_intel_vulkan(info: &wgpu::AdapterInfo) -> bool {
     info.backend == wgpu::Backend::Vulkan
         && info.vendor == 0x8086
-        && (matches!(
-            info.device,
-            0x8a50..=0x8a71 // Gen11: Ice Lake
-                | 0x9a40..=0x9a7f // Gen12: Tiger Lake
-                | 0x4c80..=0x4c9a // Gen12: Rocket Lake
-                | 0x4600..=0x46ff // Gen12: Alder Lake (incl. 0x46a8 in #4599)
-                | 0xa700..=0xa7ff // Gen12: Raptor Lake
-        ) || [
-            "ICL",
-            "Ice Lake",
-            "TGL",
-            "Tiger Lake",
-            "RKL",
-            "Rocket Lake",
-            "ADL",
-            "Alder Lake",
-            "RPL",
-            "Raptor Lake",
-        ]
-        .iter()
-        .any(|tag| info.name.contains(tag)))
+        && (info.name.contains("ICL")
+            || info.name.contains("Ice Lake")
+            || (info.device >= 0x8a50 && info.device <= 0x8a71))
 }
 
 fn supported(adapter: &wgpu::Adapter, device: &wgpu::Device) -> bool {
@@ -286,7 +261,7 @@ fn plan(
 }
 
 impl Flat {
-    /// `pipeline(layout, label, fragment entry, blend, cull)` builds a
+    /// `pipeline(layout, label, vertex entry, fragment entry, blend)` builds a
     /// terrain pipeline as the per-section ones, without the origin buffer.
     pub fn new(
         device: &wgpu::Device,
@@ -298,7 +273,6 @@ impl Flat {
             &str,
             &str,
             Option<wgpu::BlendState>,
-            Option<wgpu::Face>,
         ) -> wgpu::RenderPipeline,
     ) -> Self {
         let vertex = wgpu::ShaderStages::VERTEX;
@@ -352,23 +326,13 @@ impl Flat {
         let flatten = compute_pipeline(&compute_layout, "flatten");
         let flatten_seen = compute_pipeline(&seen_layout, "flatten_seen");
         let storage_usage = wgpu::BufferUsages::STORAGE;
-        let back = Some(wgpu::Face::Back);
         Self {
-            solid: pipeline(&layout, "Terrain solid (flat)", "fs_solid", None, back),
-            // The mirror flips the winding: its solid terrain culls the front.
-            solid_mirror: pipeline(
-                &layout,
-                "Terrain solid mirrored (flat)",
-                "fs_solid_mirror",
-                None,
-                Some(wgpu::Face::Front),
-            ),
+            solid: pipeline(&layout, "Terrain solid (flat)", "fs_solid", None),
             translucent: pipeline(
                 &layout,
                 "Terrain translucent (flat)",
                 "fs_translucent",
                 Some(wgpu::BlendState::ALPHA_BLENDING),
-                back,
             ),
             flatten,
             compute_layout,
@@ -744,23 +708,6 @@ impl Flat {
             pass.draw_indexed(call.first..call.first + call.count, 0, 0..1);
         }
     }
-    /// Draws `calls` without their index buffer, `instances` times: a shader pack's geometry
-    /// stage reads the indices itself (`hz_indices`) and stands for one emitted triangle per
-    /// instance.
-    pub fn draw_geometry<'a>(
-        &self,
-        pass: &mut wgpu::RenderPass<'_>,
-        calls: &[Call],
-        vertices: impl Fn(u32) -> &'a wgpu::Buffer,
-        page: impl Fn(&mut wgpu::RenderPass<'_>, u32),
-        instances: u32,
-    ) {
-        for call in calls {
-            self.bind_page(pass, call.page, &vertices);
-            page(pass, call.page);
-            pass.draw(call.first..call.first + call.count, 0..instances);
-        }
-    }
     /// Draws phase 2's calls, as `flatten_phase2` left them.
     pub fn draw_phase2<'a>(
         &self,

crates/horizon-client-render/src/gfx/frame_gen.rs

@@ -1,9 +1,7 @@
 //! Frame generation: FSR 3.1's frame interpolation will show a frame halfway between each
-//! two real ones. So far this holds its optical flow and interpolation; the setting that
-//! runs them comes next.
+//! two real ones. So far this holds its optical flow; the interpolation and the setting
+//! that runs them come next.
 
-// Unused until the renderer runs them.
-#[allow(dead_code)]
-mod interpolation;
+// Unused until the interpolation and the renderer use it.
 #[allow(dead_code)]
 mod optical_flow;

crates/horizon-client-render/src/gfx/frame_gen/interpolation.rs

@@ -1,806 +0,0 @@
-//! FSR 3.1's frame interpolation (AMD FidelityFX SDK 1.1.4, `ffx_frameinterpolation*`,
-//! MIT), ported to WGSL (`interpolation.wgsl`): the frame halfway between the previous
-//! real frame and this one, from the camera's motion vectors, the optical flow
-//! (`optical_flow.rs`) and the depth.
-//!
-//! The passes and their order are `ffxFrameInterpolationPrepare` then
-//! `ffxFrameInterpolationDispatch`'s: dilate the depth and motion vectors and estimate
-//! the previous frame's depth; estimate the made frame's depth; splat the game's and the
-//! optical flow's vectors to the made frame's pixels (atomic maximums of packed
-//! priorities and vectors) and fill the game field's holes from a pyramid; mask what each
-//! frame can't see; blend the two frames along both fields; fill what is left from a
-//! pyramid of the result. What differs from AMD's, all forced by WGSL or by Horizon:
-//! the game's motion vectors are computed from the depth and `Inputs::reproject` (the
-//! camera's, so what moves on its own relies on the optical flow); textures AMD updates
-//! with image atomics are storage buffers; SPD's single-pass pyramids are a pass per
-//! level; and there is no HUD-less pass, as Horizon draws its HUD over the made frame.
-
-use glam::Mat4;
-
-/// One real frame's inputs.
-pub struct Inputs<'a> {
-    /// This frame's colour without the hand and HUD: `display` size, a filterable
-    /// float texture (gamma-encoded RGB, the swapchain's values) that can be copied from.
-    pub color: &'a wgpu::TextureView,
-    /// This frame's depth: `Depth32Float` at `render_size`, reversed (1 at the near
-    /// plane, 0 at the far one), finite, jittered by `jitter`.
-    pub depth: &'a wgpu::TextureView,
-    pub render_size: [u32; 2],
-    /// The projection's sub-pixel jitter this frame, in render pixels (FSR's
-    /// `jitterOffset`); zero without TAA.
-    pub jitter: [f32; 2],
-    /// This frame's unjittered clip space to the previous frame's (camera-relative, as
-    /// `world_post::reprojection`): the motion vectors are the camera's, from this and
-    /// the depth.
-    pub reproject: Mat4,
-    pub near: f32,
-    pub far: f32,
-    /// Vertical field of view, radians.
-    pub fov_y: f32,
-    /// The previous frame is unrelated (first frame, resize, teleport): show this one.
-    pub reset: bool,
-    /// The optical flow from the previous frame's `color` to this one's
-    /// (`OpticalFlow::vectors`, `scene_change`).
-    pub flow_vectors: &'a wgpu::TextureView,
-    pub scene_change: &'a wgpu::Buffer,
-}
-
-/// `interpolation.wgsl`'s `Params`.
-#[repr(C)]
-#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
-struct Params {
-    reproject: [[f32; 4]; 4],
-    device_to_view: [f32; 4],
-    render_size: [i32; 2],
-    display_size: [i32; 2],
-    jitter: [f32; 2],
-    optical_flow_scale: [f32; 2],
-    optical_flow_size: [i32; 2],
-    reset: u32,
-    tan_half_fov: f32,
-    level_size: [i32; 2],
-    _pad: [u32; 2],
-}
-
-/// The game vector field pyramid's levels (`LoadInpaintedGameFieldMv`) and the
-/// inpainting pyramid's (`ComputeInpainting`).
-const GAME_LEVELS: u32 = 11;
-const INPAINTING_LEVELS: u32 = 10;
-
-struct Pipelines {
-    prepare: wgpu::ComputePipeline,
-    setup: wgpu::ComputePipeline,
-    reconstruct_previous_depth: wgpu::ComputePipeline,
-    game_motion_vector_field: wgpu::ComputePipeline,
-    game_field_pyramid_first: wgpu::ComputePipeline,
-    game_field_pyramid: wgpu::ComputePipeline,
-    optical_flow_vector_field: wgpu::ComputePipeline,
-    disocclusion_mask: wgpu::ComputePipeline,
-    interpolate: wgpu::ComputePipeline,
-    inpainting_pyramid_first: wgpu::ComputePipeline,
-    inpainting_pyramid: wgpu::ComputePipeline,
-    inpainting: wgpu::ComputePipeline,
-}
-
-/// A texture with a view of each of its levels (`levels`, for writing one from the one
-/// above) and of all of them.
-struct Pyramid {
-    all: wgpu::TextureView,
-    levels: Vec<wgpu::TextureView>,
-    sizes: Vec<[u32; 2]>,
-}
-
-/// What is sized like the world's render.
-struct RenderTargets {
-    size: [u32; 2],
-    dilated_depth: wgpu::TextureView,
-    dilated_mv: wgpu::TextureView,
-    rec_prev_depth: wgpu::Buffer,
-    rec_interp_depth: wgpu::Buffer,
-    game_x: wgpu::Buffer,
-    game_y: wgpu::Buffer,
-    of_x: wgpu::Buffer,
-    of_y: wgpu::Buffer,
-    disocclusion: wgpu::TextureView,
-    game_pyramid: Pyramid,
-}
-
-pub struct Interpolation {
-    display: [u32; 2],
-    pipelines: Pipelines,
-    sampler: wgpu::Sampler,
-    /// The passes' constants, and each pyramid level's.
-    params: wgpu::Buffer,
-    game_level_params: Vec<wgpu::Buffer>,
-    inpainting_level_params: Vec<wgpu::Buffer>,
-    counters: wgpu::Buffer,
-    interpolated: wgpu::TextureView,
-    output: wgpu::TextureView,
-    inpainting_pyramid: Pyramid,
-    /// The last dispatch's colour (`PREVIOUS_INTERPOLATION_SOURCE`), made on the first.
-    previous: Option<wgpu::Texture>,
-    render: Option<RenderTargets>,
-}
-
-fn texture(
-    device: &wgpu::Device,
-    label: &str,
-    size: [u32; 2],
-    format: wgpu::TextureFormat,
-    levels: u32,
-) -> wgpu::Texture {
-    device.create_texture(&wgpu::TextureDescriptor {
-        label: Some(label),
-        size: wgpu::Extent3d {
-            width: size[0].max(1),
-            height: size[1].max(1),
-            depth_or_array_layers: 1,
-        },
-        mip_level_count: levels,
-        sample_count: 1,
-        dimension: wgpu::TextureDimension::D2,
-        format,
-        usage: wgpu::TextureUsages::STORAGE_BINDING
-            | wgpu::TextureUsages::TEXTURE_BINDING
-            | wgpu::TextureUsages::COPY_SRC,
-        view_formats: &[],
-    })
-}
-
-fn storage(device: &wgpu::Device, label: &str, size: u64) -> wgpu::Buffer {
-    device.create_buffer(&wgpu::BufferDescriptor {
-        label: Some(label),
-        size: size.max(4),
-        usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
-        mapped_at_creation: false,
-    })
-}
-
-fn uniform(device: &wgpu::Device) -> wgpu::Buffer {
-    device.create_buffer(&wgpu::BufferDescriptor {
-        label: Some("Frame interpolation constants"),
-        size: std::mem::size_of::<Params>() as u64,
-        usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-        mapped_at_creation: false,
-    })
-}
-
-/// Levels of `base >> (i + 1)` for `i` below `max`, while both sides are 1 or more.
-fn pyramid(device: &wgpu::Device, label: &str, base: [u32; 2], max: u32) -> Pyramid {
-    let sizes: Vec<[u32; 2]> = (0..max)
-        .map(|i| base.map(|v| v >> (i + 1)))
-        .take_while(|s| s[0] >= 1 && s[1] >= 1)
-        .collect();
-    let levels = (sizes.len() as u32).max(1);
-    let t = texture(
-        device,
-        label,
-        base.map(|v| (v / 2).max(1)),
-        wgpu::TextureFormat::Rgba16Float,
-        levels,
-    );
-    Pyramid {
-        all: t.create_view(&Default::default()),
-        levels: (0..levels)
-            .map(|i| {
-                t.create_view(&wgpu::TextureViewDescriptor {
-                    base_mip_level: i,
-                    mip_level_count: Some(1),
-                    ..Default::default()
-                })
-            })
-            .collect(),
-        sizes,
-    }
-}
-
-impl RenderTargets {
-    fn new(device: &wgpu::Device, size: [u32; 2]) -> Self {
-        let view = |t: wgpu::Texture| t.create_view(&Default::default());
-        let field = |label| storage(device, label, u64::from(size[0] * size[1]) * 4);
-        Self {
-            size,
-            dilated_depth: view(texture(
-                device,
-                "Frame interpolation dilated depth",
-                size,
-                wgpu::TextureFormat::R32Float,
-                1,
-            )),
-            dilated_mv: view(texture(
-                device,
-                "Frame interpolation dilated motion vectors",
-                size,
-                wgpu::TextureFormat::Rg32Float,
-                1,
-            )),
-            rec_prev_depth: field("Frame interpolation previous depth"),
-            rec_interp_depth: field("Frame interpolation interpolated depth"),
-            game_x: field("Frame interpolation game vectors x"),
-            game_y: field("Frame interpolation game vectors y"),
-            of_x: field("Frame interpolation flow vectors x"),
-            of_y: field("Frame interpolation flow vectors y"),
-            disocclusion: view(texture(
-                device,
-                "Frame interpolation disocclusion",
-                size,
-                wgpu::TextureFormat::Rgba8Unorm,
-                1,
-            )),
-            game_pyramid: pyramid(
-                device,
-                "Frame interpolation game vector pyramid",
-                size,
-                GAME_LEVELS,
-            ),
-        }
-    }
-}
-
-fn bind(
-    device: &wgpu::Device,
-    pipeline: &wgpu::ComputePipeline,
-    entries: &[(u32, wgpu::BindingResource)],
-) -> wgpu::BindGroup {
-    let entries: Vec<_> = entries
-        .iter()
-        .map(|(binding, resource)| wgpu::BindGroupEntry {
-            binding: *binding,
-            resource: resource.clone(),
-        })
-        .collect();
-    device.create_bind_group(&wgpu::BindGroupDescriptor {
-        label: Some("Frame interpolation"),
-        layout: &pipeline.get_bind_group_layout(0),
-        entries: &entries,
-    })
-}
-
-fn view(v: &wgpu::TextureView) -> wgpu::BindingResource<'_> {
-    wgpu::BindingResource::TextureView(v)
-}
-
-fn whole(b: &wgpu::Buffer) -> wgpu::BindingResource<'_> {
-    b.as_entire_binding()
-}
-
-/// `setupDeviceDepthToViewSpaceDepthParams` for inverted, finite depth, in blocks
-/// (`viewSpaceToMetersFactor` 1).
-fn device_to_view(near: f32, far: f32, fov_y: f32, aspect: f32) -> [f32; 4] {
-    let (f_min, f_max) = (near.max(far), near.min(far));
-    let q = f_max / (f_min - f_max);
-    let cot_half_fov = (0.5 * fov_y).cos() / (0.5 * fov_y).sin();
-    [-q, q * f_min, aspect / cot_half_fov, 1.0 / cot_half_fov]
-}
-
-impl Interpolation {
-    /// For frames of `display` size; the render size may change between dispatches.
-    pub fn new(device: &wgpu::Device, display: [u32; 2]) -> Self {
-        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-            label: Some("Frame interpolation"),
-            source: wgpu::ShaderSource::Wgsl(include_str!("interpolation.wgsl").into()),
-        });
-        let pipeline = |entry: &str| {
-            device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
-                label: Some(entry),
-                layout: None,
-                module: &module,
-                entry_point: Some(entry),
-                compilation_options: Default::default(),
-                cache: None,
-            })
-        };
-        let view = |t: wgpu::Texture| t.create_view(&Default::default());
-        Self {
-            display,
-            pipelines: Pipelines {
-                prepare: pipeline("prepare_pass"),
-                setup: pipeline("setup_pass"),
-                reconstruct_previous_depth: pipeline("reconstruct_previous_depth_pass"),
-                game_motion_vector_field: pipeline("game_motion_vector_field_pass"),
-                game_field_pyramid_first: pipeline("game_field_pyramid_first_pass"),
-                game_field_pyramid: pipeline("game_field_pyramid_pass"),
-                optical_flow_vector_field: pipeline("optical_flow_vector_field_pass"),
-                disocclusion_mask: pipeline("disocclusion_mask_pass"),
-                interpolate: pipeline("interpolate_pass"),
-                inpainting_pyramid_first: pipeline("inpainting_pyramid_first_pass"),
-                inpainting_pyramid: pipeline("inpainting_pyramid_pass"),
-                inpainting: pipeline("inpainting_pass"),
-            },
-            sampler: device.create_sampler(&wgpu::SamplerDescriptor {
-                label: Some("Frame interpolation"),
-                mag_filter: wgpu::FilterMode::Linear,
-                min_filter: wgpu::FilterMode::Linear,
-                ..Default::default()
-            }),
-            params: uniform(device),
-            game_level_params: (0..GAME_LEVELS).map(|_| uniform(device)).collect(),
-            inpainting_level_params: (0..INPAINTING_LEVELS).map(|_| uniform(device)).collect(),
-            counters: storage(device, "Frame interpolation counters", 8),
-            interpolated: view(texture(
-                device,
-                "Frame interpolation",
-                display,
-                wgpu::TextureFormat::Rgba16Float,
-                1,
-            )),
-            output: view(texture(
-                device,
-                "Interpolated frame",
-                display,
-                wgpu::TextureFormat::Rgba16Float,
-                1,
-            )),
-            inpainting_pyramid: pyramid(
-                device,
-                "Frame interpolation inpainting pyramid",
-                display,
-                INPAINTING_LEVELS,
-            ),
-            previous: None,
-            render: None,
-        }
-    }
-
-    /// The frame halfway between the previous dispatch's `color` and this one's, into
-    /// `output`. Keeps what it needs of this frame for the next dispatch.
-    pub fn dispatch(
-        &mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        encoder: &mut wgpu::CommandEncoder,
-        inputs: &Inputs,
-    ) {
-        let color = inputs.color.texture();
-        let mut reset = inputs.reset;
-        if self
-            .previous
-            .as_ref()
-            .is_none_or(|p| p.size() != color.size() || p.format() != color.format())
-        {
-            self.previous = Some(device.create_texture(&wgpu::TextureDescriptor {
-                label: Some("Frame interpolation previous frame"),
-                size: color.size(),
-                mip_level_count: 1,
-                sample_count: 1,
-                dimension: wgpu::TextureDimension::D2,
-                format: color.format(),
-                usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-                view_formats: &[],
-            }));
-            reset = true;
-        }
-        if self
-            .render
-            .as_ref()
-            .is_none_or(|r| r.size != inputs.render_size)
-        {
-            self.render = Some(RenderTargets::new(device, inputs.render_size));
-            reset = true;
-        }
-        let r = self.render.as_ref().expect("made above");
-        let previous_texture = self.previous.as_ref().expect("made above");
-        let previous = previous_texture.create_view(&Default::default());
-        let display = self.display.map(|v| v as i32);
-        let render = inputs.render_size.map(|v| v as i32);
-        let flow_size = self
-            .display
-            .map(|v| v.div_ceil(super::optical_flow::BLOCK_SIZE) as i32);
-        let base = Params {
-            reproject: inputs.reproject.to_cols_array_2d(),
-            device_to_view: device_to_view(
-                inputs.near,
-                inputs.far,
-                inputs.fov_y,
-                render[0] as f32 / render[1].max(1) as f32,
-            ),
-            render_size: render,
-            display_size: display,
-            jitter: inputs.jitter,
-            optical_flow_scale: self.display.map(|v| 1.0 / v as f32),
-            optical_flow_size: flow_size,
-            reset: u32::from(reset),
-            tan_half_fov: (0.5 * inputs.fov_y).tan() * render[0] as f32 / render[1].max(1) as f32,
-            level_size: [0; 2],
-            _pad: [0; 2],
-        };
-        queue.write_buffer(&self.params, 0, bytemuck::bytes_of(&base));
-        let level_params = |buffers: &[wgpu::Buffer], sizes: &[[u32; 2]]| {
-            for (buffer, size) in buffers.iter().zip(sizes) {
-                let params = Params {
-                    level_size: size.map(|v| v as i32),
-                    ..base
-                };
-                queue.write_buffer(buffer, 0, bytemuck::bytes_of(&params));
-            }
-        };
-        level_params(&self.game_level_params, &r.game_pyramid.sizes);
-        level_params(
-            &self.inpainting_level_params,
-            &self.inpainting_pyramid.sizes,
-        );
-        for b in [
-            &r.rec_prev_depth,
-            &r.rec_interp_depth,
-            &r.game_x,
-            &r.game_y,
-            &r.of_x,
-            &r.of_y,
-        ] {
-            encoder.clear_buffer(b, 0, None);
-        }
-        if reset {
-            encoder.clear_buffer(&self.counters, 0, None);
-        }
-        let p = &self.pipelines;
-        let params = || whole(&self.params);
-        let sampler = || wgpu::BindingResource::Sampler(&self.sampler);
-        let groups =
-            |pipeline, entries: &[(u32, wgpu::BindingResource)]| bind(device, pipeline, entries);
-        let prepare = groups(
-            &p.prepare,
-            &[
-                (0, params()),
-                (2, view(inputs.depth)),
-                (5, view(&r.dilated_depth)),
-                (6, view(&r.dilated_mv)),
-                (9, whole(&r.rec_prev_depth)),
-            ],
-        );
-        let setup = groups(
-            &p.setup,
-            &[
-                (0, params()),
-                (22, whole(inputs.scene_change)),
-                (23, whole(&self.counters)),
-            ],
-        );
-        let colors = || {
-            [
-                (3, view(inputs.color)),
-                (4, view(&previous)),
-                (1, sampler()),
-            ]
-        };
-        let reconstruct = groups(
-            &p.reconstruct_previous_depth,
-            &[
-                (0, params()),
-                (7, view(&r.dilated_depth)),
-                (8, view(&r.dilated_mv)),
-                (10, whole(&r.rec_interp_depth)),
-            ],
-        );
-        let mut entries = vec![
-            (0, params()),
-            (7, view(&r.dilated_depth)),
-            (8, view(&r.dilated_mv)),
-            (13, whole(&r.game_x)),
-            (14, whole(&r.game_y)),
-        ];
-        entries.extend(colors());
-        let game_field = groups(&p.game_motion_vector_field, &entries);
-        let game_pyramid: Vec<_> = (0..r.game_pyramid.sizes.len())
-            .map(|i| {
-                let mut entries = vec![
-                    (0, whole(&self.game_level_params[i])),
-                    (26, view(&r.game_pyramid.levels[i])),
-                ];
-                if i == 0 {
-                    entries.extend([(15, whole(&r.game_x)), (16, whole(&r.game_y))]);
-                    groups(&p.game_field_pyramid_first, &entries)
-                } else {
-                    entries.push((25, view(&r.game_pyramid.levels[i - 1])));
-                    groups(&p.game_field_pyramid, &entries)
-                }
-            })
-            .collect();
-        let mut entries = vec![
-            (0, params()),
-            (21, view(inputs.flow_vectors)),
-            (17, whole(&r.of_x)),
-            (18, whole(&r.of_y)),
-        ];
-        entries.extend(colors());
-        let flow_field = groups(&p.optical_flow_vector_field, &entries);
-        let game_mv = || {
-            [
-                (15, whole(&r.game_x)),
-                (16, whole(&r.game_y)),
-                (27, view(&r.game_pyramid.all)),
-            ]
-        };
-        let mut entries = vec![
-            (0, params()),
-            (7, view(&r.dilated_depth)),
-            (11, whole(&r.rec_prev_depth)),
-            (12, whole(&r.rec_interp_depth)),
-            (29, view(&r.disocclusion)),
-        ];
-        entries.extend(game_mv());
-        let disocclusion = groups(&p.disocclusion_mask, &entries);
-        let mut entries = vec![
-            (0, params()),
-            (19, whole(&r.of_x)),
-            (20, whole(&r.of_y)),
-            (24, whole(&self.counters)),
-            (30, view(&r.disocclusion)),
-            (31, view(&self.interpolated)),
-        ];
-        entries.extend(game_mv());
-        entries.extend(colors());
-        let interpolate = groups(&p.interpolate, &entries);
-        let inpainting_pyramid: Vec<_> = (0..self.inpainting_pyramid.sizes.len())
-            .map(|i| {
-                let mut entries = vec![
-                    (0, whole(&self.inpainting_level_params[i])),
-                    (26, view(&self.inpainting_pyramid.levels[i])),
-                ];
-                if i == 0 {
-                    entries.push((32, view(&self.interpolated)));
-                    groups(&p.inpainting_pyramid_first, &entries)
-                } else {
-                    entries.push((25, view(&self.inpainting_pyramid.levels[i - 1])));
-                    groups(&p.inpainting_pyramid, &entries)
-                }
-            })
-            .collect();
-        let inpainting = groups(
-            &p.inpainting,
-            &[
-                (0, params()),
-                (28, view(&self.inpainting_pyramid.all)),
-                (32, view(&self.interpolated)),
-                (33, view(&self.output)),
-            ],
-        );
-        let groups_for = |size: [u32; 2]| (size[0].div_ceil(8), size[1].div_ceil(8));
-        let (rx, ry) = groups_for(inputs.render_size);
-        let (dx, dy) = groups_for(self.display);
-        let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
-            label: Some("Frame interpolation"),
-            timestamp_writes: None,
-        });
-        let mut run = |pipeline: &wgpu::ComputePipeline, group: &wgpu::BindGroup, (x, y)| {
-            pass.set_pipeline(pipeline);
-            pass.set_bind_group(0, group, &[]);
-            pass.dispatch_workgroups(x, y, 1);
-        };
-        run(&p.prepare, &prepare, (rx, ry));
-        run(&p.setup, &setup, (1, 1));
-        if !reset {
-            run(&p.reconstruct_previous_depth, &reconstruct, (rx, ry));
-            run(&p.game_motion_vector_field, &game_field, (rx, ry));
-            for (i, (group, size)) in game_pyramid.iter().zip(&r.game_pyramid.sizes).enumerate() {
-                let pipeline = if i == 0 {
-                    &p.game_field_pyramid_first
-                } else {
-                    &p.game_field_pyramid
-                };
-                run(pipeline, group, groups_for(*size));
-            }
-            run(
-                &p.optical_flow_vector_field,
-                &flow_field,
-                groups_for(flow_size.map(|v| v as u32)),
-            );
-            run(&p.disocclusion_mask, &disocclusion, (rx, ry));
-        }
-        run(&p.interpolate, &interpolate, (dx, dy));
-        for (i, (group, size)) in inpainting_pyramid
-            .iter()
-            .zip(&self.inpainting_pyramid.sizes)
-            .enumerate()
-        {
-            let pipeline = if i == 0 {
-                &p.inpainting_pyramid_first
-            } else {
-                &p.inpainting_pyramid
-            };
-            run(pipeline, group, groups_for(*size));
-        }
-        run(&p.inpainting, &inpainting, (dx, dy));
-        drop(pass);
-        encoder.copy_texture_to_texture(
-            color.as_image_copy(),
-            previous_texture.as_image_copy(),
-            color.size(),
-        );
-    }
-
-    /// The interpolated frame: `display` size, `Rgba16Float`, sampled; its colour is
-    /// encoded as `Inputs::color`'s is.
-    pub fn output(&self) -> &wgpu::TextureView {
-        &self.output
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::optical_flow::{OpticalFlow, tests as of};
-    use super::*;
-
-    #[test]
-    fn shader_validates() {
-        let module = naga::front::wgsl::parse_str(include_str!("interpolation.wgsl")).unwrap();
-        naga::valid::Validator::new(
-            naga::valid::ValidationFlags::all(),
-            naga::valid::Capabilities::empty(),
-        )
-        .validate(&module)
-        .unwrap();
-    }
-
-    fn f16(bits: u16) -> f32 {
-        let (sign, exp, frac) = (bits >> 15, (bits >> 10) & 0x1f, bits & 0x3ff);
-        let v = match exp {
-            0 => f32::from(frac) / 1024.0 * 2f32.powi(-14),
-            31 => f32::INFINITY,
-            e => (1.0 + f32::from(frac) / 1024.0) * 2f32.powi(i32::from(e) - 15),
-        };
-        if sign == 1 { -v } else { v }
-    }
-
-    /// Runs `frames` (pattern shifts) through the optical flow and the interpolation with
-    /// a camera that moves by `reproject` each frame, and returns the mean error of the
-    /// last made frame's interior against `expected`, and the last two real frames'.
-    fn interpolate(
-        seed: u32,
-        shifts: &[[i32; 2]],
-        reproject: Mat4,
-        expected: [i32; 2],
-    ) -> Option<[f32; 3]> {
-        let (device, queue) = of::device()?;
-        let size = [512, 288];
-        let depth = device.create_texture(&wgpu::TextureDescriptor {
-            label: None,
-            size: wgpu::Extent3d {
-                width: size[0],
-                height: size[1],
-                depth_or_array_layers: 1,
-            },
-            mip_level_count: 1,
-            sample_count: 1,
-            dimension: wgpu::TextureDimension::D2,
-            format: wgpu::TextureFormat::Depth32Float,
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
-            view_formats: &[],
-        });
-        let depth = depth.create_view(&Default::default());
-        let mut encoder = device.create_command_encoder(&Default::default());
-        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: None,
-            color_attachments: &[],
-            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
-                view: &depth,
-                depth_ops: Some(wgpu::Operations {
-                    load: wgpu::LoadOp::Clear(0.01),
-                    store: wgpu::StoreOp::Store,
-                }),
-                stencil_ops: None,
-            }),
-            ..Default::default()
-        });
-        queue.submit([encoder.finish()]);
-        let mut flow = OpticalFlow::new(&device, size);
-        let mut interpolation = Interpolation::new(&device, size);
-        let frames: Vec<_> = shifts
-            .iter()
-            .map(|s| {
-                let pixels = of::pattern(size, seed, *s);
-                // COPY_SRC as the frame generation's world texture has.
-                let t = device.create_texture(&wgpu::TextureDescriptor {
-                    label: None,
-                    size: wgpu::Extent3d {
-                        width: size[0],
-                        height: size[1],
-                        depth_or_array_layers: 1,
-                    },
-                    mip_level_count: 1,
-                    sample_count: 1,
-                    dimension: wgpu::TextureDimension::D2,
-                    format: wgpu::TextureFormat::Rgba8Unorm,
-                    usage: wgpu::TextureUsages::TEXTURE_BINDING
-                        | wgpu::TextureUsages::COPY_DST
-                        | wgpu::TextureUsages::COPY_SRC,
-                    view_formats: &[],
-                });
-                queue.write_texture(
-                    t.as_image_copy(),
-                    &pixels,
-                    wgpu::TexelCopyBufferLayout {
-                        offset: 0,
-                        bytes_per_row: Some(size[0] * 4),
-                        rows_per_image: None,
-                    },
-                    t.size(),
-                );
-                (t.create_view(&Default::default()), pixels)
-            })
-            .collect();
-        for (i, (color, _)) in frames.iter().enumerate() {
-            let mut encoder = device.create_command_encoder(&Default::default());
-            flow.dispatch(&device, &queue, &mut encoder, color, i == 0);
-            interpolation.dispatch(
-                &device,
-                &queue,
-                &mut encoder,
-                &Inputs {
-                    color,
-                    depth: &depth,
-                    render_size: size,
-                    jitter: [0.0; 2],
-                    reproject: if i == 0 { Mat4::IDENTITY } else { reproject },
-                    near: 0.05,
-                    far: 512.0,
-                    fov_y: 1.2,
-                    reset: i == 0,
-                    flow_vectors: flow.vectors(),
-                    scene_change: flow.scene_change(),
-                },
-            );
-            queue.submit([encoder.finish()]);
-        }
-        let out = of::read(&device, &queue, interpolation.output.texture(), 8);
-        let made: Vec<f32> = out
-            .chunks(2)
-            .map(|c| f16(u16::from_le_bytes([c[0], c[1]])))
-            .collect();
-        let truth = of::pattern(size, seed, expected);
-        let n = frames.len();
-        let error = |pixels: &dyn Fn(usize) -> f32| {
-            let (mut sum, mut count) = (0.0, 0.0);
-            for y in 32..size[1] as usize - 32 {
-                for x in 32..size[0] as usize - 32 {
-                    for c in 0..3 {
-                        let i = (y * size[0] as usize + x) * 4 + c;
-                        sum += (pixels(i) - f32::from(truth[i]) / 255.0).abs();
-                        count += 1.0;
-                    }
-                }
-            }
-            sum / count
-        };
-        Some([
-            error(&|i| made[i]),
-            error(&|i| f32::from(frames[n - 2].1[i]) / 255.0),
-            error(&|i| f32::from(frames[n - 1].1[i]) / 255.0),
-        ])
-    }
-
-    /// Something moving on its own (the camera still): the optical flow puts the made
-    /// frame's blocks halfway where its colours match better than the still camera's
-    /// (FSR prefers the game's vectors unless they clearly don't: primaries make it
-    /// clear). The first 10 frames after a reset use the game's vectors only.
-    #[test]
-    fn moves_what_the_optical_flow_follows_halfway() {
-        let mut shifts = vec![[0, 0]; 20];
-        shifts.push([16, 8]);
-        let Some([made, previous, current]) = interpolate(100, &shifts, Mat4::IDENTITY, [8, 4])
-        else {
-            return;
-        };
-        // Where the still camera's two colours happen to be the same primary (a third of
-        // the pixels), FSR keeps the game's vectors.
-        assert!(
-            made * 3.0 < previous.min(current),
-            "{made} against {previous} and {current}"
-        );
-    }
-
-    /// The camera turning: the game's motion vectors put the made frame halfway.
-    #[test]
-    fn moves_the_view_halfway_with_the_camera() {
-        let size = [512.0, 288.0];
-        // What is at a pixel now was 16 pixels to its right last frame.
-        let reproject = Mat4::from_translation(glam::Vec3::new(32.0 / size[0], 0.0, 0.0));
-        let shifts = [[0, 0], [-16, 0], [-32, 0], [-48, 0]];
-        let Some([made, previous, current]) = interpolate(1, &shifts, reproject, [-40, 0]) else {
-            return;
-        };
-        assert!(
-            made * 4.0 < previous.min(current),
-            "{made} against {previous} and {current}"
-        );
-    }
-}

crates/horizon-client-render/src/gfx/frame_gen/interpolation.wgsl

@@ -1,803 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (C) 2024 Advanced Micro Devices, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files(the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions :
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-// FidelityFX SDK 1.1.4's frame interpolation (ffx_frameinterpolation_*.h), ported to WGSL
-// for Horizon, for an SDR back buffer, inverted finite depth, the whole screen as the
-// interpolation rect and no distortion field. What differs from AMD's (interpolation.rs
-// lists why):
-// - the motion vectors come from the depth and the camera (`prepare`), already unjittered;
-// - the vector fields and reconstructed depths are storage buffers of atomics;
-// - both inpainting pyramids are a pass per level, and textures of their own;
-// - the interpolation writes one texture and the inpainting another (rgba16float can't
-//   be read_write everywhere);
-// - NaNs AMD's hardware turns into 0 (max(0, NaN)) are avoided up front.
-
-struct Params {
-    // This frame's unjittered clip space to the previous frame's.
-    reproject: mat4x4<f32>,
-    device_to_view: vec4<f32>,
-    render_size: vec2<i32>,
-    display_size: vec2<i32>,
-    // FSR's jitterOffset: render pixels.
-    jitter: vec2<f32>,
-    optical_flow_scale: vec2<f32>,
-    // GetOpticalFlowSize2.
-    optical_flow_size: vec2<i32>,
-    reset: u32,
-    tan_half_fov: f32,
-    // A mip level's size, for the pyramid passes.
-    level_size: vec2<i32>,
-    _pad: vec2<u32>,
-};
-
-@group(0) @binding(0) var<uniform> params: Params;
-@group(0) @binding(1) var linear_clamp: sampler;
-@group(0) @binding(2) var input_depth: texture_depth_2d;
-@group(0) @binding(3) var current_color: texture_2d<f32>;
-@group(0) @binding(4) var previous_color: texture_2d<f32>;
-@group(0) @binding(5) var dilated_depth_out: texture_storage_2d<r32float, write>;
-@group(0) @binding(6) var dilated_mv_out: texture_storage_2d<rg32float, write>;
-@group(0) @binding(7) var dilated_depth: texture_2d<f32>;
-@group(0) @binding(8) var dilated_mv: texture_2d<f32>;
-@group(0) @binding(9) var<storage, read_write> rec_prev_depth: array<atomic<u32>>;
-@group(0) @binding(10) var<storage, read_write> rec_interp_depth: array<atomic<u32>>;
-@group(0) @binding(11) var<storage, read> rec_prev_depth_in: array<u32>;
-@group(0) @binding(12) var<storage, read> rec_interp_depth_in: array<u32>;
-@group(0) @binding(13) var<storage, read_write> game_field_x: array<atomic<u32>>;
-@group(0) @binding(14) var<storage, read_write> game_field_y: array<atomic<u32>>;
-@group(0) @binding(15) var<storage, read> game_field_x_in: array<u32>;
-@group(0) @binding(16) var<storage, read> game_field_y_in: array<u32>;
-@group(0) @binding(17) var<storage, read_write> of_field_x: array<atomic<u32>>;
-@group(0) @binding(18) var<storage, read_write> of_field_y: array<atomic<u32>>;
-@group(0) @binding(19) var<storage, read> of_field_x_in: array<u32>;
-@group(0) @binding(20) var<storage, read> of_field_y_in: array<u32>;
-@group(0) @binding(21) var optical_flow: texture_2d<i32>;
-@group(0) @binding(22) var<storage, read> scene_change: array<u32, 3>;
-@group(0) @binding(23) var<storage, read_write> counters: array<u32, 2>;
-@group(0) @binding(24) var<storage, read> counters_in: array<u32, 2>;
-// A pyramid's previous level, and the level a pyramid pass writes.
-@group(0) @binding(25) var pyramid_in: texture_2d<f32>;
-@group(0) @binding(26) var pyramid_out: texture_storage_2d<rgba16float, write>;
-// The whole game vector field and inpainting pyramids.
-@group(0) @binding(27) var game_pyramid: texture_2d<f32>;
-@group(0) @binding(28) var inpainting_pyramid: texture_2d<f32>;
-@group(0) @binding(29) var disocclusion_out: texture_storage_2d<rgba8unorm, write>;
-@group(0) @binding(30) var disocclusion: texture_2d<f32>;
-@group(0) @binding(31) var interpolated_out: texture_storage_2d<rgba16float, write>;
-@group(0) @binding(32) var interpolated: texture_2d<f32>;
-@group(0) @binding(33) var output: texture_storage_2d<rgba16float, write>;
-
-const EPSILON: f32 = 1e-03;
-const RECONSTRUCTED_DEPTH_WEIGHT_THRESHOLD: f32 = EPSILON;
-const COUNTER_FRAME_INDEX_SINCE_LAST_RESET: u32 = 1u;
-
-fn render_index(p: vec2<i32>) -> u32 {
-    return u32(p.y * params.render_size.x + p.x);
-}
-
-fn is_on_screen(p: vec2<i32>, size: vec2<i32>) -> bool {
-    return all(vec2<u32>(p) < vec2<u32>(size));
-}
-
-fn is_uv_inside(uv: vec2<f32>) -> bool {
-    return uv.x > 0.0 && uv.x < 1.0 && uv.y > 0.0 && uv.y < 1.0;
-}
-
-fn min_divided_by_max(v0: f32, v1: f32) -> f32 {
-    let m = max(v0, v1);
-    return select(0.0, min(v0, v1) / m, m != 0.0);
-}
-
-fn normalized_dot3(v0: vec3<f32>, v1: vec3<f32>) -> f32 {
-    let m = max(length(v0), length(v1));
-    return select(1.0, dot(v0 / m, v1 / m), m > 0.0);
-}
-
-fn linear_from_srgb(c: vec3<f32>) -> vec3<f32> {
-    return select(pow(c / 1.055 + 0.055 / 1.055, vec3(2.4)), c / 12.92, c < vec3(0.04045));
-}
-
-fn raw_rgb_to_luminance(c: vec3<f32>) -> f32 {
-    return dot(linear_from_srgb(c), vec3(0.2126, 0.7152, 0.0722));
-}
-
-struct Bilinear {
-    base: vec2<i32>,
-    weights: vec4<f32>,
-};
-
-fn bilinear(uv: vec2<f32>, size: vec2<i32>) -> Bilinear {
-    let px = uv * vec2<f32>(size) - 0.5;
-    let f = fract(px);
-    var b: Bilinear;
-    b.base = vec2<i32>(floor(px));
-    b.weights = vec4(
-        (1.0 - f.x) * (1.0 - f.y),
-        f.x * (1.0 - f.y),
-        (1.0 - f.x) * f.y,
-        f.x * f.y,
-    );
-    return b;
-}
-
-fn bilinear_offset(i: i32) -> vec2<i32> {
-    return vec2(i & 1, i >> 1u);
-}
-
-fn device_to_view_depth(d: f32) -> f32 {
-    return params.device_to_view.y / (d - params.device_to_view.x);
-}
-
-fn view_space_position(px: vec2<i32>, size: vec2<i32>, d: f32) -> vec3<f32> {
-    let z = device_to_view_depth(d);
-    let ndc = vec2<f32>(px) / vec2<f32>(size) * vec2(2.0, -2.0) + vec2(-1.0, 1.0);
-    return vec3(params.device_to_view.z * ndc.x * z, params.device_to_view.w * ndc.y * z, z);
-}
-
-// MOTION VECTOR FIELD (ffx_frameinterpolation_common.h)
-const PRIMARY_VECTOR_BIT: u32 = 0x80000000u;
-const PRIORITY_LOW_MAX: u32 = 31u;
-const PRIORITY_HIGH_MAX: u32 = 1023u;
-const PRIORITY_LOW_OFFSET: u32 = 16u;
-const PRIORITY_HIGH_OFFSET: u32 = 21u;
-
-struct VectorFieldEntry {
-    motion_vector: vec2<f32>,
-    high_priority: f32,
-    low_priority: f32,
-    valid: bool,
-    primary: bool,
-    secondary: bool,
-    in_painted: bool,
-    velocity: f32,
-    neg_outside: bool,
-    pos_outside: bool,
-};
-
-fn new_entry() -> VectorFieldEntry {
-    return VectorFieldEntry(vec2(0.0), 0.0, 0.0, false, false, false, false, 0.0, false, false);
-}
-
-fn is_primary(packed: u32) -> bool {
-    return (packed & PRIMARY_VECTOR_BIT) != 0u;
-}
-
-// ffxF32ToF16 and its inverse in integer arithmetic: pack2x16float needs a capability
-// some GPUs lack.
-fn f32_to_f16(v: f32) -> u32 {
-    let x = bitcast<u32>(v);
-    let sign = (x >> 16u) & 0x8000u;
-    let e = i32((x >> 23u) & 0xffu) - 112;
-    let m = x & 0x7fffffu;
-    if e >= 31 {
-        return sign | 0x7c00u;
-    }
-    if e <= 0 {
-        if e < -10 {
-            return sign;
-        }
-        let full = m | 0x800000u;
-        let shift = u32(14 - e);
-        return sign | ((full >> shift) + ((full >> (shift - 1u)) & 1u));
-    }
-    return sign | (((u32(e) << 10u) | (m >> 13u)) + ((m >> 12u) & 1u));
-}
-
-fn f16_to_f32(h: u32) -> f32 {
-    let sign = (h & 0x8000u) << 16u;
-    let e = (h >> 10u) & 0x1fu;
-    let m = h & 0x3ffu;
-    if e == 0u {
-        let v = f32(m) * (1.0 / 16777216.0);
-        return select(v, -v, sign != 0u);
-    }
-    if e == 31u {
-        return bitcast<f32>(sign | 0x7f800000u);
-    }
-    return bitcast<f32>(sign | ((e + 112u) << 23u) | (m << 13u));
-}
-
-fn pack_entries(primary: bool, high: u32, low: u32, mv: vec2<f32>) -> vec2<u32> {
-    let priority = select(0u, PRIMARY_VECTOR_BIT, primary)
-        | ((high & PRIORITY_HIGH_MAX) << PRIORITY_HIGH_OFFSET)
-        | ((low & PRIORITY_LOW_MAX) << PRIORITY_LOW_OFFSET);
-    return vec2(priority | f32_to_f16(mv.x), priority | f32_to_f16(mv.y));
-}
-
-fn unpack_entries(packed: vec2<u32>) -> VectorFieldEntry {
-    var e = new_entry();
-    e.high_priority = f32((packed.x >> PRIORITY_HIGH_OFFSET) & PRIORITY_HIGH_MAX) / f32(PRIORITY_HIGH_MAX);
-    e.low_priority = f32((packed.x >> PRIORITY_LOW_OFFSET) & PRIORITY_LOW_MAX) / f32(PRIORITY_LOW_MAX);
-    e.primary = is_primary(packed.x);
-    e.valid = e.high_priority > 0.0;
-    e.secondary = e.valid && !e.primary;
-    if e.secondary {
-        e.high_priority = 1.0 - e.high_priority;
-    }
-    e.motion_vector = vec2(f16_to_f32(packed.x & 0xffffu), f16_to_f32(packed.y & 0xffffu));
-    return e;
-}
-
-fn load_game_field(p: vec2<i32>) -> vec2<u32> {
-    if !is_on_screen(p, params.render_size) {
-        return vec2(0u);
-    }
-    let i = render_index(p);
-    return vec2(game_field_x_in[i], game_field_y_in[i]);
-}
-
-fn compute_mv_inpainting_level(uv: vec2<f32>, level: i32, size: vec2<i32>) -> vec4<f32> {
-    let b = bilinear(uv, size);
-    var sum = 0.0;
-    var color = vec4(0.0);
-    for (var i = 0; i < 4; i++) {
-        let p = b.base + bilinear_offset(i);
-        if is_on_screen(p, size) {
-            let s = textureLoad(game_pyramid, p, level);
-            let weight = b.weights[i] * f32(s.z > 0.0) * s.z;
-            sum += weight;
-            color += s * weight;
-        }
-    }
-    return color / select(1.0, sum, sum > 0.0);
-}
-
-fn load_inpainted_game_field_mv(uv: vec2<f32>) -> VectorFieldEntry {
-    let px = vec2<i32>(uv * vec2<f32>(params.render_size));
-    var e = unpack_entries(load_game_field(px));
-    if !e.valid {
-        var size = params.render_size;
-        var v = vec4(0.0);
-        let levels = i32(textureNumLevels(game_pyramid));
-        for (var level = 0; level < min(11, levels) && v.w == 0.0; level++) {
-            size /= 2;
-            v = compute_mv_inpainting_level(uv, level, size);
-        }
-        e.motion_vector = v.xy;
-        e.high_priority = v.z;
-        e.low_priority = v.w;
-        e.in_painted = true;
-    }
-    e.neg_outside = !is_uv_inside(uv - e.motion_vector);
-    e.pos_outside = !is_uv_inside(uv + e.motion_vector);
-    e.velocity = length(e.motion_vector);
-    return e;
-}
-
-fn sample_optical_flow_field(uv: vec2<f32>) -> VectorFieldEntry {
-    let size = params.optical_flow_size;
-    let b = bilinear(uv, size);
-    var e = new_entry();
-    var weight_sum = 0.0;
-    for (var i = 0; i < 4; i++) {
-        let p = b.base + bilinear_offset(i);
-        if is_on_screen(p, size) {
-            let w = b.weights[i];
-            let j = render_index(p);
-            let s = unpack_entries(vec2(of_field_x_in[j], of_field_y_in[j]));
-            e.motion_vector += s.motion_vector * w;
-            e.high_priority += s.high_priority * w;
-            e.low_priority += s.low_priority * w;
-            weight_sum += w;
-        }
-    }
-    if weight_sum > 0.0 {
-        e.motion_vector /= weight_sum;
-        e.high_priority /= weight_sum;
-        e.low_priority /= weight_sum;
-    }
-    e.neg_outside = !is_uv_inside(uv - e.motion_vector);
-    e.pos_outside = !is_uv_inside(uv + e.motion_vector);
-    e.velocity = length(e.motion_vector);
-    return e;
-}
-
-fn has_scene_changed() -> bool {
-    return (scene_change[1] & 0xfu) != 0u;
-}
-
-// ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h, with the
-// motion vectors computed from the depth and the camera.
-fn camera_motion_vector(p: vec2<i32>, depth: f32) -> vec2<f32> {
-    let size = vec2<f32>(params.render_size);
-    let uv = (vec2<f32>(p) + 0.5) / size - params.jitter / size;
-    let ndc = vec2(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0);
-    let previous = params.reproject * vec4(ndc, depth, 1.0);
-    let previous_uv = vec2(0.5, -0.5) * previous.xy / previous.w + 0.5;
-    return previous_uv - uv;
-}
-
-fn load_input_depth(p: vec2<i32>) -> f32 {
-    if !is_on_screen(p, params.render_size) {
-        return 0.0;
-    }
-    return textureLoad(input_depth, p, 0);
-}
-
-@compute @workgroup_size(8, 8)
-fn prepare_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let p = vec2<i32>(gid.xy);
-    if !is_on_screen(p, params.render_size) {
-        return;
-    }
-    let offsets = array(
-        vec2(0, 0), vec2(1, 0), vec2(0, 1), vec2(0, -1), vec2(-1, 0),
-        vec2(-1, 1), vec2(1, 1), vec2(-1, -1), vec2(1, -1),
-    );
-    var nearest = load_input_depth(p);
-    var nearest_coord = p;
-    for (var i = 1; i < 9; i++) {
-        let q = p + offsets[i];
-        if is_on_screen(q, params.render_size) {
-            let d = load_input_depth(q);
-            if d > nearest {
-                nearest_coord = q;
-                nearest = d;
-            }
-        }
-    }
-    let mv = camera_motion_vector(nearest_coord, load_input_depth(nearest_coord));
-    textureStore(dilated_depth_out, p, vec4(nearest, 0.0, 0.0, 0.0));
-    textureStore(dilated_mv_out, p, vec4(mv, 0.0, 0.0));
-    // ReconstructPrevDepth
-    let moving = mv * f32(length(mv * vec2<f32>(params.display_size)) > 0.1);
-    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.render_size);
-    let b = bilinear(uv + moving, params.render_size);
-    for (var i = 0; i < 4; i++) {
-        if b.weights[i] > RECONSTRUCTED_DEPTH_WEIGHT_THRESHOLD {
-            let q = b.base + bilinear_offset(i);
-            if is_on_screen(q, params.render_size) {
-                atomicMax(&rec_prev_depth[render_index(q)], bitcast<u32>(nearest));
-            }
-        }
-    }
-}
-
-// ffx_frameinterpolation_setup.h: the frames since the last reset (the vector fields are
-// cleared by the encoder).
-@compute @workgroup_size(1)
-fn setup_pass() {
-    if params.reset != 0u || has_scene_changed() {
-        counters[COUNTER_FRAME_INDEX_SINCE_LAST_RESET] = 0u;
-    } else {
-        counters[COUNTER_FRAME_INDEX_SINCE_LAST_RESET] += 1u;
-    }
-}
-
-// ffx_frameinterpolation_reconstruct_previous_depth.h: the interpolated frame's depth.
-@compute @workgroup_size(8, 8)
-fn reconstruct_previous_depth_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let p = vec2<i32>(gid.xy);
-    if !is_on_screen(p, params.render_size) {
-        return;
-    }
-    let mv = textureLoad(dilated_mv, p, 0).xy * 0.5;
-    let depth = textureLoad(dilated_depth, p, 0).x;
-    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.render_size);
-    let b = bilinear(uv + mv, params.render_size);
-    for (var i = 0; i < 4; i++) {
-        let q = b.base + bilinear_offset(i);
-        if b.weights[i] > RECONSTRUCTED_DEPTH_WEIGHT_THRESHOLD && is_on_screen(q, params.render_size) {
-            atomicMax(&rec_interp_depth[render_index(q)], bitcast<u32>(depth));
-        }
-    }
-}
-
-// ffx_frameinterpolation_game_motion_vector_field.h
-fn priority_from_view_depth(view_depth_in: f32) -> u32 {
-    let d = pow(view_depth_in, 0.33);
-    let factor = u32((1.0 - d * (1.0 / (1.0 + d))) * f32(PRIORITY_HIGH_MAX));
-    return max(1u, factor);
-}
-
-fn update_game_field(p: vec2<i32>, packed: vec2<u32>) -> u32 {
-    let i = render_index(p);
-    let x = atomicMax(&game_field_x[i], packed.x);
-    let y = atomicMax(&game_field_y[i], packed.y);
-    return max(x, y);
-}
-
-@compute @workgroup_size(8, 8)
-fn game_motion_vector_field_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let p = vec2<i32>(gid.xy);
-    if !is_on_screen(p, params.render_size) {
-        return;
-    }
-    let size = vec2<f32>(params.render_size);
-    let uv = (vec2<f32>(p) + 0.5) / size;
-    let depth = textureLoad(dilated_depth, p, 0).x;
-    let mv = textureLoad(dilated_mv, p, 0).xy;
-    let half_mv = mv * 0.5;
-    let interpolated_uv = uv + half_mv;
-    let high_primary = priority_from_view_depth(device_to_view_depth(depth));
-    let previous = textureSampleLevel(previous_color, linear_clamp, uv + mv, 0.0).rgb;
-    let current = textureSampleLevel(current_color, linear_clamp, uv, 0.0).rgb;
-    let previous_luma = 0.001 + raw_rgb_to_luminance(previous);
-    let current_luma = 0.001 + raw_rgb_to_luminance(current);
-    var low = u32(round(min_divided_by_max(previous_luma, current_luma) * f32(PRIORITY_LOW_MAX)))
-        * u32(is_uv_inside(uv + mv));
-    let primary = pack_entries(true, high_primary, low, half_mv);
-    let b = bilinear(interpolated_uv, params.render_size);
-    for (var i = 0; i < 4; i++) {
-        let q = b.base + bilinear_offset(i);
-        if is_on_screen(q, params.render_size) {
-            update_game_field(q, primary);
-        }
-    }
-    if length(half_mv * size) > EPSILON {
-        var write_secondary = true;
-        var primary_hits = 0u;
-        let step_scale = length(1.0 / size);
-        let step_mv = normalize(mv);
-        let break_dist = min(length(half_mv), length(vec2(0.5, 0.5)));
-        for (var s = step_scale; s <= break_dist && write_secondary; s += step_scale) {
-            let secondary_uv = interpolated_uv - step_mv * s;
-            let sb = bilinear(secondary_uv, params.render_size);
-            let high_secondary = max(1u, PRIORITY_HIGH_MAX - high_primary);
-            let to_centre_raw = vec2(0.5, 0.5) - secondary_uv;
-            let to_centre = select(vec2(0.0), normalize(to_centre_raw), length(to_centre_raw) > 0.0);
-            low = u32(max(0.0, dot(to_centre, step_mv)) * f32(PRIORITY_LOW_MAX));
-            let secondary = pack_entries(false, high_secondary, low, half_mv);
-            let q = sb.base;
-            write_secondary = write_secondary && is_on_screen(q, params.render_size);
-            if write_secondary {
-                let existing = update_game_field(q, secondary);
-                primary_hits += u32(is_primary(existing));
-                write_secondary = write_secondary && primary_hits <= 3u;
-            }
-        }
-    }
-}
-
-// ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h: SPD, a level per
-// pass. Level 0 reads the field, the others the level above.
-fn reduce_game_field(v: array<vec4<f32>, 4>) -> vec4<f32> {
-    var sum = vec4(0.0);
-    var weight_sum = 0.0;
-    for (var i = 0; i < 4; i++) {
-        let w = f32(v[i].z > 0.0);
-        sum += v[i] * w;
-        weight_sum += w;
-    }
-    return sum / select(1.0, weight_sum, weight_sum > EPSILON);
-}
-
-@compute @workgroup_size(8, 8)
-fn game_field_pyramid_first_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let p = vec2<i32>(gid.xy);
-    if !is_on_screen(p, params.level_size) {
-        return;
-    }
-    var v: array<vec4<f32>, 4>;
-    for (var i = 0; i < 4; i++) {
-        let e = unpack_entries(load_game_field(p * 2 + bilinear_offset(i)));
-        v[i] = vec4(e.motion_vector, e.high_priority, e.low_priority);
-    }
-    textureStore(pyramid_out, p, reduce_game_field(v));
-}
-
-@compute @workgroup_size(8, 8)
-fn game_field_pyramid_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let p = vec2<i32>(gid.xy);
-    if !is_on_screen(p, params.level_size) {
-        return;
-    }
-    var v: array<vec4<f32>, 4>;
-    for (var i = 0; i < 4; i++) {
-        v[i] = textureLoad(pyramid_in, p * 2 + bilinear_offset(i), 0);
-    }
-    textureStore(pyramid_out, p, reduce_game_field(v));
-}
-
-// ffx_frameinterpolation_optical_flow_vector_field.h
-fn load_optical_flow(p: vec2<i32>) -> vec2<f32> {
-    let size = vec2<i32>(textureDimensions(optical_flow));
-    if !is_on_screen(p, size) {
-        return vec2(0.0);
-    }
-    return vec2<f32>(textureLoad(optical_flow, p, 0).xy) * params.optical_flow_scale;
-}
-
-@compute @workgroup_size(8, 8)
-fn optical_flow_vector_field_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let p = vec2<i32>(gid.xy);
-    let rect = vec2<f32>(params.display_size);
-    var avg = vec2(0.0);
-    var sw = 0.0;
-    for (var y = -1; y <= 1; y++) {
-        for (var x = -1; x <= 1; x++) {
-            let vs = load_optical_flow(p + vec2(x, y));
-            let len = length(vs * rect);
-            let w = max(0.0, 512.0 - len) * f32(len > 1.0);
-            avg += vs * w;
-            sw += w;
-        }
-    }
-    // AMD divides by 0 here, and its max(0, NaN) below gives 0 weights: a zero vector.
-    if sw > 0.0 {
-        avg /= sw;
-    }
-    var v = vec2(0.0);
-    sw = 0.0;
-    for (var y = -1; y <= 1; y++) {
-        for (var x = -1; x <= 1; x++) {
-            let vs = load_optical_flow(p + vec2(x, y));
-            let len = length(vs * rect);
-            let len_factor = max(0.0, 512.0 - len) * f32(len > 1.0);
-            let w = pow(max(0.0, dot(avg, vs)), 1.25) * len_factor;
-            v += vs * w;
-            sw += w;
-        }
-    }
-    if sw > EPSILON {
-        v /= sw;
-    }
-    // computeOpticalFlowFieldMvs
-    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.optical_flow_size);
-    let half_mv = v * 0.5;
-    let previous = textureSampleLevel(previous_color, linear_clamp, uv + v, 0.0).rgb;
-    let current = textureSampleLevel(current_color, linear_clamp, uv, 0.0).rgb;
-    let previous_luma = 0.001 + raw_rgb_to_luminance(previous);
-    let current_luma = 0.001 + raw_rgb_to_luminance(current);
-    let velocity = length(v * rect);
-    let high = u32(velocity > 1.0)
-        * u32(saturate(velocity / length(rect * 0.05)) * f32(PRIORITY_HIGH_MAX));
-    if high > 0u {
-        let low = u32(round(min_divided_by_max(previous_luma, current_luma) * f32(PRIORITY_LOW_MAX)))
-            * u32(is_uv_inside(uv + v));
-        let packed = pack_entries(true, high, low, half_mv);
-        let b = bilinear(uv + half_mv, params.optical_flow_size);
-        for (var i = 0; i < 4; i++) {
-            let q = b.base + bilinear_offset(i);
-            if is_on_screen(q, params.optical_flow_size) {
-                let j = render_index(q);
-                atomicMax(&of_field_x[j], packed.x);
-                atomicMax(&of_field_y[j], packed.y);
-            }
-        }
-    }
-}
-
-// ffx_frameinterpolation_disocclusion_mask.h
-fn load_estimated_depth(which: u32, p: vec2<i32>) -> f32 {
-    if which == 0u {
-        return bitcast<f32>(rec_prev_depth_in[render_index(p)]);
-    }
-    return textureLoad(dilated_depth, p, 0).x;
-}
-
-fn compute_depth_clip(which: u32, uv: vec2<f32>, current_depth: f32) -> f32 {
-    let current_view = device_to_view_depth(current_depth);
-    let b = bilinear(uv, params.render_size);
-    var depth = 0.0;
-    var weight_sum = 0.0;
-    for (var i = 0; i < 4; i++) {
-        let q = b.base + bilinear_offset(i);
-        let w = b.weights[i];
-        if is_on_screen(q, params.render_size) && w > RECONSTRUCTED_DEPTH_WEIGHT_THRESHOLD {
-            let previous_depth = load_estimated_depth(which, q);
-            let previous_view = device_to_view_depth(previous_depth);
-            let diff = current_view - previous_view;
-            if diff > 0.0 {
-                let plane_depth = min(previous_depth, current_depth);
-                let centre = view_space_position(params.render_size / 2, params.render_size, plane_depth);
-                let corner = view_space_position(vec2(0), params.render_size, plane_depth);
-                let half_viewport_width = length(vec2<f32>(params.render_size));
-                let threshold = min(current_view, previous_view);
-                let k_fov = length(corner) / length(centre);
-                let required = 1.37e-05 * k_fov * half_viewport_width * threshold;
-                depth += f32(required / diff >= 1.0) * w;
-                weight_sum += w;
-            }
-        }
-    }
-    return select(0.0, saturate(1.0 - depth / weight_sum), weight_sum > 0.0);
-}
-
-@compute @workgroup_size(8, 8)
-fn disocclusion_mask_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let p = vec2<i32>(gid.xy);
-    if !is_on_screen(p, params.render_size) {
-        return;
-    }
-    let depth = bitcast<f32>(rec_interp_depth_in[render_index(p)]);
-    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.render_size);
-    let game = load_inpainted_game_field_mv(uv);
-    var mask = vec2(
-        1.0 - compute_depth_clip(0u, uv + game.motion_vector, depth),
-        1.0 - compute_depth_clip(1u, uv - game.motion_vector, depth),
-    );
-    mask = vec2<f32>(mask >= vec2(EPSILON));
-    let source_mv = game.motion_vector * 2.0;
-    let size = vec2<f32>(params.render_size);
-    let previous = vec2<i32>((uv + source_mv) * size);
-    mask.x = saturate(mask.x + f32(!is_on_screen(previous, params.render_size)));
-    let current = vec2<i32>((uv - source_mv) * size);
-    mask.y = saturate(mask.y + f32(!is_on_screen(current, params.render_size)));
-    textureStore(disocclusion_out, p, vec4(mask, 0.0, 0.0));
-}
-
-// ffx_frameinterpolation.h
-struct SourceColor {
-    raw: vec3<f32>,
-    weight_sum: f32,
-};
-
-fn sample_bilinear(is_current: bool, uv: vec2<f32>, mv: vec2<f32>) -> SourceColor {
-    let size = params.display_size;
-    let b = bilinear(uv + mv, size);
-    var color = vec3(0.0);
-    var weight_sum = 0.0;
-    for (var i = 0; i < 4; i++) {
-        let q = b.base + bilinear_offset(i);
-        if is_on_screen(q, size) {
-            let w = b.weights[i];
-            if is_current {
-                color += textureLoad(current_color, q, 0).rgb * w;
-            } else {
-                color += textureLoad(previous_color, q, 0).rgb * w;
-            }
-            weight_sum += w;
-        }
-    }
-    return SourceColor(select(vec3(0.0), color / weight_sum, weight_sum != 0.0), weight_sum);
-}
-
-@compute @workgroup_size(8, 8)
-fn interpolate_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let p = vec2<i32>(gid.xy);
-    if !is_on_screen(p, params.display_size) {
-        return;
-    }
-    let frame_index = counters_in[COUNTER_FRAME_INDEX_SINCE_LAST_RESET];
-    if frame_index == 0u {
-        textureStore(interpolated_out, p, vec4(textureLoad(current_color, p, 0).rgb, 0.0));
-        return;
-    }
-    var in_painting = 0.0;
-    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.display_size);
-    let game = load_inpainted_game_field_mv(uv);
-    let flow = sample_optical_flow_field(uv);
-    var disocclusion_factor = vec2<f32>(
-        saturate(textureSampleLevel(disocclusion, linear_clamp, uv, 0.0).xy) == vec2(1.0),
-    );
-    let previous_game = sample_bilinear(false, uv, game.motion_vector);
-    let current_game = sample_bilinear(true, uv, -game.motion_vector);
-    let previous_of = sample_bilinear(false, uv, flow.motion_vector);
-    let current_of = sample_bilinear(true, uv, -flow.motion_vector);
-    disocclusion_factor.x *= f32(!game.pos_outside);
-    disocclusion_factor.y *= f32(!game.neg_outside);
-    in_painting = saturate(max(in_painting, f32(length(disocclusion_factor) <= EPSILON)));
-    var t = 0.5;
-    t += 0.5 * (1.0 - disocclusion_factor.x);
-    t -= 0.5 * (1.0 - disocclusion_factor.y);
-    var color = mix(previous_game.raw, current_game.raw, saturate(t));
-    let disoccluded = saturate(1.0 - min(disocclusion_factor.x, disocclusion_factor.y));
-    if previous_game.weight_sum == 0.0 {
-        color = current_game.raw;
-    } else if current_game.weight_sum == 0.0 {
-        color = previous_game.raw;
-    }
-    if previous_game.weight_sum == 0.0 && current_game.weight_sum == 0.0 {
-        in_painting = 1.0;
-    }
-    var of_t = 1.0;
-    if previous_of.weight_sum > 0.0 && current_of.weight_sum > 0.0 {
-        of_t = 0.5;
-    } else if previous_of.weight_sum > 0.0 {
-        of_t = 0.0;
-    }
-    let of_color = mix(previous_of.raw, current_of.raw, of_t);
-    let of_sim = normalized_dot3(previous_of.raw, current_of.raw);
-    var game_sim = normalized_dot3(previous_game.raw, current_game.raw);
-    game_sim = mix(max(EPSILON, game_sim), 1.0, disoccluded);
-    var game_bias = saturate(game_sim / max(EPSILON, of_sim));
-    game_bias = mix(game_bias, 1.0, f32(frame_index < 10u));
-    color = mix(of_color, color, saturate(game_bias));
-    textureStore(interpolated_out, p, vec4(color, in_painting));
-}
-
-// ffx_frameinterpolation_compute_inpainting_pyramid.h: SPD, a level per pass.
-fn reduce_inpainting(v: array<vec4<f32>, 4>) -> vec4<f32> {
-    let sum = v[0].w + v[1].w + v[2].w + v[3].w;
-    if sum == 0.0 {
-        return vec4(0.0);
-    }
-    return (v[0] * v[0].w + v[1] * v[1].w + v[2] * v[2].w + v[3] * v[3].w) / sum;
-}
-
-@compute @workgroup_size(8, 8)
-fn inpainting_pyramid_first_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let p = vec2<i32>(gid.xy);
-    if !is_on_screen(p, params.level_size) {
-        return;
-    }
-    var v: array<vec4<f32>, 4>;
-    for (var i = 0; i < 4; i++) {
-        let q = p * 2 + bilinear_offset(i);
-        var c = vec4(0.0);
-        if is_on_screen(q, params.display_size) {
-            c = textureLoad(interpolated, q, 0);
-            c.w = saturate(1.0 - c.w);
-        }
-        v[i] = c;
-    }
-    textureStore(pyramid_out, p, reduce_inpainting(v));
-}
-
-@compute @workgroup_size(8, 8)
-fn inpainting_pyramid_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let p = vec2<i32>(gid.xy);
-    if !is_on_screen(p, params.level_size) {
-        return;
-    }
-    var v: array<vec4<f32>, 4>;
-    for (var i = 0; i < 4; i++) {
-        v[i] = textureLoad(pyramid_in, p * 2 + bilinear_offset(i), 0);
-    }
-    textureStore(pyramid_out, p, reduce_inpainting(v));
-}
-
-// ffx_frameinterpolation_inpainting.h (no HUD-less source: Horizon draws its HUD over
-// the made frame itself).
-fn compute_inpainting_level(uv: vec2<f32>, level: i32, size: vec2<i32>) -> vec4<f32> {
-    let b = bilinear(uv, size);
-    var color = vec4(0.0);
-    for (var i = 0; i < 4; i++) {
-        let q = b.base + bilinear_offset(i);
-        if is_on_screen(q, size) {
-            let s = textureLoad(inpainting_pyramid, q, level);
-            let w = b.weights[i] * f32(s.w > 0.0);
-            color += vec4(s.rgb * w, w);
-        }
-    }
-    return color;
-}
-
-fn compute_inpainting(p: vec2<i32>) -> vec3<f32> {
-    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.display_size);
-    var color = vec4(0.0);
-    var size = params.display_size;
-    let levels = i32(textureNumLevels(inpainting_pyramid));
-    for (var level = 0; level < min(10, levels); level++) {
-        size /= 2;
-        let mip = compute_inpainting_level(uv, level, size);
-        if mip.w > 0.0 {
-            let weight = pow(1.0 - f32(level) / 10.0, 3.0) * mip.w;
-            color += vec4(mip.rgb / mip.w, 1.0) * weight;
-        }
-    }
-    return select(vec3(0.0), color.rgb / color.w, color.w > 0.0);
-}
-
-@compute @workgroup_size(8, 8)
-fn inpainting_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let p = vec2<i32>(gid.xy);
-    if !is_on_screen(p, params.display_size) {
-        return;
-    }
-    var c = textureLoad(interpolated, p, 0);
-    if c.w > EPSILON {
-        c = vec4(mix(c.rgb, compute_inpainting(p), c.w), 1.0);
-    }
-    textureStore(output, p, c);
-}

crates/horizon-client-render/src/gfx/hdr.rs

@@ -91,35 +91,9 @@ pub const TIERS: [Tier; 4] = [
         full: 0.38,
     },
 ];
-/// Which pixels of a light source's sprite may shine (`hdr_stats.wgsl`), as a fraction of
-/// the way from its darkest to its brightest opaque pixel: `parts` for one whose bright parts
-/// shine (a torch's flame, not its handle), `whole` for one that shines all over
-/// (`mesher::WHOLE`). The tier windows still decide how much.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Masks {
-    pub parts: f32,
-    pub whole: f32,
-}
-pub const MASKS: Masks = Masks {
-    parts: 0.32,
-    whole: 0.0,
-};
-/// A step of HDR calibration (`crate::hdr_calibration`): its test picture is drawn in nits
-/// above the controls instead of the frame.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Calibration {
-    /// 1 black level, 2 peak brightness, 3 paper white.
-    pub step: u32,
-    /// The slider's value, in nits.
-    pub nits: f32,
-    /// Where the controls start, as a share of the height.
-    pub band: f32,
-}
 
 pub struct Hdr {
     layout: wgpu::BindGroupLayout,
-    /// Horizon's logo as a 1-bit mask, for calibration's test pictures.
-    logo: wgpu::TextureView,
     pipeline: wgpu::RenderPipeline,
     /// Zeroes the frame's alpha once the world is kept (`keep_world`): what draws after,
     /// the hand, HUD and menus, raises it, so HDR output knows where they cover the world.
@@ -146,19 +120,10 @@ pub struct Hdr {
     pub tiers: [Tier; 4],
     /// The HUD and menus' brightness, as a share of paper white (0.25..=1).
     pub ui: f32,
-    /// Which pixels of a light source shine (`Masks`).
-    pub masks: Masks,
-    /// Calibration's test picture while it runs.
-    pub calibration: Option<Calibration>,
 }
 
 impl Hdr {
-    pub fn new(
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        format: wgpu::TextureFormat,
-        output: Output,
-    ) -> Self {
+    pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat, output: Output) -> Self {
         let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some("Horizon HDR"),
             source: wgpu::ShaderSource::Wgsl(include_str!("../hdr.wgsl").into()),
@@ -178,7 +143,6 @@ impl Hdr {
             entries: &[
                 texture(0),
                 texture(1),
-                texture(3),
                 wgpu::BindGroupLayoutEntry {
                     binding: 2,
                     visibility: wgpu::ShaderStages::FRAGMENT,
@@ -268,13 +232,12 @@ impl Hdr {
         let params = || {
             device.create_buffer(&wgpu::BufferDescriptor {
                 label: Some("Horizon HDR parameters"),
-                size: 96,
+                size: 80,
                 usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
                 mapped_at_creation: false,
             })
         };
         Self {
-            logo: logo_mask(device, queue),
             layout,
             pipeline: pipeline_for(output.format()),
             clear_alpha,
@@ -291,8 +254,6 @@ impl Hdr {
             black: 0.0,
             tiers: TIERS,
             ui: 1.0,
-            masks: MASKS,
-            calibration: None,
         }
     }
 
@@ -337,10 +298,6 @@ impl Hdr {
                         binding: 2,
                         resource: self.params.as_entire_binding(),
                     },
-                    wgpu::BindGroupEntry {
-                        binding: 3,
-                        resource: wgpu::BindingResource::TextureView(&self.logo),
-                    },
                 ],
             });
             self.targets = Some(Targets {
@@ -353,16 +310,6 @@ impl Hdr {
         self.targets.as_ref().unwrap().frame.clone()
     }
 
-    /// The peak the HDR metadata gives: while calibration's peak step runs, PQ's own
-    /// 10 000 nits, so a compositor that clips at the declared peak (KWin) lets the test
-    /// patch through as bright as the display goes and the logo under it shows.
-    pub fn declared_peak(&self) -> f32 {
-        match self.calibration {
-            Some(c) if c.step == 2 => 10_000.0,
-            _ => self.peak,
-        }
-    }
-
     /// Keeps the world as drawn so far, before the hand and HUD cover it, then zeroes the
     /// frame's alpha: the world's marks live on in the copy, and whatever draws from here
     /// on raises the alpha where it covers the world.
@@ -483,10 +430,6 @@ impl Hdr {
                     binding: 2,
                     resource: self.capture_params.as_entire_binding(),
                 },
-                wgpu::BindGroupEntry {
-                    binding: 3,
-                    resource: wgpu::BindingResource::TextureView(&self.logo),
-                },
             ],
         });
         queue.write_buffer(
@@ -499,10 +442,9 @@ impl Hdr {
     }
 
     /// hdr.wgsl's `Params`.
-    fn params(&self, world: bool, pq: bool) -> [f32; 24] {
+    fn params(&self, world: bool, pq: bool) -> [f32; 20] {
         let paper = self.paper_white.max(1.0);
-        let c = self.calibration;
-        let mut params = [0.0; 24];
+        let mut params = [0.0; 20];
         params[..5].copy_from_slice(&[
             paper / 80.0,
             (self.peak / paper).max(1.0),
@@ -517,9 +459,6 @@ impl Hdr {
             params[12 + i] = t.start;
             params[16 + i] = t.full;
         }
-        params[20] = c.map_or(0.0, |c| c.step as f32);
-        params[21] = c.map_or(0.0, |c| c.nits);
-        params[22] = c.map_or(0.0, |c| c.band);
         params
     }
 
@@ -550,47 +489,6 @@ impl Hdr {
     }
 }
 
-/// Horizon's icon (horizon-theme) as a 1-bit mask: its white strokes, one colour with hard
-/// edges, are the logo; everything else is not.
-fn logo_mask(device: &wgpu::Device, queue: &wgpu::Queue) -> wgpu::TextureView {
-    use wgpu::util::DeviceExt;
-    let (w, h, rgba) =
-        crate::hud::decode_bytes(horizon_theme::ICON_PNG).unwrap_or((1, 1, vec![0; 4]));
-    let mask: Vec<u8> = rgba
-        .as_chunks::<4>()
-        .0
-        .iter()
-        .map(|p| {
-            if p[3] > 128 && p[..3].iter().all(|&c| c > 200) {
-                255
-            } else {
-                0
-            }
-        })
-        .collect();
-    device
-        .create_texture_with_data(
-            queue,
-            &wgpu::TextureDescriptor {
-                label: Some("Horizon HDR calibration logo"),
-                size: wgpu::Extent3d {
-                    width: w,
-                    height: h,
-                    depth_or_array_layers: 1,
-                },
-                mip_level_count: 1,
-                sample_count: 1,
-                dimension: wgpu::TextureDimension::D2,
-                format: wgpu::TextureFormat::R8Unorm,
-                usage: wgpu::TextureUsages::TEXTURE_BINDING,
-                view_formats: &[],
-            },
-            wgpu::util::TextureDataOrder::LayerMajor,
-            &mask,
-        )
-        .create_view(&Default::default())
-}
-
 #[cfg(test)]
 mod tests {
     use super::{Output, pick};
@@ -602,7 +500,6 @@ mod tests {
         for source in [
             include_str!("../hdr.wgsl"),
             include_str!("../terrain.wgsl"),
-            include_str!("../hdr_stats.wgsl"),
             &entity,
         ] {
             let module = naga::front::wgsl::parse_str(source).unwrap();

crates/horizon-client-render/src/gfx/hdr_stats.rs

@@ -1,158 +0,0 @@
-//! HDR emission thresholds (`hdr_stats.wgsl`): for every block sprite, the brightness its
-//! pixels must reach to shine in HDR output, measured on the GPU from the sprite's own
-//! darkest and brightest opaque pixel when HDR output turns on. Until then (and with HDR
-//! off) the texture holds zeros: every pixel of a light source may shine, and hdr.wgsl's
-//! tier windows alone decide, as before.
-
-use super::hdr::Masks;
-
-pub struct EmissionStats {
-    /// One texel per sprite: x the layer in its array, y the array.
-    pub view: wgpu::TextureView,
-    layout: wgpu::BindGroupLayout,
-    pipeline: wgpu::RenderPipeline,
-    params: wgpu::Buffer,
-}
-
-impl EmissionStats {
-    pub fn new(device: &wgpu::Device, split: u32, arrays: u32) -> Self {
-        let texture = device.create_texture(&wgpu::TextureDescriptor {
-            label: Some("Horizon HDR emission thresholds"),
-            size: wgpu::Extent3d {
-                width: split,
-                height: arrays,
-                depth_or_array_layers: 1,
-            },
-            mip_level_count: 1,
-            sample_count: 1,
-            dimension: wgpu::TextureDimension::D2,
-            format: wgpu::TextureFormat::Rgba8Unorm,
-            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT,
-            view_formats: &[],
-        });
-        let view = texture.create_view(&Default::default());
-        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-            label: Some("Horizon HDR emission thresholds"),
-            source: wgpu::ShaderSource::Wgsl(include_str!("../hdr_stats.wgsl").into()),
-        });
-        let mut entries: Vec<_> = (0..super::SPRITE_ARRAYS)
-            .map(|binding| wgpu::BindGroupLayoutEntry {
-                binding,
-                visibility: wgpu::ShaderStages::FRAGMENT,
-                ty: wgpu::BindingType::Texture {
-                    sample_type: wgpu::TextureSampleType::Float { filterable: true },
-                    view_dimension: wgpu::TextureViewDimension::D2Array,
-                    multisampled: false,
-                },
-                count: None,
-            })
-            .collect();
-        entries.push(wgpu::BindGroupLayoutEntry {
-            binding: super::SPRITE_ARRAYS,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Buffer {
-                ty: wgpu::BufferBindingType::Uniform,
-                has_dynamic_offset: false,
-                min_binding_size: None,
-            },
-            count: None,
-        });
-        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            label: Some("Horizon HDR emission thresholds"),
-            entries: &entries,
-        });
-        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-            label: Some("Horizon HDR emission thresholds"),
-            bind_group_layouts: &[Some(&layout)],
-            ..Default::default()
-        });
-        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-            label: Some("Horizon HDR emission thresholds"),
-            layout: Some(&pipeline_layout),
-            vertex: wgpu::VertexState {
-                module: &shader,
-                entry_point: Some("vs_stats"),
-                compilation_options: Default::default(),
-                buffers: &[],
-            },
-            primitive: Default::default(),
-            depth_stencil: None,
-            multisample: Default::default(),
-            fragment: Some(wgpu::FragmentState {
-                module: &shader,
-                entry_point: Some("fs_stats"),
-                compilation_options: Default::default(),
-                targets: &[Some(wgpu::ColorTargetState {
-                    format: wgpu::TextureFormat::Rgba8Unorm,
-                    blend: None,
-                    write_mask: wgpu::ColorWrites::ALL,
-                })],
-            }),
-            multiview_mask: None,
-            cache: None,
-        });
-        let params = device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("Horizon HDR emission threshold parameters"),
-            size: 16,
-            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-            mapped_at_creation: false,
-        });
-        Self {
-            view,
-            layout,
-            pipeline,
-            params,
-        }
-    }
-
-    /// Measures every sprite of `sprites` (terrain.wgsl's arrays) at `masks`.
-    pub fn measure(
-        &self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        sprites: &[wgpu::TextureView],
-        masks: Masks,
-    ) {
-        let mut params = [0u8; 16];
-        params[..4].copy_from_slice(&masks.parts.to_le_bytes());
-        params[4..8].copy_from_slice(&masks.whole.to_le_bytes());
-        queue.write_buffer(&self.params, 0, &params);
-        let mut entries: Vec<_> = sprites
-            .iter()
-            .enumerate()
-            .map(|(binding, view)| wgpu::BindGroupEntry {
-                binding: binding as u32,
-                resource: wgpu::BindingResource::TextureView(view),
-            })
-            .collect();
-        entries.push(wgpu::BindGroupEntry {
-            binding: super::SPRITE_ARRAYS,
-            resource: self.params.as_entire_binding(),
-        });
-        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Horizon HDR emission thresholds"),
-            layout: &self.layout,
-            entries: &entries,
-        });
-        let mut encoder = device.create_command_encoder(&Default::default());
-        {
-            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                label: Some("Horizon HDR emission thresholds"),
-                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                    view: &self.view,
-                    depth_slice: None,
-                    resolve_target: None,
-                    ops: wgpu::Operations {
-                        load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
-                        store: wgpu::StoreOp::Store,
-                    },
-                })],
-                ..Default::default()
-            });
-            pass.set_pipeline(&self.pipeline);
-            pass.set_bind_group(0, &group, &[]);
-            pass.draw(0..3, 0..1);
-        }
-        queue.submit([encoder.finish()]);
-    }
-}

crates/horizon-client-render/src/gfx/lightning.rs

@@ -83,8 +83,7 @@ fn geometry(seed: i64, uv: [f32; 2]) -> Vec<Vertex> {
                             normal: [0; 4],
                             pos: c,
                             uv,
-                            // HDR output: the bolt shines like the sun (entity.wgsl fs_hdr_mark).
-                            layer: 2 | u32::from(crate::mesher::VERY_BRIGHT) << 16,
+                            layer: 2,
                             color,
                             light: 240 | 240 << 8,
 

crates/horizon-client-render/src/gfx/lightning/tests/mod.rs

@@ -57,8 +57,7 @@ fn reference(seed: i64, at: [f64; 3], camera: DVec3, uv: [f32; 2]) -> Vec<Vertex
                                 normal: [0; 4],
                                 pos: (o + glam::Vec3::from_array(c)).to_array(),
                                 uv,
-                                // The HDR tier lightning.rs adds; the geometry is vanilla's.
-                                layer: 2 | u32::from(crate::mesher::VERY_BRIGHT) << 16,
+                                layer: 2,
                                 color,
                                 light: 240 | 240 << 8,
 

crates/horizon-client-render/src/gfx/lod.rs

@@ -96,8 +96,21 @@ struct Bounds {
 
 impl Bounds {
     fn mesh(mesh: &SectionMesh) -> Option<Self> {
-        let [min, max] = mesh.bounds?;
-        Some(Self { min, max })
+        let mut positions = mesh
+            .solid
+            .iter()
+            .chain(&mesh.translucent)
+            .map(|v| Vec3::from(v.pos));
+        let first = positions.next()?;
+        let mut bounds = Self {
+            min: first,
+            max: first,
+        };
+        for pos in positions {
+            bounds.min = bounds.min.min(pos);
+            bounds.max = bounds.max.max(pos);
+        }
+        Some(bounds)
     }
 
     /// In view: the plan alone decides which tiles are in range (a circle),
@@ -152,10 +165,6 @@ impl Tile {
             None => &mut self.mesh,
         }
     }
-    /// Both meshes it holds in the arena: its own and the stand-in, if any.
-    pub fn meshes_mut(&mut self) -> impl Iterator<Item = &mut SectionGpu> {
-        std::iter::once(&mut self.mesh).chain(self.previous.as_mut().map(|(mesh, _)| mesh))
-    }
     pub fn visible(
         &self,
         key: TileKey,
@@ -410,8 +419,7 @@ impl Renderer {
             let mesh = pending.meshes.remove(&key).expect("pending tile");
             let [x, _, z] = key.origin();
             let size = key.size();
-            let keep = mesh.keep
-                || around_new.contains(&key)
+            let keep = around_new.contains(&key)
                 || taken.iter().any(|&(cx, cz)| {
                     (x..x + size).contains(&(cx * 16)) && (z..z + size).contains(&(cz * 16))
                 });
@@ -503,7 +511,6 @@ mod tests {
         let mesh = SectionMesh {
             solid: vec![vertex([0.0, -64.0, 0.0]), vertex([1024.0, 100.0, 1024.0])],
             translucent: vec![vertex([512.0, 120.0, 512.0])],
-            bounds: Some([Vec3::new(0.0, -64.0, 0.0), Vec3::new(1024.0, 120.0, 1024.0)]),
             ..Default::default()
         };
         let bounds = Bounds::mesh(&mesh).unwrap();

crates/horizon-client-render/src/gfx/native_material.rs

@@ -28,9 +28,6 @@ struct HorizonMaterialOut {
     @location(5) position: vec3<f32>,
     @location(6) spherical: f32,
     @location(7) cylindrical: f32,
-    @location(8) @interpolate(flat) face: u32,
-    @location(9) @interpolate(flat) fluid_quad: u32,
-    @location(10) @interpolate(flat) emission: f32,
 }
 fn horizon_material_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f32>,
     light: vec2<u32>, origin: vec3<f32>) -> HorizonMaterialOut {
@@ -48,19 +45,6 @@ fn horizon_material_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color
     out.position = pos;
     out.spherical = length(pos);
     out.cylindrical = max(length(pos.xz), abs(pos.y));
-    // The colour's alpha byte (mesher.rs's `fluid_face` and `emitting`): a fluid quad's
-    // high nibble is 8 + its face (0..5), every other quad keeps 0xF there; the low nibble
-    // is 15 minus the face's HDR tier. Every corner of a quad carries the same byte, so the
-    // interpolated value rounds back exactly.
-    let flags = u32(round(color.a * 255.0));
-    let high = flags >> 4u;
-    let fluid = high >= 8u && (high & 7u) < 6u;
-    out.face = select(0u, high & 7u, fluid);
-    out.fluid_quad = u32(fluid);
-    // The tier (0 none, 1 low, 2 incandescent, 3 bright, 4 very bright) as how strongly the
-    // face shines: a redstone torch 7/15, a torch 14/15, glowstone 1.
-    let tier = 15u - (flags & 15u);
-    out.emission = select(min(f32(tier) * 7.0 / 15.0, 1.0), 0.0, tier == 0u);
     return out;
 }
 @vertex fn horizon_material_vs(
@@ -81,13 +65,8 @@ fn horizon_material_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color
 }
 fn horizon_material_color(in: HorizonMaterialOut, translucent: bool) -> vec4<f32> {
     let albedo = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu);
-    // Water draws translucent and lava solid, so the pass resolves the fluid kind.
-    let fluid = select(0u, select(2u, 1u, translucent), in.fluid_quad != 0u);
-    let normal = horizon_material_normal(in.position);
-    let tangent = horizon_material_tangent(in.position, in.uv, normal);
     return material(MaterialInput(albedo, in.tint, in.light, in.lightmap, in.position, in.uv,
-        translucent, horizon_sprite_tags(in.layer & 0x7fffu), in.clip.xy / frame.resolution,
-        in.face, fluid, in.emission, normal, tangent)).color;
+        translucent)).color;
 }
 @fragment fn horizon_material_fs_solid(in: HorizonMaterialOut) -> @location(0) vec4<f32> {
     let color = horizon_material_color(in, false);
@@ -112,9 +91,6 @@ pub struct TerrainShape<'a> {
     pub sprites: [f64; 2],
     /// The world target's colour format.
     pub format: wgpu::TextureFormat,
-    /// The pack's tags of each tagged sprite layer, as `(layer, bits)`
-    /// (`Manifest::sprite_tags`).
-    pub sprite_tags: &'a [(u32, u32)],
 }
 
 /// The pack's terrain pipelines: solid (with the cutout test) and translucent, for the
@@ -134,34 +110,17 @@ fn vanilla_terrain() -> String {
     )
 }
 
-/// `horizon_sprite_tags(layer)`: the bits of `MaterialInput.tags` of each sprite layer.
-fn sprite_tags(tags: &[(u32, u32)]) -> String {
-    let mut out = String::from("fn horizon_sprite_tags(layer: u32) -> u32 {\n    switch layer {\n");
-    let mut tags = tags.to_vec();
-    tags.sort_unstable_by_key(|&(layer, bits)| (bits, layer));
-    for group in tags.chunk_by(|a, b| a.1 == b.1) {
-        let layers: Vec<String> = group.iter().map(|(layer, _)| format!("{layer}u")).collect();
-        out += &format!(
-            "        case {}: {{ return {}u; }}\n",
-            layers.join(", "),
-            group[0].1
-        );
-    }
-    out + "        default: { return 0u; }\n    }\n}\n"
-}
-
-/// The terrain shader for the pack's material stage `source`, with its sprite `tags`.
-fn shader_source(source: &str, tags: &[(u32, u32)]) -> String {
+/// The terrain shader for the pack's material stage `source`.
+fn shader_source(source: &str) -> String {
     format!(
-        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{ENTRIES}",
-        vanilla_terrain(),
-        sprite_tags(tags)
+        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{ENTRIES}",
+        vanilla_terrain()
     )
 }
 
 /// The material's naga module, its errors in the stage's file.
-fn module(stage: &CheckedStage, tags: &[(u32, u32)]) -> Result<naga::Module, String> {
-    let text = shader_source(&stage.source, tags);
+fn module(stage: &CheckedStage) -> Result<naga::Module, String> {
+    let text = shader_source(&stage.source);
     naga::front::wgsl::parse_str(&text)
         .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))
 }
@@ -175,7 +134,7 @@ impl NativeMaterial {
         stage: &CheckedStage,
         constants: &[(String, f64)],
     ) -> Result<Self, String> {
-        let module = module(stage, shape.sprite_tags)?;
+        let module = module(stage)?;
         let mut constants = present_constants(&module, constants);
         let sprite_names = [
             "horizon_terrain_SPRITE_ARRAYS",
@@ -338,22 +297,15 @@ mod tests {
             fn apply_fog(c: vec4<f32>) -> vec4<f32> { return c * gain; }\n\
             fn material(input: MaterialInput) -> Surface {\n    \
                 let lit = input.albedo * input.tint * vec4(input.lightmap, 1.0);\n    \
-                let t = vec2<i32>(input.screen * frame.resolution);\n    \
-                let behind = textureLoad(opaque_color, t, 0) * textureLoad(opaque_depth, t, 0);\n    \
-                let mirrored = textureSampleLevel(reflection, reflection_sampler, input.screen, 0.0);\n    \
-                let kind = f32(input.face + input.fluid) * input.emission * mirrored.a;\n    \
-                let frame_of = vec4(cross(input.normal, input.tangent.xyz) * input.tangent.w, kind);\n    \
-                return Surface(apply_fog(sprite(lit)) + (behind + frame_of) * 0.0);\n}\n";
+                return Surface(apply_fog(sprite(lit)));\n}\n";
         let stage = stage(own);
-        let tags = [(7, 1), (3, 1), (9, 2)];
-        assert!(sprite_tags(&tags).contains("case 3u, 7u: { return 1u; }"));
-        let module = module(&stage, &tags).unwrap();
+        let module = module(&stage).unwrap();
         let info = naga::valid::Validator::new(
             naga::valid::ValidationFlags::all(),
             naga::valid::Capabilities::all(),
         )
         .validate(&module)
-        .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&shader_source(&stage.source, &tags))));
+        .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&shader_source(&stage.source))));
         let entries: Vec<&str> = module
             .entry_points
             .iter()

crates/horizon-client-render/src/gfx/native_pack.rs

@@ -29,20 +29,7 @@ impl NativePack {
         constants: &[(String, f64)],
     ) -> Result<(Self, Vec<String>), String> {
         let (globals, format) = (terrain.globals, terrain.format);
-        let mut frame = NativeFrame::new(device);
-        // The mirror is drawn for a material that reads it, while `[reflection] option` is on.
-        let option = report.reflection.as_ref().and_then(|r| r.option.as_ref());
-        frame.reflects = report
-            .stages
-            .iter()
-            .find(|s| s.kind == StageKind::Material)
-            .is_some_and(|s| s.reads("reflection"))
-            && option.is_none_or(|id| {
-                constants
-                    .iter()
-                    .find(|(k, _)| k == id)
-                    .is_none_or(|(_, v)| *v != 0.0)
-            });
+        let frame = NativeFrame::new(device);
         let (post, others): (Vec<_>, Vec<_>) = report
             .stages
             .into_iter()

crates/horizon-client-render/src/gfx/native_post.rs

@@ -24,87 +24,20 @@ pub struct NativePost {
     nearest: wgpu::Sampler,
     /// Two targets of the world's size, written in turn (none with a single pass).
     targets: Option<([u32; 2], [wgpu::TextureView; 2])>,
-    /// Last frame's input to the last pass (`history`, binding 8), made with the targets,
-    /// and a black 1×1 in its place before then.
-    history: Option<wgpu::Texture>,
-    history_blank: wgpu::Texture,
-    /// One bind group per pass, for these world views and either the valid history or black.
-    groups: Option<(WorldViews, bool, Vec<wgpu::BindGroup>)>,
-    /// Whether `history` contains the last frame's input to the last pass.
-    history_valid: bool,
+    /// One bind group per pass, for these world views.
+    groups: Option<(WorldViews, Vec<wgpu::BindGroup>)>,
     /// The screen's colour format, the world target's too.
     format: wgpu::TextureFormat,
 }
 
-/// The `frame` every stage of a pack reads (group 3, binding 0), written once a frame, and
-/// what the material stage reads besides.
+/// The `frame` every stage of a pack reads (group 3, binding 0), written once a frame.
 pub struct NativeFrame {
     pub(super) buffer: wgpu::Buffer,
-    /// Group 3 of the sky and material stages.
+    /// Group 3 of the stages that read only the frame (the sky).
     pub layout: wgpu::BindGroupLayout,
     pub group: wgpu::BindGroup,
-    /// The world's depth before translucent terrain (the material stage's `opaque_depth`,
-    /// binding 6), copied each frame.
-    pub opaque_depth: wgpu::Texture,
-    /// The world's colour before translucent terrain (`opaque_color`, binding 11), copied
-    /// with it; 1×1 while the world draws straight to the window.
-    pub opaque_color: wgpu::Texture,
-    /// The material stage's `reflection` (binding 1): this frame's water mirror, else
-    /// `blank`; and its sampler (binding 2).
-    reflection: wgpu::TextureView,
-    blank: wgpu::TextureView,
-    reflection_sampler: wgpu::Sampler,
-    /// Whether the pack's material reads `reflection` (`NativePack::new`): else no mirror
-    /// is drawn and `has_reflection` stays 0.
-    pub reflects: bool,
-    /// Last frame's view-projection, camera and time (`write`).
-    last: Option<([[f32; 4]; 4], glam::DVec3, std::time::Instant)>,
-    /// The eased eye light (block, sky) and being in water and lava (`write`); NaN until the
-    /// first frame sets them.
-    eye: [f32; 4],
-    /// A post stage must use black history after a long gap until it has rendered a frame.
-    history_reset: bool,
     start: std::time::Instant,
     frames: u32,
-    /// `frame.wetness`, and when it was last written.
-    wetness: (f32, Option<std::time::Instant>),
-}
-
-/// A depth texture of `size` the world's depth is copied into.
-fn depth_copy(device: &wgpu::Device, size: [u32; 2]) -> wgpu::Texture {
-    copy_target(
-        device,
-        "Native shader pack opaque depth",
-        size,
-        wgpu::TextureFormat::Depth32Float,
-    )
-}
-
-/// A colour texture of `size` and `format` the world's colour is copied into.
-fn color_copy(device: &wgpu::Device, size: [u32; 2], format: wgpu::TextureFormat) -> wgpu::Texture {
-    copy_target(device, "Native shader pack opaque colour", size, format)
-}
-
-fn copy_target(
-    device: &wgpu::Device,
-    label: &str,
-    size: [u32; 2],
-    format: wgpu::TextureFormat,
-) -> wgpu::Texture {
-    device.create_texture(&wgpu::TextureDescriptor {
-        label: Some(label),
-        size: wgpu::Extent3d {
-            width: size[0].max(1),
-            height: size[1].max(1),
-            depth_or_array_layers: 1,
-        },
-        mip_level_count: 1,
-        sample_count: 1,
-        dimension: wgpu::TextureDimension::D2,
-        format,
-        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-        view_formats: &[],
-    })
 }
 
 /// The uniform `frame` at binding 0, read by `visibility`.
@@ -121,24 +54,6 @@ fn frame_entry(visibility: wgpu::ShaderStages) -> wgpu::BindGroupLayoutEntry {
     }
 }
 
-/// The size of the water mirror for a world of `size`: half of it.
-pub fn reflection_size(size: [u32; 2]) -> [u32; 2] {
-    size.map(|s| s.div_ceil(2).max(1))
-}
-
-/// Seconds between frames past which the last one is forgotten (`NativeFrame::write`).
-const MAX_FRAME_GAP: f32 = 0.5;
-
-/// `value` moved toward `target` over `dt` seconds by a half-life in seconds; a NaN `value`
-/// (the first frame) starts at `target`.
-fn eased(value: f32, target: f32, half_life: f32, dt: f32) -> f32 {
-    if value.is_nan() {
-        target
-    } else {
-        target + (value - target) * 0.5f32.powf(dt / half_life)
-    }
-}
-
 impl NativeFrame {
     pub fn new(device: &wgpu::Device) -> Self {
         let buffer = device.create_buffer(&wgpu::BufferDescriptor {
@@ -149,202 +64,32 @@ impl NativeFrame {
         });
         let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
             label: Some("Native shader pack frame"),
-            entries: &[
-                frame_entry(wgpu::ShaderStages::VERTEX_FRAGMENT),
-                texture_entry(1, wgpu::TextureSampleType::Float { filterable: true }),
-                sampler_entry(2),
-                texture_entry(6, wgpu::TextureSampleType::Depth),
-                texture_entry(11, wgpu::TextureSampleType::Float { filterable: false }),
-            ],
+            entries: &[frame_entry(wgpu::ShaderStages::VERTEX_FRAGMENT)],
         });
-        let opaque_depth = depth_copy(device, [1, 1]);
-        let opaque_color = color_copy(device, [1, 1], wgpu::TextureFormat::Rgba8Unorm);
-        let blank = copy_target(
-            device,
-            "Native shader pack reflection blank",
-            [1, 1],
-            wgpu::TextureFormat::Rgba8Unorm,
-        )
-        .create_view(&Default::default());
-        let reflection_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
-            label: Some("Native shader pack reflection sampler"),
-            mag_filter: wgpu::FilterMode::Linear,
-            min_filter: wgpu::FilterMode::Linear,
-            ..Default::default()
+        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("Native shader pack frame"),
+            layout: &layout,
+            entries: &[wgpu::BindGroupEntry {
+                binding: 0,
+                resource: buffer.as_entire_binding(),
+            }],
         });
-        let group = Self::group(
-            device,
-            &layout,
-            &buffer,
-            (&blank, &reflection_sampler),
-            &opaque_depth,
-            &opaque_color,
-        );
         Self {
             buffer,
             layout,
             group,
-            opaque_depth,
-            opaque_color,
-            reflection: blank.clone(),
-            blank,
-            reflection_sampler,
-            reflects: false,
-            last: None,
-            eye: [f32::NAN; 4],
-            history_reset: true,
             start: std::time::Instant::now(),
             frames: 0,
-            wetness: (0.0, None),
         }
     }
 
-    fn group(
-        device: &wgpu::Device,
-        layout: &wgpu::BindGroupLayout,
-        buffer: &wgpu::Buffer,
-        (reflection, sampler): (&wgpu::TextureView, &wgpu::Sampler),
-        opaque_depth: &wgpu::Texture,
-        opaque_color: &wgpu::Texture,
-    ) -> wgpu::BindGroup {
-        device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Native shader pack frame"),
-            layout,
-            entries: &[
-                wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: buffer.as_entire_binding(),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 1,
-                    resource: wgpu::BindingResource::TextureView(reflection),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 2,
-                    resource: wgpu::BindingResource::Sampler(sampler),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 6,
-                    resource: wgpu::BindingResource::TextureView(
-                        &opaque_depth.create_view(&Default::default()),
-                    ),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 11,
-                    resource: wgpu::BindingResource::TextureView(
-                        &opaque_color.create_view(&Default::default()),
-                    ),
-                },
-            ],
-        })
-    }
-
-    /// Keeps the opaque copies the size of the world's depth `depth` and, where the world's
-    /// colour `color` can be copied (the scaled target, not the window's own), its size and
-    /// format; the group is made again when they change.
-    pub fn fit_opaque(
-        &mut self,
-        device: &wgpu::Device,
-        depth: &wgpu::Texture,
-        color: Option<&wgpu::Texture>,
-    ) {
-        let size = [depth.width(), depth.height()];
-        let (color_size, format) = match color {
-            Some(c) => ([c.width(), c.height()], c.format()),
-            None => ([1, 1], self.opaque_color.format()),
-        };
-        let color_fits = [self.opaque_color.width(), self.opaque_color.height()] == color_size
-            && self.opaque_color.format() == format;
-        let depth_fits = [self.opaque_depth.width(), self.opaque_depth.height()] == size;
-        if depth_fits && color_fits {
-            return;
-        }
-        if !color_fits {
-            self.opaque_color = color_copy(device, color_size, format);
-        }
-        if !depth_fits {
-            self.opaque_depth = depth_copy(device, size);
-        }
-        self.regroup(device);
-    }
-
-    /// Binds `view` as this frame's `reflection` (`None`: the blank). The mirror is drawn
-    /// before the stages read it.
-    pub fn set_reflection(&mut self, device: &wgpu::Device, view: Option<&wgpu::TextureView>) {
-        let view = view.unwrap_or(&self.blank);
-        if *view != self.reflection {
-            self.reflection = view.clone();
-            self.regroup(device);
-        }
-    }
-
-    fn regroup(&mut self, device: &wgpu::Device) {
-        self.group = Self::group(
-            device,
-            &self.layout,
-            &self.buffer,
-            (&self.reflection, &self.reflection_sampler),
-            &self.opaque_depth,
-            &self.opaque_color,
-        );
-    }
-
     /// Writes this frame's inputs, for a world of `size`.
     pub fn write(&mut self, queue: &wgpu::Queue, frame: &Frame, size: [u32; 2]) {
         let seconds = self.start.elapsed().as_secs_f32() % 3600.0;
-        let now = std::time::Instant::now();
-        let since = self.wetness.1.map_or(0.0, |t| (now - t).as_secs_f32());
-        self.wetness = (wetness(self.wetness.0, frame.pack.rain, since), Some(now));
-        let mut inputs = frame_inputs(frame, size, seconds, self.frames);
-        inputs.wetness = self.wetness.0;
-        if !self.reflects {
-            inputs.has_reflection = 0;
-        }
-        let view_proj = (Mat4::from_cols_array_2d(&inputs.projection)
-            * Mat4::from_cols_array_2d(&inputs.view))
-        .to_cols_array_2d();
-        inputs.previous_view_projection = view_proj;
-        // `write` skips title frames, so a gap means a pause or another world: the frame
-        // before says nothing about this one, and the eased values start over.
-        match self.last {
-            Some((previous, camera, time)) if (now - time).as_secs_f32() < MAX_FRAME_GAP => {
-                inputs.previous_view_projection = previous;
-                inputs.camera_motion = (frame.camera - camera).as_vec3().to_array();
-                inputs.delta_time = (now - time).as_secs_f32();
-            }
-            _ => {
-                self.eye = [f32::NAN; 4];
-                self.history_reset = true;
-            }
-        }
-        self.last = Some((view_proj, frame.camera, now));
-        // The eye's light and medium eased by half-lives in seconds, from where they are at
-        // first.
-        let targets = [
-            (inputs.eye_light[0], 2.0),
-            (inputs.eye_light[1], 2.0),
-            (f32::from(u8::from(inputs.eye_in == 1)), 0.25),
-            (f32::from(u8::from(inputs.eye_in == 2)), 0.25),
-        ];
-        let dt = inputs.delta_time;
-        for (value, (target, half_life)) in self.eye.iter_mut().zip(targets) {
-            *value = eased(*value, target, half_life, dt);
-        }
-        let [block, sky, water, lava] = self.eye;
-        inputs.eye_light_smooth = [block, sky];
-        inputs.in_water = water;
-        inputs.in_lava = lava;
+        let inputs = frame_inputs(frame, size, seconds, self.frames);
         self.frames = self.frames.wrapping_add(1);
         queue.write_buffer(&self.buffer, 0, bytemuck::bytes_of(&inputs));
     }
-
-    /// Takes the post stage's pending history reset. It stays pending if post rendering is
-    /// skipped for a frame, so the first frame it does render still sees black history.
-    pub(super) fn take_history_reset(&mut self) -> bool {
-        let reset = self.history_reset;
-        self.history_reset = false;
-        reset
-    }
 }
 
 /// The option values of `constants` that `module` declares as overrides (wgpu refuses others).
@@ -406,7 +151,6 @@ impl NativePost {
                 texture_entry(3, float),
                 sampler_entry(4),
                 sampler_entry(5),
-                texture_entry(8, float),
             ],
         });
         let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] = Default::default();
@@ -474,10 +218,7 @@ impl NativePost {
             linear: sampler("Native shader pack linear", wgpu::FilterMode::Linear),
             nearest: sampler("Native shader pack nearest", wgpu::FilterMode::Nearest),
             targets: None,
-            history: None,
-            history_blank: history_target(device, "Native shader pack history blank", [1, 1]),
             groups: None,
-            history_valid: false,
             format,
         })
     }
@@ -492,7 +233,6 @@ impl NativePost {
         device: &wgpu::Device,
         world: (&wgpu::TextureView, &wgpu::TextureView),
         size: [u32; 2],
-        history_reset: bool,
     ) {
         if self.passes.len() > 1 && self.targets.as_ref().is_none_or(|t| t.0 != size) {
             let target = |label| {
@@ -508,10 +248,8 @@ impl NativePost {
                         sample_count: 1,
                         dimension: wgpu::TextureDimension::D2,
                         format: INTERMEDIATE,
-                        // COPY_SRC: the last pass's input is kept as next frame's `history`.
                         usage: wgpu::TextureUsages::RENDER_ATTACHMENT
-                            | wgpu::TextureUsages::TEXTURE_BINDING
-                            | wgpu::TextureUsages::COPY_SRC,
+                            | wgpu::TextureUsages::TEXTURE_BINDING,
                         view_formats: &[],
                     })
                     .create_view(&Default::default())
@@ -523,28 +261,15 @@ impl NativePost {
                     target("Native shader pack B"),
                 ],
             ));
-            self.history = Some(history_target(device, "Native shader pack history", size));
-            self.history_valid = false;
             self.groups = None;
         }
-        let blank_history = history_reset || !self.history_valid;
         if self
             .groups
             .as_ref()
-            .is_some_and(|((color, depth), blank, _)| {
-                color == world.0 && depth == world.1 && *blank == blank_history
-            })
+            .is_some_and(|((color, depth), _)| color == world.0 && depth == world.1)
         {
             return;
         }
-        let history = if blank_history {
-            &self.history_blank
-        } else {
-            self.history
-                .as_ref()
-                .expect("history exists after a post stage has more than one pass")
-        }
-        .create_view(&Default::default());
         let groups = (0..self.passes.len())
             .map(|i| {
                 // Pass i reads what pass i - 1 wrote: target (i - 1) % 2, the world for the first.
@@ -580,15 +305,11 @@ impl NativePost {
                             binding: 5,
                             resource: wgpu::BindingResource::Sampler(&self.nearest),
                         },
-                        wgpu::BindGroupEntry {
-                            binding: 8,
-                            resource: wgpu::BindingResource::TextureView(&history),
-                        },
                     ],
                 })
             })
             .collect();
-        self.groups = Some(((world.0.clone(), world.1.clone()), blank_history, groups));
+        self.groups = Some(((world.0.clone(), world.1.clone()), groups));
     }
 
     /// Runs the passes over the world target `world` (colour, depth) of `size`, the last onto
@@ -600,14 +321,13 @@ impl NativePost {
         world: (&wgpu::TextureView, &wgpu::TextureView),
         screen: &wgpu::TextureView,
         size: [u32; 2],
-        history_reset: bool,
         mut timing: Option<&mut super::pack_timing::PassTiming>,
     ) {
-        self.prepare(device, world, size, history_reset);
+        self.prepare(device, world, size);
         if let Some(t) = timing.as_deref_mut() {
             t.mark(device, encoder, (world.0, self.format));
         }
-        let Some((_, _, groups)) = &self.groups else {
+        let Some((_, groups)) = &self.groups else {
             return;
         };
         for (i, ((label, pipeline), group)) in self.passes.iter().zip(groups).enumerate() {
@@ -634,47 +354,9 @@ impl NativePost {
             pass.set_bind_group(GROUP, group, &[]);
             pass.draw(0..3, 0..1);
         }
-        // The last pass's input becomes next frame's `history`, once that pass has read this
-        // frame's.
-        let count = self.passes.len();
-        if count > 1
-            && let (Some(history), Some((_, targets))) = (&self.history, &self.targets)
-        {
-            encoder.copy_texture_to_texture(
-                targets[(count - 2) % 2].texture().as_image_copy(),
-                history.as_image_copy(),
-                history.size(),
-            );
-            self.history_valid = true;
-        }
     }
 }
 
-/// A target of `size` the post stage's `history` is copied into.
-fn history_target(device: &wgpu::Device, label: &str, size: [u32; 2]) -> wgpu::Texture {
-    device.create_texture(&wgpu::TextureDescriptor {
-        label: Some(label),
-        size: wgpu::Extent3d {
-            width: size[0].max(1),
-            height: size[1].max(1),
-            depth_or_array_layers: 1,
-        },
-        mip_level_count: 1,
-        sample_count: 1,
-        dimension: wgpu::TextureDimension::D2,
-        format: INTERMEDIATE,
-        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-        view_formats: &[],
-    })
-}
-
-/// `wetness` after `dt` seconds of `rain`: halfway there in 30 seconds while it rains
-/// harder, in 10 while it dries (the half-lives of the `shaders/` format's `wetness`).
-fn wetness(wetness: f32, rain: f32, dt: f32) -> f32 {
-    let half_life = if rain > wetness { 30.0 } else { 10.0 };
-    rain + (wetness - rain) * 0.5f32.powf(dt / half_life)
-}
-
 /// The frame as packs read it (docs/api/shaders-reference.md), from the renderer's `Frame`.
 pub fn frame_inputs(frame: &Frame, size: [u32; 2], seconds: f32, index: u32) -> FrameInputs {
     let aspect = size[0] as f32 / size[1].max(1) as f32;
@@ -734,42 +416,14 @@ pub fn frame_inputs(frame: &Frame, size: [u32; 2], seconds: f32, index: u32) ->
         },
         frame_index: index,
         hide_gui: u32::from(pack.hide_gui),
-        precipitation: pack.biome_precipitation.clamp(0, 2) as u32,
-        temperature: pack.temperature,
-        downfall: pack.rainfall,
-        wetness: pack.rain,
-        // Filled by `NativeFrame::write`, which remembers the frames before.
-        previous_view_projection: m(Mat4::IDENTITY),
-        camera_motion: [0.0; 3],
-        delta_time: 0.0,
-        eye_light_smooth: [level(pack.eye_light[0]), level(pack.eye_light[1])],
-        in_water: f32::from(u8::from(pack.eye_in as u32 == 1)),
-        in_lava: f32::from(u8::from(pack.eye_in as u32 == 2)),
-        water_plane: frame.water_plane.unwrap_or(0.0),
-        has_reflection: u32::from(frame.water_plane.is_some()),
-        reflection_resolution: reflection_size(size).map(|s| s as f32),
     }
 }
 
 #[cfg(test)]
 mod tests {
-    #[test]
-    fn eased_values_start_at_the_target_and_halve_the_distance() {
-        use super::eased;
-        assert_eq!(eased(f32::NAN, 0.25, 2.0, 0.0), 0.25);
-        assert_eq!(eased(1.0, 0.0, 2.0, 2.0), 0.5);
-        assert_eq!(eased(1.0, 0.0, 2.0, 0.0), 1.0);
-    }
     use super::*;
     use horizon_shader_api::{MANIFEST, Pack, check};
 
-    #[test]
-    fn wetness_rises_slower_than_it_dries() {
-        assert_eq!(wetness(0.0, 1.0, 30.0), 0.5);
-        assert_eq!(wetness(1.0, 0.0, 10.0), 0.5);
-        assert_eq!(wetness(0.25, 0.25, 5.0), 0.25);
-    }
-
     fn device() -> Option<(wgpu::Device, wgpu::Queue)> {
         let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
         let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
@@ -867,15 +521,7 @@ mod tests {
             ..Default::default()
         });
         let view = screen.create_view(&Default::default());
-        post.run(
-            &device,
-            &mut encoder,
-            (&color, &depth),
-            &view,
-            [4, 4],
-            true,
-            None,
-        );
+        post.run(&device, &mut encoder, (&color, &depth), &view, [4, 4], None);
         let buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: None,
             size: u64::from(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT * 4),
@@ -906,111 +552,4 @@ mod tests {
             "{pixel:?}"
         );
     }
-
-    /// `history` is black on the first frame, then what the pass before the last wrote the
-    /// frame before.
-    #[test]
-    fn the_last_pass_reads_last_frames_input_as_history() {
-        let Some((device, queue)) = device() else {
-            return;
-        };
-        let manifest = "schema = 1
-id = \"t\"
-name = \"T\"
-version = \"1\"
-api = \"0.1\"
-            [[post]]
-file = \"a.wgsl\"
-[[post]]
-file = \"b.wgsl\"
-";
-        let a = "fn post(input: PostInput) -> vec4<f32> { return vec4<f32>(input.color.rgb * 0.5, 1.0); }
-";
-        let b = "fn post(input: PostInput) -> vec4<f32> { return textureLoad(history, vec2<i32>(input.pixel), 0); }
-";
-        let files = [(MANIFEST, manifest), ("a.wgsl", a), ("b.wgsl", b)]
-            .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec()))
-            .into();
-        let report = check(&Pack::from_files(files).unwrap()).unwrap();
-        let format = wgpu::TextureFormat::Rgba8Unorm;
-        let frame = NativeFrame::new(&device);
-        let mut post = NativePost::new(&device, report.stages, &[], format, &frame).unwrap();
-        let usage = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
-        let color = texture(&device, format, usage).create_view(&Default::default());
-        let depth = texture(&device, wgpu::TextureFormat::Depth32Float, usage)
-            .create_view(&Default::default());
-        let screen = texture(
-            &device,
-            format,
-            wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
-        );
-        let view = screen.create_view(&Default::default());
-        let buffer = device.create_buffer(&wgpu::BufferDescriptor {
-            label: None,
-            size: u64::from(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT * 4),
-            usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
-            mapped_at_creation: false,
-        });
-        let mut frame_pixel = |history_reset| {
-            let mut encoder = device.create_command_encoder(&Default::default());
-            encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                label: None,
-                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                    view: &color,
-                    resolve_target: None,
-                    depth_slice: None,
-                    ops: wgpu::Operations {
-                        load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
-                        store: wgpu::StoreOp::Store,
-                    },
-                })],
-                ..Default::default()
-            });
-            post.run(
-                &device,
-                &mut encoder,
-                (&color, &depth),
-                &view,
-                [4, 4],
-                history_reset,
-                None,
-            );
-            encoder.copy_texture_to_buffer(
-                screen.as_image_copy(),
-                wgpu::TexelCopyBufferInfo {
-                    buffer: &buffer,
-                    layout: wgpu::TexelCopyBufferLayout {
-                        offset: 0,
-                        bytes_per_row: Some(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT),
-                        rows_per_image: Some(4),
-                    },
-                },
-                screen.size(),
-            );
-            queue.submit([encoder.finish()]);
-            buffer
-                .slice(..)
-                .map_async(wgpu::MapMode::Read, |r| r.unwrap());
-            device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
-            let pixel = buffer.slice(..).get_mapped_range().unwrap()[..4].to_vec();
-            buffer.unmap();
-            pixel
-        };
-        assert_eq!(
-            frame_pixel(true)[..3],
-            [0, 0, 0],
-            "black on the first frame"
-        );
-        let second = frame_pixel(false);
-        assert!(
-            second[..3].iter().all(|&v| v.abs_diff(128) <= 1),
-            "{second:?}"
-        );
-        assert_eq!(frame_pixel(true)[..3], [0, 0, 0], "black after a frame gap");
-        let fourth = frame_pixel(false);
-        assert!(
-            fourth[..3].iter().all(|&v| v.abs_diff(128) <= 1),
-            "{fourth:?}"
-        );
-    }
 }

crates/horizon-client-render/src/gfx/native_render.rs

@@ -1,74 +0,0 @@
-//! Render hook points for native mods (docs/native-mods.md): empty functions the renderer calls at
-//! fixed places of a frame, which a mod's mixins hook like those of
-//! `horizon-client/src/game/native_hooks.rs`, and listed with them in `native-hooks.json`. API
-//! 58.
-
-use super::Vertex;
-use super::pack_draw::EntitySpan;
-use glam::{DVec3, Mat4};
-
-/// What a mod can draw with once the world is drawn: after the sky, terrain, entities,
-/// particles, weather and the world post pass, before the first-person hand, the HUD and the
-/// screens. `color` holds the world's picture (copy it out before reading it: it is the target
-/// drawn into), `depth` the world's depth, reversed (0 is the sky).
-pub struct WorldDrawn<'a> {
-    pub device: &'a wgpu::Device,
-    pub queue: &'a wgpu::Queue,
-    pub encoder: &'a mut wgpu::CommandEncoder,
-    /// The frame's target and a view of it in `color_format`.
-    pub color: &'a wgpu::Texture,
-    pub color_view: &'a wgpu::TextureView,
-    pub color_format: wgpu::TextureFormat,
-    /// The size of `color`.
-    pub size: [u32; 2],
-    /// The world's depth (Depth32Float, sampleable), and its size: smaller than `size` when the
-    /// world draws at a lower resolution. It holds the frame's depth only when a mod asked for
-    /// it ([`RenderNeeds::world_depth`]) or something else kept it.
-    pub depth: &'a wgpu::TextureView,
-    pub depth_size: [u32; 2],
-    /// Camera-relative world to clip space, without TAA's jitter, and with it (what the world
-    /// was drawn with).
-    pub view_proj: Mat4,
-    pub jittered: Mat4,
-    /// The camera's position in the world.
-    pub camera: DVec3,
-    /// The camera-relative entity geometry of the frame (`Frame::entities`), quads of 4
-    /// vertices, and its runs by entity when a mod asked for them
-    /// ([`RenderNeeds::entity_spans`]) or a shader pack draws them.
-    pub entities: &'a [Vertex],
-    pub spans: &'a [EntitySpan],
-    /// The shared atlas entity UVs point into.
-    pub atlas: Option<&'a wgpu::Texture>,
-    /// Quad indices (0 1 2 0 2 3 for each 4 vertices), for as many quads as `entities` holds.
-    pub quad_indices: &'a wgpu::Buffer,
-}
-
-/// What the mods need from a frame that the game doesn't make for itself. Each mod sets what it
-/// needs and leaves the rest, so several can ask.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub struct RenderNeeds {
-    /// Record `Frame::entity_spans` without a shader pack: entity runs get a stable id from
-    /// their type's name, block entity runs their block state.
-    pub entity_spans: bool,
-    /// Keep the world pass's depth for [`native_world_drawn`] when nothing else does.
-    pub world_depth: bool,
-}
-
-/// The world is drawn (see [`WorldDrawn`]). Not called on the title screen's panorama.
-#[inline(never)]
-pub fn native_world_drawn(world: &mut WorldDrawn<'_>) {
-    let _ = world;
-}
-
-/// Asked as a frame is built and drawn: set what your mod needs.
-#[inline(never)]
-pub fn native_render_needs(needs: &mut RenderNeeds) {
-    let _ = needs;
-}
-
-/// What the mods need this frame ([`native_render_needs`]).
-pub fn render_needs() -> RenderNeeds {
-    let mut needs = RenderNeeds::default();
-    native_render_needs(&mut needs);
-    needs
-}

crates/horizon-client-render/src/gfx/occlusion.rs

@@ -128,9 +128,6 @@ struct Graph {
     /// (`Node.sourceDirections`, as the faces rather than the steps); none for
     /// the camera's.
     entered: Vec<u8>,
-    /// Whether any section in the searched top layer was reached. Sections
-    /// above a clamped box use this conservative sky-band answer.
-    sky_reached: bool,
     /// Per section corner, during a full search: `SEES`, or how far the line
     /// from it towards the camera is known to stay in reached sections (the
     /// first sample that was not). Sections are only ever added during a
@@ -159,22 +156,8 @@ impl Graph {
         )
     }
     fn contains(&self, key: SectionKey) -> bool {
-        if let Some(i) = self.index(key) {
-            self.directions[i] & REACHED != 0
-        } else if (0..=self.sections).contains(&key.1)
-            && key.1 >= self.y0 + self.height
-            && (key.0 - self.from.0).abs() <= self.radius
-            && (key.2 - self.from.2).abs() <= self.radius
-        {
-            // Everything above the highest non-air section is open sky. A
-            // full search can reach that layer from a neighbouring column,
-            // so checking only this column's top cell can hide an upper
-            // section that is visible through the open layer. Once any top
-            // cell is reached, conservatively keep the whole sky band visible.
-            self.sky_reached
-        } else {
-            false
-        }
+        self.index(key)
+            .is_some_and(|i| self.directions[i] & REACHED != 0)
     }
     /// The full search from the camera (vanilla's `scheduleFullUpdate`).
     fn search(
@@ -191,37 +174,13 @@ impl Graph {
         self.min_y = columns.min_y;
         self.sections = columns.sections;
         self.y0 = -1;
-        if from.1 >= columns.sections {
-            self.height = columns.sections + 2;
-        } else {
-            let mut max_non_air_y = 0;
-            for dz in -radius..=radius {
-                for dx in -radius..=radius {
-                    let Some(column) = columns.map.get(&(from.0 + dx, from.2 + dz)) else {
-                        continue;
-                    };
-                    for (y, &v) in column.iter().enumerate().rev() {
-                        let y = y as i32;
-                        if y <= max_non_air_y {
-                            break;
-                        }
-                        if v != ALL_VISIBLE {
-                            max_non_air_y = y;
-                            break;
-                        }
-                    }
-                }
-            }
-            let top_y = max_non_air_y.max(from.1);
-            self.height = (top_y + 3).max(3).min(columns.sections + 2);
-        }
+        self.height = columns.sections + 2;
         let side = (2 * radius + 1) as usize;
         let size = side * side * self.height as usize;
         self.directions.clear();
         self.directions.resize(size, 0);
         self.entered.clear();
         self.entered.resize(size, 0);
-        self.sky_reached = false;
         self.rays.clear();
         self.rays
             .resize((side + 1) * (side + 1) * (self.height + 1) as usize, 0);
@@ -235,8 +194,7 @@ impl Graph {
                 let base = self
                     .index((from.0 + dx, 0, from.2 + dz))
                     .expect("column inside the searched box");
-                let len = (column.len() as i32).min(self.height - 1) as usize;
-                vis[base..base + len].copy_from_slice(&column[..len]);
+                vis[base..base + column.len()].copy_from_slice(column);
             }
         }
         queue.clear();
@@ -321,9 +279,6 @@ impl Graph {
         while let Some(index) = queue.pop_front() {
             let i = index as usize;
             let key = self.key(i);
-            if key.1 == self.y0 + self.height - 1 {
-                self.sky_reached = true;
-            }
             let directions = self.directions[i];
             let entered = self.entered[i];
             let exits = if entered == 0 {
@@ -1127,64 +1082,6 @@ mod tests {
         );
     }
 
-    /// A clamped search may conservatively show sections above its searched
-    /// box, but it must never hide one that the full-height search reaches.
-    #[test]
-    fn vertical_clamping_only_adds_overdraw() {
-        let mut compared = 0;
-        let mut overdraw = 0;
-        let mut clamped = 0;
-        for seed in [0x9e37_79b9, 7, 0xdead_beef, 0x2545_f491] {
-            for (spread, count, radius) in [(6, 900, 6), (12, 2600, 12)] {
-                let mut o = Occlusion::new(0, 24);
-                random_world(&mut o, seed, count, spread);
-                let camera = at((0, 2, 0)) + DVec3::new(3.3, -5.7, 1.9);
-                o.settle(camera, radius);
-                let graph = o.graph.as_ref().expect("searched");
-                clamped += usize::from(graph.height < o.columns.sections + 2);
-                let full = reference(&o.columns, camera, radius, true);
-                let from = o.columns.section_of(camera);
-                let side = 2 * radius + 1;
-                let height = o.columns.sections + 2;
-                let full_contains = |key: SectionKey| {
-                    let (dx, dz, dy) = (key.0 - from.0, key.2 - from.2, key.1 + 1);
-                    if dx.abs() > radius || dz.abs() > radius || !(0..height).contains(&dy) {
-                        return false;
-                    }
-                    full[(((dz + radius) * side + dx + radius) * height + dy) as usize]
-                };
-                for x in from.0 - radius..=from.0 + radius {
-                    for z in from.2 - radius..=from.2 + radius {
-                        for y in -1..=o.columns.sections {
-                            let key = (x, y, z);
-                            let expected = full_contains(key);
-                            let actual = o.contains(key);
-                            compared += 1;
-                            assert!(
-                                !expected || actual,
-                                "clamped search hid {key:?} for seed {seed:#x}, spread {spread}, radius {radius}; from={from:?}, y0={}, height={}, expected={expected}, actual={actual}",
-                                graph.y0,
-                                graph.height
-                            );
-                            overdraw += usize::from(actual && !expected);
-                            if actual && !expected {
-                                assert!(
-                                    y >= graph.y0 + graph.height,
-                                    "overdraw must be above the clamped box: {key:?}, y0={}, height={}",
-                                    graph.y0,
-                                    graph.height
-                                );
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        assert!(clamped > 0, "the comparison exercised a clamped search");
-        assert!(compared > 50_000, "compared {compared} sections");
-        assert!(overdraw > 0, "the conservative top-cell rule was exercised");
-    }
-
     /// A line checked again from the sample it failed at, after more
     /// sections were reached, ends where checking it from its corner does.
     #[test]
@@ -1329,26 +1226,4 @@ mod tests {
             assert_eq!(graph.entered, local.entered);
         }
     }
-
-    #[test]
-    fn vertical_clamping_bounds_height_and_reaches_open_sky() {
-        let mut o = Occlusion::new(0, 24);
-        o.set((0, 5, 0), 0); // Wall at section 5
-        o.settle(at((0, 2, 0)), 4);
-        let graph = o.graph.as_ref().expect("searched");
-        assert_eq!(graph.height, 5 + 3);
-        assert!(o.contains((0, 2, 0)), "camera section is reached");
-        assert!(o.contains((1, 20, 1)), "open air column is reached");
-
-        // An enclosed cave cannot reach the sky
-        let mut cave = Occlusion::new(0, 24);
-        for (dx, dy, dz) in STEPS {
-            cave.set((dx, 1 + dy, dz), 0);
-        }
-        cave.settle(at((0, 1, 0)), 4);
-        assert!(
-            !cave.contains((0, 10, 0)),
-            "enclosed cave does not see the sky"
-        );
-    }
 }

crates/horizon-client-render/src/gfx/oit_features.rs

@@ -176,7 +176,7 @@ impl Features {
                 &entity_module,
                 entities,
                 &entity_buffers,
-                kind("text", "entity", Some(wgpu::Face::Back), offset),
+                kind("text", "entity", None, offset),
             ),
             crumbling: set(
                 &entity_module,
@@ -188,12 +188,7 @@ impl Features {
                 &entity_module,
                 entities,
                 &entity_buffers,
-                kind(
-                    "entity shadows",
-                    "shadow",
-                    Some(wgpu::Face::Back),
-                    shadow_bias,
-                ),
+                kind("entity shadows", "shadow", None, shadow_bias),
             ),
             swirl: set(
                 &entity_module,

crates/horizon-client-render/src/gfx/pack_atlas.rs

@@ -113,16 +113,6 @@ impl PackAtlas {
     }
 }
 
-/// A `TerrainVertex` of flat draws' arena page (`hz_vertices`, six words each) into the vertex
-/// inputs, for vertex `hz_vertex_index`.
-pub const PULL: &str = "        uint hz_pw = hz_vertex_index * 6u;\n        \
-    hz_v_pos = uintBitsToFloat(uvec3(hz_vertices[hz_pw], hz_vertices[hz_pw + 1u], hz_vertices[hz_pw + 2u]));\n        \
-    hz_v_uv = uvec2(hz_vertices[hz_pw + 3u] & 65535u, hz_vertices[hz_pw + 3u] >> 16u);\n        \
-    hz_v_layer = hz_vertices[hz_pw + 4u] & 65535u;\n        \
-    uint hz_pl = hz_vertices[hz_pw + 4u] >> 16u;\n        \
-    hz_v_light = uvec2(hz_pl & 255u, hz_pl >> 8u);\n        \
-    hz_v_color = unpackUnorm4x8(hz_vertices[hz_pw + 5u]);\n";
-
 /// GLSL: the face normal and tangent of a flat-drawn vertex, from its quad's first three corners
 /// (quads are four consecutive vertices of the page; position words 0-2, UV word 3).
 const FACE: &str = "    uint hz_q = (uint(gl_VertexIndex) & ~3u) * 6u;\n    \
@@ -204,15 +194,8 @@ impl PackAtlas {
         } else {
             "vec4(-1.0, -1.0, 0.0, 0.0)"
         };
-        // The block a face belongs to: half a block behind its centre (the quad's diagonal).
-        let mid_block = if flat {
-            "vec4((floor((hz_p0 + hz_p2) * 0.5 - 0.5 * hz_Normal) + 0.5 - hz_v_pos) * 64.0, 0.0)"
-        } else {
-            "vec4(0.0)"
-        };
         let attributes = [
             ("mc_Entity", entity),
-            ("at_midBlock", mid_block),
             (
                 "mc_midTexCoord",
                 "vec4((hz_cell + 0.5) * hz_scale, 0.0, 1.0)",

crates/horizon-client-render/src/gfx/pack_draw.rs

@@ -73,8 +73,6 @@ impl DrawUniforms {
         let mut contents = vec![0u8; stride as usize * RENDER_STAGES.len()];
         for (i, slot) in contents.chunks_mut(stride as usize).enumerate() {
             slot[..4].copy_from_slice(&(i as i32).to_le_bytes());
-            // `blockEntityId` outside block entities, as Iris has it.
-            slot[8..12].copy_from_slice(&(-1i32).to_le_bytes());
         }
         let buffer = wgpu::util::DeviceExt::create_buffer_init(
             device,

crates/horizon-client-render/src/gfx/pack_entities.rs

@@ -106,7 +106,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
 
 /// What `gbuffers_clouds` reads from the clouds' mesh (entity vertices, `vs_cloud`): the
 /// position moved by the clouds' offset, the colour of the face's shade from their palette,
-/// full light, the face's normal. Set 1 holds the clouds' uniform (`clouds::Uniform`).
+/// full sky light. Set 1 holds the clouds' uniform (`clouds::Uniform`).
 pub fn cloud_inputs() -> horizon_shaders::GbuffersInputs {
     let declarations = "layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in vec2 hz_v_uv;\n\
          layout(location = 2) in uint hz_v_overlay;\nlayout(location = 3) in vec4 hz_v_color;\n\
@@ -115,7 +115,7 @@ pub fn cloud_inputs() -> horizon_shaders::GbuffersInputs {
         .to_owned();
     let body = "    hz_Vertex = vec4(hz_v_pos + hz_cloud_offset.xyz, 1.0);\n    \
          hz_MultiTexCoord0 = vec4(hz_v_uv, 0.0, 1.0);\n    \
-         hz_MultiTexCoord1 = vec4(240.0, 240.0, 0.0, 1.0);\n    \
+         hz_MultiTexCoord1 = vec4(0.0, 240.0, 0.0, 1.0);\n    \
          hz_MultiTexCoord2 = hz_MultiTexCoord1;\n    \
          hz_Color = hz_cloud_colors[min(hz_v_light.x, 3u)];\n    \
          hz_Normal = dot(hz_v_normal.xyz, hz_v_normal.xyz) > 0.01 ? normalize(hz_v_normal.xyz) : vec3(0.0, 1.0, 0.0);\n"
@@ -123,7 +123,7 @@ pub fn cloud_inputs() -> horizon_shaders::GbuffersInputs {
     let attributes = [
         ("vaPosition", "hz_Vertex.xyz"),
         ("vaUV0", "hz_v_uv"),
-        ("vaUV2", "ivec2(240, 240)"),
+        ("vaUV2", "ivec2(0, 240)"),
         ("vaColor", "hz_Color"),
         ("vaNormal", "hz_Normal"),
     ];
@@ -349,8 +349,10 @@ impl PackEntities {
             bytes[0..4].copy_from_slice(&(span.stage as i32).to_le_bytes());
             bytes[4..8].copy_from_slice(&entity_id.to_le_bytes());
             bytes[8..12].copy_from_slice(&block_id.to_le_bytes());
-            // The overlay: the layer's low 16 bits (HDR output's tier rides in the high ones).
-            for (i, c) in entity_color(run[0].layer & 0xffff).iter().enumerate() {
+            for (i, c) in entity_color(run[0].layer & !super::entity_batch::OIT_ENTITY)
+                .iter()
+                .enumerate()
+            {
                 bytes[16 + 4 * i..20 + 4 * i].copy_from_slice(&c.to_le_bytes());
             }
             self.uniforms.extend_from_slice(&bytes);
@@ -409,9 +411,12 @@ pub(super) fn quad_indices(device: &wgpu::Device, quads: u32) -> wgpu::Buffer {
 /// celestial body, cloud, beam, End portal, crack or energy swirl (overlay codes Horizon's entity
 /// shader draws in its own way; entity.wgsl).
 fn plain(run: &[Vertex]) -> bool {
-    run.iter()
-        .step_by(4)
-        .all(|v| !matches!(v.layer & 0xffff, 2 | 4 | 6 | 9 | 10 | 11 | 12 | 34))
+    run.iter().step_by(4).all(|v| {
+        !matches!(
+            v.layer & !super::entity_batch::OIT_ENTITY,
+            2 | 4 | 6 | 9 | 10 | 11 | 12 | 34
+        )
+    })
 }
 
 /// The programs of entity runs, in the order they draw.

crates/horizon-client-render/src/gfx/pack_hand.rs

@@ -27,11 +27,12 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
     inputs
 }
 
-/// The hand's projection in GL's conventions: `hud_fov` degrees, depth scaled by
-/// `MC_HAND_DEPTH` (the view bob is in `gbufferModelView`).
-pub fn projection(hud_fov: f32, aspect: f32, far: f32) -> Mat4 {
+/// The hand's projection in GL's conventions: `hud_fov` degrees, the view bob, depth scaled by
+/// `MC_HAND_DEPTH`.
+pub fn projection(hud_fov: f32, aspect: f32, far: f32, bob: Mat4) -> Mat4 {
     Mat4::from_scale(glam::Vec3::new(1.0, 1.0, HAND_DEPTH))
         * Mat4::perspective_rh_gl(hud_fov.to_radians(), aspect, 0.05, far)
+        * bob
 }
 
 /// The hand's vertices (also read at set 1 for normals and tangents), its uniform and quad
@@ -152,7 +153,7 @@ mod tests {
     /// apart by it), and x, y match the plain projection.
     #[test]
     fn hand_depth_is_scaled_around_the_middle() {
-        let p = projection(70.0, 16.0 / 9.0, 512.0);
+        let p = projection(70.0, 16.0 / 9.0, 512.0, Mat4::IDENTITY);
         let plain = Mat4::perspective_rh_gl(70f32.to_radians(), 16.0 / 9.0, 0.05, 512.0);
         for z in [-0.06f32, -0.5, -3.0, -400.0] {
             let v = glam::Vec4::new(0.1, -0.2, z, 1.0);

crates/horizon-client-render/src/gfx/pack_images.rs

@@ -1,460 +0,0 @@
-//! A shader pack's own images (`image.<name>`) and storage buffers (`bufferObject.<n>`) on the
-//! GPU: created at the render size they depend on, kept across frames, images cleared before a
-//! frame when the pack asks.
-
-use std::collections::BTreeMap;
-
-use horizon_shaders::{BufferObject, CustomImage, Format, Kind};
-
-pub(super) struct PackImage {
-    pub(super) def: CustomImage,
-    pub(super) format: wgpu::TextureFormat,
-    pub(super) dimension: wgpu::TextureViewDimension,
-    pub(super) view: Option<wgpu::TextureView>,
-    /// Last frame's contents, for a pass that samples and stores the image (`copied`).
-    pub(super) copy: Option<wgpu::TextureView>,
-    pub(super) copied: bool,
-    /// The contents before a compute pass that reads them so (`snapshot`), apart from `copy`,
-    /// which a later pass may still sample.
-    pub(super) before: Option<wgpu::TextureView>,
-    pub(super) snapshotted: bool,
-    /// The render size the image was made for (relative images follow it).
-    made_for: [u32; 2],
-}
-
-impl PackImage {
-    pub(super) fn sample_type(&self, features: wgpu::Features) -> wgpu::TextureSampleType {
-        self.format
-            .sample_type(None, Some(features))
-            .unwrap_or(wgpu::TextureSampleType::Float { filterable: false })
-    }
-}
-
-/// The images `image.*` declares.
-pub(super) fn images(defs: Vec<CustomImage>) -> Vec<PackImage> {
-    defs.into_iter()
-        .map(|def| PackImage {
-            format: format(def.format),
-            dimension: if def.is_3d() {
-                wgpu::TextureViewDimension::D3
-            } else {
-                wgpu::TextureViewDimension::D2
-            },
-            def,
-            view: None,
-            copy: None,
-            copied: false,
-            before: None,
-            snapshotted: false,
-            made_for: [0; 2],
-        })
-        .collect()
-}
-
-/// The wgpu format of an image's internal format: a storage format of the same channels.
-pub(super) fn format(f: Format) -> wgpu::TextureFormat {
-    use wgpu::TextureFormat as T;
-    let pick = |r, rg, rgba| match f.channels {
-        1 => r,
-        2 => rg,
-        _ => rgba,
-    };
-    match (f.kind, f.bits) {
-        (Kind::Int, 8) => pick(T::R8Sint, T::Rg8Sint, T::Rgba8Sint),
-        (Kind::Int, 16) => pick(T::R16Sint, T::Rg16Sint, T::Rgba16Sint),
-        (Kind::Int, _) => pick(T::R32Sint, T::Rg32Sint, T::Rgba32Sint),
-        (Kind::Uint, 8) => pick(T::R8Uint, T::Rg8Uint, T::Rgba8Uint),
-        (Kind::Uint, 16) => pick(T::R16Uint, T::Rg16Uint, T::Rgba16Uint),
-        (Kind::Uint, _) => pick(T::R32Uint, T::Rg32Uint, T::Rgba32Uint),
-        (Kind::Float, 32) => pick(T::R32Float, T::Rg32Float, T::Rgba32Float),
-        (Kind::Float, _) => pick(T::R16Float, T::Rg16Float, T::Rgba16Float),
-        (Kind::Snorm, _) => pick(T::R8Snorm, T::Rg8Snorm, T::Rgba8Snorm),
-        (Kind::Unorm, 16) => pick(T::R16Unorm, T::Rg16Unorm, T::Rgba16Unorm),
-        (Kind::Unorm, _) => pick(T::R8Unorm, T::Rg8Unorm, T::Rgba8Unorm),
-    }
-}
-
-/// Whether this device can make `def`: its format's features, and a size in pixels within the
-/// device's limits.
-pub(super) fn makeable(device: &wgpu::Device, def: &CustomImage) -> Result<(), String> {
-    let format = format(def.format);
-    let missing = format.required_features() - device.features();
-    if !missing.is_empty() {
-        return Err(format!(
-            "{format:?} needs {missing:?}, which this GPU lacks"
-        ));
-    }
-    let limits = device.limits();
-    let largest = if def.is_3d() {
-        limits.max_texture_dimension_3d
-    } else {
-        limits.max_texture_dimension_2d
-    };
-    let [width, height, depth] = def.extent([1, 1]);
-    let relative = matches!(def.size, horizon_shaders::ImageSize::Relative(_));
-    if !relative && width.max(height).max(depth) > largest {
-        return Err(format!(
-            "{width}x{height}x{depth} is larger than this GPU's {largest}"
-        ));
-    }
-    Ok(())
-}
-
-/// Makes the images that are missing or sized for another render size; whether it made any.
-pub(super) fn resize_images(
-    device: &wgpu::Device,
-    images: &mut [PackImage],
-    size: [u32; 2],
-) -> bool {
-    let largest = device.limits().max_texture_dimension_2d;
-    let mut made = false;
-    for image in images {
-        let relative = matches!(image.def.size, horizon_shaders::ImageSize::Relative(_));
-        if image.view.is_some() && (!relative || image.made_for == size) {
-            continue;
-        }
-        made = true;
-        // A relative image larger than the render size stops at the device's limit.
-        let [width, height, depth] = image.def.extent(size);
-        let [width, height] = [width.min(largest), height.min(largest)];
-        let make = |usage| {
-            device
-                .create_texture(&wgpu::TextureDescriptor {
-                    label: Some(&image.def.name),
-                    size: wgpu::Extent3d {
-                        width,
-                        height,
-                        depth_or_array_layers: depth,
-                    },
-                    mip_level_count: 1,
-                    sample_count: 1,
-                    dimension: if image.dimension == wgpu::TextureViewDimension::D3 {
-                        wgpu::TextureDimension::D3
-                    } else {
-                        wgpu::TextureDimension::D2
-                    },
-                    format: image.format,
-                    usage: wgpu::TextureUsages::TEXTURE_BINDING | usage,
-                    view_formats: &[],
-                })
-                .create_view(&Default::default())
-        };
-        // Atomics on a texture need it made for them (Metal ignores them otherwise).
-        let atomic = device.features().contains(wgpu::Features::TEXTURE_ATOMIC)
-            && matches!(
-                image.format,
-                wgpu::TextureFormat::R32Sint | wgpu::TextureFormat::R32Uint
-            );
-        let atomic = if atomic {
-            wgpu::TextureUsages::STORAGE_ATOMIC
-        } else {
-            wgpu::TextureUsages::empty()
-        };
-        image.view = Some(make(
-            wgpu::TextureUsages::STORAGE_BINDING
-                | wgpu::TextureUsages::COPY_DST
-                | wgpu::TextureUsages::COPY_SRC
-                | atomic,
-        ));
-        image.copy = image
-            .copied
-            .then(|| make(wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::STORAGE_BINDING));
-        image.before = image
-            .snapshotted
-            .then(|| make(wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::STORAGE_BINDING));
-        image.made_for = size;
-    }
-    made
-}
-
-/// The most images a pack may have.
-pub(super) const IMAGES: usize = 64;
-
-/// Copies `image` as it is before a compute pass whose loads read it so.
-pub(super) fn snapshot(encoder: &mut wgpu::CommandEncoder, image: &PackImage) {
-    if let (Some(view), Some(before)) = (&image.view, &image.before) {
-        encoder.copy_texture_to_texture(
-            view.texture().as_image_copy(),
-            before.texture().as_image_copy(),
-            view.texture().size(),
-        );
-    }
-}
-
-/// Copies the images of `mask` (bit n: image n), which a pass samples and stores, for that pass
-/// to sample.
-pub(super) fn copy(encoder: &mut wgpu::CommandEncoder, images: &[PackImage], mask: u64) {
-    for (_, image) in images
-        .iter()
-        .enumerate()
-        .filter(|(k, _)| mask & 1 << k != 0)
-    {
-        if let (Some(view), Some(copy)) = (&image.view, &image.copy) {
-            encoder.copy_texture_to_texture(
-                view.texture().as_image_copy(),
-                copy.texture().as_image_copy(),
-                view.texture().size(),
-            );
-        }
-    }
-}
-
-/// Clears the images the pack clears before each frame: with `clear_texture` where the device
-/// has it (`clear`), else by copying from `zeros`, a buffer of zeros made large enough.
-pub(super) fn clear(
-    device: &wgpu::Device,
-    encoder: &mut wgpu::CommandEncoder,
-    images: &[PackImage],
-    clear: bool,
-    zeros: &mut Option<wgpu::Buffer>,
-) {
-    for view in images
-        .iter()
-        .filter(|i| i.def.clear)
-        .filter_map(|i| i.view.as_ref())
-    {
-        let texture = view.texture();
-        if clear {
-            encoder.clear_texture(texture, &Default::default());
-            continue;
-        }
-        let size = texture.size();
-        let texel = u64::from(texture.format().block_copy_size(None).unwrap_or(4));
-        let row = (u64::from(size.width) * texel).next_multiple_of(256);
-        // Zeros for a slice of rows at a time, the whole image taken in slices, so a large
-        // volume doesn't need a buffer of its size.
-        let rows = (ZEROS / row).clamp(1, u64::from(size.height)) as u32;
-        let bytes = row * u64::from(rows);
-        if zeros.as_ref().is_none_or(|z| z.size() < bytes) {
-            // New buffers start zeroed.
-            *zeros = Some(device.create_buffer(&wgpu::BufferDescriptor {
-                label: Some("Shader pack image zeros"),
-                size: bytes,
-                usage: wgpu::BufferUsages::COPY_SRC,
-                mapped_at_creation: false,
-            }));
-        }
-        let Some(buffer) = zeros.as_ref() else {
-            continue;
-        };
-        for z in 0..size.depth_or_array_layers {
-            for y in (0..size.height).step_by(rows as usize) {
-                let height = rows.min(size.height - y);
-                encoder.copy_buffer_to_texture(
-                    wgpu::TexelCopyBufferInfo {
-                        buffer,
-                        layout: wgpu::TexelCopyBufferLayout {
-                            offset: 0,
-                            bytes_per_row: Some(row as u32),
-                            rows_per_image: Some(height),
-                        },
-                    },
-                    wgpu::TexelCopyTextureInfo {
-                        texture,
-                        mip_level: 0,
-                        origin: wgpu::Origin3d { x: 0, y, z },
-                        aspect: wgpu::TextureAspect::All,
-                    },
-                    wgpu::Extent3d {
-                        width: size.width,
-                        height,
-                        depth_or_array_layers: 1,
-                    },
-                );
-            }
-        }
-    }
-}
-
-/// The most bytes of zeros kept to clear images without `CLEAR_TEXTURE`.
-const ZEROS: u64 = 4 << 20;
-
-/// The pack's storage buffers, bound in set 4.
-pub(super) struct Buffers {
-    pub(super) layout: wgpu::BindGroupLayout,
-    objects: BTreeMap<u32, BufferObject>,
-    pub(super) group: Option<wgpu::BindGroup>,
-    buffers: Vec<wgpu::Buffer>,
-    made_for: [u32; 2],
-}
-
-impl Buffers {
-    /// The layout of `objects`, bound in `stages`.
-    pub(super) fn new(
-        device: &wgpu::Device,
-        objects: BTreeMap<u32, BufferObject>,
-        stages: wgpu::ShaderStages,
-    ) -> Self {
-        let entries: Vec<_> = objects
-            .keys()
-            .map(|&binding| wgpu::BindGroupLayoutEntry {
-                binding,
-                visibility: stages,
-                ty: wgpu::BindingType::Buffer {
-                    ty: wgpu::BufferBindingType::Storage { read_only: false },
-                    has_dynamic_offset: false,
-                    min_binding_size: None,
-                },
-                count: None,
-            })
-            .collect();
-        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            label: Some("Shader pack buffers"),
-            entries: &entries,
-        });
-        Self {
-            layout,
-            objects,
-            group: None,
-            buffers: Vec::new(),
-            made_for: [0; 2],
-        }
-    }
-
-    /// Makes the buffers (again, when one depends on the render size and it changed): their
-    /// contents start zeroed and persist across frames.
-    pub(super) fn resize(&mut self, device: &wgpu::Device, size: [u32; 2]) {
-        let relative = self
-            .objects
-            .values()
-            .any(|o| matches!(o, BufferObject::PerPixel { .. }));
-        if self.group.is_some() && (!relative || self.made_for == size) {
-            return;
-        }
-        let limits = device.limits();
-        let largest = limits
-            .max_buffer_size
-            .min(limits.max_storage_buffer_binding_size)
-            & !3;
-        self.buffers = self
-            .objects
-            .iter()
-            .map(|(binding, o)| {
-                let wanted = o.size(size).next_multiple_of(4);
-                if wanted > largest {
-                    log::warn!(
-                        "shader pack: bufferObject.{binding} wants {wanted} bytes, this device \
-                         binds at most {largest}"
-                    );
-                }
-                device.create_buffer(&wgpu::BufferDescriptor {
-                    label: Some("Shader pack buffer"),
-                    size: wanted.min(largest),
-                    usage: wgpu::BufferUsages::STORAGE,
-                    mapped_at_creation: false,
-                })
-            })
-            .collect();
-        let entries: Vec<_> = self
-            .objects
-            .keys()
-            .zip(&self.buffers)
-            .map(|(&binding, b)| wgpu::BindGroupEntry {
-                binding,
-                resource: b.as_entire_binding(),
-            })
-            .collect();
-        self.group = Some(device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Shader pack buffers"),
-            layout: &self.layout,
-            entries: &entries,
-        }));
-        self.made_for = size;
-    }
-
-    /// Whether the pack declares buffer `binding`.
-    pub(super) fn has(&self, binding: u32) -> bool {
-        self.objects.contains_key(&binding)
-    }
-}
-
-/// A debug readback of one of the pack's images (`HORIZON_SHADER_PACK_DUMP=<name>`): every 60
-/// frames, how many of its texels are not zero, logged.
-pub(super) struct Dump {
-    name: String,
-    frame: u32,
-    pending: Option<(wgpu::Buffer, usize, [u32; 3], u32)>,
-}
-
-impl Dump {
-    pub(super) fn new() -> Option<Self> {
-        let name = std::env::var("HORIZON_SHADER_PACK_DUMP").ok()?;
-        Some(Self {
-            name,
-            frame: 0,
-            pending: None,
-        })
-    }
-
-    /// Reads last frame's copy, once its commands ran.
-    pub(super) fn read(&mut self, device: &wgpu::Device) {
-        let Some((buffer, texel, [w, h, d], row)) = self.pending.take() else {
-            return;
-        };
-        buffer.slice(..).map_async(wgpu::MapMode::Read, |_| {});
-        let _ = device.poll(wgpu::PollType::Wait {
-            submission_index: None,
-            timeout: None,
-        });
-        let Ok(data) = buffer.slice(..).get_mapped_range() else {
-            return;
-        };
-        let (mut set, mut total) = (0usize, 0usize);
-        for z in 0..d as usize {
-            for y in 0..h as usize {
-                let start = (z * h as usize + y) * row as usize;
-                for x in 0..w as usize {
-                    let at = start + x * texel;
-                    total += 1;
-                    if data[at..at + texel].iter().any(|&b| b != 0) {
-                        set += 1;
-                    }
-                }
-            }
-        }
-        log::info!(
-            "shader pack image {}: {set} of {total} texels set",
-            self.name
-        );
-    }
-
-    /// Copies the image for `read` every 60 frames.
-    pub(super) fn copy(
-        &mut self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        images: &[PackImage],
-    ) {
-        self.frame += 1;
-        if !self.frame.is_multiple_of(60) {
-            return;
-        }
-        let Some(image) = images.iter().find(|i| i.def.name == self.name) else {
-            return;
-        };
-        let Some(view) = &image.view else { return };
-        let size = view.texture().size();
-        let texel = image.format.block_copy_size(None).unwrap_or(4) as usize;
-        let row = (size.width as usize * texel).next_multiple_of(256) as u32;
-        let buffer = device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("Shader pack image dump"),
-            size: u64::from(row) * u64::from(size.height) * u64::from(size.depth_or_array_layers),
-            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
-            mapped_at_creation: false,
-        });
-        encoder.copy_texture_to_buffer(
-            view.texture().as_image_copy(),
-            wgpu::TexelCopyBufferInfo {
-                buffer: &buffer,
-                layout: wgpu::TexelCopyBufferLayout {
-                    offset: 0,
-                    bytes_per_row: Some(row),
-                    rows_per_image: Some(size.height),
-                },
-            },
-            size,
-        );
-        let dims = [size.width, size.height, size.depth_or_array_layers];
-        self.pending = Some((buffer, texel, dims, row));
-    }
-}

crates/horizon-client-render/src/gfx/pack_sky.rs

@@ -82,9 +82,9 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
          }}\n    \
          hz_Vertex = vec4(hz_p, 1.0);\n    \
          hz_MultiTexCoord0 = vec4(0.0, 0.0, 0.0, 1.0);\n    \
-         hz_MultiTexCoord1 = vec4(240.0, 240.0, 0.0, 1.0);\n    \
+         hz_MultiTexCoord1 = vec4(0.0, 240.0, 0.0, 1.0);\n    \
          hz_MultiTexCoord2 = hz_MultiTexCoord1;\n    \
-         hz_Normal = vec3(0.0, 0.0, 1.0);\n"
+         hz_Normal = vec3(0.0, 1.0, 0.0);\n"
     );
     horizon_shaders::GbuffersInputs {
         declarations,
@@ -109,7 +109,7 @@ pub fn celestial_inputs() -> horizon_shaders::GbuffersInputs {
                 .into(),
         body: "    hz_Vertex = vec4(hz_v_pos, 1.0);\n    \
              hz_MultiTexCoord0 = vec4(hz_v_uv, 0.0, 1.0);\n    \
-             hz_MultiTexCoord1 = vec4(240.0, 240.0, 0.0, 1.0);\n    \
+             hz_MultiTexCoord1 = vec4(0.0, 240.0, 0.0, 1.0);\n    \
              hz_MultiTexCoord2 = hz_MultiTexCoord1;\n    \
              hz_Color = hz_v_color;\n    \
              hz_Normal = vec3(0.0, 0.0, 1.0);\n"

crates/horizon-client-render/src/gfx/pack_textures.rs

@@ -1,339 +0,0 @@
-//! A shader pack's custom textures (`texture.<stage>.<name>`, `texture.noise`) on the GPU, and
-//! which of them a program's sampler reads.
-
-use horizon_shaders::{CustomTexture, Group, Kind, Texels, Texture, TextureDim, TextureSource};
-
-/// What a custom texture is once uploaded: an image of ours, or one the game already has.
-pub(super) enum Image {
-    View(wgpu::TextureView),
-    Lightmap,
-    Atlas,
-}
-
-pub(super) struct PackTexture {
-    pub(super) stage: String,
-    pub(super) name: String,
-    pub(super) dimension: wgpu::TextureViewDimension,
-    pub(super) sample_type: wgpu::TextureSampleType,
-    pub(super) blur: bool,
-    pub(super) clamp: bool,
-    pub(super) image: Image,
-}
-
-/// Uploads `textures`, with a note for each the game can't provide.
-pub(super) fn upload(
-    device: &wgpu::Device,
-    queue: &wgpu::Queue,
-    textures: Vec<CustomTexture>,
-    notes: &mut Vec<String>,
-) -> Vec<PackTexture> {
-    let features = device.features();
-    let mut out = Vec::new();
-    for t in textures {
-        let (image, dimension, sample_type, blur, clamp) = match t.source {
-            TextureSource::Image(texture) => {
-                let (view, sample_type) = match create(device, queue, &texture, features) {
-                    Ok(created) => created,
-                    Err(e) => {
-                        notes.push(format!("texture.{}.{}: {e}", t.stage, t.name));
-                        continue;
-                    }
-                };
-                let dimension = match texture.dim {
-                    TextureDim::D1 => wgpu::TextureViewDimension::D1,
-                    TextureDim::D2 => wgpu::TextureViewDimension::D2,
-                    TextureDim::D3 => wgpu::TextureViewDimension::D3,
-                };
-                (
-                    Image::View(view),
-                    dimension,
-                    sample_type,
-                    texture.blur,
-                    texture.clamp,
-                )
-            }
-            TextureSource::Resource(location) => {
-                let path = location.strip_prefix("minecraft:").unwrap_or(&location);
-                let image = if path.starts_with("dynamic/lightmap") {
-                    Image::Lightmap
-                } else if path.starts_with("textures/atlas/blocks") || path == "dynamic/atlas" {
-                    Image::Atlas
-                } else {
-                    notes.push(format!(
-                        "texture.{}.{}: `{location}` is not provided yet",
-                        t.stage, t.name
-                    ));
-                    continue;
-                };
-                let float = wgpu::TextureSampleType::Float { filterable: true };
-                (image, wgpu::TextureViewDimension::D2, float, true, true)
-            }
-        };
-        out.push(PackTexture {
-            stage: t.stage,
-            name: t.name,
-            dimension,
-            sample_type,
-            blur,
-            clamp,
-            image,
-        });
-    }
-    out
-}
-
-/// The stage name of `texture.<stage>.*` a program of `group` reads.
-fn stage(group: Group) -> &'static str {
-    match group {
-        Group::Gbuffers | Group::Translucent | Group::Shadow => "gbuffers",
-        Group::Prepare => "prepare",
-        Group::Deferred => "deferred",
-        Group::Composite | Group::Final => "composite",
-        Group::ShadowComp => "shadowcomp",
-    }
-}
-
-/// The custom texture a `ty name` sampler of a `group` program reads: same stage, the same
-/// name (or another name of the same buffer, `gaux1` for `colortex4`) and dimension. A unit
-/// may hold one texture per dimension.
-pub(super) fn find(textures: &[PackTexture], group: Group, ty: &str, name: &str) -> Option<usize> {
-    let dimension = if ty.contains("1D") {
-        wgpu::TextureViewDimension::D1
-    } else if ty.contains("3D") {
-        wgpu::TextureViewDimension::D3
-    } else {
-        wgpu::TextureViewDimension::D2
-    };
-    let buffer = horizon_shaders::buffer_index(name);
-    textures.iter().position(|t| {
-        t.stage == stage(group)
-            && t.dimension == dimension
-            && (t.name == name
-                || buffer.is_some() && horizon_shaders::buffer_index(&t.name) == buffer)
-    })
-}
-
-/// `texture.noise`, if the pack has one.
-pub(super) fn noise(textures: &[PackTexture]) -> Option<&wgpu::TextureView> {
-    textures
-        .iter()
-        .find(|t| t.stage == "noise" && t.dimension == wgpu::TextureViewDimension::D2)
-        .and_then(|t| match &t.image {
-            Image::View(v) => Some(v),
-            _ => None,
-        })
-}
-
-/// The wgpu format a texture of `texture.format` is stored in: sampled, never rendered to, so
-/// any format whose texels hold the values.
-fn format(texture: &Texture) -> wgpu::TextureFormat {
-    use wgpu::TextureFormat as T;
-    let f = texture.format;
-    let pick = |r, rg, rgba| match texture.components() {
-        1 => r,
-        2 => rg,
-        _ => rgba,
-    };
-    match (f.kind, f.bits) {
-        (Kind::Unorm, b) if b <= 8 => pick(T::R8Unorm, T::Rg8Unorm, T::Rgba8Unorm),
-        (Kind::Snorm, 8) => pick(T::R8Snorm, T::Rg8Snorm, T::Rgba8Snorm),
-        (Kind::Float, 32) => pick(T::R32Float, T::Rg32Float, T::Rgba32Float),
-        (Kind::Int, 8) => pick(T::R8Sint, T::Rg8Sint, T::Rgba8Sint),
-        (Kind::Int, 16) => pick(T::R16Sint, T::Rg16Sint, T::Rgba16Sint),
-        (Kind::Int, _) => pick(T::R32Sint, T::Rg32Sint, T::Rgba32Sint),
-        (Kind::Uint, 8) => pick(T::R8Uint, T::Rg8Uint, T::Rgba8Uint),
-        (Kind::Uint, 16) => pick(T::R16Uint, T::Rg16Uint, T::Rgba16Uint),
-        (Kind::Uint, _) => pick(T::R32Uint, T::Rg32Uint, T::Rgba32Uint),
-        // 16-bit and packed normalized formats, half floats and the small floats: halves hold
-        // them closely enough.
-        _ => pick(T::R16Float, T::Rg16Float, T::Rgba16Float),
-    }
-}
-
-/// `texture`'s texels as the bytes of `format`, row after row.
-fn bytes(texture: &Texture, format: wgpu::TextureFormat) -> Vec<u8> {
-    match (&texture.texels, format) {
-        (Texels::Float(v), f) if f.block_copy_size(None) == Some(texture.components() as u32) => {
-            if matches!(
-                f,
-                wgpu::TextureFormat::R8Snorm
-                    | wgpu::TextureFormat::Rg8Snorm
-                    | wgpu::TextureFormat::Rgba8Snorm
-            ) {
-                v.iter()
-                    .map(|x| (x.clamp(-1.0, 1.0) * 127.0).round() as i8 as u8)
-                    .collect()
-            } else {
-                v.iter()
-                    .map(|x| (x.clamp(0.0, 1.0) * 255.0).round() as u8)
-                    .collect()
-            }
-        }
-        (Texels::Float(v), f)
-            if f.block_copy_size(None) == Some(4 * texture.components() as u32) =>
-        {
-            v.iter().flat_map(|x| x.to_le_bytes()).collect()
-        }
-        (Texels::Float(v), _) => v
-            .iter()
-            .flat_map(|&x| half::f16::from_f32(x).to_le_bytes())
-            .collect(),
-        (Texels::Int(v), f) => {
-            let width = f.block_copy_size(None).unwrap_or(4) as usize / texture.components();
-            v.iter()
-                .flat_map(|x| x.to_le_bytes().into_iter().take(width))
-                .collect()
-        }
-        (Texels::Uint(v), f) => {
-            let width = f.block_copy_size(None).unwrap_or(4) as usize / texture.components();
-            v.iter()
-                .flat_map(|x| x.to_le_bytes().into_iter().take(width))
-                .collect()
-        }
-    }
-}
-
-fn create(
-    device: &wgpu::Device,
-    queue: &wgpu::Queue,
-    texture: &Texture,
-    features: wgpu::Features,
-) -> Result<(wgpu::TextureView, wgpu::TextureSampleType), String> {
-    let format = format(texture);
-    let bytes = bytes(texture, format);
-    let [width, height, depth] = texture.size;
-    let limits = device.limits();
-    let largest = match texture.dim {
-        TextureDim::D1 => limits.max_texture_dimension_1d,
-        TextureDim::D2 => limits.max_texture_dimension_2d,
-        TextureDim::D3 => limits.max_texture_dimension_3d,
-    };
-    if [width, height, depth].iter().any(|&n| n > largest) {
-        return Err(format!(
-            "{width}x{height}x{depth} is larger than this device's {largest}"
-        ));
-    }
-    let row = width * format.block_copy_size(None).unwrap_or(4);
-    if bytes.len() as u64 != u64::from(row) * u64::from(height) * u64::from(depth) {
-        return Err(format!(
-            "{} bytes of texels for {width}x{height}x{depth}",
-            bytes.len()
-        ));
-    }
-    let size = wgpu::Extent3d {
-        width,
-        height,
-        depth_or_array_layers: depth,
-    };
-    let dimension = match texture.dim {
-        TextureDim::D1 => wgpu::TextureDimension::D1,
-        TextureDim::D2 => wgpu::TextureDimension::D2,
-        TextureDim::D3 => wgpu::TextureDimension::D3,
-    };
-    let tex = device.create_texture(&wgpu::TextureDescriptor {
-        label: Some("Shader pack custom texture"),
-        size,
-        mip_level_count: 1,
-        sample_count: 1,
-        dimension,
-        format,
-        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-        view_formats: &[],
-    });
-    queue.write_texture(
-        tex.as_image_copy(),
-        &bytes,
-        wgpu::TexelCopyBufferLayout {
-            offset: 0,
-            bytes_per_row: Some(row),
-            rows_per_image: Some(height),
-        },
-        size,
-    );
-    let sample_type = format
-        .sample_type(None, Some(features))
-        .unwrap_or(wgpu::TextureSampleType::Float { filterable: false });
-    Ok((tex.create_view(&Default::default()), sample_type))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use horizon_shaders::Format;
-
-    fn lightmap(stage: &str, name: &str, dimension: wgpu::TextureViewDimension) -> PackTexture {
-        PackTexture {
-            stage: stage.into(),
-            name: name.into(),
-            dimension,
-            sample_type: wgpu::TextureSampleType::Float { filterable: true },
-            blur: false,
-            clamp: false,
-            image: Image::Lightmap,
-        }
-    }
-
-    fn texture(format: &str, texels: Texels) -> Texture {
-        Texture {
-            dim: TextureDim::D2,
-            size: [1, 1, 1],
-            format: Format::parse(format).unwrap(),
-            texels,
-            blur: false,
-            clamp: false,
-        }
-    }
-
-    #[test]
-    fn samplers_find_their_stage_name_and_dimension() {
-        use wgpu::TextureViewDimension as D;
-        let textures = [
-            lightmap("composite", "colortex4", D::D2),
-            lightmap("composite", "noisetex", D::D3),
-            lightmap("gbuffers", "gaux2", D::D2),
-            lightmap("composite", "noisetex", D::D1),
-        ];
-        assert_eq!(find(&textures, Group::Final, "sampler2D", "gaux1"), Some(0));
-        assert_eq!(
-            find(&textures, Group::Composite, "sampler3D", "noisetex"),
-            Some(1)
-        );
-        assert_eq!(
-            find(&textures, Group::Composite, "sampler1D", "noisetex"),
-            Some(3)
-        );
-        assert_eq!(
-            find(&textures, Group::Composite, "sampler2D", "noisetex"),
-            None
-        );
-        assert_eq!(
-            find(&textures, Group::Shadow, "sampler2D", "colortex5"),
-            Some(2)
-        );
-        assert_eq!(
-            find(&textures, Group::Deferred, "sampler2D", "colortex4"),
-            None
-        );
-    }
-
-    #[test]
-    fn texels_pack_into_their_format() {
-        let t = texture("RGBA8", Texels::Float(vec![0.0, 0.5, 1.0, 2.0]));
-        assert_eq!(format(&t), wgpu::TextureFormat::Rgba8Unorm);
-        assert_eq!(bytes(&t, format(&t)), [0, 128, 255, 255]);
-        let t = texture("RG8_SNORM", Texels::Float(vec![-1.0, 0.5]));
-        assert_eq!(format(&t), wgpu::TextureFormat::Rg8Snorm);
-        assert_eq!(bytes(&t, format(&t)), [0x81, 64]);
-        let t = texture("R32F", Texels::Float(vec![1.0]));
-        assert_eq!(bytes(&t, format(&t)), 1.0f32.to_le_bytes());
-        let t = texture("R16F", Texels::Float(vec![1.0]));
-        assert_eq!(format(&t), wgpu::TextureFormat::R16Float);
-        assert_eq!(bytes(&t, format(&t)), [0x00, 0x3c]);
-        let t = texture("RG16I", Texels::Int(vec![-2, 3]));
-        assert_eq!(format(&t), wgpu::TextureFormat::Rg16Sint);
-        assert_eq!(bytes(&t, format(&t)), [0xfe, 0xff, 3, 0]);
-        let t = texture("R8UI", Texels::Uint(vec![7]));
-        assert_eq!(format(&t), wgpu::TextureFormat::R8Uint);
-        assert_eq!(bytes(&t, format(&t)), [7]);
-    }
-}

crates/horizon-client-render/src/gfx/pack_uniforms.rs

@@ -30,8 +30,6 @@ pub struct PackInputs {
     pub biome_precipitation: i32,
     pub temperature: f32,
     pub rainfall: f32,
-    /// Whether the biome at the camera is known (its chunk is loaded).
-    pub biome_known: bool,
     /// `heldItemId`, `heldItemId2` (item.properties, 5.3) and `heldBlockLightValue(2)`.
     pub held_items: [i32; 2],
     pub held_light: [i32; 2],
@@ -162,15 +160,6 @@ pub const NAMES: &[&str] = &[
     "shadowModelViewInverse",
     "shadowProjection",
     "shadowProjectionInverse",
-    "cameraPositionInt",
-    "cameraPositionFract",
-    "previousCameraPositionInt",
-    "previousCameraPositionFract",
-    "eyePosition",
-    "relativeEyePosition",
-    "playerLookVector",
-    "playerBodyVector",
-    "firstPersonCamera",
 ];
 
 /// Values carried from frame to frame.
@@ -181,7 +170,7 @@ pub struct FrameUniforms {
     start: std::time::Instant,
     last: Option<std::time::Instant>,
     frame: u32,
-    previous: Option<(glam::DVec3, Mat4, Mat4)>,
+    previous: Option<(Vec3, Mat4, Mat4)>,
     wetness: f32,
     eye_smooth: [f32; 2],
     /// The pack's shadow settings (7.1).
@@ -214,9 +203,9 @@ fn body(angle: f32, tilt: f32) -> Vec3 {
 }
 
 /// `sunPathRotation`'s turn of the sky's bodies: `tilt` degrees about the world's X axis, so a
-/// positive angle moves the noon sun toward -Z (north), as Iris does.
+/// positive angle moves the noon sun toward +Z (south).
 pub fn tilt_matrix(tilt: f32) -> Mat4 {
-    Mat4::from_rotation_x(-tilt.to_radians())
+    Mat4::from_rotation_x(tilt.to_radians())
 }
 
 /// The world direction of the shadow light (7.1): the sun by day, the moon by night.
@@ -243,39 +232,38 @@ pub fn shadow_culling(frame: &Frame, shadow: &Shadow) -> Mat4 {
     depth * gl * view
 }
 
-/// How far toward the light the shadow projection starts, in blocks: part of the projection,
-/// not of `shadowModelView` (Iris's matrices, measured).
-const SHADOW_EYE: f32 = 100.0;
+/// Distance from the snapped point to the shadow camera, toward the light: the middle of the
+/// default near and far planes (OQ-6).
+const SHADOW_EYE: f64 = 128.0;
 
-/// The shadow camera as Iris places it (7.1; measured from the outside): its view (player
-/// space to shadow view space) and GL projection. The view undoes `sunPathRotation`, turns the
-/// light's path about Z by the light's angle from the zenith, then X by 90 degrees, so the
-/// light lies on the view's +Z. Its origin is `shadowIntervalSize / 2 - camera % interval`
-/// (the remainder takes the camera's sign) from the player on each world axis, so the map moves
-/// in whole steps. The orthographic projection covers `shadowDistance` each side and depths
-/// from `-near` to `far`, counted from `SHADOW_EYE` blocks toward the light; or perspective
-/// with `shadowMapFov`.
+/// The shadow camera (7.1; OQ-6, impl-plan.md): its view (player space to shadow view space)
+/// and GL projection. The camera looks from the light, world +Z up (+Y when the light is near
+/// Z); the point it centres moves in steps of `shadowIntervalSize` along the shadow view's
+/// own axes, and it sits `SHADOW_EYE` blocks toward the light from it. Orthographic over
+/// `shadowDistance` each side, or perspective with `shadowMapFov`.
 pub fn shadow_camera(light: Vec3, camera: DVec3, shadow: &Shadow) -> (Mat4, Mat4) {
-    let tilt = f64::from(shadow.sun_path_rotation).to_radians();
-    let untilted = DMat4::from_rotation_x(tilt).transform_vector3(light.as_dvec3());
-    let zenith = untilted.x.atan2(untilted.y);
-    let rotation = DMat4::from_rotation_x(std::f64::consts::FRAC_PI_2)
-        * DMat4::from_rotation_z(zenith)
-        * DMat4::from_rotation_x(tilt);
-    let step = f64::from(shadow.interval);
-    let origin = if step > 0.0 {
-        DVec3::splat(step / 2.0) - camera % step
+    let light = light.as_dvec3();
+    let up = if light.z.abs() > 0.99 {
+        DVec3::Y
     } else {
-        DVec3::ZERO
+        DVec3::Z
     };
-    let view = (rotation * DMat4::from_translation(-origin)).as_mat4();
+    let rotation = DMat4::look_to_rh(DVec3::ZERO, -light, up);
+    let at = rotation.transform_vector3(camera);
+    let step = f64::from(shadow.interval);
+    let snapped = if step > 0.0 {
+        (at / step).floor() * step
+    } else {
+        at
+    };
+    let offset = at - snapped - DVec3::new(0.0, 0.0, SHADOW_EYE);
+    let view = (DMat4::from_translation(offset) * rotation).as_mat4();
     let (near, far) = (shadow.near, shadow.far);
-    let eye = Mat4::from_translation(Vec3::new(0.0, 0.0, -SHADOW_EYE));
     let projection = match shadow.fov {
-        Some(fov) => Mat4::perspective_rh_gl(fov.to_radians(), 1.0, near, far) * eye,
+        Some(fov) => Mat4::perspective_rh_gl(fov.to_radians(), 1.0, near, far),
         None => {
             let d = shadow.distance;
-            Mat4::orthographic_rh_gl(-d, d, -d, d, -near, far) * eye
+            Mat4::orthographic_rh_gl(-d, d, -d, d, near, far)
         }
     };
     (view, projection)
@@ -293,33 +281,19 @@ impl FrameUniforms {
         let dt = self.last.map_or(0.0, |l| (now - l).as_secs_f32());
         self.last = Some(now);
         let aspect = size[0] as f32 / size[1].max(1) as f32;
-        // Packs take gbufferProjection for a plain perspective (they invert only its perspective
-        // terms): the view bob and the nausea spin belong to the model-view, as GL drew them.
-        let view = frame.bob * frame.spin * crate::camera::view_matrix(frame.yaw, frame.pitch);
+        let view = crate::camera::view_matrix(frame.yaw, frame.pitch);
         let projection = Mat4::perspective_rh_gl(
             frame.fov_degrees.to_radians(),
             aspect,
             0.05,
             frame.depth_far,
-        );
+        ) * frame.bob
+            * frame.spin;
         let camera = frame.camera.as_vec3();
-        let (previous_exact, previous_view, previous_projection) =
+        let (previous_camera, previous_view, previous_projection) =
             self.previous
-                .unwrap_or((glam::DVec3::ZERO, Mat4::ZERO, Mat4::ZERO));
-        let previous_camera = previous_exact.as_vec3();
-        self.previous = Some((frame.camera, view, projection));
-        // The camera's whole blocks and the rest, exact however far from the origin.
-        let whole = |p: glam::DVec3| p.floor();
-        let int = |p: glam::DVec3| Value::i(&whole(p).as_ivec3().to_array());
-        let fract = |p: glam::DVec3| Value::f(&(p - whole(p)).as_vec3().to_array());
-        // The player's, not the camera's: in a third-person view the camera is behind (or in
-        // front of, turned around) the eye the pack lights from.
-        let [yaw, pitch] = frame.eye_rotation.map(f32::to_radians);
-        let look = Vec3::new(
-            -yaw.sin() * pitch.cos(),
-            -pitch.sin(),
-            yaw.cos() * pitch.cos(),
-        );
+                .unwrap_or((Vec3::ZERO, Mat4::ZERO, Mat4::ZERO));
+        self.previous = Some((camera, view, projection));
 
         let to_view = |v: Vec3| view.transform_vector3(v);
         let sun_angle = (frame.sky.sun_angle / 360.0 + 0.25).rem_euclid(1.0);
@@ -364,15 +338,6 @@ impl FrameUniforms {
             match name {
                 "cameraPosition" => v3(camera),
                 "previousCameraPosition" => v3(previous_camera),
-                "cameraPositionInt" => int(frame.camera),
-                "cameraPositionFract" => fract(frame.camera),
-                "previousCameraPositionInt" => int(previous_exact),
-                "previousCameraPositionFract" => fract(previous_exact),
-                // The camera is the eye in first person.
-                "eyePosition" => v3(frame.eye.as_vec3()),
-                "relativeEyePosition" => v3((frame.camera - frame.eye).as_vec3()),
-                "playerLookVector" | "playerBodyVector" => v3(look),
-                "firstPersonCamera" => Value::i(&[i32::from(frame.first_person)]),
                 "eyeAltitude" => Value::f(&[frame.camera.y as f32]),
                 "upPosition" => v3(to_view(Vec3::new(0.0, 100.0, 0.0))),
                 "sunPosition" => v3(sun),
@@ -395,8 +360,7 @@ impl FrameUniforms {
                 "viewHeight" => Value::f(&[size[1] as f32]),
                 "aspectRatio" => Value::f(&[aspect]),
                 "near" => Value::f(&[0.05]),
-                // The chunk render distance, not the distant terrain's reach.
-                "far" => Value::f(&[frame.detail_distance]),
+                "far" => Value::f(&[frame.distance]),
                 "rainStrength" => Value::f(&[inputs.rain]),
                 "wetness" => Value::f(&[self.wetness]),
                 "thunderStrength" => Value::f(&[inputs.thunder]),
@@ -484,14 +448,6 @@ fn components(name: &str) -> usize {
     match name {
         "cameraPosition"
         | "previousCameraPosition"
-        | "cameraPositionInt"
-        | "cameraPositionFract"
-        | "previousCameraPositionInt"
-        | "previousCameraPositionFract"
-        | "eyePosition"
-        | "relativeEyePosition"
-        | "playerLookVector"
-        | "playerBodyVector"
         | "upPosition"
         | "sunPosition"
         | "moonPosition"
@@ -530,8 +486,8 @@ mod tests {
     fn noon_is_straight_up_and_the_sun_sets_in_the_west() {
         assert!(body(0.0, 0.0).abs_diff_eq(Vec3::new(0.0, 100.0, 0.0), 1e-3));
         assert!(body(90.0, 0.0).abs_diff_eq(Vec3::new(-100.0, 0.0, 0.0), 1e-3));
-        // sunPathRotation tilts noon toward -Z and leaves sunset on the horizon.
-        assert!(body(0.0, 30.0).abs_diff_eq(Vec3::new(0.0, 86.60254, -50.0), 1e-3));
+        // sunPathRotation tilts noon toward +Z and leaves sunset on the horizon.
+        assert!(body(0.0, 30.0).abs_diff_eq(Vec3::new(0.0, 86.60254, 50.0), 1e-3));
         assert!(body(90.0, 30.0).abs_diff_eq(Vec3::new(-100.0, 0.0, 0.0), 1e-3));
     }
 
@@ -544,13 +500,10 @@ mod tests {
         let at = |p: Vec3| view.transform_point3(p);
         // Straight down: a block below the player is farther from the light.
         assert!(at(Vec3::new(0.0, -1.0, 0.0)).z < at(Vec3::ZERO).z);
-        // The view's origin is interval / 2 - camera % interval from the player on each axis,
-        // the remainder with the camera's sign: up to a step and a half on negative axes.
-        let origin = view.inverse().w_axis.truncate();
-        assert!(
-            origin.abs_diff_eq(Vec3::new(0.7, 1.0, 1.7), 1e-3),
-            "{origin}"
-        );
+        // The player is less than a step from the centre, 128 blocks from the light.
+        let centre = at(Vec3::ZERO);
+        assert!(centre.x.abs() <= 2.0 && centre.y.abs() <= 2.0, "{centre}");
+        assert!((centre.z + 128.0).abs() < 1e-3, "{centre}");
         // Moving within a step keeps the world where it was in the map.
         camera.x = 1000.6;
         let (moved, _) = shadow_camera(Vec3::Y, camera, &shadow);
@@ -562,38 +515,7 @@ mod tests {
                 .abs_diff_eq(at(world), 1e-3)
         );
         // shadowDistance blocks reach the map's edge.
-        let edge = projection.project_point3(Vec3::new(160.0, 0.0, 0.0));
+        let edge = projection.project_point3(Vec3::new(160.0, 0.0, -128.0));
         assert!((edge.x.abs() - 1.0).abs() < 1e-4, "{edge}");
     }
-
-    /// Iris's matrices at 3000 ticks with `sunPathRotation = 30` and the camera at
-    /// (0.5, -58.38, 0.5), read from its uniforms by a probe pack.
-    #[test]
-    fn the_shadow_camera_matches_iris() {
-        let shadow = Shadow {
-            sun_path_rotation: 30.0,
-            ..Shadow::default()
-        };
-        let light = Vec3::new(0.56782, 0.71287, -0.41158).normalize();
-        let (view, projection) = shadow_camera(light, DVec3::new(0.5, -58.38, 0.5), &shadow);
-        let iris_view = Mat4::from_cols_array_2d(&[
-            [0.82315, 0.0, 0.56782, 0.0],
-            [-0.49175, -0.5, 0.71287, 0.0],
-            [0.28391, -0.86603, -0.41158, 0.0],
-            [0.12508, 1.12301, -1.06188, 1.0],
-        ]);
-        assert!(view.abs_diff_eq(iris_view, 2e-4), "{view}");
-        assert!(
-            (projection.z_axis.z + 0.0078110).abs() < 1e-6,
-            "{projection}"
-        );
-        assert!((projection.w_axis.z + 0.21851).abs() < 1e-4, "{projection}");
-        // Elsewhere the origin keeps to the steps: Iris put it at (-0.5, 1.38, 2.5) here.
-        let (view, _) = shadow_camera(light, DVec3::new(3.5, -58.38, -1.5), &shadow);
-        let origin = view.inverse().w_axis.truncate();
-        assert!(
-            origin.abs_diff_eq(Vec3::new(-0.5, 1.38, 2.5), 1e-3),
-            "{origin}"
-        );
-    }
 }

crates/horizon-client-render/src/gfx/resident.rs

@@ -2,9 +2,7 @@
 //! per-frame culling walk: a column whose box misses the frustum or lies past
 //! the render distance rejects all of its sections with one test, and the
 //! sections that remain are reached by index rather than by hashing keys.
-#[cfg(test)]
-use super::Frustum;
-use super::{Cull, SectionKey};
+use super::{Frustum, SectionKey};
 use crate::{fast_hash::FxHashMap, streaming::in_view_distance};
 use glam::{DVec3, Vec3};
 
@@ -32,7 +30,6 @@ pub struct Resident<T> {
     /// The minimum Y of section index 0 (the level's column).
     min_y: i32,
     items: Vec<(SectionKey, T)>,
-    bounds: Vec<Option<[Vec3; 2]>>,
     slots: FxHashMap<SectionKey, u32>,
     columns: Vec<Column>,
     column_index: FxHashMap<(i32, i32), u32>,
@@ -43,7 +40,6 @@ impl<T> Default for Resident<T> {
         Self {
             min_y: crate::chunk::MIN_Y,
             items: Vec::new(),
-            bounds: Vec::new(),
             slots: FxHashMap::default(),
             columns: Vec::new(),
             column_index: FxHashMap::default(),
@@ -61,9 +57,6 @@ impl<T> Resident<T> {
     pub fn values(&self) -> impl Iterator<Item = &T> {
         self.items.iter().map(|(_, v)| v)
     }
-    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut T> {
-        self.items.iter_mut().map(|(_, v)| v)
-    }
     /// `key`'s value, when it is resident.
     pub fn find(&self, key: SectionKey) -> Option<&T> {
         self.slots.get(&key).map(|&slot| self.get(slot))
@@ -85,26 +78,18 @@ impl<T> Resident<T> {
     }
     pub fn clear(&mut self) {
         self.items.clear();
-        self.bounds.clear();
         self.slots.clear();
         self.columns.clear();
         self.column_index.clear();
     }
-    /// Adds or replaces `key`'s value with default 16x16x16 bounds.
-    #[cfg(test)]
+    /// Adds or replaces `key`'s value.
     pub fn insert(&mut self, key: SectionKey, value: T) {
-        self.insert_with_bounds(key, value, None);
-    }
-    /// Adds or replaces `key`'s value with optional tight geometry bounds.
-    pub fn insert_with_bounds(&mut self, key: SectionKey, value: T, bounds: Option<[Vec3; 2]>) {
         if let Some(&slot) = self.slots.get(&key) {
             self.items[slot as usize].1 = value;
-            self.bounds[slot as usize] = bounds;
             return;
         }
         let slot = self.items.len() as u32;
         self.items.push((key, value));
-        self.bounds.push(bounds);
         self.slots.insert(key, slot);
         let column = match self.column_index.get(&(key.0, key.2)) {
             Some(&c) => &mut self.columns[c as usize],
@@ -144,7 +129,6 @@ impl<T> Resident<T> {
         } else {
             column.bounds();
         }
-        let _ = self.bounds.swap_remove(slot as usize);
         let (_, value) = self.items.swap_remove(slot as usize);
         // The last item now sits in `slot`: point its key and column at it.
         if let Some(&(moved, _)) = self.items.get(slot as usize) {
@@ -191,57 +175,31 @@ fn camera_column(camera: DVec3) -> (i32, i32) {
     )
 }
 
-/// The world AABB (min, max) of a section from its origin and optional tight bounds.
-#[inline]
-fn section_box(min: Vec3, bounds: Option<[Vec3; 2]>) -> (Vec3, Vec3) {
-    match bounds {
-        Some([bmin, bmax]) => (min + bmin, min + bmax),
-        None => (min, min + Vec3::splat(16.0)),
-    }
-}
-
 /// Whether the section at `key` is drawn: its column within the render
 /// distance of the camera's (`SectionOcclusionGraph.isInViewDistance`), and
 /// partly inside the frustum. `None` when it is not, else its squared centre
 /// distance and origin. `Resident::visible` walks columns instead.
 #[cfg(test)]
 fn in_view(key: SectionKey, camera: DVec3, radius: i32, frustum: &Frustum) -> Option<(f64, Vec3)> {
-    in_view_with_bounds(key, camera, radius, frustum, None)
-}
-
-/// `in_view` with optional tight bounds.
-#[cfg(test)]
-fn in_view_with_bounds(
-    key: SectionKey,
-    camera: DVec3,
-    radius: i32,
-    frustum: &Frustum,
-    bounds: Option<[Vec3; 2]>,
-) -> Option<(f64, Vec3)> {
     if !in_view_distance(camera_column(camera), radius, key.0, key.2) {
         return None;
     }
-    in_frustum(key, crate::chunk::MIN_Y, camera, frustum, false, bounds)
+    in_frustum(key, crate::chunk::MIN_Y, camera, frustum, false)
 }
 
 /// `in_view` without the distance test; `inside`: the section's column is
 /// entirely inside the frustum, so the section is too.
-#[cfg(test)]
 fn in_frustum(
     key: SectionKey,
     min_y: i32,
     camera: DVec3,
-    frustum: &impl Cull,
+    frustum: &Frustum,
     inside: bool,
-    bounds: Option<[Vec3; 2]>,
 ) -> Option<(f64, Vec3)> {
     let origin = origin(key, min_y, camera);
     let min = origin.as_vec3();
-    if !inside {
-        let (bmin, bmax) = section_box(min, bounds);
-        if !frustum.intersects(bmin, bmax) {
-            return None;
-        }
+    if !inside && !frustum.intersects(min, min + Vec3::splat(16.0)) {
+        return None;
     }
     Some(((origin + DVec3::splat(8.0)).length_squared(), min))
 }
@@ -263,7 +221,7 @@ impl<T> Resident<T> {
         &self,
         camera: DVec3,
         radius: i32,
-        frustum: &impl Cull,
+        frustum: &Frustum,
         reachable: impl Fn(SectionKey) -> bool,
         beyond: impl Fn(i32, i32) -> bool,
         out: &mut Vec<Visible>,
@@ -281,50 +239,17 @@ impl<T> Resident<T> {
             if !inside && !frustum.intersects(min, max) {
                 continue;
             }
-            let ox = f64::from(column.x * 16) - camera.x;
-            let oz = f64::from(column.z * 16) - camera.z;
-            let min_x = ox as f32;
-            let min_z = oz as f32;
-            let dx8 = ox + 8.0;
-            let dz8 = oz + 8.0;
-            let xz_sq = dx8 * dx8 + dz8 * dz8;
-
-            if inside {
-                for &(y, slot) in &column.sections {
-                    let key = (column.x, y, column.z);
-                    if near && !reachable(key) {
-                        continue;
-                    }
-                    let oy = f64::from(self.min_y + y * 16) - camera.y;
-                    let min = Vec3::new(min_x, oy as f32, min_z);
-                    let dy8 = oy + 8.0;
-                    let distance = xz_sq + dy8 * dy8;
-                    out.push(Visible {
-                        distance: distance.to_bits(),
-                        key,
-                        slot,
-                        origin: min.to_array(),
-                    });
+            for &(y, slot) in &column.sections {
+                let key = (column.x, y, column.z);
+                if near && !reachable(key) {
+                    continue;
                 }
-            } else {
-                for &(y, slot) in &column.sections {
-                    let key = (column.x, y, column.z);
-                    if near && !reachable(key) {
-                        continue;
-                    }
-                    let oy = f64::from(self.min_y + y * 16) - camera.y;
-                    let min = Vec3::new(min_x, oy as f32, min_z);
-                    let (bmin, bmax) = section_box(min, self.bounds[slot as usize]);
-                    if !frustum.intersects(bmin, bmax) {
-                        continue;
-                    }
-                    let dy8 = oy + 8.0;
-                    let distance = xz_sq + dy8 * dy8;
+                if let Some((d, o)) = in_frustum(key, self.min_y, camera, frustum, inside) {
                     out.push(Visible {
-                        distance: distance.to_bits(),
+                        distance: d.to_bits(),
                         key,
                         slot,
-                        origin: min.to_array(),
+                        origin: o.to_array(),
                     });
                 }
             }
@@ -346,15 +271,7 @@ mod tests {
                 for y in 0..24 {
                     // Leave holes so columns have uneven bounds.
                     if (x * 7 + y * 3 + z * 5).rem_euclid(4) != 0 {
-                        // Mix of sections with fallback None and randomized tight bounds.
-                        let bounds = if (x + y + z).rem_euclid(2) == 0 {
-                            let y_min = ((x + z).rem_euclid(4)) as f32;
-                            let y_max = y_min + 2.0 + ((y.rem_euclid(5)) as f32);
-                            Some([Vec3::new(0.0, y_min, 0.0), Vec3::new(16.0, y_max, 16.0)])
-                        } else {
-                            None
-                        };
-                        r.insert_with_bounds((x, y, z), (), bounds);
+                        r.insert((x, y, z), ());
                     }
                 }
             }
@@ -380,21 +297,12 @@ mod tests {
                 let mut slow: Vec<(SectionKey, f64, [f32; 3])> = r
                     .items
                     .iter()
-                    .enumerate()
-                    .filter_map(|(slot, &(k, _))| {
+                    .filter_map(|&(k, _)| {
                         let near = in_view_distance(camera_column(camera), radius, k.0, k.2);
                         if near {
-                            in_view_with_bounds(k, camera, radius, &frustum, r.bounds[slot])
-                                .filter(|_| reachable(k))
+                            in_view(k, camera, radius, &frustum).filter(|_| reachable(k))
                         } else if beyond(k.0, k.2) {
-                            in_frustum(
-                                k,
-                                crate::chunk::MIN_Y,
-                                camera,
-                                &frustum,
-                                false,
-                                r.bounds[slot],
-                            )
+                            in_frustum(k, crate::chunk::MIN_Y, camera, &frustum, false)
                         } else {
                             None
                         }
@@ -563,152 +471,4 @@ mod tests {
             list.len()
         );
     }
-
-    #[test]
-    fn tight_mesh_bounds_culls_section_outside_frustum() {
-        let mut r = Resident::default();
-        let key = (0, 0, 0);
-        // Section geometry only occupies local Y in [0.0, 2.0]
-        let tight = Some([Vec3::new(0.0, 0.0, 0.0), Vec3::new(16.0, 2.0, 16.0)]);
-        r.insert_with_bounds(key, (), tight);
-
-        let camera = DVec3::new(8.0, f64::from(crate::chunk::MIN_Y + 15), -2.0);
-        let projection = super::super::world_projection(70.0, 16.0 / 9.0, 512.0);
-        let view = crate::camera::view_matrix(0.0, -60.0);
-        let frustum = Frustum {
-            planes: super::super::frustum(projection * view),
-        };
-
-        // Tight bounds culls the section whose geometry is entirely outside the frustum
-        let mut out = Vec::new();
-        r.visible(camera, 4, &frustum, |_| true, |_, _| false, &mut out);
-        assert!(
-            out.is_empty(),
-            "tight bounds should cull section whose geometry is below frustum"
-        );
-
-        // With fallback 16x16x16 bounds, the section intersects the frustum and is visible
-        r.insert_with_bounds(key, (), None);
-        out.clear();
-        r.visible(camera, 4, &frustum, |_| true, |_, _| false, &mut out);
-        assert_eq!(
-            out.len(),
-            1,
-            "full 16x16x16 bounds intersect frustum and are accepted"
-        );
-    }
-
-    #[test]
-    #[ignore = "benchmark"]
-    fn tight_bounds_benchmark() {
-        use std::time::Instant;
-
-        let mut r_fallback = Resident::default();
-        let mut r_tight = Resident::default();
-
-        let radius = 16;
-        for x in -radius..=radius {
-            for z in -radius..=radius {
-                // Section 0..4: underground rock
-                for y in 0..4 {
-                    r_fallback.insert((x, y, z), ());
-                    r_tight.insert_with_bounds((x, y, z), (), None);
-                }
-                // Section 4: surface terrain with grass / hills (e.g. Y in [0, 4] or [0, 6])
-                let height = 2.0 + (((x * 3 + z * 5).rem_euclid(5)) as f32) * 1.5;
-                let surface_bounds =
-                    Some([Vec3::new(0.0, 0.0, 0.0), Vec3::new(16.0, height, 16.0)]);
-                r_fallback.insert((x, 4, z), ());
-                r_tight.insert_with_bounds((x, 4, z), (), surface_bounds);
-            }
-        }
-
-        println!("\n=== Tight Bounds Culling Benchmark ===");
-        println!("Total Resident Sections: {}", r_tight.len());
-
-        let test_views = [
-            ("Looking level across terrain (pitch 0°)", 0.0, 0.0),
-            ("Looking slightly up (pitch -15°)", 45.0, -15.0),
-            ("Looking up towards sky (pitch -35°)", 90.0, -35.0),
-            ("Looking down at ground (pitch 25°)", 180.0, 25.0),
-            ("Diagonal view (yaw 135°, pitch -10°)", 135.0, -10.0),
-        ];
-
-        let camera = DVec3::new(8.0, f64::from(crate::chunk::MIN_Y + 4 * 16 + 10), 8.0);
-        let projection = super::super::world_projection(70.0, 16.0 / 9.0, 512.0);
-
-        for (desc, yaw, pitch) in test_views {
-            let view = crate::camera::view_matrix(yaw, pitch);
-            let frustum = Frustum {
-                planes: super::super::frustum(projection * view),
-            };
-
-            let mut out_fallback = Vec::new();
-            let mut out_tight = Vec::new();
-
-            r_fallback.visible(
-                camera,
-                radius,
-                &frustum,
-                |_| true,
-                |_, _| false,
-                &mut out_fallback,
-            );
-            r_tight.visible(
-                camera,
-                radius,
-                &frustum,
-                |_| true,
-                |_, _| false,
-                &mut out_tight,
-            );
-
-            let culled_extra = out_fallback.len().saturating_sub(out_tight.len());
-            let pct_saved = if !out_fallback.is_empty() {
-                (culled_extra as f64 / out_fallback.len() as f64) * 100.0
-            } else {
-                0.0
-            };
-
-            // Timing over 1,000 passes
-            let iters = 1_000;
-            let t0 = Instant::now();
-            for _ in 0..iters {
-                out_fallback.clear();
-                r_fallback.visible(
-                    camera,
-                    radius,
-                    &frustum,
-                    |_| true,
-                    |_, _| false,
-                    &mut out_fallback,
-                );
-            }
-            let dur_fallback = t0.elapsed();
-
-            let t1 = Instant::now();
-            for _ in 0..iters {
-                out_tight.clear();
-                r_tight.visible(
-                    camera,
-                    radius,
-                    &frustum,
-                    |_| true,
-                    |_, _| false,
-                    &mut out_tight,
-                );
-            }
-            let dur_tight = t1.elapsed();
-
-            println!(
-                "{desc}\n  Fallback 16x16: {} sections | {:?}\n  Tight Bounds:   {} sections | {:?}\n  Reduction:      -{} sections ({:.1}% culled)\n",
-                out_fallback.len(),
-                dur_fallback / iters,
-                out_tight.len(),
-                dur_tight / iters,
-                culled_extra,
-                pct_saved
-            );
-        }
-    }
 }

crates/horizon-client-render/src/gfx/sunrise_fan.rs

@@ -55,9 +55,9 @@ mod tests {
         let n = |i: usize| Vec3::from_slice(&normals[i][..3]);
         let mut best = 0.0f32;
         let mut k0 = d.dot(n(TRIANGLES));
-        for (i, triangle) in normals.iter().take(TRIANGLES).enumerate() {
+        for i in 0..TRIANGLES {
             let k1 = d.dot(n(TRIANGLES + (i + 1) % TRIANGLES));
-            let w = triangle[3];
+            let w = normals[i][3];
             if k0 * w <= 0.0 && k1 * w >= 0.0 {
                 let apex = d.dot(n(i));
                 let s = apex + k1 - k0;
@@ -75,115 +75,6 @@ mod tests {
         best
     }
 
-    // Projecting the fan onto the YZ plane leaves uniformly spaced rim
-    // angles after undoing its Y squash. Test both ray directions because
-    // the projection plane goes through the camera.
-    fn sector_weight(alpha: f32, sun: Vec3, d: Vec3) -> f32 {
-        let normals = normals(alpha, sun);
-        if d.y * d.y + d.z * d.z < 1e-10 {
-            return weight(&normals, d);
-        }
-        let n = |i: usize| Vec3::from_slice(&normals[i][..3]);
-        let apex = d.dot(n(0));
-        if apex * normals[0][3] < -1e-4 {
-            return 0.0;
-        }
-        let y = d.dot(n(16));
-        let x = -d.dot(n(20));
-        let ax = x.abs();
-        let ay = y.abs();
-        let t = std::f32::consts::SQRT_2 - 1.0;
-        let q = if ay > ax {
-            if ax < ay * t { 3 } else { 2 }
-        } else if ay > ax * t {
-            1
-        } else {
-            0
-        };
-        let sector = if x >= 0.0 {
-            if y >= 0.0 { q } else { 15 - q }
-        } else if y >= 0.0 {
-            7 - q
-        } else {
-            8 + q
-        };
-        let mut best = 0.0f32;
-        let k0 = d.dot(n(16 + sector as usize));
-        let k1 = d.dot(n(16 + ((sector + 1) % 16) as usize));
-        let offsets: &[i32] = if k0.abs().min(k1.abs()) < ax.max(ay) * 0.001 {
-            &[0, 8, -1, 1, 7, 9]
-        } else {
-            &[0, 8]
-        };
-        for &offset in offsets {
-            let i = (sector + offset).rem_euclid(16) as usize;
-            let k0 = d.dot(n(16 + i));
-            let k1 = d.dot(n(16 + (i + 1) % 16));
-            let w = normals[i][3];
-            let apex = d.dot(n(i));
-            let sum = apex + k1 - k0;
-            if sum.abs() >= 1e-6
-                && sum * w > 0.0
-                && apex * sum >= 0.0
-                && k1 * sum >= 0.0
-                && k0 * sum <= 0.0
-            {
-                best = best.max(apex / sum);
-            }
-        }
-        best
-    }
-    #[test]
-    fn angular_sector_matches_random_and_exact_rim_directions() {
-        let mut state = 19u32;
-        let mut random = || {
-            state = state.wrapping_mul(1664525).wrapping_add(1013904223);
-            (state >> 8) as f32 / 16777216.0
-        };
-        for _ in 0..1000 {
-            let alpha = 0.0011 + random() * 0.9989;
-            let z = if random() > 0.5 { 0.3 } else { -0.2 };
-            let sun = Vec3::new(0.0, (1.0f32 - z * z).sqrt(), z);
-            let normals = normals(alpha, sun);
-            let (_, rim) = vertices(alpha, sun);
-            let random_ray = Vec3::new(
-                random() * 2.0 - 1.0,
-                random() * 2.0 - 1.0,
-                random() * 2.0 - 1.0,
-            )
-            .normalize();
-            for ray in rim.into_iter().chain([random_ray]) {
-                let d = ray.normalize();
-                let (got, want) = (sector_weight(alpha, sun, d), weight(&normals, d));
-                assert!(
-                    (got - want).abs() < 1e-4,
-                    "{alpha} {sun} {d}: {got} != {want}"
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn angular_sector_matches_all_triangle_search() {
-        for alpha in [0.0011f32, 0.05, 0.6, 1.0] {
-            for z in [-0.2f32, 0.3] {
-                let sun = Vec3::new(0.0, (1.0 - z * z).sqrt(), z);
-                let normals = normals(alpha, sun);
-                for yaw in 0..360 {
-                    for pitch in -89..90 {
-                        let (y, p) = ((yaw as f32).to_radians(), (pitch as f32).to_radians());
-                        let d = Vec3::new(y.cos() * p.cos(), p.sin(), y.sin() * p.cos());
-                        let (got, want) = (sector_weight(alpha, sun, d), weight(&normals, d));
-                        assert!(
-                            (got - want).abs() < 1e-4,
-                            "alpha={alpha} z={z} d={d} {got} != {want}"
-                        );
-                    }
-                }
-            }
-        }
-    }
-
     /// The shader's former per-pixel Möller-Trumbore over the same vertices.
     fn reference(alpha: f32, sun: Vec3, d: Vec3) -> f32 {
         let (apex, rim) = vertices(alpha, sun);

crates/horizon-client-render/src/gfx/weather.rs

@@ -53,7 +53,13 @@ impl Weather {
                 topology: wgpu::PrimitiveTopology::TriangleList,
                 ..Default::default()
             },
-            depth_stencil: Some(depth_stencil()),
+            depth_stencil: Some(wgpu::DepthStencilState {
+                format: wgpu::TextureFormat::Depth32Float,
+                depth_write_enabled: Some(true),
+                depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
+                stencil: Default::default(),
+                bias: Default::default(),
+            }),
             multisample: Default::default(),
             fragment: Some(wgpu::FragmentState {
                 module: shader,
@@ -151,33 +157,11 @@ impl Weather {
     }
 }
 
-/// RenderPipelines.WEATHER: depth-tested, but no depth write, so the water
-/// and glass drawn behind the rain still show through it.
-fn depth_stencil() -> wgpu::DepthStencilState {
-    wgpu::DepthStencilState {
-        format: wgpu::TextureFormat::Depth32Float,
-        depth_write_enabled: Some(false),
-        depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
-        stencil: Default::default(),
-        bias: Default::default(),
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::weather::{Parameters, Time};
     use wgpu::util::DeviceExt;
 
-    #[test]
-    fn weather_writes_no_depth() {
-        let depth = super::depth_stencil();
-        assert_eq!(depth.depth_write_enabled, Some(false));
-        assert_eq!(
-            depth.depth_compare,
-            Some(wgpu::CompareFunction::GreaterEqual)
-        );
-    }
-
     #[repr(C)]
     #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
     struct Case {

crates/horizon-client-render/src/gfx/world_post.rs

@@ -335,11 +335,8 @@ impl Post {
                     view_formats: &[],
                 })
             };
-            // COPY_SRC: a native pack's material stage reads copies of them (`opaque_depth`,
-            // `opaque_color`).
-            let sampled = wgpu::TextureUsages::RENDER_ATTACHMENT
-                | wgpu::TextureUsages::TEXTURE_BINDING
-                | wgpu::TextureUsages::COPY_SRC;
+            let sampled =
+                wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
             let color = make_tex("Scaled world", size, self.format, sampled)
                 .create_view(&Default::default());
             // TEXTURE_BINDING: occlusion culling and TAA read it.

crates/horizon-client-render/src/graphics.rs

@@ -334,7 +334,7 @@ pub fn lod_capped(info: &wgpu::AdapterInfo) -> bool {
 }
 /// A LOD distance as far terrain uses it on this adapter.
 pub fn lod_distance_capped(distance: u32, info: &wgpu::AdapterInfo) -> u32 {
-    let distance = distance.min(crate::lod::MAX_CHUNKS);
+    let distance = distance.min(1024);
     if lod_capped(info) {
         distance.min(INTEGRATED_LOD_DISTANCE)
     } else {
@@ -399,10 +399,6 @@ pub struct Graphics {
     /// or behind other windows, and half the worker threads. Off by default;
     /// it changes when frames are drawn, never what they show or the ticks.
     pub battery: bool,
-    /// Reuse the shader pack's last shadow map when sun, view, scene revision and
-    /// pack uniforms still match. Off by default: vanilla loaders redraw every frame
-    /// (or every `shadowInterval`), and a hit with a stale key shows old shadows.
-    pub shadow_cache: bool,
     /// The graphics API (Windows only; see `GraphicsApi`).
     pub api: GraphicsApi,
     /// The shader pack picked in `shaderpacks/` (`shader_pack_list`); empty: none. Its key is
@@ -439,7 +435,6 @@ impl Default for Graphics {
             hdr_ui_brightness: 100,
             hdr_key: "key.keyboard.unknown".into(),
             battery: false,
-            shadow_cache: false,
             api: GraphicsApi::Auto,
             shader_pack: String::new(),
         }
@@ -477,9 +472,7 @@ impl Graphics {
             let number = |d: u32| value.parse().unwrap_or(d);
             match key.trim() {
                 "preset" => g.preset = Preset::parse(value),
-                "lodDistance" => {
-                    g.lod_distance = number(g.lod_distance).min(crate::lod::MAX_CHUNKS)
-                }
+                "lodDistance" => g.lod_distance = number(g.lod_distance).min(1024),
                 "farDetail" => g.far_detail = FarDetail::parse(value),
                 "caveCulling" => g.cave_culling = flag(g.cave_culling),
                 "entityCulling" => g.entity_culling = flag(g.entity_culling),
@@ -506,7 +499,7 @@ impl Graphics {
                 "hdrPaperWhite" => {
                     g.hdr_paper_white = match number(g.hdr_paper_white) {
                         0 => 0,
-                        n => n.clamp(10, 480),
+                        n => n.clamp(80, 480),
                     }
                 }
                 "hdrPeak" => {
@@ -521,7 +514,6 @@ impl Graphics {
                 }
                 "hdrKey" if value.starts_with("key.") => g.hdr_key = value.to_owned(),
                 "batteryMode" => g.battery = flag(g.battery),
-                "shadowCache" => g.shadow_cache = flag(g.shadow_cache),
                 "graphicsApi" => g.api = GraphicsApi::from_name(value).unwrap_or_default(),
                 "pickedShaderPack" => g.shader_pack = value.to_owned(),
                 "overlay" => {
@@ -538,7 +530,7 @@ impl Graphics {
     }
     pub fn serialize(&self) -> String {
         format!(
-            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\n",
+            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrKey:{}\nbatteryMode:{}\ngraphicsApi:{}\npickedShaderPack:{}\n",
             self.preset.name(),
             self.lod_distance,
             self.far_detail.name(),
@@ -572,7 +564,6 @@ impl Graphics {
             self.hdr_ui_brightness,
             self.hdr_key,
             bool_text(self.battery),
-            bool_text(self.shadow_cache),
             self.api.name(),
             self.shader_pack,
         )
@@ -717,7 +708,6 @@ mod tests {
             hdr_ui_brightness: 60,
             hdr_key: "key.keyboard.h".into(),
             battery: true,
-            shadow_cache: true,
             api: GraphicsApi::Dx12,
             shader_pack: "Golden Hour".into(),
         };
@@ -727,7 +717,7 @@ mod tests {
         assert_eq!(Graphics::parse("hdrPeak:0\n").hdr_peak, 0);
         assert_eq!(Graphics::parse("hdrPeak:50\n").hdr_peak, 200);
         assert_eq!(Graphics::parse("hdrPaperWhite:0\n").hdr_paper_white, 0);
-        assert_eq!(Graphics::parse("hdrPaperWhite:5\n").hdr_paper_white, 10);
+        assert_eq!(Graphics::parse("hdrPaperWhite:5\n").hdr_paper_white, 80);
         // The old menus' Simple / Advanced choice is ignored, and so is the
         // shader pack older versions saved.
         assert_eq!(Graphics::parse("level:advanced\n"), Graphics::default());
@@ -784,15 +774,12 @@ mod tests {
     #[test]
     fn lod_distance_is_opt_in_and_bounded() {
         assert_eq!(Graphics::default().lod_distance, 0);
-        for distance in [0, 64, 128, 256, 512, 1024, 65_536, crate::lod::MAX_CHUNKS] {
+        for distance in [0, 64, 128, 256, 512, 1024] {
             let g = Graphics::parse(&format!("lodDistance:{distance}\n"));
             assert_eq!(g.lod_distance, distance);
             assert_eq!(Graphics::parse(&g.serialize()), g);
         }
-        assert_eq!(
-            Graphics::parse("lodDistance:99999999\n").lod_distance,
-            crate::lod::MAX_CHUNKS
-        );
+        assert_eq!(Graphics::parse("lodDistance:10000\n").lod_distance, 1024);
         assert_eq!(Graphics::parse("lodDistance:-1\n").lod_distance, 0);
         assert_eq!(Graphics::parse("lodDistance:invalid\n").lod_distance, 0);
     }

crates/horizon-client-render/src/graphics_style.rs

@@ -147,34 +147,6 @@ impl Style {
             dragging && active,
         );
     }
-    pub fn slider_ext(
-        &self,
-        batch: &mut HudBatch,
-        atlas: &HudAtlas,
-        (x, y, w): (f32, f32, f32),
-        label: &Text,
-        value: f32,
-        hover: bool,
-        focused: bool,
-        can_change_value: bool,
-        active: bool,
-        dragging: bool,
-    ) {
-        ui::slider_ext(
-            batch,
-            atlas,
-            x,
-            y,
-            w,
-            label,
-            value,
-            hover && active,
-            focused,
-            can_change_value,
-            active,
-            dragging && active,
-        );
-    }
     /// The cost tag and the description beside a control, wrapped to two lines.
     pub fn description(
         &self,

crates/horizon-client-render/src/graphics_ui.rs

@@ -46,13 +46,10 @@ pub enum H {
     HdrBlackLevel,
     /// Binds `Graphics::hdr_key`.
     HdrKey,
-    /// Starts HDR calibration (`crate::hdr_calibration`).
-    HdrCalibrate,
     HdrPeak,
     HdrPaperWhite,
     HdrUiBrightness,
     BatteryMode,
-    ShadowCache,
     GraphicsApi,
 }
 
@@ -139,11 +136,6 @@ pub fn rows(level: Level) -> Vec<Row> {
                 None,
                 "Lava, fire and sunlight shine brighter than white. Needs an HDR display.",
             ),
-            h(
-                H::HdrCalibrate,
-                None,
-                "Sets the three below full screen, one test picture at a time.",
-            ),
             h(
                 H::HdrBlackLevel,
                 None,
@@ -314,11 +306,6 @@ pub fn rows(level: Level) -> Vec<Row> {
                 None,
                 "60 FPS cap (30 in menus or unfocused), half the workers: less power.",
             ),
-            h(
-                H::ShadowCache,
-                Saves,
-                "Reuses the pack shadow map when sun, view and world match. Off by default.",
-            ),
             h(
                 H::Workers,
                 None,
@@ -352,28 +339,6 @@ pub fn rows(level: Level) -> Vec<Row> {
 }
 
 const UPLOAD_STEPS: [u32; 8] = [0, 256, 512, 1024, 2048, 4096, 8192, 16384];
-/// What the LOD Distance slider stops at, in chunks: off, then each doubling
-/// up to the whole world.
-const LOD_STEPS: [u32; 18] = [
-    0,
-    64,
-    128,
-    256,
-    512,
-    1024,
-    2048,
-    4096,
-    8192,
-    16384,
-    32768,
-    65536,
-    131072,
-    262144,
-    524288,
-    1048576,
-    2097152,
-    crate::lod::MAX_CHUNKS,
-];
 
 /// Horizon's graphics screens supplement the vanilla options on Video Settings.
 /// Upscaling is only there while TAA is, which does it.
@@ -397,46 +362,6 @@ fn extra_rows(level: Level, settings: &Settings) -> Vec<Row> {
     rows
 }
 
-/// Whether the system set HDR up for the display, and whether the player kept it.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum Setup {
-    /// The system says nothing: the player calibrates.
-    Unknown,
-    /// Peak Brightness and Paper White follow the system.
-    Automatic,
-    /// The system said, and the player changed them anyway.
-    Changed,
-}
-fn setup(s: &Settings) -> Setup {
-    setup_of(&s.horizon, crate::graphics::reported().is_some())
-}
-fn setup_of(g: &crate::graphics::Graphics, reported: bool) -> Setup {
-    if !reported {
-        Setup::Unknown
-    } else if g.hdr_peak == 0 && g.hdr_paper_white == 0 {
-        Setup::Automatic
-    } else {
-        Setup::Changed
-    }
-}
-/// The description beside `item` where it depends on [`setup`]; `text` otherwise.
-fn description(item: Item, s: &Settings, text: &'static str) -> &'static str {
-    match (item, setup(s)) {
-        (Item::Horizon(H::HdrCalibrate), Setup::Unknown) => {
-            "Your display didn't say how bright it gets: calibrate to set it up."
-        }
-        (Item::Horizon(H::HdrCalibrate), Setup::Automatic) => {
-            "Already set up for your display. Only calibrate if HDR looks wrong."
-        }
-        (Item::Horizon(H::HdrCalibrate), Setup::Changed) => {
-            "Puts Peak Brightness and Paper White back to your display's setup."
-        }
-        (Item::Horizon(H::HdrPeak | H::HdrPaperWhite), Setup::Automatic | Setup::Changed) => {
-            "Set up for your display. Leave on Auto unless it looks wrong."
-        }
-        _ => text,
-    }
-}
 fn on_off(on: bool) -> String {
     lang::get(if on { "On" } else { "Off" })
 }
@@ -459,17 +384,13 @@ impl H {
                     .unwrap_or(UPLOAD_STEPS.len() - 1);
                 Some(i as f32 / (UPLOAD_STEPS.len() - 1) as f32)
             }
-            H::LodDistance => {
-                let i = LOD_STEPS
-                    .iter()
-                    .position(|&d| d >= g.lod_distance)
-                    .unwrap_or(LOD_STEPS.len() - 1);
-                Some(i as f32 / (LOD_STEPS.len() - 1) as f32)
-            }
             H::Workers => Some(g.workers as f32 / max_workers() as f32),
             H::ResolutionScale => Some((g.resolution_scale as f32 - 50.0) / 150.0),
-            // Auto, then 10..480 by 10.
-            H::HdrPaperWhite => Some(g.hdr_paper_white as f32 / 480.0),
+            // Auto, then 80..480 by 10.
+            H::HdrPaperWhite => Some(match g.hdr_paper_white {
+                0 => 0.0,
+                n => (n as f32 - 70.0) / 410.0,
+            }),
             // Auto, then 200..2000 by 50.
             H::HdrPeak => Some(match g.hdr_peak {
                 0 => 0.0,
@@ -480,19 +401,6 @@ impl H {
             _ => None,
         }
     }
-    pub fn slider_steps(self) -> Option<u32> {
-        match self {
-            H::ChunkUpdates => Some(64),
-            H::UploadBudget => Some((UPLOAD_STEPS.len() - 1) as u32),
-            H::Workers => Some(max_workers()),
-            H::ResolutionScale => Some(30),
-            H::HdrPaperWhite => Some(41),
-            H::HdrPeak => Some(37),
-            H::HdrBlackLevel => Some(100),
-            H::HdrUiBrightness => Some(15),
-            _ => None,
-        }
-    }
     fn label(self, s: &Settings) -> Text {
         let g = &s.horizon;
         match self {
@@ -546,11 +454,6 @@ impl H {
             H::Upscaling => labelled("Upscaling", g.upscaling.label()),
             H::Hdr => labelled("HDR", on_off(g.hdr)),
             H::HdrSettings => Text::literal(lang::get("HDR Settings...")),
-            H::HdrCalibrate => Text::literal(lang::get(match setup(s) {
-                Setup::Unknown => "Calibrate...",
-                Setup::Automatic => "Calibrate Anyway...",
-                Setup::Changed => "Use Automatic Setup",
-            })),
             H::HdrPaperWhite => match g.hdr_paper_white {
                 0 => labelled(
                     "Paper White",
@@ -577,7 +480,6 @@ impl H {
                 Text::literal("Shortcut: ").append(crate::keybinds::display_name(&g.hdr_key))
             }
             H::BatteryMode => labelled("Battery Mode", on_off(g.battery)),
-            H::ShadowCache => labelled("Shadow Cache", on_off(g.shadow_cache)),
             H::GraphicsApi => labelled("Graphics API", g.api.label()),
             H::Overlay => labelled(
                 "Performance Overlay",
@@ -597,12 +499,14 @@ impl H {
                 g.upload_budget_kib =
                     UPLOAD_STEPS[(v * (UPLOAD_STEPS.len() - 1) as f32).round() as usize]
             }
-            H::LodDistance => {
-                g.lod_distance = LOD_STEPS[(v * (LOD_STEPS.len() - 1) as f32).round() as usize]
-            }
             H::Workers => g.workers = (v * max_workers() as f32).round() as u32,
             H::ResolutionScale => g.resolution_scale = (50.0 + (v * 30.0).round() * 5.0) as u32,
-            H::HdrPaperWhite => g.hdr_paper_white = (v * 48.0).round() as u32 * 10,
+            H::HdrPaperWhite => {
+                g.hdr_paper_white = match (v * 41.0).round() as u32 {
+                    0 => 0,
+                    step => 70 + step * 10,
+                }
+            }
             H::HdrPeak => {
                 g.hdr_peak = match (v * 37.0).round() as u32 {
                     0 => 0,
@@ -628,6 +532,9 @@ impl H {
         }
         let g = &mut s.horizon;
         match self {
+            H::LodDistance => {
+                g.lod_distance = step(&[0, 64, 128, 256, 512, 1024], g.lod_distance, back)
+            }
             H::FarDetail => {
                 g.far_detail = step(&[FarDetail::Full, FarDetail::Reduced], g.far_detail, back)
             }
@@ -656,7 +563,6 @@ impl H {
             }
             H::Hdr => g.hdr = !g.hdr,
             H::BatteryMode => g.battery = !g.battery,
-            H::ShadowCache => g.shadow_cache = !g.shadow_cache,
             H::GraphicsApi => g.api = step(GraphicsApi::choices(), g.api, back),
             H::Pacing => {
                 g.pacing = match g.pacing {
@@ -698,11 +604,7 @@ impl Item {
                 Some("Your display or system doesn't offer HDR output.")
             }
             Item::Horizon(
-                H::HdrCalibrate
-                | H::HdrBlackLevel
-                | H::HdrPeak
-                | H::HdrPaperWhite
-                | H::HdrUiBrightness,
+                H::HdrBlackLevel | H::HdrPeak | H::HdrPaperWhite | H::HdrUiBrightness,
             ) if !s.horizon.hdr => Some("Turn HDR on to use it."),
             _ => None,
         }
@@ -719,7 +621,6 @@ impl Item {
             Item::Horizon(H::AnimatedTextures) => g.animated_textures,
             Item::Horizon(H::Hdr) => g.hdr,
             Item::Horizon(H::BatteryMode) => g.battery,
-            Item::Horizon(H::ShadowCache) => g.shadow_cache,
             Item::Vanilla(Opt::ViewBobbing) => s.view_bobbing,
             Item::Vanilla(Opt::Vsync) => s.vsync,
             Item::Vanilla(Opt::Fullscreen) => s.fullscreen,
@@ -779,7 +680,6 @@ impl Item {
                     | H::PresentMode
                     | H::Workers
                     | H::BatteryMode
-                    | H::ShadowCache
                     | H::GraphicsApi
             ) | Item::Vanilla(
                 Opt::GuiScale
@@ -800,39 +700,6 @@ impl Item {
             s.horizon.preset = Preset::Custom;
         }
     }
-    pub fn slider_steps(self) -> Option<u32> {
-        match self {
-            Item::Vanilla(o) => o.slider_steps(),
-            Item::Horizon(h) => h.slider_steps(),
-        }
-    }
-    pub fn step_slider(self, s: &mut Settings, forward: bool, width: f32) {
-        if !self.available() || self.blocked(s).is_some() {
-            return;
-        }
-        let Some(pos) = self.slider(s) else {
-            return;
-        };
-        let next_pos = if let Some(steps) = self.slider_steps() {
-            let steps = steps as f32;
-            let current = (pos * steps).round();
-            let next = if forward {
-                current + 1.0
-            } else {
-                current - 1.0
-            };
-            (next / steps).clamp(0.0, 1.0)
-        } else {
-            let delta = 1.0 / (width - 8.0).max(1.0);
-            if forward {
-                (pos + delta).min(1.0)
-            } else {
-                (pos - delta).max(0.0)
-            }
-        };
-        self.set_slider(s, next_pos);
-        self.touched(s);
-    }
 }
 
 /// What the options screens must do after an interaction here.
@@ -846,13 +713,11 @@ pub enum Action {
     OpenHdr,
     /// Wait for a key or mouse button to bind to this name.
     BindKey(&'static str),
-    /// Start HDR calibration.
-    Calibrate,
     Done,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Target {
+#[derive(Clone, Copy)]
+enum Target {
     Item(Item),
     Button(Action),
 }
@@ -870,8 +735,6 @@ pub struct GraphicsUi {
     /// The list's scroll amount and its held scrollbar (`AbstractScrollArea`).
     scroll: ui::Scroll,
     dragging: Option<Item>,
-    pub focus: Option<Target>,
-    pub can_change_value: bool,
     /// The key binding the options screen is waiting on (`Action::BindKey`).
     pub binding: Option<&'static str>,
 }
@@ -880,8 +743,6 @@ impl GraphicsUi {
     pub fn reset(&mut self) {
         self.scroll = ui::Scroll::default();
         self.dragging = None;
-        self.focus = None;
-        self.can_change_value = false;
     }
     /// The scrollbar's column: right of the descriptions.
     fn scrollbar_x(w: f32) -> f32 {
@@ -999,10 +860,8 @@ impl GraphicsUi {
         let mut index = 0;
         let mut tooltip = None;
         for wd in &widgets {
-            let is_focused = self.focus == Some(wd.target);
-            let hover = (ui::hovered(cursor, wd.x, wd.y, wd.w, 20.0)
-                && (!wd.list || (cursor.1 >= top && cursor.1 < bottom)))
-                || is_focused;
+            let hover = ui::hovered(cursor, wd.x, wd.y, wd.w, 20.0)
+                && (!wd.list || (cursor.1 >= top && cursor.1 < bottom));
             match wd.target {
                 Target::Item(item) => {
                     let (cost, text) = descriptions[index];
@@ -1023,15 +882,13 @@ impl GraphicsUi {
                         tooltip = Some(atlas.font.split(&Text::literal(lang::get(why)), 170.0));
                     }
                     match item.slider(s) {
-                        Some(value) => STYLE.slider_ext(
+                        Some(value) => STYLE.slider(
                             batch,
                             atlas,
                             (wd.x, wd.y, wd.w),
                             &label,
                             value,
                             hover || self.dragging == Some(item),
-                            is_focused,
-                            self.can_change_value && is_focused,
                             live,
                             self.dragging == Some(item),
                         ),
@@ -1050,7 +907,7 @@ impl GraphicsUi {
                         wd.x + wd.w + STYLE.gap,
                         wd.y + 1.0,
                         cost,
-                        description(item, s, text),
+                        text,
                     );
                 }
                 Target::Button(action) => {
@@ -1136,26 +993,13 @@ impl GraphicsUi {
             if wd.list && (y < top || y >= bottom || wd.y < top || wd.y + 20.0 > bottom) {
                 continue;
             }
-            self.focus = Some(wd.target);
             return match wd.target {
-                Target::Button(action) => {
-                    self.can_change_value = false;
-                    vec![Action::ButtonClick, action]
-                }
+                Target::Button(action) => vec![Action::ButtonClick, action],
                 // A disabled control does nothing: no sound, no preset change.
                 Target::Item(item) if item.blocked(s).is_some() => Vec::new(),
                 Target::Item(Item::Horizon(H::HdrSettings)) => {
-                    self.can_change_value = false;
                     vec![Action::ButtonClick, Action::OpenHdr]
                 }
-                Target::Item(Item::Horizon(H::HdrCalibrate)) if setup(s) == Setup::Changed => {
-                    s.horizon.hdr_peak = 0;
-                    s.horizon.hdr_paper_white = 0;
-                    vec![Action::ButtonClick, Action::Changed]
-                }
-                Target::Item(Item::Horizon(H::HdrCalibrate)) => {
-                    vec![Action::ButtonClick, Action::Calibrate]
-                }
                 Target::Item(Item::Horizon(H::HdrKey)) => {
                     vec![
                         Action::ButtonClick,
@@ -1164,12 +1008,10 @@ impl GraphicsUi {
                 }
                 Target::Item(item) => {
                     if item.slider(s).is_some() {
-                        self.can_change_value = true;
                         self.dragging = Some(item);
                         item.set_slider(s, ui::slider_value(wd.x, wd.w, x));
                         vec![Action::SliderDrag]
                     } else {
-                        self.can_change_value = false;
                         item.cycle(s, right, framebuffer);
                         vec![Action::ButtonClick, Action::Changed]
                     }
@@ -1189,246 +1031,6 @@ impl GraphicsUi {
         self.scroll.clamp(top, bottom, content);
         self.scroll.wheel(amount, 18.0, top, bottom, content);
     }
-
-    /// Mouse wheel over a control cycles it (cycle button). Sliders and disabled
-    /// rows fall through to scroll the page, matching Vanilla list behavior.
-    /// **Horizon improvement (diverges from Vanilla 26.3):** when a slider or
-    /// cycle item is keyboard-focused (`self.focus`), the wheel steps/cycles it
-    /// regardless of cursor position.  Vanilla 26.3 does not intercept the
-    /// wheel for sliders at all.
-    pub fn wheel(
-        &mut self,
-        level: Level,
-        s: &mut Settings,
-        cursor: (f32, f32),
-        (w, h): (f32, f32),
-        framebuffer: [i32; 2],
-        amount: f32,
-    ) -> Vec<Action> {
-        // Horizon improvement: focused slider/cycle intercepts wheel first.
-        if amount != 0.0
-            && self.can_change_value
-            && let Some(Target::Item(item)) = self.focus
-            && item.available()
-            && item.blocked(s).is_none()
-        {
-            if item.slider(s).is_some() {
-                item.step_slider(s, amount > 0.0, w);
-                return vec![Action::SliderDrag, Action::Changed];
-            } else if !matches!(item, Item::Horizon(H::HdrSettings)) {
-                item.cycle(s, amount > 0.0, framebuffer);
-                return vec![Action::ButtonClick, Action::Changed];
-            }
-        }
-        let (widgets, _, _) = self.layout(level, s, w, h);
-        let (top, bottom) = Self::bounds(h);
-        let hovered = widgets.iter().find(|wd| {
-            ui::hovered(cursor, wd.x, wd.y, wd.w, 20.0)
-                && (!wd.list
-                    || (cursor.1 >= top
-                        && cursor.1 < bottom
-                        && wd.y >= top
-                        && wd.y + 20.0 <= bottom))
-        });
-        if let Some(wd) = hovered
-            && let Target::Item(item) = wd.target
-            && item.available()
-            && item.blocked(s).is_none()
-            && item.slider(s).is_none()
-            && !matches!(item, Item::Horizon(H::HdrSettings))
-        {
-            if amount != 0.0 {
-                item.cycle(s, amount > 0.0, framebuffer);
-                return vec![Action::ButtonClick, Action::Changed];
-            }
-            return Vec::new();
-        }
-        self.scroll(level, s, h, amount);
-        Vec::new()
-    }
-
-    /// Keyboard navigation and value adjustments.
-    pub fn key_modifiers(
-        &mut self,
-        level: Level,
-        s: &mut Settings,
-        key: winit::keyboard::KeyCode,
-        shift: bool,
-        (w, h): (f32, f32),
-        framebuffer: [i32; 2],
-    ) -> (Vec<Action>, bool) {
-        use winit::keyboard::KeyCode as K;
-        let (widgets, _, content) = self.layout(level, s, w, h);
-        let (top, bottom) = Self::bounds(h);
-        let focusables: Vec<(Target, [f32; 4], bool)> = widgets
-            .iter()
-            .filter_map(|wd| match wd.target {
-                Target::Item(item) if item.available() && item.blocked(s).is_none() => {
-                    Some((wd.target, [wd.x, wd.y, wd.w, 20.0], wd.list))
-                }
-                Target::Button(_) => Some((wd.target, [wd.x, wd.y, wd.w, 20.0], wd.list)),
-                _ => None,
-            })
-            .collect();
-
-        if focusables.is_empty() {
-            return (Vec::new(), false);
-        }
-
-        // 1. Tab / Shift+Tab navigation
-        if key == K::Tab {
-            let cur = self
-                .focus
-                .and_then(|f| focusables.iter().position(|&(t, ..)| t == f));
-            let next_idx = match cur {
-                Some(i) => {
-                    if shift {
-                        if i == 0 { focusables.len() - 1 } else { i - 1 }
-                    } else {
-                        (i + 1) % focusables.len()
-                    }
-                }
-                None => {
-                    if shift {
-                        focusables.len() - 1
-                    } else {
-                        0
-                    }
-                }
-            };
-            let (target, [_, wy, _, wh], is_list) = focusables[next_idx];
-            self.focus = Some(target);
-            let is_slider = matches!(target, Target::Item(item) if item.slider(s).is_some());
-            self.can_change_value = is_slider;
-            if is_list {
-                if wy < top + 4.0 {
-                    self.scroll.amount -= top + 4.0 - wy;
-                } else if wy + wh > bottom - 4.0 {
-                    self.scroll.amount += wy + wh - (bottom - 4.0);
-                }
-                self.clamp_scroll(h, content);
-            }
-            return (Vec::new(), true);
-        }
-
-        // 2. Left / Right Arrow keys
-        if matches!(key, K::ArrowLeft | K::ArrowRight) {
-            let forward = key == K::ArrowRight;
-            if let Some(Target::Item(item)) = self.focus
-                && item.slider(s).is_some()
-                && self.can_change_value
-            {
-                let width = widgets
-                    .iter()
-                    .find(|wd| wd.target == Target::Item(item))
-                    .map_or(STYLE.control_width, |wd| wd.w);
-                item.step_slider(s, forward, width);
-                return (vec![Action::SliderDrag], true);
-            }
-            if let Some(cur_target) = self.focus
-                && let Some(cur_pos) = focusables.iter().position(|&(t, ..)| t == cur_target)
-            {
-                let from = focusables[cur_pos].1;
-                let rects: Vec<[f32; 4]> = focusables.iter().map(|f| f.1).collect();
-                let dir = if forward {
-                    crate::gamepad::Button::DPadRight
-                } else {
-                    crate::gamepad::Button::DPadLeft
-                };
-                if let Some(next_idx) = crate::gamepad::focus_step_rect(from, dir, &rects) {
-                    let (target, [_, wy, _, wh], is_list) = focusables[next_idx];
-                    self.focus = Some(target);
-                    self.can_change_value = false;
-                    if is_list {
-                        if wy < top + 4.0 {
-                            self.scroll.amount -= top + 4.0 - wy;
-                        } else if wy + wh > bottom - 4.0 {
-                            self.scroll.amount += wy + wh - (bottom - 4.0);
-                        }
-                        self.clamp_scroll(h, content);
-                    }
-                    return (Vec::new(), true);
-                }
-            }
-            return (Vec::new(), false);
-        }
-
-        // 3. Up / Down Arrow keys
-        if matches!(key, K::ArrowUp | K::ArrowDown) {
-            let down = key == K::ArrowDown;
-            if let Some(cur_target) = self.focus
-                && let Some(cur_pos) = focusables.iter().position(|&(t, ..)| t == cur_target)
-            {
-                let from = focusables[cur_pos].1;
-                let rects: Vec<[f32; 4]> = focusables.iter().map(|f| f.1).collect();
-                let dir = if down {
-                    crate::gamepad::Button::DPadDown
-                } else {
-                    crate::gamepad::Button::DPadUp
-                };
-                if let Some(next_idx) = crate::gamepad::focus_step_rect(from, dir, &rects) {
-                    let (target, [_, wy, _, wh], is_list) = focusables[next_idx];
-                    self.focus = Some(target);
-                    self.can_change_value = false;
-                    if is_list {
-                        if wy < top + 4.0 {
-                            self.scroll.amount -= top + 4.0 - wy;
-                        } else if wy + wh > bottom - 4.0 {
-                            self.scroll.amount += wy + wh - (bottom - 4.0);
-                        }
-                        self.clamp_scroll(h, content);
-                    }
-                    return (Vec::new(), true);
-                }
-            } else if !focusables.is_empty() {
-                let first = if down { 0 } else { focusables.len() - 1 };
-                let (target, [_, wy, _, wh], is_list) = focusables[first];
-                self.focus = Some(target);
-                self.can_change_value = false;
-                if is_list {
-                    if wy < top + 4.0 {
-                        self.scroll.amount -= top + 4.0 - wy;
-                    } else if wy + wh > bottom - 4.0 {
-                        self.scroll.amount += wy + wh - (bottom - 4.0);
-                    }
-                    self.clamp_scroll(h, content);
-                }
-                return (Vec::new(), true);
-            }
-            return (Vec::new(), false);
-        }
-
-        // 4. Space / Enter / NumpadEnter
-        if matches!(key, K::Space | K::Enter | K::NumpadEnter)
-            && let Some(target) = self.focus
-        {
-            match target {
-                Target::Item(item) => {
-                    if item.slider(s).is_some() {
-                        self.can_change_value = !self.can_change_value;
-                        return (Vec::new(), true);
-                    } else if item == Item::Horizon(H::HdrSettings) {
-                        return (vec![Action::ButtonClick, Action::OpenHdr], true);
-                    } else {
-                        item.cycle(s, shift, framebuffer);
-                        return (vec![Action::ButtonClick, Action::Changed], true);
-                    }
-                }
-                Target::Button(action) => {
-                    return (vec![Action::ButtonClick, action], true);
-                }
-            }
-        }
-
-        // 5. Escape: the screen closes on the first press, as `Screen.keyPressed` handles it
-        // before the focused slider.
-        if key == K::Escape {
-            self.can_change_value = false;
-            return (Vec::new(), false);
-        }
-
-        (Vec::new(), false)
-    }
 }
 
 #[cfg(test)]
@@ -1655,19 +1257,9 @@ mod tests {
         }
     }
 
-    #[test]
-    fn hdr_setup_follows_what_the_system_reported() {
-        let mut g = crate::graphics::Graphics::default();
-        assert_eq!(setup_of(&g, false), Setup::Unknown);
-        assert_eq!(setup_of(&g, true), Setup::Automatic);
-        g.hdr_paper_white = 80;
-        assert_eq!(setup_of(&g, true), Setup::Changed);
-        assert_eq!(setup_of(&g, false), Setup::Unknown);
-    }
-
     #[test]
     fn every_advanced_setting_has_a_description() {
-        for level in [Level::Simple, Level::Advanced, Level::Hdr] {
+        for level in [Level::Simple, Level::Advanced] {
             for row in rows(level) {
                 if let Row::Setting(s) = row {
                     assert!(!s.text.is_empty(), "{:?}", s.item);
@@ -1678,12 +1270,11 @@ mod tests {
     }
 
     #[test]
-    fn lod_distance_slides_in_both_levels_without_changing_near_distance() {
+    fn lod_distance_cycles_in_both_levels_without_changing_near_distance() {
         let mut s = Settings::default();
         let item = Item::Horizon(H::LodDistance);
         let near = s.render_distance;
         assert_eq!(item.label(&s).plain(), "LOD Distance: Off");
-        assert_eq!(item.slider(&s), Some(0.0));
         for level in [Level::Simple, Level::Advanced] {
             let items: Vec<_> = rows(level)
                 .into_iter()
@@ -1698,29 +1289,14 @@ mod tests {
                 .unwrap();
             assert_eq!(items[render + 1], item);
         }
-        // Every stop is reachable and reads back as the same position.
-        for (i, &distance) in LOD_STEPS.iter().enumerate() {
-            let at = i as f32 / (LOD_STEPS.len() - 1) as f32;
-            item.set_slider(&mut s, at);
+        for distance in [64, 128, 256, 512, 1024, 0] {
+            item.cycle(&mut s, false, [854, 480]);
             assert_eq!(s.horizon.lod_distance, distance);
-            assert_eq!(item.slider(&s), Some(at));
             assert_eq!(s.render_distance, near);
         }
-        // The ends are off and the whole world, which the far terrain plans.
-        item.set_slider(&mut s, 0.0);
-        assert_eq!(s.horizon.lod_distance, 0);
-        item.set_slider(&mut s, 1.0);
-        assert_eq!(s.horizon.lod_distance, crate::lod::MAX_CHUNKS);
-        assert_eq!(
-            item.label(&s).plain(),
-            format!("LOD Distance: {} chunks", crate::lod::MAX_CHUNKS)
-        );
-        item.set_slider(&mut s, 5.0 / 17.0);
+        item.cycle(&mut s, true, [854, 480]);
         assert_eq!(s.horizon.lod_distance, 1024);
         assert_eq!(item.label(&s).plain(), "LOD Distance: 1024 chunks");
-        // A distance between stops (from the file) sits on the next one.
-        s.horizon.lod_distance = 3000;
-        assert_eq!(item.slider(&s), Some(7.0 / 17.0));
         assert_eq!(
             Item::Vanilla(Opt::RenderDistance).label(&s).plain(),
             format!("Full Detail Distance: {near} chunks")
@@ -1825,159 +1401,4 @@ mod tests {
         }
         assert_eq!(item.label(&s).plain(), "Entity Culling: On");
     }
-
-    #[test]
-    fn graphics_slider_keyboard_navigation_and_selection_toggle_parity() {
-        use winit::keyboard::KeyCode as K;
-        let mut s = Settings::default();
-        let mut ui = GraphicsUi::default();
-        let size = (480.0, 600.0);
-        let fb = [854, 480];
-
-        s.horizon.chunk_updates = 10;
-        s.horizon.resolution_scale = 100;
-
-        // 1. Tab navigates down to Chunk Updates slider (in Level::Advanced)
-        let mut found_chunk_updates = false;
-        for _ in 0..15 {
-            ui.key_modifiers(Level::Advanced, &mut s, K::Tab, false, size, fb);
-            if ui.focus == Some(Target::Item(Item::Horizon(H::ChunkUpdates))) {
-                found_chunk_updates = true;
-                break;
-            }
-        }
-        assert!(found_chunk_updates);
-        assert!(
-            ui.can_change_value,
-            "Tab onto slider activates can_change_value"
-        );
-
-        // 2. Right Arrow steps chunk updates from 10 to 11
-        let (actions, handled) =
-            ui.key_modifiers(Level::Advanced, &mut s, K::ArrowRight, false, size, fb);
-        assert!(handled);
-        assert_eq!(actions, vec![Action::SliderDrag]);
-        assert_eq!(s.horizon.chunk_updates, 11);
-
-        // 3. Left Arrow steps back to 10
-        ui.key_modifiers(Level::Advanced, &mut s, K::ArrowLeft, false, size, fb);
-        assert_eq!(s.horizon.chunk_updates, 10);
-
-        // 4. Space toggles can_change_value to false
-        ui.key_modifiers(Level::Advanced, &mut s, K::Space, false, size, fb);
-        assert!(!ui.can_change_value);
-
-        // 5. Space toggles can_change_value back to true
-        ui.key_modifiers(Level::Advanced, &mut s, K::Enter, false, size, fb);
-        assert!(ui.can_change_value);
-
-        // 6. Escape is left to the screen, which closes, even while a slider changes values
-        let (actions, handled) =
-            ui.key_modifiers(Level::Advanced, &mut s, K::Escape, false, size, fb);
-        assert!(!handled);
-        assert!(actions.is_empty());
-        assert!(!ui.can_change_value);
-
-        // 8. Tab to ResolutionScale (steps by 5%)
-        let mut found_res = false;
-        for _ in 0..20 {
-            ui.key_modifiers(Level::Advanced, &mut s, K::Tab, false, size, fb);
-            if ui.focus == Some(Target::Item(Item::Horizon(H::ResolutionScale))) {
-                found_res = true;
-                break;
-            }
-        }
-        assert!(found_res);
-        assert!(ui.can_change_value);
-        ui.key_modifiers(Level::Advanced, &mut s, K::ArrowRight, false, size, fb);
-        assert_eq!(s.horizon.resolution_scale, 105);
-        ui.key_modifiers(Level::Advanced, &mut s, K::ArrowLeft, false, size, fb);
-        assert_eq!(s.horizon.resolution_scale, 100);
-    }
-
-    #[test]
-    fn graphics_cycle_wheel_cycles_and_slider_falls_through_to_scroll() {
-        let mut s = Settings::default();
-        let mut ui = GraphicsUi::default();
-        let size = (480.0, 300.0);
-        let fb = [854, 480];
-
-        // 1. Wheel on a Cycle button: Far Detail cycles mode
-        let (widgets, _, _) = ui.layout(Level::Advanced, &s, size.0, size.1);
-        let far = widgets
-            .iter()
-            .find(|w| matches!(w.target, Target::Item(Item::Horizon(H::FarDetail))))
-            .unwrap();
-        let cursor = (far.x + 5.0, far.y + 5.0);
-        s.horizon.far_detail = FarDetail::Full;
-        let actions = ui.wheel(Level::Advanced, &mut s, cursor, size, fb, 1.0);
-        assert_eq!(actions, vec![Action::ButtonClick, Action::Changed]);
-        assert_eq!(s.horizon.far_detail, FarDetail::Reduced);
-
-        // 2. Wheel over a slider: Chunk Updates scrolls the page, doesn't change slider value
-        s.horizon.chunk_updates = 16;
-        let (widgets, _, _) = ui.layout(Level::Advanced, &s, size.0, size.1);
-        let cu = widgets
-            .iter()
-            .find(|w| matches!(w.target, Target::Item(Item::Horizon(H::ChunkUpdates))))
-            .unwrap();
-        let cursor = (cu.x + 5.0, cu.y + 5.0);
-        let scroll_before = ui.scroll.amount;
-        let actions = ui.wheel(Level::Advanced, &mut s, cursor, size, fb, -1.0);
-        assert!(actions.is_empty());
-        assert_eq!(s.horizon.chunk_updates, 16);
-        assert!(ui.scroll.amount > scroll_before);
-    }
-
-    #[test]
-    fn graphics_step_slider_matches_set_slider_for_all_options() {
-        let options = [
-            H::ChunkUpdates,
-            H::UploadBudget,
-            H::Workers,
-            H::ResolutionScale,
-            H::HdrPaperWhite,
-            H::HdrPeak,
-            H::HdrBlackLevel,
-            H::HdrUiBrightness,
-        ];
-        for h in options {
-            let item = Item::Horizon(h);
-            let steps = h.slider_steps().expect("steps defined");
-            for i in 0..steps {
-                let pos = i as f32 / steps as f32;
-                let mut s1 = Settings::default();
-                let mut s2 = Settings::default();
-                s1.horizon.hdr = true;
-                s2.horizon.hdr = true;
-                h.set_slider(&mut s1, pos);
-
-                item.step_slider(&mut s1, true, 200.0);
-                let next_pos = (i + 1) as f32 / steps as f32;
-                h.set_slider(&mut s2, next_pos);
-                assert_eq!(
-                    item.slider(&s1),
-                    item.slider(&s2),
-                    "{h:?} step forward from {i}"
-                );
-            }
-            for i in 1..=steps {
-                let pos = i as f32 / steps as f32;
-                let mut s1 = Settings::default();
-                let mut s2 = Settings::default();
-                s1.horizon.hdr = true;
-                s2.horizon.hdr = true;
-                h.set_slider(&mut s1, pos);
-
-                item.step_slider(&mut s1, false, 200.0);
-                let prev_pos = (i - 1) as f32 / steps as f32;
-                h.set_slider(&mut s2, prev_pos);
-                assert_eq!(
-                    item.slider(&s1),
-                    item.slider(&s2),
-                    "{h:?} step backward from {i}"
-                );
-            }
-        }
-    }
 }

crates/horizon-client-render/src/hdr.wgsl

@@ -26,14 +26,8 @@ struct Params {
     share: vec4<f32>,
     start: vec4<f32>,
     full: vec4<f32>,
-    // HDR calibration (hdr_calibration.rs): x its step (0 none, 1 black level,
-    // 2 peak, 3 paper white), y the slider in nits, z where its controls start,
-    // a share of the height.
-    calibration: vec4<f32>,
 };
 @group(0) @binding(2) var<uniform> params: Params;
-// Horizon's logo, 1 inside, 0 outside, for calibration's test pictures.
-@group(0) @binding(3) var logo: texture_2d<f32>;
 
 // Light sources are lifted evenly rather than by a highlight curve: vanilla's
 // textures were drawn for SDR, so a curve on their brightest pixels blows out
@@ -87,48 +81,6 @@ fn lift_black(e: vec3<f32>) -> vec3<f32> {
     return e + pq(vec3(params.black)).x * pow(vec3(1.0) - n, vec3(4.0));
 }
 
-// Whether `p` falls on the logo drawn `size` pixels wide around `centre`.
-fn on_logo(p: vec2<f32>, centre: vec2<f32>, size: f32) -> bool {
-    let uv = (p - centre) / size + 0.5;
-    if any(uv < vec2(0.0)) || any(uv >= vec2(1.0)) {
-        return false;
-    }
-    let texels = vec2<f32>(textureDimensions(logo));
-    return textureLoad(logo, vec2<i32>(uv * texels), 0).r > 0.5;
-}
-
-// A calibration step's test picture at `p`, in nits, the way display calibration
-// tools draw them: nothing in it is bright over a large area, so the display
-// doesn't dim itself while it is judged.
-fn calibration_nits(p: vec2<f32>, size: vec2<f32>) -> f32 {
-    let top = size.y * params.calibration.z;
-    let centre = vec2(size.x, top) / 2.0;
-    let v = params.calibration.y;
-    switch u32(params.calibration.x) {
-        // Black level: the logo at the slider on 0. Lowered until it disappears,
-        // it sits on the darkest the display shows.
-        case 1u: {
-            return select(0.0, v, on_logo(p, centre, top * 0.4));
-        }
-        // Peak: a tenth of the screen at 10 000 nits, which the display clips at
-        // its brightest, the logo inside at the slider. Raised until it
-        // disappears, it sits on that brightest.
-        case 2u: {
-            let side = sqrt(0.1 * size.x * size.y);
-            if all(abs(p - centre) < vec2(side / 2.0)) {
-                return select(10000.0, v, on_logo(p, centre, side * 0.7));
-            }
-            return 0.0;
-        }
-        // Paper white: a white card at the slider, on a dim grey, to match a
-        // sheet of paper held beside the screen.
-        default: {
-            let card = vec2(top * 0.9, top * 0.6);
-            return select(3.0, v, all(abs(p - centre) < card / 2.0));
-        }
-    }
-}
-
 @vertex fn vs_hdr(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
     let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
     return vec4(p * 2.0 - 1.0, 0.0, 1.0);
@@ -141,16 +93,6 @@ fn calibration_nits(p: vec2<f32>, size: vec2<f32>) -> f32 {
 
 @fragment fn fs_hdr(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
     let at = vec2<i32>(pos.xy);
-    // Calibration: above its controls the test picture, straight in nits, past
-    // paper white, the lift and the black level.
-    let size = vec2<f32>(textureDimensions(frame));
-    if params.calibration.x > 0.5 && pos.y < size.y * params.calibration.z {
-        let nits = vec3(calibration_nits(pos.xy, size));
-        if params.pq > 0.5 {
-            return vec4(pq(nits), 1.0);
-        }
-        return vec4(nits / 80.0, 1.0);
-    }
     let f = textureLoad(frame, at, 0);
     let c = f.rgb;
     // What covers the world here (Hdr::keep_world): nothing at 0, the hand at

crates/horizon-client-render/src/hdr_calibration.rs

@@ -1,311 +0,0 @@
-//! HDR calibration (Graphics: HDR, Calibrate...): full screen, one step at a time, the way
-//! display calibration tools do it. HDR output draws each step's test picture straight in
-//! nits above a band of controls (`hdr.wgsl`, `Hdr::calibration`), past everything that
-//! shapes the game's picture, so what the player sees is the display alone:
-//!
-//! - Black Level: Horizon's logo at the slider's brightness on 0 nits; lowered until it
-//!   disappears, it sits on the darkest the display shows.
-//! - Peak Brightness: a patch of a tenth of the screen at 10 000 nits (the display clips
-//!   it at its brightest), the logo inside at the slider; raised until it disappears, it
-//!   sits on that brightest. Small, so the display doesn't dim a bright full screen; the
-//!   HDR metadata declares PQ's 10 000 nits meanwhile, so a compositor that clips at the
-//!   declared peak (KWin) lets the patch through.
-//! - Paper White: a white card at the slider, matched to a sheet of white paper held
-//!   beside the screen in the light the player plays in: white is where the eyes have
-//!   adapted to, lower in a dark room than by day (as ITU-R BT.2408's reference white).
-//!
-//! Nothing changes until Save, which writes the three into Horizon's settings; Cancel
-//! or Escape leaves them as they were.
-use crate::{
-    hud::{HudAtlas, HudBatch, rgba},
-    settings::Settings,
-    text::Text,
-    ui,
-};
-use winit::keyboard::KeyCode;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Step {
-    Black,
-    Peak,
-    PaperWhite,
-}
-const STEPS: [Step; 3] = [Step::Black, Step::Peak, Step::PaperWhite];
-
-/// What the options screen does after an input here.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Outcome {
-    Nothing,
-    Click,
-    Changed,
-    Save,
-    Cancel,
-}
-
-pub struct Calibration {
-    step: usize,
-    /// Nits, in the order of `STEPS`.
-    values: [f32; 3],
-    /// Which values were Auto (peak, paper white): saved as Auto again unless the
-    /// player moved them.
-    auto: [Option<f32>; 2],
-    dragging: bool,
-}
-
-/// Height of the band of controls at the bottom, in GUI pixels.
-const BAND: f32 = 84.0;
-
-impl Step {
-    /// Range and step of the slider, in nits: the settings' own.
-    fn range(self) -> (f32, f32, f32) {
-        match self {
-            Step::Black => (0.0, 1.0, 0.01),
-            Step::Peak => (200.0, 2000.0, 50.0),
-            Step::PaperWhite => (10.0, 480.0, 10.0),
-        }
-    }
-    fn name(self) -> &'static str {
-        match self {
-            Step::Black => "Black Level",
-            Step::Peak => "Peak Brightness",
-            Step::PaperWhite => "Paper White",
-        }
-    }
-    fn hint(self) -> &'static str {
-        match self {
-            Step::Black => "Lower it until the logo just disappears into the black.",
-            Step::Peak => "Raise it until the logo just disappears into the bright square.",
-            Step::PaperWhite => {
-                "Make the card a white that's comfortable to look at for a long time, in the light you play in."
-            }
-        }
-    }
-    /// `hdr::Calibration::step`'s number.
-    pub fn number(self) -> u32 {
-        match self {
-            Step::Black => 1,
-            Step::Peak => 2,
-            Step::PaperWhite => 3,
-        }
-    }
-}
-
-struct Layout {
-    top: f32,
-    slider: (f32, f32, f32),
-    cancel: (f32, f32, f32),
-    back: (f32, f32, f32),
-    next: (f32, f32, f32),
-}
-fn layout(w: f32, h: f32) -> Layout {
-    let top = (h - BAND).floor();
-    let cx = (w / 2.0).floor();
-    let by = top + 58.0;
-    Layout {
-        top,
-        slider: (cx - 100.0, top + 32.0, 200.0),
-        cancel: (cx - 152.0, by, 98.0),
-        back: (cx - 49.0, by, 98.0),
-        next: (cx + 54.0, by, 98.0),
-    }
-}
-fn over(cursor: (f32, f32), (x, y, w): (f32, f32, f32)) -> bool {
-    ui::hovered(cursor, x, y, w, 20.0)
-}
-
-impl Calibration {
-    pub fn new(s: &Settings) -> Self {
-        let g = &s.horizon;
-        Self {
-            step: 0,
-            values: [
-                g.hdr_black_level as f32 / 100.0,
-                g.peak_nits() as f32,
-                g.paper_white_nits() as f32,
-            ],
-            auto: [
-                (g.hdr_peak == 0).then_some(g.peak_nits() as f32),
-                (g.hdr_paper_white == 0).then_some(g.paper_white_nits() as f32),
-            ],
-            dragging: false,
-        }
-    }
-    fn current(&self) -> Step {
-        STEPS[self.step]
-    }
-    fn set(&mut self, v: f32) {
-        let (min, max, step) = self.current().range();
-        self.values[self.step] = (min + ((v - min) / step).round() * step).clamp(min, max);
-    }
-    fn label(&self) -> Text {
-        let v = self.values[self.step];
-        Text::literal(match self.current() {
-            Step::Black => format!("Black Level: {v:.2} nits"),
-            step => format!("{}: {v:.0} nits", step.name()),
-        })
-    }
-    /// The step, its nits and where the controls start (a share of the height), for
-    /// HDR output's test picture.
-    pub fn picture(&self, h: f32) -> (Step, f32, f32) {
-        (
-            self.current(),
-            self.values[self.step],
-            layout(0.0, h).top / h.max(1.0),
-        )
-    }
-    pub fn draw(&self, batch: &mut HudBatch, atlas: &HudAtlas, cursor: (f32, f32)) {
-        let (w, h) = (batch.width, batch.height);
-        let l = layout(w, h);
-        // Above the band HDR output draws the test picture over whatever is here.
-        batch.fill(atlas, 0.0, 0.0, w, h, rgba(0, 0, 0, 255));
-        batch.fill(atlas, 0.0, l.top, w, h - l.top, rgba(24, 24, 24, 255));
-        let step = self.current();
-        let title = Text::literal(format!(
-            "HDR Calibration {}/{}: {}",
-            self.step + 1,
-            STEPS.len(),
-            step.name()
-        ));
-        ui::centered_text(batch, atlas, &title, 0.0, l.top + 6.0, w, u32::MAX);
-        let hint = Text::literal(step.hint());
-        ui::centered_text(
-            batch,
-            atlas,
-            &hint,
-            0.0,
-            l.top + 18.0,
-            w,
-            rgba(160, 160, 160, 255),
-        );
-        let (min, max, _) = step.range();
-        let (x, y, sw) = l.slider;
-        ui::slider(
-            batch,
-            atlas,
-            x,
-            y,
-            sw,
-            &self.label(),
-            (self.values[self.step] - min) / (max - min),
-            over(cursor, l.slider) || self.dragging,
-            true,
-            self.dragging,
-        );
-        let last = self.step + 1 == STEPS.len();
-        for (rect, label, active) in [
-            (l.cancel, "Cancel", true),
-            (l.back, "Back", self.step > 0),
-            (l.next, if last { "Save" } else { "Next" }, true),
-        ] {
-            let hover = over(cursor, rect) && active;
-            ui::button(
-                batch,
-                atlas,
-                rect.0,
-                rect.1,
-                rect.2,
-                20.0,
-                &Text::literal(label),
-                active,
-                hover,
-            );
-        }
-    }
-    /// A press, or a drag with `drag`, at `cursor`.
-    pub fn click(&mut self, cursor: (f32, f32), (w, h): (f32, f32), drag: bool) -> Outcome {
-        let l = layout(w, h);
-        let (x, _, sw) = l.slider;
-        if drag {
-            if !self.dragging {
-                return Outcome::Nothing;
-            }
-            let (min, max, _) = self.current().range();
-            self.set(min + ui::slider_value(x, sw, cursor.0) * (max - min));
-            return Outcome::Changed;
-        }
-        if over(cursor, l.slider) {
-            self.dragging = true;
-            let (min, max, _) = self.current().range();
-            self.set(min + ui::slider_value(x, sw, cursor.0) * (max - min));
-            return Outcome::Changed;
-        }
-        if over(cursor, l.cancel) {
-            return Outcome::Cancel;
-        }
-        if over(cursor, l.back) && self.step > 0 {
-            self.step -= 1;
-            return Outcome::Click;
-        }
-        if over(cursor, l.next) {
-            return self.next();
-        }
-        Outcome::Nothing
-    }
-    fn next(&mut self) -> Outcome {
-        if self.step + 1 == STEPS.len() {
-            return Outcome::Save;
-        }
-        self.step += 1;
-        Outcome::Click
-    }
-    /// The slider let go: true if it was held (it clicks on release, as sliders do).
-    pub fn release(&mut self) -> bool {
-        std::mem::take(&mut self.dragging)
-    }
-    /// Left and Right step the slider, Enter goes on, Escape cancels.
-    pub fn key(&mut self, key: KeyCode) -> Outcome {
-        let (_, _, step) = self.current().range();
-        match key {
-            KeyCode::ArrowLeft | KeyCode::ArrowDown => {
-                self.set(self.values[self.step] - step);
-                Outcome::Changed
-            }
-            KeyCode::ArrowRight | KeyCode::ArrowUp => {
-                self.set(self.values[self.step] + step);
-                Outcome::Changed
-            }
-            KeyCode::Enter | KeyCode::NumpadEnter => self.next(),
-            KeyCode::Escape => Outcome::Cancel,
-            _ => Outcome::Nothing,
-        }
-    }
-    /// Writes what the player landed on into Horizon's settings.
-    pub fn save(&self, s: &mut Settings) {
-        let g = &mut s.horizon;
-        g.hdr_black_level = (self.values[0] * 100.0).round() as u32;
-        let [peak, paper_white] = [1, 2].map(|i| match self.auto[i - 1] {
-            Some(auto) if auto == self.values[i] => 0,
-            _ => self.values[i].round() as u32,
-        });
-        g.hdr_peak = peak;
-        g.hdr_paper_white = paper_white;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn calibration_saves_only_on_save() {
-        let mut s = Settings::default();
-        s.horizon.hdr_black_level = 5;
-        let before = s.horizon.clone();
-        let mut c = Calibration::new(&s);
-        assert_eq!(c.key(KeyCode::ArrowLeft), Outcome::Changed);
-        assert_eq!(c.key(KeyCode::ArrowLeft), Outcome::Changed);
-        assert!((c.picture(100.0).1 - 0.03).abs() < 1e-6);
-        assert_eq!(c.key(KeyCode::Escape), Outcome::Cancel);
-        assert_eq!(s.horizon, before);
-        // Black, then Peak (one step up), then Paper White, then Save.
-        assert_eq!(c.key(KeyCode::Enter), Outcome::Click);
-        assert_eq!(c.key(KeyCode::ArrowRight), Outcome::Changed);
-        assert_eq!(c.key(KeyCode::Enter), Outcome::Click);
-        assert_eq!(c.picture(100.0).0, Step::PaperWhite);
-        assert_eq!(c.key(KeyCode::Enter), Outcome::Save);
-        c.save(&mut s);
-        assert_eq!(s.horizon.hdr_black_level, 3);
-        assert_eq!(s.horizon.hdr_peak, before.peak_nits() + 50);
-        assert_eq!(s.horizon.hdr_paper_white, before.hdr_paper_white);
-    }
-}