launcher: GitHub's mark on Sponsor on GitHub, Sculk's card on every page, no border

dezer-x's launcher feedback, points 12 and 13:
- Sponsor on GitHub carries GitHub's mark (github.svg in the glass icons, drawn for Horizon:
  filled, its cat cut out by a mask).
- Sculk's card stays at the sidebar's foot on every page, Servers too; its border is gone (it
  still lifts under the pointer).
- On Servers, Sculk's banner sits right under the server, where it shows without scrolling past
  the server's tabs.

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

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

@@ -9,9 +9,9 @@ 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
+    # One of our small runners (horizon-light), out of GitHub's 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: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
     steps:
       - name: Cancel the pull request's unfinished runs
         env:

.github/workflows/cargo-horizon-mod.yml

@@ -0,0 +1,107 @@
+name: cargo-horizon-mod
+# `cargo binstall --git https://github.com/horizon-rust/horizon cargo-horizon-mod` (#2120): binstall reads
+# [package.metadata.binstall] from crates/cargo-horizon-mod/Cargo.toml and downloads the archive this workflow
+# attaches to the tag `cargo-horizon-mod-v<version>`, whose version must be the manifest's. The targets come from
+# tools/horizon_mod_binstall.py, the same file the manifest's template is checked against, so a platform added there
+# is built here and one nobody publishes is caught before it ships. A pull request builds the archives and publishes
+# nothing.
+on:
+  push:
+    tags: ['cargo-horizon-mod-v*']
+  pull_request:
+    paths:
+      - 'crates/cargo-horizon-mod/**'
+      - 'tools/horizon_mod_binstall.py'
+      - '.github/workflows/cargo-horizon-mod.yml'
+permissions:
+  contents: read
+jobs:
+  plan:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    outputs:
+      platforms: ${{ steps.platforms.outputs.platforms }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: platforms
+        run: echo "platforms=$(python3 -c 'import json, tools.horizon_mod_binstall as m; print(json.dumps(m.PLATFORMS))')" >> "$GITHUB_OUTPUT"
+  build:
+    needs: plan
+    name: build ${{ matrix.target }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJSON(needs.plan.outputs.platforms) }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+      - name: The aarch64 Linux linker
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu
+          echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc" >> "$GITHUB_ENV"
+      - name: Build
+        run: cargo build --release --locked -p cargo-horizon-mod --target ${{ matrix.target }}
+      - name: It starts
+        if: matrix.run
+        shell: bash
+        run: |
+          set -euo pipefail
+          binary="target/${{ matrix.target }}/release/cargo-horizon-mod"
+          [ -f "$binary.exe" ] && binary="$binary.exe"
+          out=$("$binary" 2>&1 || true)
+          case "$out" in
+            *"usage: cargo horizon-mod"*) ;;
+            *) echo "$out"; echo "::error::$binary does not start"; exit 1 ;;
+          esac
+      - name: Package
+        shell: bash
+        run: |
+          set -euo pipefail
+          binary="target/${{ matrix.target }}/release/cargo-horizon-mod"
+          [ -f "$binary.exe" ] && binary="$binary.exe"
+          mkdir -p dist
+          tar -czf "dist/$(basename "$binary" | sed 's/\.exe$//')-${{ matrix.target }}.tar.gz" -C "$(dirname "$binary")" "$(basename "$binary")"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cargo-horizon-mod-${{ matrix.target }}
+          path: dist/*.tar.gz
+          if-no-files-found: error
+          retention-days: 3
+  publish:
+    needs: build
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: cargo-horizon-mod-*
+          path: dist
+          merge-multiple: true
+      - name: The tag and the manifest name the same release and archives
+        run: python3 tools/horizon_mod_binstall.py dist "$GITHUB_REF_NAME"
+      - name: Checksums
+        run: |
+          set -euo pipefail
+          cd dist
+          for file in *.tar.gz; do sha256sum "$file" | cut -d' ' -f1 > "$file.sha256"; done
+      - name: Publish
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+          notes="\`cargo binstall --git https://github.com/horizon-rust/horizon cargo-horizon-mod\`"
+          if gh release view "$GITHUB_REF_NAME" >/dev/null 2>&1; then
+            gh release upload "$GITHUB_REF_NAME" dist/* --clobber
+          else
+            gh release create "$GITHUB_REF_NAME" dist/* --latest=false --title "cargo-horizon-mod ${GITHUB_REF_NAME#cargo-horizon-mod-v}" --notes "$notes"
+          fi

.github/workflows/ci.yml

@@ -27,13 +27,18 @@ 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.
+  # Where (docs/ci-runners.md): our checks runners (label horizon-checks: the desktop's, an isolated user, so a fork's
+  # pull request runs there too) take the pull requests whose number ends in 0 or 1, about what their three runners
+  # can do; GitHub's runners take the others and main's pushes (which also save the Rust cache GitHub's pull request
+  # runs read), so both pools work at once. The repository variable SELF_HOSTED_CI moves them: `all` every job to
+  # ours, `light` (the desktop paused) or `off` every job to GitHub's. On ours 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' }}
+    runs-on: >-
+      ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && (vars.SELF_HOSTED_CI == 'all' ||
+      github.event_name == 'pull_request' && (endsWith(format('{0}', github.event.pull_request.number), '0') ||
+      endsWith(format('{0}', github.event.pull_request.number), '1'))) &&
+      fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
     timeout-minutes: 45
     steps:
       - uses: actions/checkout@v4
@@ -63,6 +68,16 @@ jobs:
           else
             python tools/check_public_tree.py --history
           fi
+      # Our runners as GitHub's: some Python tests compile Rust with a bare `rustc` (GitHub's image has a default
+      # toolchain, our runners' own rustup homes may not), and the GPU tests find no adapter there, so they return
+      # early. Ours have Mesa's software Vulkan for parity; a backend Linux lacks keeps the tests from it, so a pull
+      # request's verify doesn't depend on which pool took it (#8627: a GPU test that flakes on lavapipe).
+      - name: Our runners as GitHub's (a default Rust toolchain, no GPU)
+        if: runner.environment != 'github-hosted'
+        run: |
+          rustup toolchain install stable --profile minimal --component rustfmt --component clippy
+          rustup default stable
+          echo "WGPU_BACKEND=dx12" >> "$GITHUB_ENV"
       - 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
@@ -104,7 +119,11 @@ 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' }}
+    runs-on: >-
+      ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && (vars.SELF_HOSTED_CI == 'all' ||
+      github.event_name == 'pull_request' && (endsWith(format('{0}', github.event.pull_request.number), '0') ||
+      endsWith(format('{0}', github.event.pull_request.number), '1'))) &&
+      fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
     timeout-minutes: 45
     steps:
       - uses: actions/checkout@v4
@@ -145,8 +164,8 @@ 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' }}
+    # A git diff of this repository's own branch: one of our small runners (horizon-light, docs/ci-runners.md).
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
     outputs:
       run: ${{ steps.scope.outputs.run }}
     steps:

.github/workflows/claim-command.yml

@@ -29,8 +29,8 @@ 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' }}
+    # One of our small runners (horizon-light), out of GitHub's pool: main's script only (docs/ci-runners.md).
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
     timeout-minutes: 5
     permissions:
       contents: read
@@ -56,8 +56,8 @@ 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' }}
+    # One of our small runners (horizon-light), out of GitHub's pool: main's script only (docs/ci-runners.md).
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
     timeout-minutes: 10
     permissions:
       contents: read

.github/workflows/mod-registry.yml

@@ -15,9 +15,13 @@ on:
       - '.github/workflows/mod-registry.yml'
 permissions:
   contents: read
+concurrency:
+  group: mod-registry-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 jobs:
   check:
-    runs-on: ubuntu-latest
+    # Our checks runners (label horizon-checks, docs/ci-runners.md); SELF_HOSTED_CI=light or off: GitHub's.
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
     timeout-minutes: 20
     defaults:
       run:
@@ -25,7 +29,9 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - run: rustup toolchain install stable --profile minimal --component rustfmt --component clippy
+      # Ours keep their build folder between jobs.
       - uses: Swatinem/rust-cache@v2
+        if: runner.environment == 'github-hosted'
         with:
           workspaces: crates/horizon-mod-registry
           save-if: ${{ github.ref == 'refs/heads/main' }}

.github/workflows/mojang-republish.yml

@@ -21,7 +21,8 @@ concurrency:
 
 jobs:
   check:
-    runs-on: ubuntu-latest
+    # One of our small runners (label horizon-light, docs/ci-runners.md): main's script, Mojang's public manifest.
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4

.github/workflows/nightly-build.yml

@@ -253,7 +253,8 @@ jobs:
     # Tells the thread that asked for this build how it ended. A conflict `pick` already explained there.
     needs: [pick, build, sign, publish]
     if: always() && inputs.issue != '' && needs.pick.result == 'success'
-    runs-on: ubuntu-latest
+    # One comment, no checkout and no secret: one of our small runners (label horizon-light, docs/ci-runners.md).
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
     timeout-minutes: 5
     permissions:
       issues: write

.github/workflows/overlap-note.yml

@@ -19,9 +19,9 @@ 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
+    # One of our small runners (horizon-light), out of GitHub's 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: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
     timeout-minutes: 10
     permissions:
       contents: read

.github/workflows/pack-bench.yml

@@ -22,17 +22,24 @@ env:
 
 jobs:
   bench:
-    runs-on: ubuntu-latest
+    # Our checks runners (label horizon-checks, docs/ci-runners.md): the branch and the base on the same machine, as
+    # the comparison needs. SELF_HOSTED_CI=light or off: GitHub's.
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
     timeout-minutes: 90
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Install Rust and the ALSA and udev headers
+        env:
+          HOSTED: ${{ runner.environment == 'github-hosted' }}
         run: |
-          sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
+          if [ "$HOSTED" = true ]; then
+            sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
+          fi
           rustup toolchain install stable --profile minimal
       - uses: Swatinem/rust-cache@v2
+        if: runner.environment == 'github-hosted'
         with:
           shared-key: pack-bench
       - name: Bench the branch
@@ -46,11 +53,15 @@ jobs:
           SCALE: ${{ inputs.scale || '1' }}
         run: |
           git fetch https://github.com/horizon-rust/horizon.git "$BASE"
+          # Our runners keep the folder beside the checkout between jobs.
+          git worktree remove --force ../base 2> /dev/null || rm -rf ../base
+          git worktree prune
           git worktree add ../base FETCH_HEAD
           cp crates/horizon-client-render/examples/pack_load_bench.rs ../base/crates/horizon-client-render/examples/
           # A bench row that times a function the base lacks keeps it from building there: then
           # the branch's own rows compare the two ways.
-          (cd ../base && CARGO_TARGET_DIR="$GITHUB_WORKSPACE/target" cargo run --profile fast -p horizon-client-render \
+          target=${CARGO_TARGET_DIR:-$GITHUB_WORKSPACE/target}
+          (cd ../base && CARGO_TARGET_DIR="$target" cargo run --profile fast -p horizon-client-render \
             --example pack_load_bench -- --scale "$SCALE") > base.md \
             || echo "The bench does not build on the base." > base.md
       - name: Summary

.github/workflows/pr-labels.yml

@@ -16,9 +16,9 @@ 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
+    # One of our small runners (horizon-light), out of GitHub's 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: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
     timeout-minutes: 5
     permissions:
       contents: read

.github/workflows/telemetry-server.yml

@@ -15,9 +15,13 @@ on:
       - '.github/workflows/telemetry-server.yml'
 permissions:
   contents: read
+concurrency:
+  group: telemetry-server-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 jobs:
   check:
-    runs-on: ubuntu-latest
+    # Our checks runners (label horizon-checks, docs/ci-runners.md); SELF_HOSTED_CI=light or off: GitHub's.
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
     timeout-minutes: 20
     defaults:
       run:
@@ -25,7 +29,9 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - run: rustup toolchain install stable --profile minimal --component rustfmt --component clippy
+      # Ours keep their build folder between jobs.
       - uses: Swatinem/rust-cache@v2
+        if: runner.environment == 'github-hosted'
         with:
           workspaces: crates/horizon-telemetry-server
           save-if: ${{ github.ref == 'refs/heads/main' }}

.github/workflows/triage-command.yml

@@ -21,7 +21,8 @@ jobs:
       startsWith(github.event.comment.body, '/reopen') ||
       startsWith(github.event.comment.body, '/label') ||
       startsWith(github.event.comment.body, '/unlabel'))
-    runs-on: ubuntu-latest
+    # One of our small runners (label horizon-light, docs/ci-runners.md): main's script only, as above.
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
     timeout-minutes: 5
     permissions:
       contents: read

CONTRIBUTING.md

@@ -5,7 +5,8 @@ everything is that **it plays exactly like vanilla**. This page is the short ver
 welcome on [Discord](https://discord.gg/playhorizon).
 
 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.
+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.
 
 **Where to start: [playhorizon.dev/hub](https://playhorizon.dev/hub).** It shows what is being done now and next
 ([ROADMAP.md](ROADMAP.md) in the repository), the work board, good first tasks, and the forms to report a bug or
@@ -14,23 +15,25 @@ queue (the hub, or `/suggest` on Discord) rather than to issues, which are for b
 
 ## Build it
 
-You need Rust (stable), Python 3.10+, JDK 25, and on Linux the ALSA and udev headers (`libasound2-dev libudev-dev`).
-Horizon never downloads the game: it prepares its resources from your own copy of Minecraft 26.3, as described in
-[Build from source](README.md#build-from-source).
+- **Prerequisites:** Rust (stable), Python 3.10+, JDK 25, and on Linux the ALSA and udev headers
+  (`libasound2-dev libudev-dev`).
+- **Resources:** Horizon never downloads the game; it prepares its resources from your own copy of Minecraft 26.3, as
+  described in [Build from source](README.md#build-from-source).
+- **Commands:**
 
-```sh
-cargo run --release -p horizon-prepare -- --prepare --server-jar ~/Downloads/server.jar
-cargo run --release -p horizon-client
-```
+  ```sh
+  cargo run --release -p horizon-prepare -- --prepare --server-jar ~/Downloads/server.jar
+  cargo run --release -p horizon-client
+  ```
 
-The launcher is its own Cargo workspace in `launcher/` (`cd launcher && cargo run`; on NixOS, `nix-shell` first).
+- **Launcher:** its own Cargo workspace in `launcher/` (`cd launcher && cargo run`; on NixOS, `nix-shell` first).
 
 ## Vanilla first
 
-Wherever vanilla has a feature, vanilla is the specification, down to the order of random calls. "Parity" here
-means Horizon gives the same results as the pinned 26.3 client and server for the same inputs, checked by a
-**harness**: a `tools/test_*_parity.py` script that runs a small Java oracle against the real game and a Rust
-probe against Horizon, and compares their outputs. There are about 290 of them.
+Wherever vanilla has a feature, vanilla is the specification, down to the order of random calls. "Parity" here means
+Horizon gives the same results as the pinned 26.3 client and server for the same inputs, checked by a **harness**: a
+`tools/test_*_parity.py` script that runs a small Java oracle against the real game and a Rust probe against Horizon,
+and compares their outputs. There are about 290 of them.
 
 - **Read the vanilla code before writing Horizon's.** `tools/rea_vanilla.py` queries the pinned game bytecode:
   `python3 tools/rea_vanilla.py method net.minecraft.world.level.block.DispenserBlock dispenseFrom`.
@@ -41,11 +44,10 @@ probe against Horizon, and compares their outputs. There are about 290 of them.
   off by default wherever they would change the vanilla look.
 - **Everything players run is Rust.** Python and Java are fine for dev tools and harness drivers in `tools/`, never
   for player-facing code.
-
-Never commit game files, decompiled source or prepared resources (`.local/`): `tools/check_public_tree.py` rejects
-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.
+- **No game files in the repo.** Never commit game files, decompiled source or prepared resources (`.local/`):
+  `tools/check_public_tree.py` rejects 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
 
@@ -54,24 +56,23 @@ another project's source may also be read and used, **only when that project's l
 
 - **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.
+- **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.
+  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.
+User documentation and file formats are fine to read, and packs and mods are fine to run and observe, whatever their
+license. Shader packs are a clean-room rewrite of the pack format, produced from a written description of it (see
+#1561); they carry no foreign source, and the rules above still apply to anything you read while working on them.
 
 ## Before asking for review
 
@@ -87,8 +88,8 @@ your change can affect. Without the vanilla data on your machine it lists those
 `--quick` skips the harnesses. It exits non-zero when something fails.
 
 For the game workspace, Clippy checks all targets of the touched crates and their transitive workspace dependents,
-including examples. The dependency scope includes optional, platform, build and development dependencies.
-Tests run library, binary, integration and doc tests without building unrelated example executables. Shared Cargo
+including examples. The dependency scope includes optional, platform, build and development dependencies. Tests run
+library, binary, integration and doc tests without building unrelated example executables. Shared Cargo
 configuration and toolchain changes select the whole workspace; CI also keeps its workspace-wide checks.
 
 ## Claim before you start
@@ -123,8 +124,8 @@ it (edited on every push, never repeated): talk to its author in the thread befo
   that label, and area labels (`launcher`, `mobs`, `worldgen`, `rendering`...) from the paths you change.
   `label:parity` is the list of real progress toward vanilla.
 - **Release labels** (we set them if you can't): `feature` also puts it under "New" in the release notes,
-  `skip-release` when players see no change (tooling, docs, tests), nothing for a fix.
-  `release-now` is for crash fixes that shouldn't wait. pr_ready suggests one.
+  `skip-release` when players see no change (tooling, docs, tests), nothing for a fix. `release-now` is for crash
+  fixes that shouldn't wait. pr_ready suggests one.
 
 Who reviews and merges: the Horizon Team, on CI for ordinary pull requests; risky ones (saves, network, world
 generation, the launcher's updates) wait for a local proof first ([merging](docs/release-flow.md#merging)).

Cargo.lock

@@ -1429,6 +1429,7 @@ dependencies = [
  "horizon-world",
  "log",
  "miniz_oxide 0.8.9",
+ "mio",
  "naga",
  "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
@@ -1445,6 +1446,7 @@ dependencies = [
  "ureq",
  "wgpu",
  "winit",
+ "xxhash-rust",
  "zip",
 ]
 
@@ -2315,6 +2317,18 @@ dependencies = [
  "simd-adler32",
 ]
 
+[[package]]
+name = "mio"
+version = "1.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1788edb87fdc09c7e26304471e2f5be8cdefb1b6930d6e3985fc02ff53bf86ee"
+dependencies = [
+ "libc",
+ "log",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "multiversion_no_op"
 version = "1.0.0"

README.md

@@ -7,7 +7,7 @@
   <img src="https://img.shields.io/badge/Minecraft-Java%2026.3-5D9C3F" alt="Minecraft Java 26.3">
   <img src="https://img.shields.io/badge/Rust-stable-B7410E?logo=rust&logoColor=white" alt="Rust">
   <img src="https://img.shields.io/badge/vanilla%20parity-100%25-F0795A" alt="Vanilla parity 100%">
-  <a href="#project-status"><img src="https://img.shields.io/badge/player--visible%20gaps-833%20open-F0795A" alt="Player-visible gaps open"></a>
+  <a href="#project-status"><img src="https://img.shields.io/badge/player--visible%20gaps-0%20open-F0795A" alt="Player-visible gaps open"></a>
   <img src="https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Windows-2A2470" alt="Linux, macOS and Windows">
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-3B2F7E" alt="MIT license"></a>
 </p>
@@ -122,13 +122,13 @@ It runs rustfmt, clippy, the touched crates' tests, the Python tests, the public
 
 ## 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.
+**Player-visible gaps: 0 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: Animals [0](https://github.com/horizon-rust/horizon/issues/3512); Monsters and bosses [0](https://github.com/horizon-rust/horizon/issues/3513); Entities, projectiles, vehicles and decorations [0](https://github.com/horizon-rust/horizon/issues/3514); Items, enchantments and inventories [0](https://github.com/horizon-rust/horizon/issues/3515); Blocks, redstone and fluids [0](https://github.com/horizon-rust/horizon/issues/3516); World, world generation and saves [0](https://github.com/horizon-rust/horizon/issues/3517); Screens, HUD and client packets [0](https://github.com/horizon-rust/horizon/issues/3518); Entity and block rendering, models [0](https://github.com/horizon-rust/horizon/issues/3519); Server and players on the server [0](https://github.com/horizon-rust/horizon/issues/3520); Mob AI, villagers and raids [0](https://github.com/horizon-rust/horizon/issues/3521). 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.
 
 ### 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.
+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: the harnesses pass on Linux and macOS. The [port ledger](tools/port_ledger.py) adds a method-by-method view of what is ported.
 
 | Subsystem | Score | Main gaps |
 | --- | ---: | --- |

THIRD_PARTY_NOTICES.md

@@ -14,6 +14,9 @@ Apache-2.0; both licenses are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).
 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`).
 
+The GLSL frontend also resets the common type for each comma-separated declarator so one
+variable's array specifier does not change later variables.
+
 ## libmimalloc-sys and mimalloc
 
 `third_party/libmimalloc-sys` is [libmimalloc-sys](https://github.com/purpleprotocol/mimalloc_rust)

benchmarks/particle-culling/2026-11-02/README.md

@@ -0,0 +1,27 @@
+# Particle culling review measurements — 2026-11-02
+
+Ordinary-scene captures and measurements for PR #7054. The scene contains 24 mobs, about 9,400–10,100 rain particles, and about 50–100 campfire smoke particles. Two opposite-order passes were run with 2 s warmup and 8 s measurement per condition. Host: Intel Core i7-3770S, Intel HD Graphics 4000, Vulkan/Mesa, 675×727, render distance 4, VSync off, 260 FPS cap.
+
+These are means of the two samples. CPU is the harness's average CPU time per frame; p99 is frame time. The normal scene is not expected to show large gains because most particles are visible.
+
+| Condition | FPS | CPU ms/frame | Frame p99 ms |
+| --- | ---: | ---: | ---: |
+| Main, culling Off | 88.39 | 1.930 | 23.85 |
+| Particle branch, culling Off | 88.55 | 1.828 | 24.88 |
+| Main, Entity Culling Synchronous | 89.12 | 1.887 | 23.07 |
+| Particle branch, Entity Culling Synchronous, Particle Culling Off | 89.06 | 1.897 | 25.18 |
+| Particle Culling Synchronous | 88.87 | 1.774 | 24.94 |
+| Particle Culling Asynchronous* | 89.00 | 1.754 | 24.90 |
+
+*The asynchronous samples predate the final switch to a dedicated particle worker. They are retained only as historical context and are not a measurement of the final worker implementation. No FPS improvement is claimed from these ordinary-scene runs. The Off path delegates directly to `render`; `disabled_culled_render_matches_the_regular_particle_path` checks that it produces the same vertices.
+
+The FPS and CPU differences are within run-to-run variability for this GPU-limited scene. The first four conditions are the reviewer's requested Main-versus-branch default and existing synchronous-mode comparisons. Particle Sync/Async rows are branch-internal mode comparisons.
+
+## Captures
+
+The screenshots show the same ordinary test world and FPS overlay:
+
+- `main-off.png`
+- `particle-off.png`
+- `particle-sync.png`
+- `particle-async.png`

crates/cargo-horizon-mod/Cargo.toml

@@ -6,6 +6,14 @@ license.workspace = true
 rust-version = "1.86"
 description = "cargo horizon-mod new/build/run/check: make Horizon content mods (docs/mods.md)"
 
+# `cargo binstall --git https://github.com/horizon-rust/horizon cargo-horizon-mod` (#2120) reads this: the archive
+# `cargo-horizon-mod`'s workflow attaches to the `cargo-horizon-mod-v<version>` release for the runner's target,
+# holding the binary at its root. tools/horizon_mod_binstall.py expands it for the workflow's targets.
+[package.metadata.binstall]
+pkg-url = "https://github.com/horizon-rust/horizon/releases/download/cargo-horizon-mod-v{ version }/{ name }-{ target }.tar.gz"
+bin-dir = "{ bin }{ binary-ext }"
+pkg-fmt = "tgz"
+
 [dependencies]
 horizon-mods = { path = "../horizon-mods", default-features = false, features = ["index"] }
 serde_json = "1.0.151"

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

@@ -100,6 +100,222 @@ impl ResourceSource for Bundled {
             "assets/horizon/lang/ur_pk.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/ur_pk.json")
             }
+            "assets/horizon/lang/fa_ir.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/fa_ir.json")
+            }
+            "assets/horizon/lang/he_il.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/he_il.json")
+            }
+            "assets/horizon/lang/hu_hu.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/hu_hu.json")
+            }
+            "assets/horizon/lang/ro_ro.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ro_ro.json")
+            }
+            "assets/horizon/lang/da_dk.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/da_dk.json")
+            }
+            "assets/horizon/lang/fi_fi.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/fi_fi.json")
+            }
+            "assets/horizon/lang/no_no.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/no_no.json")
+            }
+            "assets/horizon/lang/bg_bg.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/bg_bg.json")
+            }
+            "assets/horizon/lang/sk_sk.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/sk_sk.json")
+            }
+            "assets/horizon/lang/lt_lt.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/lt_lt.json")
+            }
+            "assets/horizon/lang/it_it.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/it_it.json")
+            }
+            "assets/horizon/lang/nl_nl.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/nl_nl.json")
+            }
+            "assets/horizon/lang/vi_vn.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/vi_vn.json")
+            }
+            "assets/horizon/lang/th_th.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/th_th.json")
+            }
+            "assets/horizon/lang/ja_jp.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ja_jp.json")
+            }
+            "assets/horizon/lang/ar_sa.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ar_sa.json")
+            }
+            "assets/horizon/lang/pt_br.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/pt_br.json")
+            }
+            "assets/horizon/lang/cs_cz.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/cs_cz.json")
+            }
+            "assets/horizon/lang/sv_se.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/sv_se.json")
+            }
+            "assets/horizon/lang/el_gr.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/el_gr.json")
+            }
+            "assets/horizon/lang/ca_es.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ca_es.json")
+            }
+            "assets/horizon/lang/et_ee.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/et_ee.json")
+            }
+            "assets/horizon/lang/lv_lv.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/lv_lv.json")
+            }
+            "assets/horizon/lang/sl_si.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/sl_si.json")
+            }
+            "assets/horizon/lang/sr_cs.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/sr_cs.json")
+            }
+            "assets/horizon/lang/is_is.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/is_is.json")
+            }
+            "assets/horizon/lang/af_za.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/af_za.json")
+            }
+            "assets/horizon/lang/ms_my.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ms_my.json")
+            }
+            "assets/horizon/lang/be_by.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/be_by.json")
+            }
+            "assets/horizon/lang/sr_sp.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/sr_sp.json")
+            }
+            "assets/horizon/lang/az_az.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/az_az.json")
+            }
+            "assets/horizon/lang/uz_uz.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/uz_uz.json")
+            }
+            "assets/horizon/lang/kk_kz.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/kk_kz.json")
+            }
+            "assets/horizon/lang/ka_ge.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ka_ge.json")
+            }
+            "assets/horizon/lang/hy_am.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/hy_am.json")
+            }
+            "assets/horizon/lang/bs_ba.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/bs_ba.json")
+            }
+            "assets/horizon/lang/mk_mk.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/mk_mk.json")
+            }
+            "assets/horizon/lang/sq_al.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/sq_al.json")
+            }
+            "assets/horizon/lang/cy_gb.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/cy_gb.json")
+            }
+            "assets/horizon/lang/ga_ie.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ga_ie.json")
+            }
+            "assets/horizon/lang/eu_es.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/eu_es.json")
+            }
+            "assets/horizon/lang/gl_es.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/gl_es.json")
+            }
+            "assets/horizon/lang/fil_ph.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/fil_ph.json")
+            }
+            "assets/horizon/lang/ta_in.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ta_in.json")
+            }
+            "assets/horizon/lang/mn_mn.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/mn_mn.json")
+            }
+            "assets/horizon/lang/lo_la.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/lo_la.json")
+            }
+            "assets/horizon/lang/so_so.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/so_so.json")
+            }
+            "assets/horizon/lang/fy_nl.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/fy_nl.json")
+            }
+            "assets/horizon/lang/gd_gb.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/gd_gb.json")
+            }
+            "assets/horizon/lang/lb_lu.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/lb_lu.json")
+            }
+            "assets/horizon/lang/ky_kg.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ky_kg.json")
+            }
+            "assets/horizon/lang/kn_in.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/kn_in.json")
+            }
+            "assets/horizon/lang/mt_mt.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/mt_mt.json")
+            }
+            "assets/horizon/lang/eo_uy.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/eo_uy.json")
+            }
+            "assets/horizon/lang/haw_us.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/haw_us.json")
+            }
+            "assets/horizon/lang/ig_ng.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ig_ng.json")
+            }
+            "assets/horizon/lang/la_la.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/la_la.json")
+            }
+            "assets/horizon/lang/tt_ru.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/tt_ru.json")
+            }
+            "assets/horizon/lang/yi_de.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/yi_de.json")
+            }
+            "assets/horizon/lang/yo_ng.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/yo_ng.json")
+            }
+            "assets/horizon/lang/ba_ru.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ba_ru.json")
+            }
+            "assets/horizon/lang/br_fr.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/br_fr.json")
+            }
+            "assets/horizon/lang/cv_cu.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/cv_cu.json")
+            }
+            "assets/horizon/lang/fo_fo.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/fo_fo.json")
+            }
+            "assets/horizon/lang/fur_it.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/fur_it.json")
+            }
+            "assets/horizon/lang/li_li.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/li_li.json")
+            }
+            "assets/horizon/lang/lmo.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/lmo.json")
+            }
+            "assets/horizon/lang/oc_fr.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/oc_fr.json")
+            }
+            "assets/horizon/lang/sah_sah.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/sah_sah.json")
+            }
+            "assets/horizon/lang/se_no.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/se_no.json")
+            }
+            "assets/horizon/lang/szl.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/szl.json")
+            }
+            "assets/horizon/lang/vec_it.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/vec_it.json")
+            }
             "assets/horizon/lang/de_de.json" | "assets/horizon/lang/de_at.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/de_de.json")
             }

crates/horizon-client-lib/Cargo.toml

@@ -63,6 +63,10 @@ ab_glyph = "0.2.32"
 log = "0.4"
 chrono = { version = "0.4.42", default-features = false, features = ["clock", "std"] }
 flate2 = { version = "1.1.10", default-features = false, features = ["zlib-rs", "runtime_detection"] }
+# The network threads of a server's players: epoll, kqueue or Windows' AFD (lan/io_pool.rs).
+mio = { version = "1.2.4", features = ["os-poll", "net"] }
+# Shared chunk frames are found by one keyed 128-bit hash of their body (lan/conn.rs SharedFrames).
+xxhash-rust = { version = "0.8.19", features = ["xxh3"] }
 horizon-theme = { path = "../horizon-theme" }
 # Opt-in data collection: the game keeps, the launcher sends (docs/telemetry.md); `live` is
 # the anonymous "I'm playing" ping the game sends itself (`heartbeat.rs`).

crates/horizon-client-render/examples/entity_shadow_ownership.rs

@@ -64,6 +64,7 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
         None,
         GraphicsApi::Vulkan,
         false,
+        false,
         true,
     ))?;
     assert!(!renderer.pack_entity_shadows(), "no selected pack");

crates/horizon-client-render/examples/scene_replay.rs

@@ -0,0 +1,827 @@
+//! Draws a scene `horizon-ctl render-capture DIR` wrote, offscreen, from its camera, with the
+//! real `Renderer`, and prints GPU and CPU milliseconds per frame and Horizon's own passes'
+//! GPU times as JSON (docs/graphics.md, "Render capture and replay").
+//! `cargo run --release -p horizon-client-render --example scene_replay -- DIR [--frames 300]
+//! [--warmup 60] [--yaw-offsets 0,90,180,270] [--texture-filtering 0|1|2] [--anisotropy-bit N]
+//! [--mipmaps N] [--lod-distance CHUNKS] [--render-distance CHUNKS] [--size WxH]
+//! [--section-draws flat|indirect] [--section-cull on|off] [--section-sides on|off]
+//! [--gpu-culling on|off] [--root RESOURCES] [--screenshot PNG]
+//! [--world SAVE --leaf-culling MODE] [--memory on]`
+//! `--screenshot` saves the first view's last frame, after the timed frames.
+//! `--world` meshes the captured sections again from that save's region files
+//! (blocks, biomes and saved light; `ao`, `biomeBlendRadius` and `cutoutLeaves`
+//! from `./options.txt`) with `--leaf-culling` (default `off`), so a mesher
+//! change can be measured on the captured view. A section whose 3x3 columns are
+//! not all saved keeps its captured mesh.
+//! `--memory on` adds the renderer's largest GPU resources and, on macOS, the process's
+//! physical footprint by category (`footprint`), taken after the timed frames.
+use horizon_client_render::{
+    assets::{Assets, RenderAssets},
+    biome::Biomes,
+    blocks::BlockFacts,
+    chunk::{BIOME_STRATEGY, Chunk, ColumnLayout, Light, block_strategy},
+    fast_hash::{FxHashMap, FxHashSet},
+    gfx::{
+        PreparedTextures, Renderer, ScreenshotRequest,
+        capture::{self, AtlasCheck, Scene},
+        panorama::Faces,
+    },
+    graphics::LeafCullingMode,
+    hud::HudBatch,
+    lod::TileKey,
+    mesher::{MeshScratch, MeshTables, Mesher, SectionMesh, packed},
+    models,
+};
+use horizon_core::{
+    biome::{BiomeZoom, obfuscate_seed},
+    paletted::PalettedContainer,
+};
+use horizon_world::{
+    chunk::BlockState,
+    nbt::{Limits, NamedTag, Tag},
+    region::RegionFile,
+    registry::BlockRegistry,
+};
+use serde_json::{Value, json};
+use std::{
+    path::{Path, PathBuf},
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+    time::{Duration, Instant},
+};
+use winit::{
+    application::ApplicationHandler,
+    event::WindowEvent,
+    event_loop::{ActiveEventLoop, EventLoop},
+    window::{Window, WindowId},
+};
+
+// The game's allocator, so that `--memory`'s footprint is the game's: the system heap kept
+// gigabytes of the meshes `--world` frees dirty.
+#[global_allocator]
+static ALLOCATOR: horizon_threads::Allocator = horizon_threads::ALLOCATOR;
+
+#[derive(Default)]
+struct Options {
+    dir: PathBuf,
+    frames: usize,
+    warmup: usize,
+    yaw_offsets: Vec<f32>,
+    root: Option<PathBuf>,
+    texture_filtering: Option<i32>,
+    anisotropy_bit: Option<i32>,
+    mipmaps: Option<u32>,
+    lod_distance: Option<u32>,
+    render_distance: Option<i32>,
+    size: Option<[u32; 2]>,
+    flat: Option<bool>,
+    cull: Option<bool>,
+    sides: Option<bool>,
+    gpu_culling: Option<bool>,
+    screenshot: Option<PathBuf>,
+    world: Option<PathBuf>,
+    leaf_culling: LeafCullingMode,
+    memory: bool,
+}
+
+fn on_off(value: &str) -> Result<bool, String> {
+    match value {
+        "on" | "flat" => Ok(true),
+        "off" | "indirect" => Ok(false),
+        other => Err(format!("expected on or off, got {other}")),
+    }
+}
+
+fn options() -> Result<Options, String> {
+    let mut o = Options {
+        frames: 300,
+        warmup: 60,
+        yaw_offsets: vec![0.0],
+        ..Default::default()
+    };
+    let mut args = std::env::args().skip(1);
+    let mut dir = None;
+    while let Some(arg) = args.next() {
+        if !arg.starts_with("--") {
+            dir = Some(PathBuf::from(arg));
+            continue;
+        }
+        let value = args.next().ok_or(format!("{arg} needs a value"))?;
+        let number = |v: &str| v.parse::<i64>().map_err(|e| format!("{arg}: {e}"));
+        match arg.as_str() {
+            "--frames" => o.frames = number(&value)?.max(1) as usize,
+            "--warmup" => o.warmup = number(&value)?.max(0) as usize,
+            "--yaw-offsets" => {
+                o.yaw_offsets = value
+                    .split(',')
+                    .map(|v| v.trim().parse::<f32>().map_err(|e| format!("{arg}: {e}")))
+                    .collect::<Result<_, _>>()?
+            }
+            "--root" => o.root = Some(value.into()),
+            "--texture-filtering" => o.texture_filtering = Some(number(&value)? as i32),
+            "--anisotropy-bit" => o.anisotropy_bit = Some(number(&value)? as i32),
+            "--mipmaps" => o.mipmaps = Some(number(&value)?.max(0) as u32),
+            "--lod-distance" => o.lod_distance = Some(number(&value)?.max(0) as u32),
+            "--render-distance" => o.render_distance = Some(number(&value)?.max(0) as i32),
+            "--size" => {
+                let (w, h) = value.split_once('x').ok_or("--size takes WxH")?;
+                o.size = Some([number(w)? as u32, number(h)? as u32]);
+            }
+            "--section-draws" => o.flat = Some(on_off(&value)?),
+            "--section-cull" => o.cull = Some(on_off(&value)?),
+            "--section-sides" => o.sides = Some(on_off(&value)?),
+            "--gpu-culling" => o.gpu_culling = Some(on_off(&value)?),
+            "--screenshot" => o.screenshot = Some(value.into()),
+            "--world" => o.world = Some(value.into()),
+            "--memory" => o.memory = on_off(&value)?,
+            "--leaf-culling" => {
+                o.leaf_culling = LeafCullingMode::ALL
+                    .into_iter()
+                    .find(|mode| mode.name() == value)
+                    .ok_or(format!("no leaf culling mode {value}"))?;
+            }
+            other => return Err(format!("unknown option {other}")),
+        }
+    }
+    o.dir = dir.ok_or("the capture directory is required")?;
+    Ok(o)
+}
+
+/// Milliseconds: average, median, 95th percentile and slowest, over `samples`.
+fn summary(samples: &[f32]) -> Value {
+    if samples.is_empty() {
+        return Value::Null;
+    }
+    let mut sorted = samples.to_vec();
+    sorted.sort_by(f32::total_cmp);
+    let at = |q: f32| sorted[((sorted.len() - 1) as f32 * q).round() as usize];
+    json!({
+        "avg": samples.iter().sum::<f32>() / samples.len() as f32,
+        "min": sorted[0],
+        "p10": at(0.1),
+        "p50": at(0.5),
+        "p95": at(0.95),
+        "max": sorted[sorted.len() - 1],
+        "samples": samples.len(),
+    })
+}
+
+fn ms(d: Duration) -> f32 {
+    d.as_secs_f32() * 1000.0
+}
+
+fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
+    let o = options()?;
+    let scene = Scene::read(&o.dir)?;
+    let settings = &scene.settings;
+    let root = o.root.clone().unwrap_or_else(|| settings.resources.clone());
+    let loading = Instant::now();
+    let assets = Assets::load(&root)?;
+    let render = assets.reload(&root)?;
+    if AtlasCheck::of(&render) != settings.atlas {
+        return Err(format!(
+            "the block sprites at {} are not the ones the capture was made with (resource packs \
+             or mods?): pass --root with the game's resource root",
+            root.display()
+        )
+        .into());
+    }
+    let one = [255u8; 4];
+    let zero = [0u8; 4];
+    let prepared = PreparedTextures::new(
+        &render.pixels,
+        render.sprite_size,
+        render.texture_layers,
+        &render.sprite_mips,
+        (&zero[..], 1),
+    )
+    .with_pbr(
+        &render.pbr_normals,
+        &render.pbr_specular,
+        render.pbr_size,
+        render.texture_layers,
+    );
+    let mut renderer = pollster::block_on(Renderer::new(
+        window,
+        true,
+        &render.pixels,
+        render.sprite_size,
+        render.sprite_minimum_size,
+        render.texture_layers,
+        &render.sprite_mips,
+        &render.animations,
+        (&one[..], 1, 1),
+        (&zero[..], 1, 1),
+        (&zero[..], 1, 1),
+        (&zero[..], 1),
+        Arc::new(Faces::colour([0, 0, 0, 255])),
+        Some(prepared),
+        None,
+        settings.graphics_api(),
+        settings.translucent_batching,
+        false,
+        false,
+    ))?;
+    let state = &scene.renderer;
+    let [width, height] = o.size.unwrap_or(state.size);
+    renderer.resize(width, height);
+    renderer.gamma = state.gamma;
+    renderer.fullbright = state.fullbright;
+    renderer.improved_transparency = state.improved_transparency;
+    renderer.animated_textures = state.animated_textures;
+    let filtering = o.texture_filtering.unwrap_or(settings.texture_filtering);
+    let anisotropy = o.anisotropy_bit.unwrap_or(settings.anisotropy_bit);
+    renderer.set_texture_filtering(filtering, anisotropy);
+    renderer.set_mipmap_levels(o.mipmaps.unwrap_or(settings.mipmap_levels));
+    renderer.set_world_post(
+        settings.resolution_scale,
+        settings.fxaa,
+        settings.taa,
+        settings.upscale,
+    );
+    let mut notes = Vec::new();
+    let mut note = |what: &str, result: horizon_client_render::Result<()>| {
+        if let Err(e) = result {
+            notes.push(format!("{what}: {e}"));
+        }
+    };
+    note(
+        "section-draws",
+        renderer.set_flat_draws(o.flat.unwrap_or(state.flat_draws)),
+    );
+    note(
+        "section-cull",
+        renderer.set_section_cull(o.cull.unwrap_or(state.section_cull)),
+    );
+    note(
+        "gpu-culling",
+        renderer.set_gpu_culling(o.gpu_culling.unwrap_or(state.gpu_culling)),
+    );
+    renderer.set_section_sides(o.sides.unwrap_or(state.section_sides));
+    renderer.set_pass_timing(true);
+    let layout = ColumnLayout::of_level(state.min_y, state.sections as i32 * 16);
+    if layout != ColumnLayout::VANILLA {
+        renderer.clear_sections(layout);
+    }
+
+    // Near sections first: with no far tile resident yet, none fades in.
+    let camera = scene.frame.camera;
+    let column = |x: f64| (x.floor() as i32) >> 4;
+    let (cx, cz) = (column(camera[0]), column(camera[2]));
+    let near = |x: i32, z: i32| {
+        o.render_distance
+            .is_none_or(|r| (x - cx).pow(2) + (z - cz).pow(2) <= r * r)
+    };
+    let (mut remeshed, mut world_report) = (FxHashMap::default(), Value::Null);
+    if let Some(world) = &o.world {
+        let keys: Vec<[i32; 3]> = section_keys(&o.dir)?
+            .into_iter()
+            .filter(|&[x, _, z]| near(x, z))
+            .collect();
+        let started = Instant::now();
+        remeshed = remesh(world, &root, &assets, &render, o.leaf_culling, &keys)?;
+        world_report = json!({
+            "save": world.display().to_string(),
+            "leaf_culling": o.leaf_culling.name(),
+            "remeshed": remeshed.len(),
+            "kept": keys.len() - remeshed.len(),
+            "remesh_ms": ms(started.elapsed()),
+        });
+    }
+    let leaf_layers = leaf_layers(&render);
+    let (mut sections, mut quads, mut leaf_quads) = (0, 0usize, 0usize);
+    let mut packed_quads = 0usize;
+    capture::read_meshes(&o.dir, "sections", |[x, y, z], captured| {
+        if near(x, z) {
+            let mesh = remeshed.remove(&[x, y, z]).unwrap_or(captured);
+            quads += mesh.solid.len() / 4;
+            packed_quads += packed::packed_quads(&mesh.packed, mesh.solid.len() / 4);
+            leaf_quads += mesh
+                .solid
+                .iter()
+                .filter(|v| leaf_layers.contains(&v.layer))
+                .count()
+                / 4;
+            renderer.upload((x, y, z), &mesh);
+            sections += 1;
+        }
+    })?;
+    let mut tiles: Vec<(TileKey, SectionMesh)> = Vec::new();
+    capture::read_meshes(&o.dir, "tiles", |[x, z, level], mesh| {
+        let key = TileKey {
+            x,
+            z,
+            level: level as u8,
+        };
+        let [ox, _, oz] = key.origin();
+        let half = f64::from(key.size()) / 2.0;
+        let (dx, dz) = (
+            f64::from(ox) + half - camera[0],
+            f64::from(oz) + half - camera[2],
+        );
+        let near = o
+            .lod_distance
+            .is_none_or(|d| (dx * dx + dz * dz).sqrt() <= f64::from(d) * 16.0);
+        if near {
+            tiles.push((key, mesh));
+        }
+    })?;
+    let tile_count = tiles.len();
+    if !tiles.is_empty() {
+        let cutout: FxHashSet<(i32, i32)> = scene.lod_cutout.iter().copied().collect();
+        renderer.queue_lods(tiles, Vec::new(), Some(cutout));
+        renderer.upload_lods(Duration::from_secs(3600));
+    }
+    let loaded_ms = ms(loading.elapsed());
+
+    let hud = HudBatch::new([width, height]);
+    let mut views = Vec::new();
+    for &offset in &o.yaw_offsets {
+        let mut frame = scene.frame(&hud);
+        frame.yaw += offset;
+        frame.eye_rotation[0] += offset;
+        if let Some(r) = o.render_distance {
+            frame.distance = (r * 16) as f32;
+            frame.detail_distance = frame.distance;
+        }
+        let draw = |renderer: &mut Renderer| -> horizon_client_render::Result<Duration> {
+            if frame.cave_culling {
+                renderer.start_occlusion(frame.camera, frame.distance);
+            }
+            let started = Instant::now();
+            renderer.render(&frame)?;
+            Ok(started.elapsed())
+        };
+        for _ in 0..o.warmup {
+            draw(&mut renderer)?;
+        }
+        renderer.gpu_times.clear();
+        let (mut call, mut encode, mut gpu) = (Vec::new(), Vec::new(), Vec::new());
+        for _ in 0..o.frames {
+            call.push(ms(draw(&mut renderer)?));
+            encode.push(ms(renderer.last_encode));
+            gpu.append(&mut renderer.gpu_times);
+        }
+        // Timestamps arrive a few frames late: a few more of the same frame bring them in.
+        for _ in 0..16 {
+            if gpu.len() >= o.frames {
+                break;
+            }
+            draw(&mut renderer)?;
+            gpu.append(&mut renderer.gpu_times);
+        }
+        gpu.truncate(o.frames);
+        if let Some(path) = o.screenshot.as_ref().filter(|_| views.is_empty()) {
+            renderer.screenshot_result = None;
+            renderer.screenshot = Some(ScreenshotRequest {
+                path: path.clone(),
+                size: None,
+                scaled: false,
+            });
+            for _ in 0..32 {
+                draw(&mut renderer)?;
+                if renderer.screenshot_result.is_some() {
+                    break;
+                }
+            }
+            match renderer.screenshot_result.take() {
+                Some(Ok(_)) => {}
+                Some(Err(e)) => notes.push(format!("screenshot: {e}")),
+                None => notes.push("screenshot: not saved".into()),
+            }
+        }
+        views.push(json!({
+            "yaw_offset": offset,
+            "gpu_ms": summary(&gpu),
+            "render_call_ms": summary(&call),
+            "cpu_encode_ms": summary(&encode),
+            "gpu_passes_median_ms": renderer
+                .own_pass_times()
+                .into_iter()
+                .map(|(name, ms)| (name, json!(ms)))
+                .collect::<serde_json::Map<_, _>>(),
+            "drawn_sections": renderer.drawn_sections,
+            "section_draws": renderer.section_draws,
+            "section_draw_calls": renderer.section_draw_calls,
+            // Occlusion culling's last result: boxes hidden, boxes tested, share of solid
+            // indices hidden.
+            "culled": renderer.culled_sections(),
+        }));
+    }
+    let section_draws = if renderer.flat_draws() {
+        "flat"
+    } else {
+        "indirect"
+    };
+    let memory = o.memory.then(|| memory_report(&renderer));
+    let report = json!({
+        "capture": o.dir.display().to_string(),
+        "adapter": renderer.info.name,
+        "captured_on": state.adapter,
+        "size": [width, height],
+        "sections": sections,
+        "solid_quads": quads,
+        "leaf_quads": leaf_quads,
+        // Solid quads uploaded as one record each (`mesher::packed`).
+        "packed_quads": packed_quads,
+        "world": world_report,
+        "tiles": tile_count,
+        "load_ms": loaded_ms,
+        "frames": o.frames,
+        "warmup": o.warmup,
+        "settings": {
+            "texture_filtering": filtering,
+            "anisotropy_bit": anisotropy,
+            "mipmaps": o.mipmaps.unwrap_or(settings.mipmap_levels),
+            "lod_distance": o.lod_distance,
+            "render_distance": o.render_distance,
+            "section_draws": section_draws,
+            "section_cull": renderer.section_cull(),
+            "section_sides": renderer.section_sides(),
+            "gpu_culling": renderer.gpu_culling(),
+            "shader_pack_left_out": state.shader_pack,
+        },
+        "notes": notes,
+        "views": views,
+        "memory": memory,
+    });
+    println!("{}", serde_json::to_string_pretty(&report)?);
+    Ok(())
+}
+
+fn mb(bytes: u64) -> f64 {
+    (bytes as f64 / 1048576.0 * 10.0).round() / 10.0
+}
+
+/// `--memory`: the renderer's census in MiB and, on macOS, `footprint`'s summary of this
+/// process (GPU buffers and textures count as IOAccelerator memory there).
+fn memory_report(renderer: &Renderer) -> Value {
+    let gpu: serde_json::Map<String, Value> = renderer
+        .gpu_census()
+        .into_iter()
+        .map(|(name, bytes)| (format!("{name}_mb"), json!(mb(bytes))))
+        .collect();
+    let footprint = std::process::Command::new("/usr/bin/footprint")
+        .args(["-f", "bytes", "-p", &std::process::id().to_string()])
+        .output()
+        .ok()
+        .map(|out| String::from_utf8_lossy(&out.stdout).into_owned());
+    let footprint = footprint.map(|text| {
+        let mut total = None;
+        let mut categories = Vec::new();
+        for line in text.lines() {
+            if let Some(at) = line.find("Footprint: ") {
+                total = line[at + 11..]
+                    .split_whitespace()
+                    .next()
+                    .and_then(|v| v.parse::<u64>().ok());
+            }
+            // "  <dirty> B  <clean> B  <reclaimable> B  <regions>  <category>"
+            let words: Vec<&str> = line.split_whitespace().collect();
+            if words.len() >= 8
+                && words[1] == "B"
+                && let Ok(dirty) = words[0].parse::<u64>()
+                && dirty >= 1 << 20
+            {
+                categories.push(json!([words[7..].join(" "), mb(dirty)]));
+            }
+        }
+        json!({ "total_mb": total.map(mb), "dirty_by_category_mb": categories })
+    });
+    json!({ "gpu": gpu, "footprint": footprint })
+}
+
+struct App;
+impl ApplicationHandler for App {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        let window = Arc::new(
+            event_loop
+                .create_window(Window::default_attributes().with_visible(false))
+                .unwrap(),
+        );
+        if let Err(error) = replay(window) {
+            eprintln!("scene_replay: {error}");
+            std::process::exit(1);
+        }
+        event_loop.exit();
+    }
+    fn window_event(&mut self, _: &ActiveEventLoop, _: WindowId, _: WindowEvent) {}
+}
+
+fn main() {
+    EventLoop::new().unwrap().run_app(&mut App).unwrap();
+}
+
+/// The captured sections' keys, from the index alone.
+fn section_keys(dir: &Path) -> Result<Vec<[i32; 3]>, Box<dyn std::error::Error>> {
+    #[derive(serde::Deserialize)]
+    struct Key {
+        key: [i32; 3],
+    }
+    let records: Vec<Key> = serde_json::from_reader(std::io::BufReader::new(std::fs::File::open(
+        dir.join("sections.json"),
+    )?))?;
+    Ok(records.into_iter().map(|r| r.key).collect())
+}
+
+/// Sprite layers of every leaves block, as terrain vertices carry them (with or
+/// without `OPAQUE_LAYER`).
+fn leaf_layers(render: &RenderAssets) -> FxHashSet<u16> {
+    render
+        .sprite_layers
+        .iter()
+        .filter(|(name, _)| name.ends_with("_leaves"))
+        .flat_map(|(_, &layer)| {
+            [
+                layer as u16,
+                layer as u16 | horizon_client_render::mesher::OPAQUE_LAYER,
+            ]
+        })
+        .collect()
+}
+
+/// `--world`: the sections `keys` meshed again from `save`'s overworld region
+/// files, on every core, as the game's workers mesh them.
+fn remesh(
+    save: &Path,
+    root: &Path,
+    assets: &Assets,
+    render: &RenderAssets,
+    leaf_culling: LeafCullingMode,
+    keys: &[[i32; 3]],
+) -> Result<FxHashMap<[i32; 3], SectionMesh>, Box<dyn std::error::Error>> {
+    let facts = BlockFacts::load(root, assets.registry)?;
+    let visibility = models::load_visibility(root, assets.registry)?;
+    let tables = MeshTables::new(assets, render, &facts, visibility)?;
+    let biomes = Biomes::load(root)?;
+    let seed = world_seed(save).unwrap_or_else(|| {
+        eprintln!(
+            "scene_replay: no seed in {}, biome blending uses 0",
+            save.display()
+        );
+        0
+    });
+    let options = std::fs::read_to_string("options.txt").unwrap_or_default();
+    let option = |key: &str| {
+        options
+            .lines()
+            .find_map(|l| l.strip_prefix(key)?.strip_prefix(':').map(str::to_owned))
+    };
+    let smooth_lighting = option("ao").is_none_or(|v| v == "true");
+    let cutout_leaves = option("cutoutLeaves").is_none_or(|v| v == "true");
+    let blend_radius = option("biomeBlendRadius")
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(2);
+
+    let mut columns: Vec<(i32, i32)> = keys
+        .iter()
+        .flat_map(|&[x, _, z]| {
+            (-1..=1).flat_map(move |dz| (-1..=1).map(move |dx| (x + dx, z + dz)))
+        })
+        .collect();
+    columns.sort_unstable();
+    columns.dedup();
+    let threads = std::thread::available_parallelism().map_or(4, |n| n.get());
+    let region_dir = save.join("dimensions/minecraft/overworld/region");
+    let next = AtomicUsize::new(0);
+    let chunks: FxHashMap<(i32, i32), Chunk> = std::thread::scope(|scope| {
+        let workers: Vec<_> = (0..threads)
+            .map(|_| {
+                scope.spawn(|| {
+                    let mut files: FxHashMap<(i32, i32), Option<RegionFile>> = FxHashMap::default();
+                    let mut out = Vec::new();
+                    loop {
+                        let i = next.fetch_add(1, Ordering::Relaxed);
+                        let Some(&(x, z)) = columns.get(i) else {
+                            break;
+                        };
+                        let file = files.entry((x >> 5, z >> 5)).or_insert_with(|| {
+                            RegionFile::open(region_dir.join(format!(
+                                "r.{}.{}.mca",
+                                x >> 5,
+                                z >> 5
+                            )))
+                            .ok()
+                        });
+                        let root = file
+                            .as_mut()
+                            .and_then(|f| {
+                                f.read(horizon_core::position::ChunkPos::new(x, z))
+                                    .ok()
+                                    .flatten()
+                            })
+                            .and_then(|record| record.nbt(Limits::default()).ok());
+                        if let Some(chunk) =
+                            root.and_then(|root| decode(&root, assets.registry, &biomes))
+                        {
+                            out.push(((x, z), chunk));
+                        }
+                    }
+                    out
+                })
+            })
+            .collect();
+        workers
+            .into_iter()
+            .flat_map(|w| w.join().unwrap())
+            .collect()
+    });
+
+    let meshable: Vec<[i32; 3]> = keys
+        .iter()
+        .copied()
+        .filter(|&[x, _, z]| {
+            (-1..=1).all(|dz| (-1..=1).all(|dx| chunks.contains_key(&(x + dx, z + dz))))
+        })
+        .collect();
+    let next = AtomicUsize::new(0);
+    let meshes = std::thread::scope(|scope| {
+        let workers: Vec<_> = (0..threads)
+            .map(|_| {
+                scope.spawn(|| {
+                    let mut mesher = Mesher {
+                        nether_shading: false,
+                        shader_pack_lighting: false,
+                        separate_ao: false,
+                        assets,
+                        render,
+                        tables: &tables,
+                        biomes: &biomes,
+                        visibility: tables.visibility.clone(),
+                        zoom: BiomeZoom::new(obfuscate_seed(seed)),
+                        blend_radius,
+                        smooth_lighting,
+                        cutout_leaves,
+                        translucent_layers: &[],
+                        leaf_culling,
+                    };
+                    let mut scratch = MeshScratch::default();
+                    let mut out = Vec::new();
+                    loop {
+                        let i = next.fetch_add(1, Ordering::Relaxed);
+                        let Some(&[x, y, z]) = meshable.get(i) else {
+                            break;
+                        };
+                        let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|dz| {
+                            std::array::from_fn(|dx| {
+                                chunks.get(&(x + dx as i32 - 1, z + dz as i32 - 1))
+                            })
+                        });
+                        let mut mesh =
+                            mesher.mesh_reusing(&region, y, SectionMesh::default(), &mut scratch);
+                        mesh.sort_solid();
+                        out.push(([x, y, z], mesh));
+                    }
+                    out
+                })
+            })
+            .collect();
+        workers
+            .into_iter()
+            .flat_map(|w| w.join().unwrap())
+            .collect::<FxHashMap<_, _>>()
+    });
+    Ok(meshes)
+}
+
+/// The world seed: `data/minecraft/world_gen_settings.dat`, or level.dat's
+/// `Data.WorldGenSettings` in older saves.
+fn world_seed(save: &Path) -> Option<i64> {
+    let read = |path: PathBuf| {
+        horizon_world::datafix::files::read_dat(&path)
+            .ok()
+            .flatten()
+    };
+    let seed = |tag: Option<&Tag>| match tag?.get("seed")? {
+        Tag::Long(seed) => Some(*seed),
+        _ => None,
+    };
+    seed(
+        read(save.join("data/minecraft/world_gen_settings.dat"))
+            .as_ref()
+            .and_then(|t| t.get("data")),
+    )
+    .or_else(|| {
+        seed(
+            read(save.join("level.dat"))?
+                .get("Data")?
+                .get("WorldGenSettings"),
+        )
+    })
+}
+
+/// A saved full chunk's blocks, biomes and light, as the client's own save
+/// loader reads them (`save::decode_lit`, in horizon-client).
+fn decode(root: &NamedTag, registry: &BlockRegistry, biomes: &Biomes) -> Option<Chunk> {
+    let tag = &root.tag;
+    let text = |t: Option<&Tag>| match t {
+        Some(Tag::String(s)) => Some(s.to_string_lossy().to_string()),
+        _ => None,
+    };
+    if text(tag.get("Status")).is_some_and(|s| s != "minecraft:full" && s != "full") {
+        return None;
+    }
+    if tag.get("isLightOn") != Some(&Tag::Byte(1)) {
+        return None;
+    }
+    let (Some(Tag::Int(x)), Some(Tag::Int(z))) = (tag.get("xPos"), tag.get("zPos")) else {
+        return None;
+    };
+    let mut chunk = Chunk::with_layout(*x, *z, ColumnLayout::VANILLA);
+    let air = registry.default_state("minecraft:air")?.0;
+    let Some(Tag::List(sections)) = tag.get("sections") else {
+        return Some(chunk);
+    };
+    let longs = |t: Option<&Tag>| match t {
+        Some(Tag::LongArray(data)) => Some(data.iter().map(|&w| w as u64).collect::<Vec<_>>()),
+        _ => None,
+    };
+    let mut layers = vec![(None, None); chunk.sections.len()];
+    for section in sections {
+        let Some(Tag::Byte(y)) = section.get("Y") else {
+            continue;
+        };
+        let Some(si) = chunk.section_index(i32::from(*y) * 16) else {
+            continue;
+        };
+        let target = Arc::make_mut(&mut chunk.sections[si]);
+        if let Some(states) = section.get("block_states")
+            && let Some(Tag::List(palette)) = states.get("palette")
+        {
+            let palette: Vec<u32> = palette
+                .iter()
+                .map(|p| {
+                    BlockState::from_nbt(p)
+                        .ok()
+                        .and_then(|s| {
+                            registry.id(&s).or_else(|| {
+                                let default = registry.default_state(&s.name)?;
+                                let mut full = registry.state(default)?.clone();
+                                for (k, v) in &s.properties {
+                                    if full.properties.contains_key(k) {
+                                        full.properties.insert(k.clone(), v.clone());
+                                    }
+                                }
+                                registry.id(&full).or(Some(default))
+                            })
+                        })
+                        .map_or(air, |id| id.0)
+                })
+                .collect();
+            let data = longs(states.get("data"));
+            if let Ok(blocks) =
+                PalettedContainer::from_packed(block_strategy(), palette, data.as_deref())
+            {
+                target.blocks = blocks;
+            }
+        }
+        if let Some(b) = section.get("biomes")
+            && let Some(Tag::List(palette)) = b.get("palette")
+        {
+            let palette: Vec<u32> = palette
+                .iter()
+                .map(|p| match p {
+                    Tag::String(s) => u32::from(biomes.id(&s.to_string_lossy())),
+                    _ => 0,
+                })
+                .collect();
+            let data = longs(b.get("data"));
+            if let Ok(container) =
+                PalettedContainer::from_packed(BIOME_STRATEGY, palette, data.as_deref())
+            {
+                target.biomes = container;
+            }
+        }
+        let layer = |name: &str| match section.get(name) {
+            Some(Tag::ByteArray(a)) if a.len() == 2048 => Some(a.clone()),
+            _ => None,
+        };
+        layers[si] = (layer("SkyLight"), layer("BlockLight"));
+    }
+    // `save::load_light`: a section without saved sky light takes the light
+    // of the blocks above it, from the top of the column down.
+    let mut above = [15u8; 256];
+    for (si, (sky, block)) in layers.into_iter().enumerate().rev() {
+        let mut data = Box::new([0u8; 4096]);
+        for (i, v) in data.iter_mut().enumerate() {
+            let nibble =
+                |layer: &Option<Vec<u8>>| layer.as_ref().map(|l| l[i >> 1] >> ((i & 1) << 2) & 15);
+            let s = nibble(&sky).unwrap_or(above[i & 255]);
+            let b = nibble(&block).unwrap_or(0);
+            *v = s << 4 | b;
+        }
+        if sky.is_some() {
+            for (i, a) in above.iter_mut().enumerate() {
+                *a = data[i] >> 4;
+            }
+        }
+        let section = Arc::make_mut(&mut chunk.sections[si]);
+        section.light = Light::Full(data);
+        section.compact();
+    }
+    chunk.lit = true;
+    chunk.light_loaded = true;
+    Some(chunk)
+}

crates/horizon-client-render/examples/standard_pack_gpu_entities.rs

@@ -121,6 +121,7 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
         None,
         GraphicsApi::Vulkan,
         false,
+        false,
         true,
     ))?;
     renderer.resize(320, 180);

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

@@ -207,6 +207,20 @@ impl Assets {
     pub fn reload(&self, root: &Path) -> Result<RenderAssets> {
         RenderAssets::load(root, self)
     }
+    /// [`Assets::reload`] with the model library already parsed.
+    ///
+    /// Parsing it reads every model file under `assets/`, which needs no
+    /// block registry, so a caller that has the files to spare can start
+    /// it before `Assets::load` finishes and hand the result in here. On
+    /// a cold cache that is most of a second of reading moved off the
+    /// critical path.
+    pub fn reload_with_models(
+        &self,
+        root: &Path,
+        parsed: crate::model_library::ParsedModels,
+    ) -> Result<RenderAssets> {
+        RenderAssets::load_with_parsed(root, self, true, Some(parsed))
+    }
     /// [`Assets::reload`] for a server, which draws nothing: the sprites'
     /// layers, without the block or item models or the textures' pixels.
     pub fn reload_for_server(&self, root: &Path) -> Result<RenderAssets> {
@@ -218,6 +232,16 @@ impl RenderAssets {
         Self::load_with(root, assets, true)
     }
     fn load_with(root: &Path, assets: &Assets, draws: bool) -> Result<Self> {
+        Self::load_with_parsed(root, assets, draws, None)
+    }
+    /// `parsed`: the model library when a caller parsed it ahead of this
+    /// (see [`Assets::reload_with_models`]); otherwise it is parsed here.
+    fn load_with_parsed(
+        root: &Path,
+        assets: &Assets,
+        draws: bool,
+        parsed: Option<crate::model_library::ParsedModels>,
+    ) -> Result<Self> {
         let registry = assets.registry;
         let mut sprites = crate::sprites::Sprites::with_disk_cache(root);
         for name in MATERIALS {
@@ -225,17 +249,24 @@ impl RenderAssets {
         }
         // 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 = match parsed {
+            Some(parsed) => parsed,
+            None if draws => {
+                let _step = crate::spans::startup::step("core.models_parse");
+                crate::model_library::ParsedModels::load(root)
+            }
+            None => crate::model_library::ParsedModels::default(),
         };
         let mut models = if draws {
+            let _step = crate::spans::startup::step("core.models_bake");
             crate::models::prepare_with_models(root, registry, &mut sprites, &parsed)?
         } else {
             crate::models::PreparedModels::default()
         };
-        let model_library = parsed.into_item_library();
+        let model_library = {
+            let _step = crate::spans::startup::step("core.item_library");
+            parsed.into_item_library()
+        };
         // Fluids are drawn by the fluid renderer, not block models; breaking
         // progress uses the destroy-stage overlays.
         for name in [
@@ -251,6 +282,7 @@ impl RenderAssets {
             sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
         }
         let fusion = if draws {
+            let _step = crate::spans::startup::step("core.fusion");
             crate::fusion::FusionTextures::load(root, registry, &mut sprites, &mut models.catalog)
         } else {
             Default::default()

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

@@ -379,14 +379,17 @@ pub fn generate(
             let (_, _, key) = load(palette_key, "textures/palettes")?;
             let (_, _, target) = load(palette, "textures/palettes")?;
             let mut mapped = argb(&pixels);
-            apply_palette(&mut mapped, &argb(&key), &argb(&target))?;
-            let out = mapped
+            let key = argb(&key);
+            let target = argb(&target);
+            apply_palette(&mut mapped, &key, &target)?;
+            let out: Vec<u8> = mapped
                 .iter()
                 .flat_map(|p| {
                     let [a, r, g, b] = p.to_be_bytes();
                     [r, g, b, a]
                 })
                 .collect();
+            drop(mapped);
             Some((w, h, out))
         }
     }

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

@@ -61,6 +61,8 @@ struct Mixer {
     world_names: Vec<String>,
     /// The callback's cameras (position, basis, world), kept to be refilled without allocating.
     cameras: Vec<([f64; 3], Basis, u32)>,
+    /// Per-source gain/pan/step cache for one buffer, reused across callbacks.
+    voices: Vec<(ChannelId, [f32; 3], f64)>,
     limiter_peak: f32,
     /// The output device the stream was opened on (`Library.currentDeviceName`).
     #[cfg(feature = "audio")]
@@ -544,9 +546,8 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
         (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(
+    mixer.cameras.clear();
+    mixer.cameras.extend(
         std::iter::once((
             0,
             (mixer.listener, mixer.listener_yaw, mixer.listener_pitch),
@@ -565,10 +566,11 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
             )
         }),
     );
-    let shared = cameras.len() > 1;
+    let shared = mixer.cameras.len() > 1;
     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();
+    let mut voices = std::mem::take(&mut mixer.voices);
+    voices.clear();
     for (id, c) in &mixer.channels {
         let Some((_, source_rate)) = &c.samples else {
             continue;
@@ -586,7 +588,8 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
         };
         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
+        let camera = mixer
+            .cameras
             .iter()
             .filter(|camera| c.relative || camera.2 == c.world)
             .min_by(|a, b| length(away(a.0)).total_cmp(&length(away(b.0))))
@@ -617,8 +620,7 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
         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 {
+    for (id, [left, right, gain], step) in voices.iter().copied() {
         let Some(c) = mixer.channels.get_mut(&id) else {
             continue;
         };
@@ -648,6 +650,7 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
             c.position += step;
         }
     }
+    mixer.voices = voices;
     // Limit the whole buffer together, preserving waveform and stereo balance
     // instead of flattening each overloaded sample; release over 200 ms
     // (OpenAL Soft's output limiter, `ALC_OUTPUT_LIMITER_SOFT`, releases

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

@@ -101,6 +101,22 @@ impl AuthSession {
         let _ = std::fs::remove_file(path);
         Self::parse(&text.map_err(|e| format!("{}: {e}", path.display()))?)
     }
+    /// The access token's expiry (its JWT `exp`) has passed, or is a minute away: the session
+    /// service would refuse it. A token that doesn't read as a JWT counts as good: the server
+    /// says.
+    pub fn expired(&self) -> bool {
+        let exp = self
+            .access_token
+            .split('.')
+            .nth(1)
+            .and_then(|p| crate::skins::base64_decode(&p.replace('-', "+").replace('_', "/")))
+            .and_then(|json| serde_json::from_slice::<serde_json::Value>(&json).ok())
+            .and_then(|v| v.get("exp")?.as_u64());
+        let now = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .map_or(0, |d| d.as_secs());
+        exp.is_some_and(|exp| exp <= now + 60)
+    }
 }
 
 static CURRENT: OnceLock<Arc<AuthSession>> = OnceLock::new();
@@ -436,11 +452,8 @@ struct ChatKeys {
     fetching: bool,
     next_try: Option<std::time::Instant>,
 }
-static CHAT_KEYS: Mutex<ChatKeys> = Mutex::new(ChatKeys {
-    current: None,
-    fetching: false,
-    next_try: None,
-});
+static CHAT_KEYS: std::sync::LazyLock<Mutex<std::collections::HashMap<u128, ChatKeys>>> =
+    std::sync::LazyLock::new(|| Mutex::new(std::collections::HashMap::new()));
 
 /// prepareKeyPair (`now`: on a join) or, from a tick, shouldRefreshKeyPair
 /// then prepareKeyPair: start fetching when there is no key pair or it is
@@ -449,7 +462,14 @@ pub fn prepare_chat_keys(now: bool) {
     let Some(session) = current() else {
         return;
     };
-    let mut keys = CHAT_KEYS.lock().unwrap();
+    prepare_chat_keys_for(session, now);
+}
+
+/// Prepare keys for this player, independently of the other local accounts.
+pub fn prepare_chat_keys_for(session: Arc<AuthSession>, now: bool) {
+    let uuid = session.uuid;
+    let mut accounts = CHAT_KEYS.lock().unwrap();
+    let keys = accounts.entry(uuid).or_default();
     let instant = std::time::Instant::now();
     if keys.fetching || !now && keys.next_try.is_some_and(|t| instant < t) {
         return;
@@ -463,12 +483,13 @@ pub fn prepare_chat_keys(now: bool) {
         return;
     }
     keys.fetching = true;
-    drop(keys);
+    drop(accounts);
     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();
+            let mut accounts = CHAT_KEYS.lock().unwrap();
+            let keys = accounts.entry(uuid).or_default();
             keys.fetching = false;
             match result {
                 Ok(pair) => keys.current = Some(Arc::new(pair)),
@@ -476,19 +497,24 @@ pub fn prepare_chat_keys(now: bool) {
             }
         });
     if spawned.is_err() {
-        CHAT_KEYS.lock().unwrap().fetching = false;
+        CHAT_KEYS.lock().unwrap().entry(uuid).or_default().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_for(current()?.uuid)
+}
+
+/// This account's key pair; another local player's keys can never be returned.
+pub fn chat_keys_for(uuid: u128) -> Option<Arc<ChatKeyPair>> {
     CHAT_KEYS
         .lock()
         .unwrap()
+        .get(&uuid)?
         .current
         .clone()
-        .filter(|k| !k.public.has_expired(now))
+        .filter(|k| !k.public.has_expired(now_millis()))
 }
 
 const MINECRAFT_PROFILE: &str = "https://api.minecraftservices.com/minecraft/profile";
@@ -632,6 +658,42 @@ mod tests {
         }
     }
 
+    /// base64url without padding, as a JWT's parts are.
+    fn base64url(bytes: &[u8]) -> String {
+        const ALPHABET: &[u8; 64] =
+            b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+        let mut out = String::new();
+        for chunk in bytes.chunks(3) {
+            let n =
+                chunk.iter().fold(0u32, |n, &b| n << 8 | u32::from(b)) << (8 * (3 - chunk.len()));
+            for k in 0..=chunk.len() {
+                out.push(char::from(ALPHABET[(n >> (18 - 6 * k) & 63) as usize]));
+            }
+        }
+        out
+    }
+
+    #[test]
+    fn a_token_past_its_exp_is_expired() {
+        // header.payload.signature, the payload base64url without padding.
+        let token = |exp: u64| {
+            let json = format!(r#"{{"exp":{exp}}}"#);
+            let payload = base64url(json.as_bytes());
+            AuthSession::new("Ann", UUID, &format!("e30.{payload}.sig"))
+        };
+        let now = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        assert!(token(now - 10).expired());
+        assert!(
+            token(now + 30).expired(),
+            "a minute from its end: as good as gone"
+        );
+        assert!(!token(now + 3600).expired());
+        assert!(!AuthSession::new("Ann", UUID, "not-a-jwt").expired());
+    }
+
     fn write(dir: &Path, text: &str, mode: u32) -> std::path::PathBuf {
         let path = dir.join("session.json");
         std::fs::write(&path, text).unwrap();
@@ -795,6 +857,37 @@ mod tests {
         .to_string()
     }
 
+    #[test]
+    fn local_accounts_use_their_own_chat_keys() {
+        let pair = |signature: &[u8]| {
+            let mut keys = parse_certificates(&certificates(PRIVATE_B64, PUBLIC_B64)).unwrap();
+            keys.public.expires_at = i64::MAX;
+            keys.refreshed_after = i64::MAX;
+            keys.public.signature = signature.to_vec();
+            Arc::new(keys)
+        };
+        let ann = pair(b"ann");
+        let bea = pair(b"bea");
+        {
+            let mut accounts = CHAT_KEYS.lock().unwrap();
+            for (uuid, keys) in [(101, ann.clone()), (102, bea.clone())] {
+                accounts.insert(
+                    uuid,
+                    ChatKeys {
+                        current: Some(keys),
+                        ..Default::default()
+                    },
+                );
+            }
+        }
+        prepare_chat_keys_for(Arc::new(AuthSession::new("Ann", 101, "unused")), true);
+        assert!(Arc::ptr_eq(&chat_keys_for(101).unwrap(), &ann));
+        assert!(Arc::ptr_eq(&chat_keys_for(102).unwrap(), &bea));
+        assert!(chat_keys_for(103).is_none());
+        CHAT_KEYS.lock().unwrap().remove(&101);
+        CHAT_KEYS.lock().unwrap().remove(&102);
+    }
+
     #[test]
     fn certificates_response() {
         let pair = parse_certificates(&certificates(PRIVATE_B64, PUBLIC_B64)).unwrap();

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

@@ -50,8 +50,9 @@ struct Out {
     @builtin(position) clip: vec4<f32>,
     @location(0) uv: vec2<f32>,
     @location(1) color: vec4<f32>,
-    @location(2) spherical: f32,
-    @location(3) cylindrical: f32,
+    // The distances fog reads: .x spherical, .y cylindrical. One vec2 rather than two floats, so that
+    // the fragment stage stays within 14 user-defined inputs plus front_facing (GL's limit of 15, #8195).
+    @location(2) fog_distance: vec2<f32>,
     // entity.vsh's overlayColor: the OverlayTexture texel (see overlay_texel).
     @location(5) overlay_color: vec4<f32>,
     @location(4) @interpolate(flat) overlay: u32,
@@ -157,11 +158,11 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
     out.back_color = back;
     out.overlay_color = overlay_texel(overlay);
     // Sky geometry (clouds, celestial bodies) is exempt from render-distance fog.
-    out.spherical = select(length(position), 0.0, overlay >= 2u && overlay <= 4u);
-    out.cylindrical = select(max(length(position.xz), abs(position.y)), 0.0, overlay >= 2u && overlay <= 4u);
+    out.fog_distance.x = select(length(position), 0.0, overlay >= 2u && overlay <= 4u);
+    out.fog_distance.y = select(max(length(position.xz), abs(position.y)), 0.0, overlay >= 2u && overlay <= 4u);
     out.overlay = overlay;
     out.glint_uv = vec2(0.0);
-    if overlay == 4u { out.spherical = length(position); }
+    if overlay == 4u { out.fog_distance.x = length(position); }
     return out;
 }
 @vertex fn vs_entity(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
@@ -293,7 +294,7 @@ fn entity_color(in: Out, front: bool) -> vec4<f32> {
         color = vec4(c, 1.0);
     } else if in.overlay == 4u {
         // clouds.fsh: alpha fades out towards the cloud fog end.
-        return vec4(color.rgb, color.a * (1.0 - linear_fog(in.spherical, 0.0, globals.fog_ends.y)));
+        return vec4(color.rgb, color.a * (1.0 - linear_fog(in.fog_distance.x, 0.0, globals.fog_ends.y)));
     }
     if color.a < 0.1 || (in.cull != 0u && !front) { discard; }
     // entity.fsh calculateFinalColor: the overlay (hurt red, TNT white) over the
@@ -312,8 +313,8 @@ fn entity_color(in: Out, front: bool) -> vec4<f32> {
             textureSample(glint_armor_tex, glint_sampler, armor_glint_uv(in.glint_uv)),
         );
     }
-    let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
-                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
+    let f = max(linear_fog(in.fog_distance.x, globals.fog.x, globals.fog.y),
+                linear_fog(in.fog_distance.y, globals.fog.z, globals.fog.w));
     return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
 }
 
@@ -327,8 +328,8 @@ fn entity_color(in: Out, front: bool) -> vec4<f32> {
 fn shadow_color(in: Out) -> vec4<f32> {
     var color = textureSample(atlas, atlas_sampler, in.uv) * in.color;
     color *= in.light_color;
-    let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
-                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
+    let f = max(linear_fog(in.fog_distance.x, globals.fog.x, globals.fog.y),
+                linear_fog(in.fog_distance.y, globals.fog.z, globals.fog.w));
     return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
 }
 
@@ -347,8 +348,8 @@ fn shadow_color(in: Out) -> vec4<f32> {
     let texel = textureSample(atlas, atlas_sampler, uv);
     if texel.a < 0.1 { discard; }
     // Fog hides a light source and the light on a surface as it hides everything else.
-    let fogged = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
-        linear_fog(in.cylindrical, globals.fog.z, globals.fog.w)) * globals.fog_color.a;
+    let fogged = max(linear_fog(in.fog_distance.x, globals.fog.x, globals.fog.y),
+        linear_fog(in.fog_distance.y, globals.fog.z, globals.fog.w)) * globals.fog_color.a;
     if in.tier == 0u {
         return vec4(0.0, 0.0, 0.0, hdr_scene_alpha(mix(in.scene, globals.hdr_light.y, fogged)));
     }
@@ -379,7 +380,7 @@ fn hdr_mark(tier: u32, y: f32) -> f32 {
 // HDR lighting on clouds, drawn again after them with only alpha written: they're lit by the
 // sky, so they take its value, which their blending would otherwise cover.
 @fragment fn fs_hdr_cloud_mark(in: Out) -> @location(0) vec4<f32> {
-    let a = in.color.a * (1.0 - linear_fog(in.spherical, 0.0, globals.fog_ends.y));
+    let a = in.color.a * (1.0 - linear_fog(in.fog_distance.x, 0.0, globals.fog_ends.y));
     if a < 0.1 { discard; }
     return vec4(0.0, 0.0, 0.0, hdr_scene_alpha(globals.hdr_light.y));
 }
@@ -388,8 +389,8 @@ fn celestial_color(in: Out) -> vec4<f32> {
     // RenderPipelines.DRAGON_RAYS / rendertype_lightning.fsh: untextured
     // vertex colour, with fog fading both RGB and alpha before additive blending.
     if in.overlay == 37u {
-        let fog = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
-                      linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
+        let fog = max(linear_fog(in.fog_distance.x, globals.fog.x, globals.fog.y),
+                      linear_fog(in.fog_distance.y, globals.fog.z, globals.fog.w));
         return in.color * (1.0 - fog);
     }
     return textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
@@ -428,8 +429,8 @@ fn energy_swirl_base(in: Out) -> vec4<f32> {
     return vec4(color.rgb * (128.0 / 255.0), color.a);
 }
 fn energy_swirl_fog(in: Out) -> f32 {
-    let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
-                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
+    let f = max(linear_fog(in.fog_distance.x, globals.fog.x, globals.fog.y),
+                linear_fog(in.fog_distance.y, globals.fog.z, globals.fog.w));
     return f * globals.fog_color.a;
 }
 @fragment fn fs_energy_swirl(in: Out) -> @location(0) vec4<f32> {
@@ -572,7 +573,7 @@ fn weather_color(in: Out) -> vec4<f32> {
     var color = textureLoad(atlas, texel, 0) * in.color;
     if color.a < 0.1 { discard; }
     color *= in.light_color;
-    let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
-                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
+    let f = max(linear_fog(in.fog_distance.x, globals.fog.x, globals.fog.y),
+                linear_fog(in.fog_distance.y, globals.fog.z, globals.fog.w));
     return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
 }

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

@@ -120,7 +120,7 @@ pub struct Environment {
     tracks: HashMap<String, Track>,
     base: HashMap<String, [f32; 4]>,
 }
-#[derive(Clone, Copy, Debug, Default)]
+#[derive(Clone, Copy, Debug, Default, serde::Serialize, serde::Deserialize)]
 pub struct Sky {
     pub sky_color: [f32; 3],
     pub fog_color: [f32; 3],

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

@@ -8,6 +8,8 @@ use std::{collections::VecDeque, fs, path::Path};
 pub const FILE: &str = "horizon-extras.txt";
 /// The name the options screen uses while the sort key waits for a key.
 pub const SORT_KEY: &str = "horizon.sort";
+/// The 3D skin layers line, here and in the `options.txt` that held it first.
+const SKIN_LAYERS_KEY: &str = "threeDSkinLayers";
 
 /// The minimap's sizes in GUI pixels, and its zooms in blocks per pixel.
 pub const MINIMAP_SIZES: [(u8, &str); 3] = [(64, "Small"), (96, "Medium"), (128, "Large")];
@@ -157,6 +159,10 @@ pub struct Extras {
     pub cosmetics_mine: bool,
     pub cosmetics_others: horizon_cosmetics::prefs::Others,
     pub cosmetics_auras: bool,
+    /// 3D skin layers (`threeDSkinLayers`, Options → Skin Customization): each
+    /// painted texel of a player's outer layer drawn as a slab
+    /// (`horizon_client::mobs::skin_layers`).
+    pub three_d_skin_layers: bool,
 }
 impl Default for Extras {
     fn default() -> Self {
@@ -206,6 +212,7 @@ impl Default for Extras {
             cosmetics_mine: true,
             cosmetics_others: horizon_cosmetics::prefs::Others::Shown,
             cosmetics_auras: false,
+            three_d_skin_layers: false,
         }
     }
 }
@@ -307,6 +314,7 @@ impl Extras {
                         horizon_cosmetics::prefs::Others::parse(value).unwrap_or(e.cosmetics_others)
                 }
                 "cosmeticsAuras" => e.cosmetics_auras = flag(e.cosmetics_auras),
+                SKIN_LAYERS_KEY => e.three_d_skin_layers = flag(e.three_d_skin_layers),
                 _ => {}
             }
         }
@@ -314,7 +322,7 @@ impl Extras {
     }
     pub fn serialize(&self) -> String {
         format!(
-            "packBrowser:{}\nfullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nmovedToMods:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nuiSoundReserve:{}\nownNameTag:{}\nhideBlockParticles:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\nchatAnimation:{}\nchatIndicator:{}\n{}:{}\nagentControl:{}\nreproKeys:{}\ndiscordPresence:{}\nsplitscreen:{}\nsplitscreenTwo:{}\nsplitscreenThree:{}\nsplitscreenNames:{}\nwheelCyclesSettings:{}\nmusicOff:{}\nmusicPage:{}\ncosmeticsMine:{}\ncosmeticsOthers:{}\ncosmeticsAuras:{}\n",
+            "packBrowser:{}\nfullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nmovedToMods:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nuiSoundReserve:{}\nownNameTag:{}\nhideBlockParticles:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\nchatAnimation:{}\nchatIndicator:{}\n{}:{}\nagentControl:{}\nreproKeys:{}\ndiscordPresence:{}\nsplitscreen:{}\nsplitscreenTwo:{}\nsplitscreenThree:{}\nsplitscreenNames:{}\nwheelCyclesSettings:{}\nmusicOff:{}\nmusicPage:{}\ncosmeticsMine:{}\ncosmeticsOthers:{}\ncosmeticsAuras:{}\n{}:{}\n",
             bool_text(self.pack_browser),
             bool_text(self.fullbright),
             bool_text(self.dynamic_lights),
@@ -365,8 +373,28 @@ impl Extras {
             bool_text(self.cosmetics_mine),
             self.cosmetics_others.name(),
             bool_text(self.cosmetics_auras),
+            SKIN_LAYERS_KEY,
+            bool_text(self.three_d_skin_layers),
         )
     }
+    /// Adopts the settings `options.txt` held before they moved here, while
+    /// this file (`own`) has no line of its own: 3D skin layers was an
+    /// `options.txt` line. Vanilla's `Options.save` drops lines it doesn't
+    /// know, so it is read there once, the first start after the update.
+    pub fn read_old_options(&mut self, own: &str, options_txt: &str) {
+        fn line(text: &str) -> Option<&str> {
+            text.lines().find_map(|l| {
+                l.split_once(':')
+                    .filter(|(key, _)| *key == SKIN_LAYERS_KEY)
+                    .map(|(_, value)| value)
+            })
+        }
+        if line(own).is_none()
+            && let Some(value) = line(options_txt)
+        {
+            self.three_d_skin_layers = value == "true";
+        }
+    }
     /// Binds the extra key `name` (`SORT_KEY`); false for
     /// another name (a vanilla mapping).
     pub fn set_key(&mut self, name: &str, value: String) -> bool {

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

@@ -21,7 +21,7 @@ pub enum FogType {
 }
 
 /// The fog uniform (`FogData`).
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct FogData {
     pub color: [f32; 4],
     pub environmental_start: f32,

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

@@ -104,8 +104,11 @@ struct FontSet {
     providers: Vec<Provider>,
     /// Every char drawn looks up here, so the hasher is Fx, not SipHash.
     glyphs: crate::fast_hash::FxHashMap<char, Glyph>,
-    /// `glyphsByWidth` for obfuscated text (built on first use).
-    by_width: Option<HashMap<u32, Vec<char>>>,
+    /// `SelectedGlyphs.nonFishy` of the characters whose first glyph has a fishy advance (the
+    /// others use `glyphs`): what obfuscated text draws.
+    non_fishy: crate::fast_hash::FxHashMap<char, Glyph>,
+    /// `glyphsByWidth` for obfuscated text (built on first use), by `ceil(advance)`.
+    by_width: Option<HashMap<i32, Vec<char>>>,
 }
 /// The atlas region glyphs are rasterized into, filled in rows.
 struct Region {
@@ -258,10 +261,11 @@ fn used_width(pixels: &[u8], stride: u32, (cx, cy, cw, ch): (u32, u32, u32, u32)
         })
         .map_or(0, |x| x + 1)
 }
-/// `FontSet.hasFishyAdvance`: a provider glyph whose advance is under 0 or
-/// over 32 is not used. `FontSet.computeGlyphInfo` moves on to the next
-/// provider that has the character, so a pack's absurd advance cannot widen
-/// a line; Horizon keeps one advance per glyph and tests it here.
+/// `FontSet.hasFishyAdvance`: an advance under 0 or over 32. Such a glyph is still the one drawn
+/// (`SelectedGlyphs.any` is the first provider's); only `SelectedGlyphs.nonFishy`, what obfuscated
+/// text draws, moves on to the next provider that has the character. Packs rely on it: a `space`
+/// provider's kerning runs from -512 to 512, and a tall bitmap's glyphs pass 32. Horizon keeps one
+/// advance per glyph and tests it here.
 fn fishy_advance(advance: f32) -> bool {
     !(0.0..=32.0).contains(&advance)
 }
@@ -674,6 +678,7 @@ impl Font {
         FontSet {
             providers,
             glyphs: Default::default(),
+            non_fishy: Default::default(),
             by_width: None,
         }
     }
@@ -682,6 +687,7 @@ impl Font {
         let mut cache = self.cache.borrow_mut();
         for (_, set) in &mut cache.sets {
             set.glyphs.clear();
+            set.non_fishy.clear();
             set.by_width = None;
         }
         cache.region.cursor = (0, 0);
@@ -735,7 +741,7 @@ impl Font {
             return *g;
         }
         let was_full = std::mem::replace(&mut region.full, false);
-        let found = self.resolve(set, region, c);
+        let found = self.resolve(set, region, c, false);
         // No room: the missing glyph for now, not remembered, so the
         // character is tried again once `begin_frame` cleared the region.
         let overflowed = std::mem::replace(&mut region.full, was_full);
@@ -747,13 +753,46 @@ impl Font {
         set.glyphs.insert(c, glyph);
         glyph
     }
-    fn resolve(&self, set: &mut FontSet, region: &mut Region, c: char) -> Option<Glyph> {
+    /// `FontSet.getRandomGlyph`'s `SelectedGlyphs.nonFishy`: the glyph of the first provider whose
+    /// advance is not fishy, else the missing glyph. A character whose first glyph is fine has
+    /// the same one for both.
+    fn glyph_non_fishy(&self, id: &str, c: char) -> Glyph {
+        let any = self.glyph_of(id, c);
+        if !fishy_advance(any.advance) {
+            return any;
+        }
+        let mut cache = self.cache.borrow_mut();
+        let Cache { sets, region, .. } = &mut *cache;
+        let Some((_, set)) = sets.iter_mut().find(|(k, _)| k == id) else {
+            return self.missing;
+        };
+        if let Some(g) = set.non_fishy.get(&c) {
+            return *g;
+        }
+        let was_full = std::mem::replace(&mut region.full, false);
+        let found = self.resolve(set, region, c, true);
+        let overflowed = std::mem::replace(&mut region.full, was_full);
+        region.full |= overflowed;
+        if overflowed {
+            return self.missing;
+        }
+        let glyph = found.unwrap_or(self.missing);
+        set.non_fishy.insert(c, glyph);
+        glyph
+    }
+    fn resolve(
+        &self,
+        set: &mut FontSet,
+        region: &mut Region,
+        c: char,
+        non_fishy: bool,
+    ) -> Option<Glyph> {
         let (uniform, japanese) = (self.uniform, self.japanese);
         for provider in &mut set.providers {
             match provider {
                 Provider::Space(advances) => {
                     if let Some(a) = advances.get(&c)
-                        && !fishy_advance(*a)
+                        && !(non_fishy && fishy_advance(*a))
                     {
                         return Some(Glyph {
                             rect: None,
@@ -768,10 +807,12 @@ impl Font {
                 }
                 Provider::Bitmap(filter, glyphs) if filter.passes(uniform, japanese) => {
                     match glyphs.get(&c) {
-                        Some(BitmapGlyph::Atlas(g)) if !fishy_advance(g.advance) => {
+                        Some(BitmapGlyph::Atlas(g)) if !(non_fishy && fishy_advance(g.advance)) => {
                             return Some(*g);
                         }
-                        Some(BitmapGlyph::Sheet(cell)) if !fishy_advance(cell.glyph.advance) => {
+                        Some(BitmapGlyph::Sheet(cell))
+                            if !(non_fishy && fishy_advance(cell.glyph.advance)) =>
+                        {
                             let (stride, pixels) = (&cell.sheet.0, &cell.sheet.1);
                             let mut rgba = Vec::with_capacity((cell.w * cell.h * 4) as usize);
                             for y in cell.y..cell.y + cell.h {
@@ -791,14 +832,14 @@ impl Font {
                 Provider::Unihex(filter, def, glyphs) if filter.passes(uniform, japanese) => {
                     let glyphs = glyphs.get_or_insert_with(|| load_hex(&self.root, def));
                     if let Some(h) = glyphs.get(&u32::from(c)).copied()
-                        && !fishy_advance(hex_advance(&h))
+                        && !(non_fishy && fishy_advance(hex_advance(&h)))
                     {
                         return self.rasterize_hex(region, h);
                     }
                 }
                 Provider::TrueType(filter, ttf) if filter.passes(uniform, japanese) => {
                     if let Some(id) = ttf.ids.get(&c)
-                        && !fishy_advance(ttf.advance(*id))
+                        && !(non_fishy && fishy_advance(ttf.advance(*id)))
                     {
                         let (glyph, bitmap) = ttf.glyph(*id);
                         return match bitmap {
@@ -851,7 +892,7 @@ impl Font {
     pub fn random_glyph(&self, style: &Style, advance: f32) -> Glyph {
         use horizon_core::random::RandomSource;
         let id = style.font.as_deref().unwrap_or(DEFAULT);
-        let width = advance.ceil() as u32;
+        let width = advance.ceil() as i32;
         let pick = {
             let mut cache = self.cache.borrow_mut();
             let Cache { sets, random, .. } = &mut *cache;
@@ -869,9 +910,9 @@ impl Font {
                     chars.get(i as usize).copied()
                 })
         };
-        pick.map_or(self.missing, |c| self.glyph_of(id, c))
+        pick.map_or(self.missing, |c| self.glyph_non_fishy(id, c))
     }
-    fn glyphs_by_width(&self, set: &mut FontSet) -> HashMap<u32, Vec<char>> {
+    fn glyphs_by_width(&self, set: &mut FontSet) -> HashMap<i32, Vec<char>> {
         let (uniform, japanese) = (self.uniform, self.japanese);
         let mut chars = std::collections::BTreeSet::new();
         let mut in_atlas = false;
@@ -893,33 +934,31 @@ impl Font {
             // Nothing in the atlas: the glyphs below U+0250, rasterized as used.
             chars.extend((0..0x250u32).filter_map(char::from_u32));
         }
-        let mut out: HashMap<u32, Vec<char>> = HashMap::new();
+        let mut out: HashMap<i32, Vec<char>> = HashMap::new();
         for c in chars {
             if let Some(advance) = self.provider_advance(set, c) {
-                out.entry(advance.ceil() as u32).or_default().push(c);
+                out.entry(advance.ceil() as i32).or_default().push(c);
             }
         }
         out
     }
-    /// A character's advance in `set` (its first provider that has it),
-    /// without rasterizing it.
+    /// A character's advance in `set` (its first provider that has it, fishy or not, as the
+    /// by-width table of `FontSet.reload` takes it), without rasterizing it.
     fn provider_advance(&self, set: &mut FontSet, c: char) -> Option<f32> {
         let (uniform, japanese) = (self.uniform, self.japanese);
         for provider in &mut set.providers {
             match provider {
                 Provider::Space(advances) => {
-                    if let Some(a) = advances.get(&c)
-                        && !fishy_advance(*a)
-                    {
+                    if let Some(a) = advances.get(&c) {
                         return Some(*a);
                     }
                 }
                 Provider::Bitmap(filter, glyphs) if filter.passes(uniform, japanese) => {
                     match glyphs.get(&c) {
-                        Some(BitmapGlyph::Atlas(g)) if !fishy_advance(g.advance) => {
+                        Some(BitmapGlyph::Atlas(g)) => {
                             return Some(g.advance);
                         }
-                        Some(BitmapGlyph::Sheet(cell)) if !fishy_advance(cell.glyph.advance) => {
+                        Some(BitmapGlyph::Sheet(cell)) => {
                             return Some(cell.glyph.advance);
                         }
                         _ => {}
@@ -927,16 +966,12 @@ impl Font {
                 }
                 Provider::Unihex(filter, def, glyphs) if filter.passes(uniform, japanese) => {
                     let glyphs = glyphs.get_or_insert_with(|| load_hex(&self.root, def));
-                    if let Some(h) = glyphs.get(&u32::from(c))
-                        && !fishy_advance(hex_advance(h))
-                    {
+                    if let Some(h) = glyphs.get(&u32::from(c)) {
                         return Some(hex_advance(h));
                     }
                 }
                 Provider::TrueType(filter, ttf) if filter.passes(uniform, japanese) => {
-                    if let Some(id) = ttf.ids.get(&c)
-                        && !fishy_advance(ttf.advance(*id))
-                    {
+                    if let Some(id) = ttf.ids.get(&c) {
                         return Some(ttf.advance(*id));
                     }
                 }
@@ -1406,12 +1441,13 @@ mod tests {
         assert!(!font.take_patches().is_empty());
     }
 
-    /// `FontSet.computeGlyphInfo`: a provider glyph with an advance outside
-    /// 0..32 is skipped, so the next provider that has the character is used.
+    /// `FontSet.computeGlyphInfo`: `SelectedGlyphs.any` is the first provider's glyph, fishy
+    /// advance or not, and is what is drawn and measured; `nonFishy`, what obfuscated text draws,
+    /// is the first provider whose advance is within 0..32, else the missing glyph.
     #[test]
-    fn a_fishy_advance_falls_through_to_the_next_provider() {
-        // 64 opaque columns: the first provider's 'a' would advance 65, past
-        // the 32 vanilla allows, so the narrow provider's 'a' is the one used.
+    fn a_fishy_glyph_is_drawn_and_only_obfuscated_text_falls_through() {
+        // 64 opaque columns: the first provider's 'a' advances 65, past the 32 vanilla
+        // calls fishy, and the narrow provider's 'a' advances 3.
         let wide = png(64, 8, |_, _| true);
         let narrow = png(16, 8, |x, _| x < 2);
         let def = br#"{"providers":[{"type":"bitmap","file":"minecraft:font/wide.png","ascent":7,"chars":["a"]},{"type":"bitmap","file":"minecraft:font/narrow.png","ascent":7,"chars":["a"]}]}"#;
@@ -1425,11 +1461,80 @@ mod tests {
         );
         let font = load(&root);
         let _ = std::fs::remove_dir_all(&root);
-        assert_eq!(font.glyph('a').advance, 3.0, "the narrow provider wins");
-        assert_eq!(font.advance('a', &Style::default()), 3.0);
-        // Obfuscated text picks a glyph by its own advance: nothing is 65 wide.
-        let obfuscated = font.random_glyph(&Style::default(), 65.0);
-        assert_eq!(obfuscated.advance, 6.0, "the missing glyph");
+        let drawn = font.glyph('a');
+        assert_eq!(drawn.advance, 65.0, "the first provider's glyph is drawn");
+        assert!(drawn.rect.is_some());
+        assert_eq!(font.advance('a', &Style::default()), 65.0);
+        // The by-width table files 'a' under its first glyph's 65; the glyph it then draws is
+        // the narrow provider's (`nonFishy`).
+        assert_eq!(font.random_glyph(&Style::default(), 65.0).advance, 3.0);
+        // Nothing else is 3 wide in the table, and the missing glyph is 6.
+        assert_eq!(font.random_glyph(&Style::default(), 3.0).advance, 6.0);
+    }
+
+    /// A `space` provider's shift glyphs (kerning in server packs: -512 to 512) are drawn and
+    /// measured as they are, and `nonFishy` has nothing else to draw for them.
+    #[test]
+    fn space_glyphs_with_any_advance_are_kept() {
+        let shifts: Vec<i32> = (0..10)
+            .map(|i| -(1 << i))
+            .chain((0..10).map(|i| 1 << i))
+            .collect();
+        let advances: Vec<String> = shifts
+            .iter()
+            .enumerate()
+            .map(|(i, a)| format!("\"\\ue{:03x}\": {a}", i))
+            .collect();
+        let def = format!(
+            r#"{{"providers":[{{"type":"space","advances":{{{}}}}}]}}"#,
+            advances.join(",")
+        );
+        let root = root(
+            "space-shifts",
+            &[("assets/minecraft/font/default.json", def.as_bytes())],
+        );
+        let font = load(&root);
+        let _ = std::fs::remove_dir_all(&root);
+        for (i, a) in shifts.iter().enumerate() {
+            let c = char::from_u32(0xe000 + i as u32).unwrap();
+            assert_eq!(font.glyph(c).advance, *a as f32, "{c:?}");
+            assert_eq!(font.advance(c, &Style::default()), *a as f32);
+        }
+        // Obfuscated text asks for a glyph of a given width: a fishy space has none to give.
+        let c = char::from_u32(0xe000 + 19).unwrap();
+        assert_eq!(font.glyph(c).advance, 512.0);
+        assert_eq!(
+            font.glyph_non_fishy(DEFAULT, c).advance,
+            6.0,
+            "the missing glyph"
+        );
+        assert_eq!(font.random_glyph(&Style::default(), 512.0).advance, 6.0);
+    }
+
+    /// Nexo's GUI glyphs: a bitmap `height` of 287 with no advance, so every glyph wider than 31
+    /// pixels has a fishy advance, and is still drawn.
+    #[test]
+    fn a_wide_bitmap_glyph_is_drawn() {
+        let sheet = png(40, 287, |_, _| true);
+        let def = br#"{"providers":[{"type":"bitmap","file":"minecraft:font/gui.png","height":287,"ascent":65,"chars":["a"]}]}"#;
+        let root = root(
+            "wide-bitmap",
+            &[
+                ("assets/minecraft/font/default.json", def),
+                ("assets/minecraft/textures/font/gui.png", &sheet),
+            ],
+        );
+        let font = load(&root);
+        let _ = std::fs::remove_dir_all(&root);
+        let g = font.glyph('a');
+        assert_eq!(g.advance, 41.0, "the glyph's 40 columns and one");
+        assert!(g.rect.is_some(), "drawn, not the missing glyph");
+        assert!(fishy_advance(g.advance));
+        assert_eq!(
+            font.glyph_non_fishy(DEFAULT, 'a').advance,
+            6.0,
+            "excluded from what obfuscated text draws"
+        );
     }
 
     /// StringDecomposer.iterateFormatted: a `§` that ends a part stops that

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

@@ -877,6 +877,8 @@ mod tests {
             start,
             translucent_at,
             solid,
+            solid_slots: u64::from(solid) * 4,
+            packed: false,
             sides: crate::mesher::Sides::unsorted(solid),
             translucent,
             sort: super::super::translucency::SortState::new(Vec::new()),
@@ -930,11 +932,12 @@ mod tests {
                 .iter()
                 .map(|s| (s.page, s.start, s.translucent_at))
                 .collect();
-            // The sections with solid quads have records, on page 0.
+            // The sections with solid quads have records, on page 0, each with
+            // its cell's box.
             let mut records = gpu_culling::Records::default();
             for (i, s) in sections.iter_mut().enumerate() {
                 if s.solid > 0 {
-                    s.gpu_id = Some(records.insert((i as i32, 0, 0), s.page, s.start, s.solid));
+                    s.gpu_id = Some(records.insert(s.record((i as i32, 0, 0), None)));
                 }
             }
             let recorded = records.live() as u32;
@@ -957,9 +960,8 @@ mod tests {
             let word =
                 |(page, at): (u32, u64)| read(&device, &queue, arena.buffer(page), at * stride);
             for (i, s) in sections.iter().enumerate() {
-                // Its record names its solid quads where they are now.
-                let record = (s.solid > 0)
-                    .then(|| gpu_culling::Record::new((i as i32, 0, 0), s.page, s.start, s.solid));
+                // Its record names its solid quads where they are now, its box kept.
+                let record = (s.solid > 0).then(|| s.record((i as i32, 0, 0), None));
                 let held = s.gpu_id.and_then(|id| records.at(id));
                 assert_eq!(held, record.as_ref(), "split {split}, section {i}");
                 let Some((page, start, len)) = s.vertex_ranges(split).0 else {
@@ -1014,7 +1016,7 @@ mod tests {
             label: None,
             entries: &[],
         });
-        let pipeline = |layout: &wgpu::PipelineLayout, label: &str, _: &str, _: &str, _, _| {
+        let pipeline = |layout: &wgpu::PipelineLayout, label: &str, _: &str, _: &str, _, _, _| {
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                 label: Some(label),
                 layout: Some(layout),
@@ -1071,6 +1073,8 @@ mod tests {
             start: 0,
             translucent_at: (0, at),
             solid: 64,
+            solid_slots: 64 * 4,
+            packed: false,
             sides: crate::mesher::Sides::unsorted(64),
             translucent: 128,
             sort: super::super::translucency::SortState::new(Vec::new()),
@@ -1295,6 +1299,8 @@ mod tests {
                 start: 0,
                 translucent_at: if indices { (7, 7) } else { at },
                 solid,
+                solid_slots: u64::from(solid) * 4,
+                packed: false,
                 sides: crate::mesher::Sides::unsorted(solid),
                 translucent,
                 sort: super::super::translucency::SortState::new(Vec::new()),

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

@@ -0,0 +1,574 @@
+//! `horizon-ctl render-capture`: what the renderer needs to draw the current frame again
+//! without the game, for `examples/scene_replay.rs` (docs/graphics.md, "Render capture and
+//! replay").
+//!
+//! The renderer keeps no CPU copy of the meshes it uploads, so while capturing is on
+//! (`Renderer::keep_capture_copies`) it keeps one of every section and far tile mesh as it is
+//! handed over, at the mesher-to-renderer seam. A capture writes those of the sections and
+//! tiles it holds, the frame's camera and inputs, and the settings that change GPU work. Only
+//! the build that wrote a capture reads it.
+//!
+//! Files: `scene.json` (`Scene`), `sections.json` and `tiles.json` (one `MeshRecord` per mesh,
+//! in order), `sections.bin` and `tiles.bin` (each mesh's solid then translucent
+//! `TerrainVertex`es), `celestial.bin` (the sun and moon `Vertex`es).
+use super::{Frame, Renderer, SectionKey};
+use crate::{
+    Result,
+    environment::Sky,
+    fast_hash::{FxHashMap, FxHashSet},
+    fog::FogData,
+    graphics::GraphicsApi,
+    hud::HudBatch,
+    lod::TileKey,
+    mesher::{SectionMesh, Sides, TerrainVertex, Vertex},
+};
+use glam::{DVec3, Mat4, Vec3};
+use serde::{Deserialize, Serialize};
+use std::{
+    fs::{self, File},
+    io::{BufReader, BufWriter, Read, Write},
+    path::{Path, PathBuf},
+};
+
+/// CPU copies of the meshes uploaded since capturing was turned on.
+#[derive(Default)]
+pub(super) struct Copies {
+    sections: FxHashMap<SectionKey, SectionMesh>,
+    tiles: FxHashMap<TileKey, SectionMesh>,
+}
+
+impl Copies {
+    pub(super) fn section(&mut self, key: SectionKey, mesh: &SectionMesh) {
+        self.sections.insert(key, copy(mesh));
+    }
+    /// Columns unloaded (`Renderer::remove_columns`).
+    pub(super) fn remove_columns(&mut self, columns: &[(i32, i32)]) {
+        if columns.is_empty() {
+            return;
+        }
+        let gone: FxHashSet<(i32, i32)> = columns.iter().copied().collect();
+        self.sections
+            .retain(|&(x, _, z), _| !gone.contains(&(x, z)));
+    }
+    pub(super) fn tile(&mut self, key: TileKey, mesh: &SectionMesh) {
+        self.tiles.insert(key, copy(mesh));
+    }
+    pub(super) fn forget_tile(&mut self, key: TileKey) {
+        self.tiles.remove(&key);
+    }
+    pub(super) fn clear_tiles(&mut self) {
+        self.tiles.clear();
+    }
+}
+
+fn copy(mesh: &SectionMesh) -> SectionMesh {
+    SectionMesh {
+        solid: mesh.solid.clone(),
+        sides: mesh.sides,
+        translucent: mesh.translucent.clone(),
+        packed: mesh.packed.clone(),
+        solid_tints: Vec::new(),
+        visibility: mesh.visibility,
+        block_entities: mesh.block_entities.clone(),
+        lights: mesh.lights.clone(),
+        sprite_layers: mesh.sprite_layers.clone(),
+        bounds: mesh.bounds,
+        keep: mesh.keep,
+    }
+}
+
+/// A capture asked for: where to write it, and the game's settings the renderer does not hold.
+pub struct Request {
+    pub dir: PathBuf,
+    pub settings: Settings,
+}
+
+/// The game's settings that change GPU work, as the game applied them to the renderer.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Settings {
+    /// `GraphicsApi`'s variant name.
+    pub graphics_api: String,
+    pub translucent_batching: bool,
+    /// `textureFiltering` and `maxAnisotropyBit` (`Renderer::set_texture_filtering`).
+    pub texture_filtering: i32,
+    pub anisotropy_bit: i32,
+    pub mipmap_levels: u32,
+    /// `Renderer::set_world_post`'s arguments.
+    pub resolution_scale: f32,
+    pub fxaa: bool,
+    pub taa: bool,
+    pub upscale: f32,
+    /// Chunks.
+    pub render_distance: i32,
+    pub lod_distance: u32,
+    /// The game's prepared resources, where the replay loads the block sprites from.
+    pub resources: PathBuf,
+    /// The block sprites the meshes were made against.
+    pub atlas: AtlasCheck,
+}
+
+impl Settings {
+    pub fn graphics_api(&self) -> GraphicsApi {
+        GraphicsApi::ALL
+            .into_iter()
+            .find(|api| format!("{api:?}") == self.graphics_api)
+            .unwrap_or_default()
+    }
+}
+
+/// Which block sprite layers the meshes' vertices name: the replay's must be the same.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AtlasCheck {
+    pub sprite_size: u32,
+    pub texture_layers: u32,
+    /// FNV-1a of every sprite's name and layer.
+    pub layers: u64,
+}
+
+impl AtlasCheck {
+    pub fn of(render: &crate::assets::RenderAssets) -> Self {
+        let mut hash = 0xcbf2_9ce4_8422_2325u64;
+        for (name, layer) in &render.sprite_layers {
+            for byte in name.bytes().chain(layer.to_le_bytes()) {
+                hash = (hash ^ u64::from(byte)).wrapping_mul(0x0000_0100_0000_01b3);
+            }
+        }
+        Self {
+            sprite_size: render.sprite_size,
+            texture_layers: render.texture_layers,
+            layers: hash,
+        }
+    }
+}
+
+/// The renderer's own state that changes GPU work.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct RendererState {
+    pub adapter: String,
+    pub backend: String,
+    /// The frame's size in pixels.
+    pub size: [u32; 2],
+    /// The column layout: lowest block y and sections.
+    pub min_y: i32,
+    pub sections: usize,
+    pub flat_draws: bool,
+    pub section_cull: bool,
+    pub section_sides: bool,
+    pub gpu_culling: bool,
+    pub gamma: f32,
+    pub fullbright: bool,
+    pub improved_transparency: bool,
+    pub animated_textures: bool,
+    /// A shader pack was running; the replay draws without it.
+    pub shader_pack: bool,
+}
+
+/// The cloud inputs of the frame (`clouds::Input`), with the clouds texture.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Clouds {
+    pub texture: (u32, u32, Vec<bool>),
+    pub uv: [f32; 2],
+    pub camera: [f64; 3],
+    pub time: i64,
+    pub partial_tick: f64,
+    pub range: i32,
+    pub fast: bool,
+    pub color: [f32; 4],
+}
+
+/// The frame's camera and the inputs of its globals, sky, fog and lightmap.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct FrameInputs {
+    pub camera: [f64; 3],
+    pub yaw: f32,
+    pub pitch: f32,
+    pub fov_degrees: f32,
+    pub eye: [f64; 3],
+    pub eye_rotation: [f32; 2],
+    pub first_person: bool,
+    pub bob: [f32; 16],
+    pub spin: [f32; 16],
+    pub sky: Sky,
+    pub distance: f32,
+    pub detail_distance: f32,
+    pub depth_far: f32,
+    pub underwater: bool,
+    pub water_plane: Option<f32>,
+    pub cave_culling: bool,
+    pub sky_blocked: bool,
+    pub skybox: bool,
+    pub end_sky: bool,
+    pub end_sky_sprite: Option<[f32; 4]>,
+    pub environment_fog: Option<(f32, f32)>,
+    pub water_fog: [f32; 3],
+    pub fog: Option<FogData>,
+    pub dark_disc: bool,
+    pub nether_lighting: bool,
+    pub glint_alpha: f32,
+    pub glint_ticks: f32,
+    pub hand_fov_degrees: f32,
+    pub stars: Option<([f32; 16], f32)>,
+    pub clouds: Option<Clouds>,
+    pub game_time: f32,
+    pub shader_game_time: f32,
+    pub end_portal_sprites: [[f32; 4]; 2],
+    pub crumbling_sprite: [f32; 4],
+    pub ticks: u64,
+    pub darkness: (f32, f32),
+    pub night_vision: f32,
+    pub block_flicker: f32,
+    pub boss_darken: f32,
+}
+
+/// `scene.json`.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Scene {
+    pub settings: Settings,
+    pub renderer: RendererState,
+    pub frame: FrameInputs,
+    pub sections: usize,
+    pub tiles: usize,
+    /// The chunk columns far tiles leave out for full-detail sections.
+    pub lod_cutout: Vec<(i32, i32)>,
+    /// `celestial.bin`.
+    #[serde(skip)]
+    pub celestial: Vec<Vertex>,
+}
+
+/// One mesh of `sections.json` or `tiles.json`; its vertices follow the previous mesh's in
+/// the `.bin` file. `key` is (x, section y, z) for a section, (x, z, level) for a tile.
+#[derive(Serialize, Deserialize)]
+struct MeshRecord {
+    key: [i32; 3],
+    solid: usize,
+    translucent: usize,
+    sides: Sides,
+    visibility: u64,
+    block_entities: Vec<([i32; 3], u32)>,
+    lights: Vec<([i32; 3], u32)>,
+    sprite_layers: Vec<u16>,
+    bounds: Option<[[f32; 3]; 2]>,
+    keep: bool,
+}
+
+/// Writes `name.json` and `name.bin`: (meshes, vertex bytes).
+fn write_meshes<'m>(
+    dir: &Path,
+    name: &str,
+    meshes: impl Iterator<Item = ([i32; 3], &'m SectionMesh)>,
+) -> Result<(usize, u64)> {
+    let mut blob = BufWriter::new(File::create(dir.join(format!("{name}.bin")))?);
+    let mut records = Vec::new();
+    let mut bytes = 0u64;
+    for (key, mesh) in meshes {
+        for part in [&mesh.solid, &mesh.translucent] {
+            let raw: &[u8] = bytemuck::cast_slice(part.as_slice());
+            blob.write_all(raw)?;
+            bytes += raw.len() as u64;
+        }
+        records.push(MeshRecord {
+            key,
+            solid: mesh.solid.len(),
+            translucent: mesh.translucent.len(),
+            sides: mesh.sides,
+            visibility: mesh.visibility,
+            block_entities: mesh.block_entities.clone(),
+            lights: mesh.lights.clone(),
+            sprite_layers: mesh.sprite_layers.clone(),
+            bounds: mesh
+                .bounds
+                .map(|[min, max]| [min.to_array(), max.to_array()]),
+            keep: mesh.keep,
+        });
+    }
+    blob.flush()?;
+    let mut list = BufWriter::new(File::create(dir.join(format!("{name}.json")))?);
+    serde_json::to_writer(&mut list, &records)?;
+    list.flush()?;
+    Ok((records.len(), bytes))
+}
+
+/// Reads `name.json` and `name.bin`, handing each mesh to `each` as it is read.
+pub fn read_meshes(
+    dir: &Path,
+    name: &str,
+    mut each: impl FnMut([i32; 3], SectionMesh),
+) -> Result<()> {
+    let records: Vec<MeshRecord> = serde_json::from_reader(BufReader::new(File::open(
+        dir.join(format!("{name}.json")),
+    )?))?;
+    let mut blob = BufReader::new(File::open(dir.join(format!("{name}.bin")))?);
+    for record in records {
+        let mut solid = vec![<TerrainVertex as bytemuck::Zeroable>::zeroed(); record.solid];
+        blob.read_exact(bytemuck::cast_slice_mut::<TerrainVertex, u8>(
+            solid.as_mut_slice(),
+        ))?;
+        let mut translucent =
+            vec![<TerrainVertex as bytemuck::Zeroable>::zeroed(); record.translucent];
+        blob.read_exact(bytemuck::cast_slice_mut::<TerrainVertex, u8>(
+            translucent.as_mut_slice(),
+        ))?;
+        each(
+            record.key,
+            SectionMesh {
+                solid,
+                sides: record.sides,
+                translucent,
+                visibility: record.visibility,
+                block_entities: record.block_entities,
+                lights: record.lights,
+                sprite_layers: record.sprite_layers,
+                bounds: record
+                    .bounds
+                    .map(|[min, max]| [Vec3::from_array(min), Vec3::from_array(max)]),
+                keep: record.keep,
+                ..Default::default()
+            },
+        );
+    }
+    Ok(())
+}
+
+impl Renderer {
+    /// Keeps CPU copies of the meshes uploaded from now on, for `render-capture`, or drops
+    /// them. They start empty: the caller meshes everything again for a complete capture.
+    pub fn keep_capture_copies(&mut self, on: bool) {
+        if on != self.capture_copies.is_some() {
+            self.capture_copies = on.then(Copies::default);
+        }
+    }
+    pub fn keeps_capture_copies(&self) -> bool {
+        self.capture_copies.is_some()
+    }
+
+    /// Writes the scene `frame` draws to `request.dir` (`render` calls it for `capture`).
+    pub(super) fn write_capture(
+        &self,
+        request: &Request,
+        frame: &Frame,
+    ) -> Result<serde_json::Value> {
+        let copies = self
+            .capture_copies
+            .as_ref()
+            .ok_or("no mesh copies kept: render-capture on first")?;
+        let dir = &request.dir;
+        fs::create_dir_all(dir)?;
+        let (sections, section_bytes) = write_meshes(
+            dir,
+            "sections",
+            copies
+                .sections
+                .iter()
+                .map(|(&(x, y, z), mesh)| ([x, y, z], mesh)),
+        )?;
+        let standing = self.standing_lods();
+        let (tiles, tile_bytes) = write_meshes(
+            dir,
+            "tiles",
+            copies
+                .tiles
+                .iter()
+                .filter(|(key, _)| standing.contains(*key))
+                .map(|(key, mesh)| ([key.x, key.z, i32::from(key.level)], mesh)),
+        )?;
+        fs::write(
+            dir.join("celestial.bin"),
+            bytemuck::cast_slice::<Vertex, u8>(frame.celestial),
+        )?;
+        let scene = Scene {
+            settings: request.settings.clone(),
+            renderer: RendererState {
+                adapter: self.info.name.clone(),
+                backend: format!("{:?}", self.info.backend),
+                size: [self.config.width, self.config.height],
+                min_y: self.layout.min_y(),
+                sections: self.layout.sections(),
+                flat_draws: self.flat_draws(),
+                section_cull: self.section_cull(),
+                section_sides: self.section_sides(),
+                gpu_culling: self.gpu_culling(),
+                gamma: self.gamma,
+                fullbright: self.fullbright,
+                improved_transparency: self.improved_transparency,
+                animated_textures: self.animated_textures,
+                shader_pack: self.pack_post.is_some() || self.native.is_some(),
+            },
+            frame: FrameInputs {
+                camera: frame.camera.to_array(),
+                yaw: frame.yaw,
+                pitch: frame.pitch,
+                fov_degrees: frame.fov_degrees,
+                eye: frame.eye.to_array(),
+                eye_rotation: frame.eye_rotation,
+                first_person: frame.first_person,
+                bob: frame.bob.to_cols_array(),
+                spin: frame.spin.to_cols_array(),
+                sky: frame.sky,
+                distance: frame.distance,
+                detail_distance: frame.detail_distance,
+                depth_far: frame.depth_far,
+                underwater: frame.underwater,
+                water_plane: frame.water_plane,
+                cave_culling: frame.cave_culling,
+                sky_blocked: frame.sky_blocked,
+                skybox: frame.skybox,
+                end_sky: frame.end_sky,
+                end_sky_sprite: frame.end_sky_sprite,
+                environment_fog: frame.environment_fog,
+                water_fog: frame.water_fog,
+                fog: frame.fog,
+                dark_disc: frame.dark_disc,
+                nether_lighting: frame.nether_lighting,
+                glint_alpha: frame.glint_alpha,
+                glint_ticks: frame.glint_ticks,
+                hand_fov_degrees: frame.hand_fov_degrees,
+                stars: frame
+                    .stars
+                    .map(|(rotation, brightness)| (rotation.to_cols_array(), brightness)),
+                clouds: frame.clouds.as_ref().map(|c| Clouds {
+                    texture: c.texture.clone(),
+                    uv: c.uv,
+                    camera: c.camera.to_array(),
+                    time: c.time,
+                    partial_tick: c.partial_tick,
+                    range: c.range,
+                    fast: c.fast,
+                    color: c.color,
+                }),
+                game_time: frame.game_time,
+                shader_game_time: frame.shader_game_time,
+                end_portal_sprites: frame.end_portal_sprites,
+                crumbling_sprite: frame.crumbling_sprite,
+                ticks: frame.ticks,
+                darkness: frame.darkness,
+                night_vision: frame.night_vision,
+                block_flicker: frame.block_flicker,
+                boss_darken: frame.boss_darken,
+            },
+            sections,
+            tiles,
+            lod_cutout: self.lod_cutout.iter().copied().collect(),
+            celestial: Vec::new(),
+        };
+        let mut out = BufWriter::new(File::create(dir.join("scene.json"))?);
+        serde_json::to_writer_pretty(&mut out, &scene)?;
+        out.flush()?;
+        Ok(serde_json::json!({
+            "ok": true,
+            "dir": dir.display().to_string(),
+            "sections": sections,
+            "tiles": tiles,
+            "vertex_bytes": section_bytes + tile_bytes,
+            "shader_pack_left_out": scene.renderer.shader_pack,
+        }))
+    }
+}
+
+impl Scene {
+    /// Reads `scene.json` and `celestial.bin` (the meshes: `read_meshes`).
+    pub fn read(dir: &Path) -> Result<Self> {
+        let mut scene: Scene =
+            serde_json::from_reader(BufReader::new(File::open(dir.join("scene.json"))?))?;
+        let bytes = fs::read(dir.join("celestial.bin"))?;
+        let size = std::mem::size_of::<Vertex>();
+        let mut celestial = vec![<Vertex as bytemuck::Zeroable>::zeroed(); bytes.len() / size];
+        let len = celestial.len() * size;
+        bytemuck::cast_slice_mut::<Vertex, u8>(celestial.as_mut_slice())
+            .copy_from_slice(&bytes[..len]);
+        scene.celestial = celestial;
+        Ok(scene)
+    }
+
+    /// The captured frame: its camera, sky, fog, clouds, sun, moon and stars, without
+    /// entities, particles, weather, the hand, the outline or the HUD.
+    pub fn frame<'a>(&'a self, hud: &'a HudBatch) -> Frame<'a> {
+        let f = &self.frame;
+        Frame {
+            weather: &[],
+            weather_time: crate::weather::Time::new(0, 0.0),
+            camera: DVec3::from_array(f.camera),
+            yaw: f.yaw,
+            pitch: f.pitch,
+            fov_degrees: f.fov_degrees,
+            eye: DVec3::from_array(f.eye),
+            eye_rotation: f.eye_rotation,
+            first_person: f.first_person,
+            bob: Mat4::from_cols_array(&f.bob),
+            spin: Mat4::from_cols_array(&f.spin),
+            sky: f.sky,
+            shadow_scene_revision: (0, 0),
+            shadow_cache: false,
+            distance: f.distance,
+            detail_distance: f.detail_distance,
+            depth_far: f.depth_far,
+            underwater: f.underwater,
+            water_plane: f.water_plane,
+            cave_culling: f.cave_culling,
+            title: false,
+            sky_blocked: f.sky_blocked,
+            skybox: f.skybox,
+            end_sky: f.end_sky,
+            end_sky_sprite: f.end_sky_sprite,
+            environment_fog: f.environment_fog,
+            water_fog: f.water_fog,
+            fog: f.fog,
+            dark_disc: f.dark_disc,
+            outline: Vec::new(),
+            outline_after_terrain: false,
+            outline_high_contrast: false,
+            debug_lines: &[],
+            debug_lines_on_top: &[],
+            debug_crosshair: &[],
+            hud,
+            glint_alpha: f.glint_alpha,
+            glint_ticks: f.glint_ticks,
+            nether_lighting: f.nether_lighting,
+            entities: &[],
+            static_block_entities: &[],
+            visible_static_block_entity_sections: &[],
+            static_block_entity_stats: Default::default(),
+            entity_motion: &[],
+            entity_spans: &[],
+            skin: None,
+            glowing: &[],
+            dynamic_lights: &[],
+            colored_lights: &[],
+            emissive_layers: &[],
+            clouds: f.clouds.as_ref().map(|c| crate::clouds::Input {
+                texture: &c.texture,
+                uv: c.uv,
+                camera: DVec3::from_array(c.camera),
+                time: c.time,
+                partial_tick: c.partial_tick,
+                range: c.range,
+                fast: c.fast,
+                color: c.color,
+            }),
+            lightning: Default::default(),
+            additive: &[],
+            see_through: &[],
+            shadow_only: &[],
+            celestial: &self.celestial,
+            stars: f
+                .stars
+                .map(|(rotation, brightness)| (Mat4::from_cols_array(&rotation), brightness)),
+            hand: &[],
+            hand_fov_degrees: f.hand_fov_degrees,
+            screen: &[],
+            pack: Default::default(),
+            border: None,
+            game_time: f.game_time,
+            shader_game_time: f.shader_game_time,
+            end_portal_sprites: f.end_portal_sprites,
+            crumbling_sprite: f.crumbling_sprite,
+            ticks: f.ticks,
+            darkness: f.darkness,
+            night_vision: f.night_vision,
+            block_flicker: f.block_flicker,
+            boss_darken: f.boss_darken,
+            chunk_fade: 0.0,
+            post_effects: crate::post_chain::Request::none(),
+            menu_blur: None,
+        }
+    }
+}

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

@@ -0,0 +1,486 @@
+//! A resource pack's `core/rendertype_lines` shader on the block outline (`RenderTypes.LINES`,
+//! and `secondaryBlockOutline` under a high contrast one): an outline its fragment shader colours
+//! or animates. Without one the outline draws natively (`vs_line` in terrain.wgsl).
+
+use glam::Mat4;
+use horizon_shaders::{CoreProgram, Glue};
+
+/// The outline's edges (`pack_lines::layout`: start, end, ARGB colour and width per instance) as
+/// vanilla's lines: four vertices an edge, the start twice and the end twice, the side
+/// `gl_VertexIndex % 2`, as `vs_line` draws them.
+pub(crate) const GLUE: Glue = Glue {
+    inputs: &[
+        ("Position", "vec3"),
+        ("Color", "vec4"),
+        ("Normal", "vec3"),
+        ("LineWidth", "float"),
+    ],
+    prelude: "layout(location = 0) in vec3 hz_start;\n\
+              layout(location = 1) in vec3 hz_end;\n\
+              layout(location = 2) in vec4 hz_argb;\n\
+              layout(location = 3) in float hz_width;",
+    // ARGB in a little-endian u32 reads as B, G, R, A. ShapeRenderer's normal: the direction.
+    setup: "Position = hz_start; if (int(gl_VertexIndex) >= 2) Position = hz_end; \
+            Color = hz_argb.zyxw; Normal = normalize(hz_end - hz_start); LineWidth = hz_width;",
+    // 26.3's ProjMat already has wgpu's reversed 0 to 1 depth (Projection: zZeroToOne).
+    finish: "",
+    vertex_id: "int(gl_VertexIndex)",
+};
+
+/// Each uniform block's offset in the one buffer (`core_shader::BLOCKS` order).
+const BLOCK_OFFSETS: [u64; 4] = [0, 256, 512, 768];
+const BLOCK_SIZES: [u64; 4] = [48, 64, 160, 48];
+
+pub(super) struct CoreLines {
+    lines: wgpu::RenderPipeline,
+    secondary: wgpu::RenderPipeline,
+    group: wgpu::BindGroup,
+    uniform: wgpu::Buffer,
+}
+
+impl CoreLines {
+    pub(super) fn new(
+        device: &wgpu::Device,
+        format: wgpu::TextureFormat,
+        program: &CoreProgram,
+    ) -> Option<Self> {
+        // A pack's shader is untrusted: the backend failing to compile it is an internal error.
+        let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
+        let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
+        let module = |label, module: &naga::Module| {
+            device.create_shader_module(wgpu::ShaderModuleDescriptor {
+                label: Some(label),
+                source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module.clone())),
+            })
+        };
+        let vertex = module("Resource pack lines (vertex)", &program.vertex);
+        let fragment = module("Resource pack lines (fragment)", &program.fragment);
+        // Vanilla's LINES pipeline has no samplers: a pack that reads one is not used. The
+        // blocks' sizes are checked here too, not at the draw: a pack's own larger block fails
+        // in this scope.
+        let entries: Vec<wgpu::BindGroupLayoutEntry> = (0..4)
+            .map(|binding| wgpu::BindGroupLayoutEntry {
+                binding,
+                visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+                ty: wgpu::BindingType::Buffer {
+                    ty: wgpu::BufferBindingType::Uniform,
+                    has_dynamic_offset: false,
+                    min_binding_size: wgpu::BufferSize::new(BLOCK_SIZES[binding as usize]),
+                },
+                count: None,
+            })
+            .collect();
+        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Resource pack lines"),
+            entries: &entries,
+        });
+        let uniform = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Resource pack lines uniforms"),
+            size: 1024,
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        let resources: Vec<wgpu::BindGroupEntry> = (0..4)
+            .map(|i| wgpu::BindGroupEntry {
+                binding: i as u32,
+                resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+                    buffer: &uniform,
+                    offset: BLOCK_OFFSETS[i],
+                    size: wgpu::BufferSize::new(BLOCK_SIZES[i]),
+                }),
+            })
+            .collect();
+        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("Resource pack lines"),
+            layout: &layout,
+            entries: &resources,
+        });
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Resource pack lines"),
+            bind_group_layouts: &[Some(&layout)],
+            ..Default::default()
+        });
+        // The built-in outline's state: a strip per edge, reversed-Z depth test, translucent.
+        let pipeline = |label, depth_write| {
+            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: Some(label),
+                layout: Some(&pipeline_layout),
+                vertex: wgpu::VertexState {
+                    module: &vertex,
+                    entry_point: Some("main"),
+                    compilation_options: Default::default(),
+                    buffers: &[Some(super::pack_lines::layout())],
+                },
+                primitive: wgpu::PrimitiveState {
+                    topology: wgpu::PrimitiveTopology::TriangleStrip,
+                    ..Default::default()
+                },
+                depth_stencil: Some(wgpu::DepthStencilState {
+                    format: wgpu::TextureFormat::Depth32Float,
+                    depth_write_enabled: Some(depth_write),
+                    depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
+                    stencil: Default::default(),
+                    bias: Default::default(),
+                }),
+                multisample: Default::default(),
+                fragment: Some(wgpu::FragmentState {
+                    module: &fragment,
+                    entry_point: Some("main"),
+                    compilation_options: Default::default(),
+                    targets: &[Some(wgpu::ColorTargetState {
+                        format,
+                        blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                        write_mask: wgpu::ColorWrites::ALL,
+                    })],
+                }),
+                multiview_mask: None,
+                cache: None,
+            })
+        };
+        let lines = pipeline("Resource pack block outline", true);
+        let secondary = pipeline("Resource pack block outline secondary", false);
+        let internal = pollster::block_on(internal.pop());
+        if let Some(e) = internal.or(pollster::block_on(validation.pop())) {
+            log::warn!("the resource pack's rendertype_lines shader is not used: {e}");
+            return None;
+        }
+        Some(Self {
+            lines,
+            secondary,
+            group,
+            uniform,
+        })
+    }
+
+    pub(super) fn uniform(&self) -> &wgpu::Buffer {
+        &self.uniform
+    }
+
+    /// Draw `edges` (instances of the outline buffer bound at slot 0) with the pack's shader:
+    /// the secondary stroke without depth writes. The caller sets its own group 0 again after.
+    pub(super) fn draw(
+        &self,
+        pass: &mut wgpu::RenderPass<'_>,
+        secondary: bool,
+        edges: std::ops::Range<u32>,
+    ) {
+        pass.set_pipeline(if secondary {
+            &self.secondary
+        } else {
+            &self.lines
+        });
+        pass.set_bind_group(0, &self.group, &[]);
+        pass.draw(0..4, edges);
+    }
+}
+
+/// The std140 blocks: `Globals` (`post_chain::Globals::bytes`), `Projection` (`jitter`, the lens
+/// and the view bob `pose`, as vanilla's projection matrix carries it), `DynamicTransforms` (the
+/// camera's rotation with the PERSPECTIVE `layering` scale, colour modulator white) and `Fog`
+/// (`fog`: environmental start and end, render distance start and end, sky end, clouds end).
+/// `ProjMat · ModelViewMat` is `vs_line`'s `view_proj` with its layering scale.
+pub(super) fn uniforms(
+    globals: [u8; 48],
+    view: &super::View,
+    pose: Mat4,
+    jitter: Mat4,
+    layering: f32,
+    fog_color: [f32; 4],
+    fog: [f32; 6],
+) -> Vec<u8> {
+    let projection = jitter * view.projection * pose;
+    let model_view = view.view * Mat4::from_scale(glam::Vec3::splat(layering));
+    let mut data = vec![0f32; 256];
+    data[64..80].copy_from_slice(&projection.to_cols_array());
+    let transforms = 128;
+    data[transforms..transforms + 16].copy_from_slice(&model_view.to_cols_array());
+    data[transforms + 16..transforms + 32].copy_from_slice(&Mat4::IDENTITY.to_cols_array());
+    data[transforms + 32..transforms + 36].fill(1.0);
+    data[192..196].copy_from_slice(&fog_color);
+    data[196..202].copy_from_slice(&fog);
+    let mut bytes: Vec<u8> = bytemuck::cast_slice(&data).to_vec();
+    bytes[..48].copy_from_slice(&globals);
+    bytes
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use glam::{Vec3, Vec4};
+
+    const INCLUDES: [(&str, &str); 3] = [
+        (
+            "minecraft:shaders/include/globals.glsl",
+            "layout(std140) uniform Globals {\n    ivec3 CameraBlockPos;\n    float GlintAlpha;\n    vec3 CameraOffset;\n    float GameTime;\n    vec2 ScreenSize;\n    int MenuBlurRadius;\n    int UseRgss;\n};\n",
+        ),
+        (
+            "minecraft:shaders/include/dynamictransforms.glsl",
+            "layout(std140) uniform DynamicTransforms {\n    mat4 ModelViewMat;\n    mat4 TextureMat;\n    vec4 ColorModulator;\n    vec3 ModelOffset;\n};\n",
+        ),
+        (
+            "minecraft:shaders/include/projection.glsl",
+            "layout(std140) uniform Projection {\n    mat4 ProjMat;\n};\n",
+        ),
+    ];
+
+    fn include(id: &str) -> Option<String> {
+        INCLUDES
+            .iter()
+            .find(|(path, _)| *path == id)
+            .map(|(_, text)| (*text).to_owned())
+    }
+
+    /// 26.3's `rendertype_lines.vsh` in shape: a stroke `LineWidth` pixels wide across the
+    /// screen-space direction of `Normal`, its side from `gl_VertexIndex % 2`.
+    const LINES_VSH: &str = "#version 330\n#extension GL_ARB_separate_shader_objects : require\n\
+        #include <minecraft:globals.glsl>\n#include <minecraft:dynamictransforms.glsl>\n#include <minecraft:projection.glsl>\n\
+        layout(location = 0) in vec3 Position;\nlayout(location = 1) in vec4 Color;\n\
+        layout(location = 2) in vec3 Normal;\nlayout(location = 3) in float LineWidth;\n\
+        layout(location = 2) out vec4 vertexColor;\n\
+        const mat4 SHRINK = mat4(0.99, 0.0, 0.0, 0.0, 0.0, 0.99, 0.0, 0.0, 0.0, 0.0, 0.99, 0.0, 0.0, 0.0, 0.0, 1.0);\n\
+        void main() {\n    vec4 from = ProjMat * SHRINK * ModelViewMat * vec4(Position, 1.0);\n\
+            vec4 to = ProjMat * SHRINK * ModelViewMat * vec4(Position + Normal, 1.0);\n\
+            vec2 along = normalize((to.xy / to.w - from.xy / from.w) * ScreenSize);\n\
+            vec2 side = vec2(-along.y, along.x) * LineWidth / ScreenSize;\n\
+            if (gl_VertexIndex % 2 == 0) {\n        side = -side;\n    }\n\
+            gl_Position = vec4(from.xy / from.w + side, from.z / from.w, 1.0) * from.w;\n\
+            vertexColor = Color;\n}\n";
+
+    /// An RGB outline pack's fragment shader in shape: the colour from `GameTime`.
+    const RGB_FSH: &str = "#version 330\n#extension GL_ARB_separate_shader_objects : require\n\
+        #include <minecraft:globals.glsl>\n\
+        layout(location = 2) in vec4 vertexColor;\nlayout(location = 0) out vec4 fragColor;\n\
+        void main() {\n    fragColor = vec4(GameTime, 1.0 - GameTime, vertexColor.b, 1.0);\n}\n";
+
+    /// ProjMat · ModelViewMat (with the vertex shader's shrink between them) is `vs_line`'s
+    /// view_proj on the layered, shrunk position: the pack's outline sits where the built-in one
+    /// does, view bob and TAA jitter included.
+    #[test]
+    fn the_pack_matrices_put_the_outline_where_vs_line_does() {
+        let view = super::super::View::screen(37.0, -21.0, 70.0, 16.0 / 9.0, 256.0);
+        let pose =
+            Mat4::from_rotation_z(0.02) * Mat4::from_translation(Vec3::new(0.01, -0.03, 0.0));
+        let jitter = Mat4::from_translation(Vec3::new(0.0004, -0.0002, 0.0));
+        let layering = 1.0 - 1.0 / 4096.0;
+        let bytes = uniforms([0; 48], &view, pose, jitter, layering, [0.0; 4], [0.0; 6]);
+        let data: Vec<f32> = bytes
+            .as_chunks()
+            .0
+            .iter()
+            .map(|b| f32::from_le_bytes(*b))
+            .collect();
+        let projection = Mat4::from_cols_slice(&data[64..80]);
+        let model_view = Mat4::from_cols_slice(&data[128..144]);
+        assert_eq!(&data[160..164], &[1.0; 4], "ColorModulator");
+        let shrink = 1.0 - 1.0 / 256.0;
+        for p in [Vec3::new(1.5, -0.2, 3.0), Vec3::new(-4.0, 2.0, -0.5)] {
+            let pack =
+                projection * Mat4::from_scale(Vec3::splat(shrink)) * model_view * p.extend(1.0);
+            let native = jitter * view.view_proj(pose) * (p * layering * shrink).extend(1.0);
+            let error: Vec4 = (pack - native).abs();
+            assert!(
+                error.max_element() < 1e-5 * native.w.abs(),
+                "{pack} {native}"
+            );
+        }
+    }
+
+    fn device() -> Option<(wgpu::Device, wgpu::Queue)> {
+        let instance = crate::gfx::test_gpu::instance();
+        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
+        pollster::block_on(adapter.request_device(&Default::default())).ok()
+    }
+
+    /// One edge across the middle of a 64 by 64 target, 4 pixels wide, blue (ARGB `ff0000ff`),
+    /// at `GameTime` 0.25, drawn with `program`: the RGBA rows read back.
+    fn draw_edge(device: &wgpu::Device, queue: &wgpu::Queue, program: &CoreProgram) -> Vec<u8> {
+        const SIZE: u32 = 64;
+        let lines = CoreLines::new(device, wgpu::TextureFormat::Rgba8Unorm, program)
+            .expect("the pack's pipelines");
+        let target = |format, usage| {
+            device.create_texture(&wgpu::TextureDescriptor {
+                label: None,
+                size: wgpu::Extent3d {
+                    width: SIZE,
+                    height: SIZE,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format,
+                usage: wgpu::TextureUsages::RENDER_ATTACHMENT | usage,
+                view_formats: &[],
+            })
+        };
+        let color = target(
+            wgpu::TextureFormat::Rgba8Unorm,
+            wgpu::TextureUsages::COPY_SRC,
+        );
+        let depth = target(
+            wgpu::TextureFormat::Depth32Float,
+            wgpu::TextureUsages::empty(),
+        );
+        let view = super::super::View {
+            view: Mat4::IDENTITY,
+            projection: super::super::world_projection(70.0, 1.0, 64.0),
+            aspect: 1.0,
+            tan_half_fov: 35f32.to_radians().tan(),
+        };
+        let globals = crate::post_chain::Globals {
+            game_time: 0.25,
+            ..Default::default()
+        };
+        let data = uniforms(
+            globals.bytes([SIZE, SIZE], 0),
+            &view,
+            Mat4::IDENTITY,
+            Mat4::IDENTITY,
+            1.0,
+            [0.0; 4],
+            [0.0; 6],
+        );
+        queue.write_buffer(lines.uniform(), 0, &data);
+        let mut edge = [-1.0, 0.0, -2.0, 1.0, 0.0, -2.0, 0.0, 4.0f32];
+        edge[6] = f32::from_bits(0xff00_00ff);
+        let edges = wgpu::util::DeviceExt::create_buffer_init(
+            device,
+            &wgpu::util::BufferInitDescriptor {
+                label: None,
+                contents: bytemuck::cast_slice(&edge),
+                usage: wgpu::BufferUsages::VERTEX,
+            },
+        );
+        let read = device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: u64::from(SIZE * SIZE * 4),
+            usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        let mut encoder = device.create_command_encoder(&Default::default());
+        {
+            let color_view = color.create_view(&Default::default());
+            let depth_view = depth.create_view(&Default::default());
+            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: None,
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &color_view,
+                    depth_slice: None,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                    view: &depth_view,
+                    depth_ops: Some(wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(0.0),
+                        store: wgpu::StoreOp::Store,
+                    }),
+                    stencil_ops: None,
+                }),
+                ..Default::default()
+            });
+            pass.set_vertex_buffer(0, edges.slice(..));
+            lines.draw(&mut pass, false, 0..1);
+        }
+        encoder.copy_texture_to_buffer(
+            color.as_image_copy(),
+            wgpu::TexelCopyBufferInfo {
+                buffer: &read,
+                layout: wgpu::TexelCopyBufferLayout {
+                    offset: 0,
+                    bytes_per_row: Some(SIZE * 4),
+                    rows_per_image: Some(SIZE),
+                },
+            },
+            color.size(),
+        );
+        queue.submit([encoder.finish()]);
+        read.slice(..)
+            .map_async(wgpu::MapMode::Read, |r| r.unwrap());
+        device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+        read.slice(..).get_mapped_range().unwrap().to_vec()
+    }
+
+    /// The stroke's middle takes the pack's colour (`GameTime` red, its inverse green, the
+    /// vertex colour's blue); a pixel far from it stays clear.
+    fn assert_pack_coloured(pixels: &[u8]) {
+        let at = |x: usize, y: usize| &pixels[(y * 64 + x) * 4..(y * 64 + x) * 4 + 4];
+        for y in [31, 32] {
+            let pixel = at(32, y);
+            let want = [64, 191, 255, 255];
+            assert!(
+                pixel.iter().zip(want).all(|(&p, w)| p.abs_diff(w) <= 1),
+                "row {y}: {pixel:?}"
+            );
+        }
+        assert_eq!(at(32, 4), [0, 0, 0, 0]);
+    }
+
+    #[test]
+    fn a_pack_fragment_shader_colours_the_outline() {
+        let Some((device, queue)) = device() else {
+            eprintln!("no GPU: skipping");
+            return;
+        };
+        let program = horizon_shaders::translate_core(LINES_VSH, RGB_FSH, &[], &include, &GLUE)
+            .expect("the shaders translate");
+        assert_pack_coloured(&draw_edge(&device, &queue, &program));
+    }
+
+    /// A pack's own include with a bigger block than vanilla's (an older `DynamicTransforms`)
+    /// is not used, and the outline draws natively, rather than failing at the draw.
+    #[test]
+    fn a_pack_block_bigger_than_vanillas_falls_back() {
+        let Some((device, _)) = device() else {
+            return;
+        };
+        let bigger = |id: &str| {
+            include(id)
+                .map(|text| text.replace("vec3 ModelOffset;", "vec3 ModelOffset;\n    vec4 More;"))
+        };
+        let program = horizon_shaders::translate_core(LINES_VSH, RGB_FSH, &[], &bigger, &GLUE)
+            .expect("the shaders translate");
+        assert!(CoreLines::new(&device, wgpu::TextureFormat::Rgba8Unorm, &program).is_none());
+    }
+
+    /// Vanilla's own `rendertype_lines.vsh` (from the prepared resources) under a pack's
+    /// fragment shader.
+    #[test]
+    fn vanillas_lines_vertex_shader_takes_a_packs_fragment_shader() {
+        let root = std::env::var_os("HORIZON_RESOURCES")
+            .map(std::path::PathBuf::from)
+            .unwrap_or_else(|| {
+                std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                    .join("../../.local/horizon-client")
+                    .join(horizon_core::VANILLA_VERSION)
+            });
+        let Ok(vertex) = std::fs::read_to_string(
+            root.join("assets/minecraft/shaders/core/rendertype_lines.vsh"),
+        ) else {
+            eprintln!(
+                "skipping resource-backed lines shader check: {}",
+                root.display()
+            );
+            return;
+        };
+        let include = |id: &str| {
+            let (namespace, path) = id.split_once(':')?;
+            std::fs::read_to_string(root.join(format!("assets/{namespace}/{path}"))).ok()
+        };
+        let program = horizon_shaders::translate_core(&vertex, RGB_FSH, &[], &include, &GLUE)
+            .expect("vanilla's vertex shader translates");
+        // A pack that replaces only the vertex shader runs vanilla's fragment shader.
+        let fragment = include("minecraft:shaders/core/rendertype_lines.fsh").unwrap();
+        let vanilla = horizon_shaders::translate_core(&vertex, &fragment, &[], &include, &GLUE)
+            .expect("vanilla's fragment shader translates");
+        let Some((device, queue)) = device() else {
+            eprintln!("no GPU: skipping the draw");
+            return;
+        };
+        assert_pack_coloured(&draw_edge(&device, &queue, &program));
+        assert!(CoreLines::new(&device, wgpu::TextureFormat::Rgba8Unorm, &vanilla).is_some());
+    }
+}

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

@@ -19,6 +19,10 @@
 //! the results only sorts sections between the phases: a stale result draws
 //! a hidden section in phase 1, or tests a section that is in sight.
 //!
+//! Far terrain tiles are tested the same way, with their meshes' own
+//! bounds for a box (grown by a block too, which keeps their faces off the
+//! box's), and resident slots of their own (`TILE`).
+//!
 //! Every solid draw is an entry of one of the two lists, so the CPU records
 //! as many draws as without culling: drivers that unroll an indirect
 //! multi-draw on the CPU (Mesa's on Intel Gen9) pay per entry. Phase 2's
@@ -39,6 +43,11 @@ use std::sync::{
 };
 
 const WORDS: u64 = 5 * 4;
+/// A tested section's box, around its origin: its cell grown by a block.
+pub const SECTION_BOX: [[f32; 3]; 2] = [[-1.0; 3], [17.0; 3]];
+/// The bit that marks a far tile's slot (`Renderer::tile_cull_slot`): tiles
+/// count their slots apart from the sections' resident ones.
+pub const TILE: u32 = 1 << 31;
 /// Phase 1's sections are each tested every `RETEST` frames.
 const RETEST: u32 = 8;
 /// Culling runs while the last result read back hid at least this share of
@@ -63,6 +72,17 @@ const FREE: u8 = 0;
 const PENDING: u8 = 1;
 const MAPPED: u8 = 2;
 
+/// One test, as `cull.wgsl` reads it: visible index and phase 2 draws
+/// (`place`), then its box's corners around the origin.
+#[repr(C)]
+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+struct Test {
+    data: [u32; 4],
+    low: [f32; 4],
+    high: [f32; 4],
+}
+const TEST_BYTES: u64 = std::mem::size_of::<Test>() as u64;
+
 #[repr(C)]
 #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
 struct Params {
@@ -131,8 +151,10 @@ pub struct Cull {
     phase2_capacity: u64,
     tests: wgpu::Buffer,
     tests_capacity: u64,
-    /// This frame's tests: visible index, first phase 2 draw, phase 2 draws.
-    test_data: Vec<[u32; 4]>,
+    /// This frame's tests: visible index, then its phase 2 draws in each
+    /// solid pass (`place`): the first of the first pass's, both counts (the
+    /// second's in the high half), the first of the second pass's; and its box.
+    test_data: Vec<Test>,
     test_slots: Vec<u32>,
     test_indices: Vec<u32>,
     total: u64,
@@ -142,8 +164,10 @@ pub struct Cull {
     readbacks: Vec<Readback>,
     next: usize,
     current: Option<usize>,
-    /// Per resident slot: whether the last result read back saw it.
+    /// Per resident slot: whether the last result read back saw it; and per
+    /// far tile's slot (`TILE`).
     seen: Vec<bool>,
+    seen_tiles: Vec<bool>,
     stamp: u32,
     /// Of the boxes the last test read back drew, how many it did not see
     /// and how many it drew, and the share of solid indices hidden.
@@ -325,7 +349,7 @@ impl Cull {
             ),
             phase2: buffer(device, "Section draws, phase 2", WORDS, PHASE2_USAGE),
             phase2_capacity: 1,
-            tests: buffer(device, "Section tests", 16, TESTS_USAGE),
+            tests: buffer(device, "Section tests", TEST_BYTES, TESTS_USAGE),
             tests_capacity: 1,
             test_data: Vec::new(),
             test_slots: Vec::new(),
@@ -347,6 +371,7 @@ impl Cull {
             next: 0,
             current: None,
             seen: Vec::new(),
+            seen_tiles: Vec::new(),
             stamp: 0,
             hidden: ([0; 2], 1.0),
             always: false,
@@ -378,11 +403,15 @@ impl Cull {
                 let share = indices as f32 / r.total.max(1) as f32;
                 self.hidden = ([hidden, results.len()], share);
                 for (&slot, &result) in r.slots.iter().zip(&results) {
-                    let slot = slot as usize;
-                    if slot >= self.seen.len() {
-                        self.seen.resize(slot + 1, false);
+                    let (seen, slot) = if slot & TILE != 0 {
+                        (&mut self.seen_tiles, (slot & !TILE) as usize)
+                    } else {
+                        (&mut self.seen, slot as usize)
+                    };
+                    if slot >= seen.len() {
+                        seen.resize(slot + 1, false);
                     }
-                    self.seen[slot] = result == r.stamp;
+                    seen[slot] = result == r.stamp;
                 }
             }
             r.buffer.unmap();
@@ -397,30 +426,61 @@ impl Cull {
         !self.probe || self.stamp.is_multiple_of(PROBE)
     }
 
-    /// Whether phase 1 draws the section in resident `slot`.
+    /// Whether phase 1 draws the section in resident `slot` (or the far tile
+    /// in its `TILE` slot).
     pub fn first(&self, slot: u32) -> bool {
+        if slot & TILE != 0 {
+            return self
+                .seen_tiles
+                .get((slot & !TILE) as usize)
+                .copied()
+                .unwrap_or(false);
+        }
         self.seen.get(slot as usize).copied().unwrap_or(false)
     }
 
     /// A section phase 1 draws, `index` in the visible list, with `indices`
-    /// solid indices: tested in turn.
-    pub fn drawn(&mut self, index: usize, slot: u32, indices: u32) {
+    /// solid indices and the box `bounds` around its origin: tested in turn.
+    pub fn drawn(&mut self, index: usize, slot: u32, indices: u32, bounds: [[f32; 3]; 2]) {
         self.total += u64::from(indices);
         if indices > 0 && (self.probe || slot.wrapping_add(self.stamp).is_multiple_of(RETEST)) {
-            self.push([index as u32, 0, 0, 0], slot, indices);
+            self.push(index, bounds, slot, indices);
         }
     }
 
-    /// A section left to phase 2: its `draws` from phase 2's `first`.
-    pub fn deferred(&mut self, index: usize, slot: u32, first: usize, draws: usize, indices: u32) {
+    /// A section left to phase 2, with `draws` draws there: its test, whose
+    /// draws `place` gives once phase 2's list is in its final order.
+    pub fn deferred(
+        &mut self,
+        index: usize,
+        slot: u32,
+        draws: usize,
+        indices: u32,
+        bounds: [[f32; 3]; 2],
+    ) -> Option<u32> {
         self.total += u64::from(indices);
-        if draws > 0 {
-            self.push([index as u32, first as u32, draws as u32, 0], slot, indices);
-        }
+        (draws > 0).then(|| {
+            self.push(index, bounds, slot, indices);
+            self.test_data.len() as u32 - 1
+        })
     }
 
-    fn push(&mut self, test: [u32; 4], slot: u32, indices: u32) {
-        self.test_data.push(test);
+    /// `test`'s draws in solid pass `pass` (0 or 1): `draws` from phase 2's
+    /// `first`. Each pass draws its own part of the section's quads.
+    pub fn place(&mut self, test: u32, pass: u32, first: u32, draws: u32) {
+        debug_assert!(pass < 2 && draws < 1 << 16);
+        let t = &mut self.test_data[test as usize].data;
+        t[1 + 2 * pass as usize] = first;
+        t[2] |= draws << (16 * pass);
+    }
+
+    fn push(&mut self, index: usize, bounds: [[f32; 3]; 2], slot: u32, indices: u32) {
+        let [low, high] = bounds.map(|[x, y, z]| [x, y, z, 0.0]);
+        self.test_data.push(Test {
+            data: [index as u32, 0, 0, 0],
+            low,
+            high,
+        });
         self.test_slots.push(slot);
         self.test_indices.push(indices);
     }
@@ -454,7 +514,7 @@ impl Cull {
             self.tests = buffer(
                 device,
                 "Section tests",
-                self.tests_capacity * 16,
+                self.tests_capacity * TEST_BYTES,
                 TESTS_USAGE,
             );
             self.results = buffer(

crates/horizon-client-render/src/gfx/cull.wgsl

@@ -11,10 +11,19 @@ struct Globals {
     view_proj: mat4x4<f32>,
 }
 
-// One test per section: its visible index (which names its origin), its
-// first draw in `phase2` and how many draws it has there (0: phase 1 drew
-// it, and the test only tells whether it is still in sight).
-@group(0) @binding(0) var<storage, read> tests: array<vec4<u32>>;
+// One test per section or far tile: its visible index (which names its
+// origin), then its draws in `phase2` for each solid pass (gfx/cull.rs's
+// `place`): the first pass's first draw, both passes' draw counts (the
+// second's in the high 16 bits), the second pass's first draw. No draws:
+// phase 1 drew it, and the test only tells whether it is still in sight.
+// Then its box's lowest and highest corner around the origin (a section's:
+// -1 and 17, `SECTION_BOX`).
+struct Test {
+    data: vec4<u32>,
+    low: vec4<f32>,
+    high: vec4<f32>,
+}
+@group(0) @binding(0) var<storage, read> tests: array<Test>;
 // Per test: the stamp of the frame whose test saw the box.
 @group(0) @binding(1) var<storage, read_write> results: array<u32>;
 // Phase 2's draws, 5 words each, with instance counts of 0 until seen.
@@ -36,23 +45,27 @@ struct Box {
     @location(0) @interpolate(flat) test: u32,
 }
 
-fn corner(origin: vec3<f32>, c: u32) -> vec3<f32> {
+fn corner(origin: vec3<f32>, low: vec3<f32>, high: vec3<f32>, c: u32) -> vec3<f32> {
     return origin + vec3(
-        select(-1.0, 17.0, (c & 1u) != 0u),
-        select(-1.0, 17.0, (c & 2u) != 0u),
-        select(-1.0, 17.0, (c & 4u) != 0u),
+        select(low.x, high.x, (c & 1u) != 0u),
+        select(low.y, high.y, (c & 2u) != 0u),
+        select(low.z, high.z, (c & 4u) != 0u),
     );
 }
 
-// Each tested section's box, grown by a block (block models reach one block
-// out of their cell), drawn after phase 1 against its depth with back faces
-// culled: a front face fragment that passes the depth test is the box's
-// nearest point on that pixel in front of phase 1's depth, so the section
-// may show there. A box failing everywhere would have every fragment of its
-// section fail the depth test against the final depth, which is only nearer.
+// Each tested section's or far tile's box, grown by a block (block models
+// reach one block out of their cell), drawn after phase 1 against its depth
+// with back faces culled: a front face fragment that passes the depth test
+// is the box's nearest point on that pixel in front of phase 1's depth, so
+// the section may show there. A box failing everywhere would have every
+// fragment of its section fail the depth test against the final depth,
+// which is only nearer.
 @vertex
 fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> Box {
-    let origin = origins[tests[t].x].xyz;
+    let test = tests[t];
+    let origin = origins[test.data.x].xyz;
+    let low = test.low.xyz;
+    let high = test.high.xyz;
     var out: Box;
     out.test = t;
     // The box's screen rectangle, from the corners in front of the camera.
@@ -60,7 +73,7 @@ fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> Box
     var hi = vec2(-1e30);
     var behind = false;
     for (var c = 0u; c < 8u; c++) {
-        let p = globals.view_proj * vec4(corner(origin, c), 1.0);
+        let p = globals.view_proj * vec4(corner(origin, low, high, c), 1.0);
         behind = behind || p.w <= 0.0;
         let q = p.xy / max(p.w, 1e-6);
         lo = min(lo, q);
@@ -71,7 +84,7 @@ fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> Box
     // clips its front faces away, and a box over a large part of the screen
     // is nearly always in sight and costly to test: both count as seen,
     // through a small triangle in the top left corner at the nearest depth.
-    let near = all(origin < vec3(2.0)) && all(origin > vec3(-18.0));
+    let near = all(origin < vec3(1.0) - low) && all(origin > vec3(-1.0) - high);
     if near || (!behind && size.x * size.y > params.big * 4.0) {
         var p = vec2(-1.0, 1.0);
         if v == 1u {
@@ -82,7 +95,7 @@ fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> Box
         out.position = select(vec4(0.0, 0.0, 0.0, 1.0), vec4(p, 1.0, 1.0), v < 3u);
         return out;
     }
-    out.position = globals.view_proj * vec4(corner(origin, CORNERS[v]), 1.0);
+    out.position = globals.view_proj * vec4(corner(origin, low, high, CORNERS[v]), 1.0);
     return out;
 }
 
@@ -91,10 +104,13 @@ fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> Box
 fn see(t: u32) {
     if results[t] != params.stamp {
         results[t] = params.stamp;
-        let test = tests[t];
-        for (var k = 0u; k < test.z; k++) {
+        let test = tests[t].data;
+        for (var k = 0u; k < (test.z & 0xffffu); k++) {
             phase2[(test.y + k) * 5u + 1u] = 1u;
         }
+        for (var k = 0u; k < (test.z >> 16u); k++) {
+            phase2[(test.w + k) * 5u + 1u] = 1u;
+        }
     }
 }
 

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

@@ -0,0 +1,707 @@
+//! `[displacement]` of Horizon's own shader packs (docs/api/shaders.md): near the camera the
+//! solid faces whose textures have LabPBR heights are drawn again as a grid of cells, each
+//! corner moved along the face's normal by the pack's `displacement`, while the flat quads
+//! leave those pixels to them (`native_material.rs`'s `horizon_displaced_layer`).
+//!
+//! Each frame the solid quads of the sections around the camera are copied out of the arena
+//! into one buffer, a compute pass picks the ones the grid draws (opaque, with relief, within
+//! the distance, facing the eye and in view) into an indirect draw, and the material's
+//! displaced pipeline draws one instance a quad.
+
+use crate::mesher::TerrainVertex;
+
+/// The solid quads the grid can draw a frame, and the sections they come from.
+const MAX_QUADS: u64 = 1 << 16;
+const MAX_SECTIONS: usize = 64;
+/// Bytes of one quad's corners.
+const QUAD_BYTES: u64 = 4 * std::mem::size_of::<TerrainVertex>() as u64;
+/// How far past the flat face the relief may reach, in blocks, for the view test.
+const RELIEF_MARGIN: f32 = 0.5;
+
+/// Which quads the grid takes over, for the flat terrain's pipelines (the material's and the
+/// shadow's) and the grid's: `horizon_displace_distance` and the LabPBR normal maps
+/// `horizon_pbr_normals` (group 3, binding 12), declared by the module.
+pub const RELIEF: &str = "
+// `[displacement] distance` (0 without): the flat quads leave the pixels within it on faces
+// with relief to the grid.
+override horizon_displace_distance: f32 = 0.0;
+// The mean LabPBR height of a sprite: its normal map's last mip level (1 without one).
+fn horizon_relief_mean(layer: u32) -> f32 {
+    if textureDimensions(horizon_pbr_normals).x <= 1u
+        || layer >= textureNumLayers(horizon_pbr_normals) {
+        return 1.0;
+    }
+    let top = i32(textureNumLevels(horizon_pbr_normals)) - 1;
+    return textureLoad(horizon_pbr_normals, vec2(0i), i32(layer), top).a;
+}
+// The quads the grid redraws near the camera (`PICK`): opaque, on a texture whose height
+// varies.
+fn horizon_displaced_layer(layer: u32) -> bool {
+    return horizon_displace_distance > 0.0 && (layer & 0x8000u) != 0u
+        && horizon_relief_mean(layer & 0x7fffu) < 0.998;
+}
+";
+
+/// The grid's points (`horizon_displace_point`): one instance a quad the pick chose, its
+/// corners read from the copy of the arena, each of its `horizon_displace_cells` squared
+/// cells two triangles moved along the face's normal by the pack's `displacement`, measured
+/// from the texture's mean height so that the face's edges, pinned there, meet their
+/// neighbours whatever their relief. Needs `RELIEF`, the pack's `displacement` and
+/// `horizon_material_displace` (its vertex stage).
+pub const GRID: &str = "
+struct HorizonDisplaceSection {
+    origin: vec4<f32>,
+    first: u32,
+    quads: u32,
+    pad0: u32,
+    pad1: u32,
+}
+@group(1) @binding(8) var<storage, read> horizon_displace_vertices: array<u32>;
+@group(1) @binding(9) var<storage, read> horizon_displace_picked: array<vec2<u32>>;
+@group(1) @binding(10) var<storage, read> horizon_displace_sections: array<HorizonDisplaceSection>;
+// The grid's cells along a face's side.
+override horizon_displace_cells: u32 = 16u;
+// Each cell a flat step with walls to its neighbours (`grid_vertices`), not a smooth surface.
+override horizon_displace_steps: bool = false;
+struct HorizonDisplaceCorner {
+    position: vec3<f32>,
+    uv: vec2<f32>,
+    layer: u32,
+    light: vec2<f32>,
+    color: vec4<f32>,
+}
+// A corner of a quad as `TerrainVertex` holds it (24 bytes); light: sky, block.
+fn horizon_displace_corner(quad: u32, i: u32, step: f32) -> HorizonDisplaceCorner {
+    let b = (quad * 4u + i) * 6u;
+    var c: HorizonDisplaceCorner;
+    c.position = vec3(bitcast<f32>(horizon_displace_vertices[b]),
+        bitcast<f32>(horizon_displace_vertices[b + 1u]),
+        bitcast<f32>(horizon_displace_vertices[b + 2u]));
+    let uv = horizon_displace_vertices[b + 3u];
+    c.uv = vec2<f32>(vec2(uv & 0xffffu, uv >> 16u)) * step;
+    let w = horizon_displace_vertices[b + 4u];
+    c.layer = w & 0xffffu;
+    c.light = vec2(f32((w >> 16u) & 0xffu), f32(w >> 24u));
+    c.color = unpack4x8unorm(horizon_displace_vertices[b + 5u]);
+    return c;
+}
+// The height map at `uv`, filtered between the texels of mip level `lod`.
+fn horizon_displace_height(uv: vec2<f32>, layer: u32, lod: i32) -> f32 {
+    let size = vec2<i32>(textureDimensions(horizon_pbr_normals, lod));
+    let p = clamp(uv, vec2(0.0), vec2(1.0)) * vec2<f32>(size) - 0.5;
+    let i = vec2<i32>(floor(p));
+    let f = p - floor(p);
+    let m = size - 1;
+    let l = i32(layer);
+    let a = textureLoad(horizon_pbr_normals, clamp(i, vec2(0), m), l, lod).a;
+    let b = textureLoad(horizon_pbr_normals, clamp(i + vec2(1, 0), vec2(0), m), l, lod).a;
+    let c = textureLoad(horizon_pbr_normals, clamp(i + vec2(0, 1), vec2(0), m), l, lod).a;
+    let d = textureLoad(horizon_pbr_normals, clamp(i + vec2(1, 1), vec2(0), m), l, lod).a;
+    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+// The height map's texel at `uv` of mip level `lod`.
+fn horizon_displace_texel(uv: vec2<f32>, layer: u32, lod: i32) -> f32 {
+    let size = vec2<i32>(textureDimensions(horizon_pbr_normals, lod));
+    let i = clamp(vec2<i32>(uv * vec2<f32>(size)), vec2(0), size - 1);
+    return textureLoad(horizon_pbr_normals, i, i32(layer), lod).a;
+}
+struct HorizonDisplacePoint {
+    // Where it is drawn, and where it lies on the flat face (both camera-relative).
+    position: vec3<f32>,
+    base: vec3<f32>,
+    uv: vec2<f32>,
+    layer: u32,
+    light: vec2<f32>,
+    color: vec4<f32>,
+    // The face's normal, and how much of the relief the point has by its distance.
+    normal: vec3<f32>,
+    near: f32,
+}
+// A quad's corners, for the steps.
+struct HorizonDisplaceQuad {
+    c0: HorizonDisplaceCorner,
+    c1: HorizonDisplaceCorner,
+    c2: HorizonDisplaceCorner,
+    c3: HorizonDisplaceCorner,
+    origin: vec3<f32>,
+    normal: vec3<f32>,
+}
+fn horizon_displace_at(q: HorizonDisplaceQuad, s: f32, t: f32) -> vec3<f32> {
+    return mix(mix(q.c0.position, q.c1.position, s), mix(q.c3.position, q.c2.position, s), t)
+        + q.origin;
+}
+fn horizon_displace_uv(q: HorizonDisplaceQuad, s: f32, t: f32) -> vec2<f32> {
+    return mix(mix(q.c0.uv, q.c1.uv, s), mix(q.c3.uv, q.c2.uv, s), t);
+}
+// How far cell (`i`, `j`) sinks: nothing outside the face, whose edges keep the mean height so
+// that they meet their neighbours.
+fn horizon_displace_cell_depth(q: HorizonDisplaceQuad, i: i32, j: i32) -> f32 {
+    let g = i32(horizon_displace_cells);
+    if i < 0 || j < 0 || i >= g || j >= g {
+        return 0.0;
+    }
+    let s = (f32(i) + 0.5) / f32(g);
+    let t = (f32(j) + 0.5) / f32(g);
+    let base = horizon_displace_at(q, s, t);
+    let uv = horizon_displace_uv(q, s, t);
+    let layer = q.c0.layer & 0x7fffu;
+    let lods = i32(textureNumLevels(horizon_pbr_normals)) - 1;
+    let size = f32(textureDimensions(horizon_pbr_normals).x);
+    let lod = clamp(i32(floor(log2(size / f32(g)))), 0, lods);
+    let material_id = horizon_sprite_material(layer);
+    let height = horizon_displace_texel(uv, layer, lod);
+    let mean = horizon_relief_mean(layer);
+    let depth = displacement(DisplacementInput(base, q.normal, uv, material_id, height))
+        - displacement(DisplacementInput(base, q.normal, uv, material_id, mean));
+    let r = horizon_displace_distance;
+    return depth * (1.0 - smoothstep(0.75 * r, r - 0.1, length(base)));
+}
+// Vertex `v` of a stepped grid: per cell, from -1 so that the first walls have a cell before
+// them, its flat top and its walls to the next cell along each side. A wall faces the way
+// out of the higher cell and takes that cell's texture.
+fn horizon_displace_step(v: u32, q: HorizonDisplaceQuad) -> HorizonDisplacePoint {
+    let g = horizon_displace_cells;
+    let cell = v / 18u;
+    let part = (v / 6u) % 3u;
+    let i = i32(cell % (g + 1u)) - 1;
+    let j = i32(cell / (g + 1u)) - 1;
+    let cells = f32(g);
+    var k = v % 6u;
+    var s = 0.0;
+    var t = 0.0;
+    var uv_s = 0.0;
+    var uv_t = 0.0;
+    var depth = 0.0;
+    if part == 0u {
+        if i >= 0 && j >= 0 {
+            s = (f32(i) + f32((0x16u >> k) & 1u)) / cells;
+            t = (f32(j) + f32((0x34u >> k) & 1u)) / cells;
+            depth = horizon_displace_cell_depth(q, i, j);
+        }
+        uv_s = s;
+        uv_t = t;
+    } else if part == 1u {
+        if j >= 0 {
+            let here = horizon_displace_cell_depth(q, i, j);
+            let next = horizon_displace_cell_depth(q, i + 1, j);
+            if next < here {
+                k = (0x453120u >> (k * 4u)) & 15u;
+            }
+            s = f32(i + 1) / cells;
+            t = (f32(j) + f32((0x16u >> k) & 1u)) / cells;
+            depth = select(max(here, next), min(here, next), ((0x34u >> k) & 1u) == 1u);
+            uv_s = s + select(0.25, -0.25, here <= next) / cells;
+            uv_t = t;
+        }
+    } else {
+        if i >= 0 {
+            let here = horizon_displace_cell_depth(q, i, j);
+            let next = horizon_displace_cell_depth(q, i, j + 1);
+            if here < next {
+                k = (0x453120u >> (k * 4u)) & 15u;
+            }
+            s = (f32(i) + f32((0x16u >> k) & 1u)) / cells;
+            t = f32(j + 1) / cells;
+            depth = select(max(here, next), min(here, next), ((0x34u >> k) & 1u) == 1u);
+            uv_s = s;
+            uv_t = t + select(0.25, -0.25, here <= next) / cells;
+        }
+    }
+    var p: HorizonDisplacePoint;
+    let position = horizon_displace_at(q, s, t);
+    let c = clamp(vec2(uv_s, uv_t), vec2(0.0), vec2(1.0));
+    p.uv = horizon_displace_uv(q, c.x, c.y);
+    p.light = mix(mix(q.c0.light, q.c1.light, s), mix(q.c3.light, q.c2.light, s), t);
+    p.color = mix(mix(q.c0.color, q.c1.color, s), mix(q.c3.color, q.c2.color, s), t);
+    p.layer = q.c0.layer;
+    p.normal = q.normal;
+    p.base = horizon_material_displace(position, p.uv, q.c0.layer, p.color,
+        vec2<u32>(p.light + 0.5));
+    p.near = 1.0 - smoothstep(0.75 * horizon_displace_distance, horizon_displace_distance - 0.1,
+        length(p.base));
+    p.position = p.base - p.normal * depth;
+    return p;
+}
+// Vertex `v` of instance `instance`'s grid.
+fn horizon_displace_point(v: u32, instance: u32) -> HorizonDisplacePoint {
+    let pick = horizon_displace_picked[instance];
+    let section = horizon_displace_sections[pick.y];
+    let c0 = horizon_displace_corner(pick.x, 0u, section.origin.w);
+    let c1 = horizon_displace_corner(pick.x, 1u, section.origin.w);
+    let c2 = horizon_displace_corner(pick.x, 2u, section.origin.w);
+    let c3 = horizon_displace_corner(pick.x, 3u, section.origin.w);
+    if horizon_displace_steps {
+        return horizon_displace_step(v, HorizonDisplaceQuad(c0, c1, c2, c3, section.origin.xyz,
+            normalize(cross(c1.position - c0.position, c2.position - c0.position))));
+    }
+    // The cell's two triangles wind as the quad's (0, 1, 2) and (0, 2, 3).
+    let g = horizon_displace_cells;
+    let cell = v / 6u;
+    let k = v % 6u;
+    let s = f32(cell % g + ((0x16u >> k) & 1u)) / f32(g);
+    let t = f32(cell / g + ((0x34u >> k) & 1u)) / f32(g);
+    var p: HorizonDisplacePoint;
+    let position = mix(mix(c0.position, c1.position, s), mix(c3.position, c2.position, s), t);
+    p.uv = mix(mix(c0.uv, c1.uv, s), mix(c3.uv, c2.uv, s), t);
+    p.light = mix(mix(c0.light, c1.light, s), mix(c3.light, c2.light, s), t);
+    p.color = mix(mix(c0.color, c1.color, s), mix(c3.color, c2.color, s), t);
+    p.layer = c0.layer;
+    p.normal = normalize(cross(c1.position - c0.position, c2.position - c0.position));
+    p.base = horizon_material_displace(position + section.origin.xyz, p.uv, c0.layer, p.color,
+        vec2<u32>(p.light + 0.5));
+    let layer = c0.layer & 0x7fffu;
+    // The heights at about a texel a cell.
+    let lods = i32(textureNumLevels(horizon_pbr_normals)) - 1;
+    let size = f32(textureDimensions(horizon_pbr_normals).x);
+    let lod = clamp(i32(floor(log2(size / f32(g)))), 0, lods);
+    let material_id = horizon_sprite_material(layer);
+    let height = horizon_displace_height(p.uv, layer, lod);
+    let mean = horizon_relief_mean(layer);
+    let depth = displacement(DisplacementInput(p.base, p.normal, p.uv, material_id, height))
+        - displacement(DisplacementInput(p.base, p.normal, p.uv, material_id, mean));
+    // Pinned at the face's edges, easing out toward the distance.
+    let edge = min(min(s, 1.0 - s), min(t, 1.0 - t)) * f32(g);
+    let r = horizon_displace_distance;
+    p.near = 1.0 - smoothstep(0.75 * r, r - 0.1, length(p.base));
+    p.position = p.base - p.normal * depth * clamp(edge, 0.0, 1.0) * p.near;
+    return p;
+}
+";
+
+const PICK: &str = "
+struct Params {
+    view_proj: mat4x4<f32>,
+    distance: f32,
+    sections: u32,
+    margin: f32,
+    capacity: u32,
+    // 1 for the shadow map's list: every side, wherever the eye looks.
+    shadow: u32,
+    pad0: u32,
+    pad1: u32,
+    pad2: u32,
+}
+struct Section {
+    origin: vec4<f32>,
+    first: u32,
+    quads: u32,
+    pad0: u32,
+    pad1: u32,
+}
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read> sections: array<Section>;
+@group(0) @binding(2) var<storage, read> vertices: array<u32>;
+@group(0) @binding(3) var<storage, read_write> picked: array<vec2<u32>>;
+@group(0) @binding(4) var<storage, read_write> draw: array<atomic<u32>, 4>;
+@group(0) @binding(5) var normals: texture_2d_array<f32>;
+
+fn corner(quad: u32, i: u32, origin: vec3<f32>) -> vec3<f32> {
+    let b = (quad * 4u + i) * 6u;
+    return vec3(bitcast<f32>(vertices[b]), bitcast<f32>(vertices[b + 1u]),
+        bitcast<f32>(vertices[b + 2u])) + origin;
+}
+
+// Every corner of the box beyond one side of the view.
+fn outside(lo: vec3<f32>, hi: vec3<f32>) -> bool {
+    var out = vec4(true);
+    var behind = true;
+    for (var i = 0u; i < 8u; i++) {
+        let p = select(lo, hi, vec3((i & 1u) != 0u, (i & 2u) != 0u, (i & 4u) != 0u));
+        let c = params.view_proj * vec4(p, 1.0);
+        out = out & vec4((c.x < -c.w), (c.x > c.w), (c.y < -c.w), (c.y > c.w));
+        behind = behind && c.w <= 0.0;
+    }
+    return any(out) || behind;
+}
+
+@compute @workgroup_size(64) fn pick(@builtin(global_invocation_id) id: vec3<u32>) {
+    if id.y >= params.sections {
+        return;
+    }
+    let section = sections[id.y];
+    if id.x >= section.quads {
+        return;
+    }
+    let quad = section.first + id.x;
+    // As `horizon_displaced_layer`: opaque, with a LabPBR height that varies.
+    let layer = vertices[quad * 24u + 4u] & 0xffffu;
+    let l = layer & 0x7fffu;
+    if (layer & 0x8000u) == 0u || textureDimensions(normals).x <= 1u
+        || l >= textureNumLayers(normals) {
+        return;
+    }
+    let top = i32(textureNumLevels(normals)) - 1;
+    if textureLoad(normals, vec2(0i), i32(l), top).a >= 0.998 {
+        return;
+    }
+    let p0 = corner(quad, 0u, section.origin.xyz);
+    let p1 = corner(quad, 1u, section.origin.xyz);
+    let p2 = corner(quad, 2u, section.origin.xyz);
+    let p3 = corner(quad, 3u, section.origin.xyz);
+    let lo = min(min(p0, p1), min(p2, p3));
+    let hi = max(max(p0, p1), max(p2, p3));
+    if length(clamp(vec3(0.0), lo, hi)) >= params.distance {
+        return;
+    }
+    // Facing away from the eye (at the origin), where the flat quad is culled too, or out of
+    // its view; the shadow map takes them all, as the flat terrain draws both sides there.
+    if params.shadow == 0u && (dot(cross(p1 - p0, p2 - p0), p0) >= 0.0
+        || outside(lo - params.margin, hi + params.margin)) {
+        return;
+    }
+    let i = atomicAdd(&draw[1], 1u);
+    if i >= params.capacity {
+        atomicSub(&draw[1], 1u);
+        return;
+    }
+    picked[i] = vec2(quad, id.y);
+}
+";
+
+#[repr(C)]
+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+struct Params {
+    view_proj: [[f32; 4]; 4],
+    distance: f32,
+    sections: u32,
+    margin: f32,
+    capacity: u32,
+    shadow: u32,
+    pad: [u32; 3],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+struct Section {
+    origin: [f32; 4],
+    first: u32,
+    quads: u32,
+    pad: [u32; 2],
+}
+
+/// A section the grid may draw from this frame: its arena range of solid quads and its
+/// camera-relative origin.
+pub struct Near<'a> {
+    pub buffer: &'a wgpu::Buffer,
+    pub start: u64,
+    pub quads: u32,
+    pub origin: [f32; 3],
+}
+
+/// One list of picked quads and its indirect draw.
+pub struct Picks {
+    /// The grid's cells along a face's side.
+    pub cells: u32,
+    /// Each cell a flat step with walls.
+    pub steps: bool,
+    params: wgpu::Buffer,
+    /// The indirect draw: the grid's vertices, then the quads picked.
+    draw: wgpu::Buffer,
+    pick_group: wgpu::BindGroup,
+    /// Group 1 of the pipelines drawing it (bindings 8 to 10).
+    pub draw_group: wgpu::BindGroup,
+}
+
+pub struct Displacement {
+    /// `[displacement] distance`, in blocks.
+    pub distance: f32,
+    vertices: wgpu::Buffer,
+    sections: wgpu::Buffer,
+    pick: wgpu::ComputePipeline,
+    /// The quads the eye sees, and the ones the shadow map draws (when the pack has one).
+    pub view: Picks,
+    pub shadow: Option<Picks>,
+    /// Group 1's layout for the grid's pipelines.
+    pub draw_layout: wgpu::BindGroupLayout,
+    /// Sections the pick ran over this frame (0: nothing to draw).
+    pub drawn: usize,
+}
+
+fn storage(
+    binding: u32,
+    read_only: bool,
+    visibility: wgpu::ShaderStages,
+) -> wgpu::BindGroupLayoutEntry {
+    wgpu::BindGroupLayoutEntry {
+        binding,
+        visibility,
+        ty: wgpu::BindingType::Buffer {
+            ty: wgpu::BufferBindingType::Storage { read_only },
+            has_dynamic_offset: false,
+            min_binding_size: None,
+        },
+        count: None,
+    }
+}
+
+/// The shadow map's grid is coarser: its texels near the camera are a 32nd of a block.
+pub const SHADOW_CELLS: u32 = 16;
+
+/// The vertices of one quad's grid: two triangles a cell, or in `steps` also two walls a cell,
+/// with a row and a column more for the walls at the face's first edges.
+fn grid_vertices(cells: u32, steps: bool) -> u32 {
+    if steps {
+        (cells + 1) * (cells + 1) * 18
+    } else {
+        cells * cells * 6
+    }
+}
+
+impl Displacement {
+    /// The grid's buffers and pick pass for `[displacement]` with `distance` and `cells`, in
+    /// `steps` or not, reading the LabPBR normal maps `normals`; with a list for the shadow map
+    /// when `shadow`.
+    pub fn new(
+        device: &wgpu::Device,
+        distance: f32,
+        cells: u32,
+        steps: bool,
+        normals: &wgpu::TextureView,
+        shadow: bool,
+    ) -> Self {
+        let buffer = |label, size, usage| {
+            device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some(label),
+                size,
+                usage,
+                mapped_at_creation: false,
+            })
+        };
+        use wgpu::BufferUsages as U;
+        let vertices = buffer(
+            "Displacement quads",
+            MAX_QUADS * QUAD_BYTES,
+            U::STORAGE | U::COPY_DST,
+        );
+        let sections = buffer(
+            "Displacement sections",
+            (MAX_SECTIONS * std::mem::size_of::<Section>()) as u64,
+            U::STORAGE | U::COPY_DST,
+        );
+        let compute = wgpu::ShaderStages::COMPUTE;
+        let pick_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Displacement pick"),
+            entries: &[
+                wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: compute,
+                    ty: wgpu::BindingType::Buffer {
+                        ty: wgpu::BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: None,
+                    },
+                    count: None,
+                },
+                storage(1, true, compute),
+                storage(2, true, compute),
+                storage(3, false, compute),
+                storage(4, false, compute),
+                wgpu::BindGroupLayoutEntry {
+                    binding: 5,
+                    visibility: compute,
+                    ty: wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2Array,
+                        multisampled: false,
+                    },
+                    count: None,
+                },
+            ],
+        });
+        let vertex = wgpu::ShaderStages::VERTEX;
+        let draw_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Displacement draw"),
+            entries: &[
+                storage(8, true, vertex),
+                storage(9, true, vertex),
+                storage(10, true, vertex),
+            ],
+        });
+        fn entry(binding: u32, resource: wgpu::BindingResource<'_>) -> wgpu::BindGroupEntry<'_> {
+            wgpu::BindGroupEntry { binding, resource }
+        }
+        let picks = |cells: u32| {
+            let params = buffer(
+                "Displacement parameters",
+                std::mem::size_of::<Params>() as u64,
+                U::UNIFORM | U::COPY_DST,
+            );
+            let picked = buffer("Displacement picks", MAX_QUADS * 8, U::STORAGE);
+            let draw = buffer(
+                "Displacement draw",
+                16,
+                U::STORAGE | U::INDIRECT | U::COPY_DST,
+            );
+            let pick_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: Some("Displacement pick"),
+                layout: &pick_layout,
+                entries: &[
+                    entry(0, params.as_entire_binding()),
+                    entry(1, sections.as_entire_binding()),
+                    entry(2, vertices.as_entire_binding()),
+                    entry(3, picked.as_entire_binding()),
+                    entry(4, draw.as_entire_binding()),
+                    entry(5, wgpu::BindingResource::TextureView(normals)),
+                ],
+            });
+            let draw_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: Some("Displacement draw"),
+                layout: &draw_layout,
+                entries: &[
+                    entry(8, vertices.as_entire_binding()),
+                    entry(9, picked.as_entire_binding()),
+                    entry(10, sections.as_entire_binding()),
+                ],
+            });
+            Picks {
+                cells,
+                steps,
+                params,
+                draw,
+                pick_group,
+                draw_group,
+            }
+        };
+        let view = picks(cells);
+        // A step's flat top has to lie where its shadow was cast from, or it shadows itself in
+        // grain; a smooth surface hides the difference and can take fewer cells.
+        let shadow = shadow.then(|| {
+            picks(if steps {
+                cells
+            } else {
+                cells.min(SHADOW_CELLS)
+            })
+        });
+        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Displacement pick"),
+            source: wgpu::ShaderSource::Wgsl(PICK.into()),
+        });
+        let pick = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+            label: Some("Displacement pick"),
+            layout: Some(
+                &device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                    label: Some("Displacement pick"),
+                    bind_group_layouts: &[Some(&pick_layout)],
+                    ..Default::default()
+                }),
+            ),
+            module: &module,
+            entry_point: Some("pick"),
+            compilation_options: Default::default(),
+            cache: None,
+        });
+        Self {
+            distance,
+            vertices,
+            sections,
+            pick,
+            view,
+            shadow,
+            draw_layout,
+            drawn: 0,
+        }
+    }
+
+    /// Copies the solid quads of `near` (nearest first) and picks this frame's in `encoder`.
+    pub fn prepare(
+        &mut self,
+        queue: &wgpu::Queue,
+        encoder: &mut wgpu::CommandEncoder,
+        near: &[Near<'_>],
+        view_proj: glam::Mat4,
+    ) {
+        let mut table = Vec::with_capacity(near.len().min(MAX_SECTIONS));
+        let mut first = 0u64;
+        let mut most = 0u32;
+        for n in near.iter().take(MAX_SECTIONS) {
+            let quads = u64::from(n.quads).min(MAX_QUADS - first);
+            if quads == 0 {
+                break;
+            }
+            let stride = std::mem::size_of::<TerrainVertex>() as u64;
+            encoder.copy_buffer_to_buffer(
+                n.buffer,
+                n.start * stride,
+                &self.vertices,
+                first * QUAD_BYTES,
+                quads * QUAD_BYTES,
+            );
+            table.push(Section {
+                origin: [
+                    n.origin[0],
+                    n.origin[1],
+                    n.origin[2],
+                    1.0 / crate::mesher::UV_STEPS,
+                ],
+                first: first as u32,
+                quads: quads as u32,
+                pad: [0; 2],
+            });
+            first += quads;
+            most = most.max(quads as u32);
+        }
+        self.drawn = table.len();
+        if table.is_empty() {
+            return;
+        }
+        queue.write_buffer(&self.sections, 0, bytemuck::cast_slice(&table));
+        let lists = std::iter::once((&self.view, 0)).chain(self.shadow.iter().map(|s| (s, 1)));
+        let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
+            label: Some("Displacement pick"),
+            timestamp_writes: None,
+        });
+        pass.set_pipeline(&self.pick);
+        for (picks, shadow) in lists {
+            let params = Params {
+                view_proj: view_proj.to_cols_array_2d(),
+                distance: self.distance,
+                sections: table.len() as u32,
+                margin: RELIEF_MARGIN,
+                capacity: MAX_QUADS as u32,
+                shadow,
+                pad: [0; 3],
+            };
+            queue.write_buffer(&picks.params, 0, bytemuck::bytes_of(&params));
+            let vertices = grid_vertices(picks.cells, picks.steps);
+            queue.write_buffer(&picks.draw, 0, bytemuck::cast_slice(&[vertices, 0, 0, 0]));
+            pass.set_bind_group(0, &picks.pick_group, &[]);
+            pass.dispatch_workgroups(most.div_ceil(64), table.len() as u32, 1);
+        }
+    }
+
+    /// Draws `picks`' grids with `pipeline`, its other groups bound.
+    pub fn draw(
+        &self,
+        pass: &mut wgpu::RenderPass<'_>,
+        picks: &Picks,
+        pipeline: &wgpu::RenderPipeline,
+    ) {
+        if self.drawn == 0 {
+            return;
+        }
+        pass.set_pipeline(pipeline);
+        pass.set_bind_group(1, &picks.draw_group, &[]);
+        pass.draw_indirect(&picks.draw, 0);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn a_stepped_grid_has_a_top_and_two_walls_a_cell_and_the_first_edges() {
+        assert_eq!(super::grid_vertices(16, false), 16 * 16 * 6);
+        assert_eq!(super::grid_vertices(16, true), 17 * 17 * 18);
+    }
+
+    #[test]
+    fn the_pick_validates() {
+        let module = naga::front::wgsl::parse_str(super::PICK)
+            .unwrap_or_else(|e| panic!("{}", e.emit_to_string(super::PICK)));
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::all(),
+        )
+        .validate(&module)
+        .unwrap_or_else(|e| panic!("{}", e.emit_to_string(super::PICK)));
+    }
+}

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

@@ -42,8 +42,9 @@ struct Plan {
     solid_calls: usize,
     /// Where the shadow camera's solid and translucent calls begin.
     shadow_calls: [usize; 2],
-    /// Where Metal's opaque pass ends and its cutout pass begins in phase 1's calls.
-    pass_calls: [usize; 2],
+    /// Where Metal's opaque pass ends and its cutout pass begins in phase 1's calls,
+    /// and where its cutout pass begins in phase 2's.
+    pass_calls: [usize; 3],
     total: u64,
 }
 const QUADS: u32 = u32::MAX;
@@ -53,10 +54,15 @@ const GROUP_LIMIT: u32 = 65535;
 /// below it. A call names its key: its vertices come from that arena's page.
 pub const TRANSLUCENT_KEYS: u32 = 1 << 10;
 
+/// terrain.wgsl's `arena_page`: the page the solid draws read their vertices from.
+pub const ARENA_BINDING: u32 = 19;
+
 struct PageTable {
     /// Section id of every block of the page.
     blocks: wgpu::Buffer,
     group: Option<wgpu::BindGroup>,
+    /// The section arena's page `group` binds at `ARENA_BINDING` (`bind_pages`).
+    arena: Option<wgpu::Buffer>,
 }
 
 /// Writes the fragment's alpha over the frame's and leaves its colour.
@@ -81,8 +87,9 @@ pub struct Flat {
     /// The solid draws in one pass (`fs_solid`), where the GPU doesn't hide pixels
     /// by tiles (`split_solid` in `Renderer::draw_frame`: elsewhere than Metal).
     pub solid: wgpu::RenderPipeline,
-    /// The solid draws in two passes over the same draws (terrain.wgsl's `opaque_quad`):
-    /// the quads with no cutout first, through a shader that never discards, then the rest.
+    /// The solid draws in two passes, each over its own part of the draws (terrain.wgsl's
+    /// `opaque_quad`): the quads with no cutout first, through a shader that never discards,
+    /// then the rest.
     pub solid_opaque: wgpu::RenderPipeline,
     pub solid_cutout: wgpu::RenderPipeline,
     /// The solid draws as the water mirror's camera draws them (`fs_solid_mirror`).
@@ -128,8 +135,9 @@ pub struct Flat {
     pub phase1_calls: usize,
     pub solid_calls: usize,
     /// Metal's two solid passes over phase 1: the opaque one draws
-    /// `calls[..pass_calls[0]]`, the cutout one `calls[pass_calls[1]..phase1_calls]`.
-    pub pass_calls: [usize; 2],
+    /// `calls[..pass_calls[0]]`, the cutout one `calls[pass_calls[1]..phase1_calls]`;
+    /// over phase 2, `calls[phase1_calls..pass_calls[2]]` and the rest.
+    pub pass_calls: [usize; 3],
     /// Where a shader pack's shadow camera's solid and translucent calls
     /// begin (`calls.len()` without them): the camera's translucent calls
     /// end at the first.
@@ -137,6 +145,10 @@ pub struct Flat {
     /// Frames with fewer sections in view keep the per-section draws.
     pub min_sections: usize,
     range_align: u64,
+    /// Phase 2's calls draw their page key as their first instance, as `draw_paged` does:
+    /// the visibility buffer's ID pass (`visbuffer`) reads it. The other flat pipelines
+    /// have no instance-rate inputs.
+    pub page_instances: bool,
 }
 
 /// Sections in view (and distant tiles) from which a frame is drawn flat.
@@ -247,7 +259,8 @@ fn buffer(
 /// instead of a destination: the call's room holds all of its draws. Draws
 /// from `shadow[0]` (solid) and `shadow[1]` (translucent) on are a shader
 /// pack's shadow camera's, with calls of their own. Phase 1's draws before
-/// `passes[0]` and from `passes[1]` on, the two solid passes' on Metal, too.
+/// `passes[0]` and from `passes[1]` on, the two solid passes' on Metal, too,
+/// and phase 2's from `passes[2]` on (its cutout pass's).
 #[allow(clippy::too_many_arguments)]
 fn plan(
     draws: &[[u32; 5]],
@@ -255,7 +268,7 @@ fn plan(
     phase1_draws: usize,
     solid_draws: usize,
     shadow: [usize; 2],
-    passes: [usize; 2],
+    passes: [usize; 3],
     align: u64,
     key: impl Fn(u32, Option<u32>) -> u32,
     calls: &mut Vec<Call>,
@@ -267,7 +280,7 @@ fn plan(
     segments.clear();
     let (mut phase1_calls, mut solid_calls) = (None, None);
     let mut shadow_calls = [None; 2];
-    let mut pass_calls = [None; 2];
+    let mut pass_calls = [None; 3];
     let mut total = 0u64;
     let mut by_source: Vec<(Source, Vec<Range>)> = Vec::new();
     for (i, (d, &(page, sorted))) in draws.iter().zip(pages).enumerate() {
@@ -329,14 +342,22 @@ fn plan(
         phase1_calls,
         solid_calls,
         shadow_calls: shadow_calls.map(|c| c.unwrap_or(calls.len())),
-        pass_calls: pass_calls.map(|c| c.unwrap_or(calls.len()).min(phase1_calls)),
+        pass_calls: {
+            let [opaque, cutout, phase2] = pass_calls.map(|c| c.unwrap_or(calls.len()));
+            [
+                opaque.min(phase1_calls),
+                cutout.min(phase1_calls),
+                phase2.clamp(phase1_calls, solid_calls),
+            ]
+        },
         total,
     }
 }
 
 impl Flat {
-    /// `pipeline(layout, label, vertex entry, fragment entry, blend, cull)` builds a
-    /// terrain pipeline as the per-section ones, without the origin buffer.
+    /// `pipeline(layout, label, vertex entry, fragment entry, blend, cull, pulled)` builds a
+    /// terrain pipeline as the per-section ones, without the origin buffer, and without
+    /// vertex buffers when `pulled` (its vertex shader reads the page, `ARENA_BINDING`).
     pub fn new(
         device: &wgpu::Device,
         terrain_layout: &wgpu::BindGroupLayout,
@@ -349,13 +370,18 @@ impl Flat {
             &str,
             Option<wgpu::BlendState>,
             Option<wgpu::Face>,
+            bool,
         ) -> wgpu::RenderPipeline,
     ) -> Self {
         let vertex = wgpu::ShaderStages::VERTEX;
         let compute = wgpu::ShaderStages::COMPUTE;
         let draw_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
             label: Some("Flat section draws"),
-            entries: &[storage(0, vertex, true), storage(1, vertex, true)],
+            entries: &[
+                storage(0, vertex, true),
+                storage(1, vertex, true),
+                storage(ARENA_BINDING, vertex, true),
+            ],
         });
         let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
             label: Some("Flat terrain layout"),
@@ -404,38 +430,44 @@ impl Flat {
         let storage_usage = wgpu::BufferUsages::STORAGE;
         let back = Some(wgpu::Face::Back);
         Self {
+            // The solid draws read either layout of the solid quads (`mesher::packed`) from
+            // the page; translucent ones keep their vertex buffer.
             solid: pipeline(
                 &layout,
                 "Terrain solid (flat)",
-                "vs_terrain_flat",
+                "vs_section_flat",
                 "fs_solid",
                 None,
                 back,
+                true,
             ),
             solid_opaque: pipeline(
                 &layout,
                 "Terrain solid opaque (flat)",
-                "vs_terrain_flat_opaque",
+                "vs_section_flat_opaque",
                 "fs_opaque",
                 None,
                 back,
+                true,
             ),
             solid_cutout: pipeline(
                 &layout,
                 "Terrain solid cutout (flat)",
-                "vs_terrain_flat_cutout",
+                "vs_section_flat_cutout",
                 "fs_solid",
                 None,
                 back,
+                true,
             ),
             // The mirror flips the winding: its solid terrain culls the front.
             solid_mirror: pipeline(
                 &layout,
                 "Terrain solid mirrored (flat)",
-                "vs_terrain_flat",
+                "vs_section_flat",
                 "fs_solid_mirror",
                 None,
                 Some(wgpu::Face::Front),
+                true,
             ),
             translucent: pipeline(
                 &layout,
@@ -444,6 +476,7 @@ impl Flat {
                 "fs_translucent",
                 Some(wgpu::BlendState::ALPHA_BLENDING),
                 back,
+                false,
             ),
             translucent_mark: pipeline(
                 &layout,
@@ -452,6 +485,7 @@ impl Flat {
                 "fs_translucent_mark",
                 Some(ALPHA_ONLY),
                 back,
+                false,
             ),
             flatten,
             compute_layout,
@@ -490,11 +524,12 @@ impl Flat {
             calls: Vec::new(),
             phase1_calls: 0,
             solid_calls: 0,
-            pass_calls: [0; 2],
+            pass_calls: [0; 3],
             shadow_calls: [0; 2],
             min_sections,
             range_align: (u64::from(device.limits().min_storage_buffer_offset_alignment) / 16)
                 .max(1),
+            page_instances: false,
         }
     }
     /// A section uploaded to `vertices` vertices from `start` of the page keyed `page`:
@@ -539,13 +574,15 @@ impl Flat {
             self.pages.resize_with(page + 1, || None);
         }
         let table = self.pages[page].get_or_insert_with(|| PageTable {
+            // Copied whole into the visibility buffer's table of every page (`visbuffer`).
             blocks: buffer(
                 device,
                 "Section ids by block",
                 blocks * 4,
-                wgpu::BufferUsages::STORAGE,
+                wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
             ),
             group: None,
+            arena: None,
         });
         let first = start / GRAIN;
         let ids = vec![id; vertices.div_ceil(GRAIN) as usize];
@@ -606,7 +643,7 @@ impl Flat {
         phase1_draws: usize,
         solid_draws: usize,
         shadow: [usize; 2],
-        passes: [usize; 2],
+        passes: [usize; 3],
         phase2: Option<&wgpu::Buffer>,
         translucent_arena: bool,
         origins: impl Iterator<Item = (u32, [f32; 4])>,
@@ -680,7 +717,7 @@ impl Flat {
             self.phase1_calls = 0;
             self.solid_calls = 0;
             self.shadow_calls = [0; 2];
-            self.pass_calls = [0; 2];
+            self.pass_calls = [0; 3];
             return false;
         }
         if self.range_data.len() as u64 > self.range_capacity {
@@ -709,10 +746,11 @@ impl Flat {
         );
         // Phase 2's calls start empty, each at the start of its room.
         self.phase2_call_data.clear();
+        let page_instances = self.page_instances;
         self.phase2_call_data.extend(
             self.calls[phase1_calls..solid_calls]
                 .iter()
-                .map(|c| [0, 1, c.first, 0, 0]),
+                .map(|c| [0, 1, c.first, 0, if page_instances { c.page } else { 0 }]),
         );
         let phase2_calls = self.phase2_call_data.len() as u64;
         if phase2_calls > self.phase2_call_capacity {
@@ -807,29 +845,53 @@ impl Flat {
             pass.dispatch_workgroups((*count).min(GROUP_LIMIT), count.div_ceil(GROUP_LIMIT), 1);
         }
         drop(pass);
-        for page in self.calls.iter().map(|c| c.page) {
-            let table = self.pages[page as usize]
-                .as_mut()
-                .expect("a drawn page has its block table");
-            if table.group.is_none() {
-                table.group = Some(device.create_bind_group(&wgpu::BindGroupDescriptor {
-                    label: Some("Flat section draws"),
-                    layout: &self.draw_layout,
-                    entries: &[
-                        wgpu::BindGroupEntry {
-                            binding: 0,
-                            resource: table.blocks.as_entire_binding(),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 1,
-                            resource: self.origins.as_entire_binding(),
-                        },
-                    ],
-                }));
-            }
-        }
         true
     }
+    /// Gives every page table its bind group (`bind_page`): its blocks, the origins and, for
+    /// a page of the section arena, that page (`arena`, by page) for the solid draws to read.
+    /// Before each frame's draws, flat or not: the per-section solid draws bind the groups too
+    /// (`page_group`), and a page that grew is another buffer.
+    pub fn bind_pages<'a>(
+        &mut self,
+        device: &wgpu::Device,
+        arena: impl Fn(u32) -> Option<&'a wgpu::Buffer>,
+    ) {
+        for (key, slot) in self.pages.iter_mut().enumerate() {
+            let Some(table) = slot else {
+                continue;
+            };
+            let page = (key < TRANSLUCENT_KEYS as usize)
+                .then(|| arena(key as u32))
+                .flatten();
+            if table.group.is_some() && table.arena.as_ref() == page {
+                continue;
+            }
+            table.arena = page.cloned();
+            table.group = Some(device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: Some("Flat section draws"),
+                layout: &self.draw_layout,
+                entries: &[
+                    wgpu::BindGroupEntry {
+                        binding: 0,
+                        resource: table.blocks.as_entire_binding(),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 1,
+                        resource: self.origins.as_entire_binding(),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: ARENA_BINDING,
+                        resource: page.unwrap_or(&self.empty).as_entire_binding(),
+                    },
+                ],
+            }));
+        }
+    }
+    /// The bind group of the section arena's page `page` (`bind_pages`), which the solid
+    /// draws read their vertices through.
+    pub fn page_group(&self, page: u32) -> Option<&wgpu::BindGroup> {
+        self.pages.get(page as usize)?.as_ref()?.group.as_ref()
+    }
     /// After occlusion culling's test: copies the phase 2 draws it saw.
     pub fn flatten_phase2(
         &self,
@@ -879,6 +941,46 @@ impl Flat {
             pass.draw_indexed(call.first..call.first + call.count, 0, 0..1);
         }
     }
+    /// `draw`, each call as the instance its page key names: the visibility buffer's ID
+    /// pass (`visbuffer`) tells the pages apart by it.
+    pub(super) fn draw_paged<'a>(
+        &self,
+        pass: &mut wgpu::RenderPass<'_>,
+        calls: &[Call],
+        vertices: impl Fn(u32) -> wgpu::BufferSlice<'a>,
+    ) {
+        pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
+        for call in calls {
+            self.bind_page(pass, call.page, &vertices);
+            pass.draw_indexed(
+                call.first..call.first + call.count,
+                0,
+                call.page..call.page + 1,
+            );
+        }
+    }
+    /// Bytes of its buffers: the index list, ranges, origins and block tables.
+    pub fn bytes(&self) -> u64 {
+        let tables: u64 = self.pages.iter().flatten().map(|t| t.blocks.size()).sum();
+        self.indices.size()
+            + self.ranges.size()
+            + self.origins.size()
+            + self.phase2_calls.size()
+            + tables
+    }
+    /// The origins by section id, which the visibility buffer's resolve (`visbuffer`) reads
+    /// in its fragment shader.
+    pub(super) fn origins(&self) -> &wgpu::Buffer {
+        &self.origins
+    }
+    /// The block table of the section arena's page `page` (`blocks_per_page` entries), which
+    /// the visibility buffer copies into its table of every page.
+    pub(super) fn block_table(&self, page: u32) -> Option<&wgpu::Buffer> {
+        Some(&self.pages.get(page as usize)?.as_ref()?.blocks)
+    }
+    pub(super) fn blocks_per_page(&self) -> u64 {
+        self.blocks_per_page
+    }
     /// 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.
@@ -896,19 +998,22 @@ impl Flat {
             pass.draw(call.first..call.first + call.count, 0..instances);
         }
     }
-    /// Draws phase 2's calls, as `flatten_phase2` left them.
+    /// Draws phase 2's `calls` (`calls[phase1_calls..solid_calls]` counted from 0), as
+    /// `flatten_phase2` left them.
     pub fn draw_phase2<'a>(
         &self,
         pass: &mut wgpu::RenderPass<'_>,
+        calls: std::ops::Range<usize>,
         vertices: impl Fn(u32) -> wgpu::BufferSlice<'a>,
     ) {
         pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
-        for (k, call) in self.calls[self.phase1_calls..self.solid_calls]
+        let first = self.phase1_calls + calls.start;
+        for (k, call) in self.calls[first..self.phase1_calls + calls.end]
             .iter()
             .enumerate()
         {
             self.bind_page(pass, call.page, &vertices);
-            pass.draw_indexed_indirect(&self.phase2_calls, k as u64 * 20);
+            pass.draw_indexed_indirect(&self.phase2_calls, (calls.start + k) as u64 * 20);
         }
     }
     fn bind_page<'a>(
@@ -968,7 +1073,7 @@ mod tests {
             solid,
             solid,
             [draws.len(); 2],
-            [draws.len(), 0],
+            [draws.len(), 0, solid],
             4,
             |page, _| page,
             &mut calls,
@@ -1017,14 +1122,14 @@ mod tests {
             solid,
             solid,
             [draws.len(); 2],
-            [3, 1],
+            [3, 1, solid],
             4,
             |page, _| page,
             &mut calls,
             &mut ranges,
             &mut segments,
         );
-        assert_eq!((plan.pass_calls, plan.solid_calls), ([3, 1], 4));
+        assert_eq!((plan.pass_calls, plan.solid_calls), ([3, 1, 4], 4));
         let call = |page, first, count| Call { page, first, count };
         assert_eq!(
             calls,
@@ -1053,7 +1158,7 @@ mod tests {
             solid,
             solid,
             [camera, camera + 2],
-            [camera, 0],
+            [camera, 0, solid],
             4,
             |page, _| page,
             &mut calls,
@@ -1082,7 +1187,7 @@ mod tests {
             2,
             solid,
             [draws.len(); 2],
-            [draws.len(), 0],
+            [draws.len(), 0, solid],
             4,
             |page, _| page,
             &mut calls,
@@ -1095,7 +1200,7 @@ mod tests {
                 phase1_calls: 1,
                 solid_calls: 3,
                 shadow_calls: [4, 4],
-                pass_calls: [1, 0],
+                pass_calls: [1, 0, 3],
                 total: 6 * 13
             }
         );
@@ -1200,7 +1305,7 @@ mod tests {
                 phase1,
                 solid,
                 [draws.len(); 2],
-                [draws.len(), 0],
+                [draws.len(), 0, solid],
                 align,
                 |page, _| page,
                 &mut calls,

crates/horizon-client-render/src/gfx/gpu_culling.wgsl

@@ -1,30 +1,42 @@
 // GPU culling (gfx/gpu_culling.rs). `apply` writes the records that changed.
-// `cull`: one invocation per section id keeps the sections the CPU's walk
-// chose, writes each one's origin and counts it in its page, per block of 64
-// ids. `scan`: one workgroup per page turns the blocks' counts into where
-// each block's draws start, and the page's count. `scatter`: each block
-// writes its sections' draws there, in id order, so a page's draws come in
-// the same order every frame (atomics alone would order them as the GPU
-// schedules, and where faces of two sections meet at the same depth the later
-// draw keeps the pixel). Nothing here computes with floats: the origins are
-// the CPU's bits, copied.
+// `cull`: one invocation per section id keeps the sections whose column is
+// within the render distance, that cave culling's graph reaches (occlusion.rs)
+// and whose box is in the frustum, writes each one's origin and counts it in
+// its page, per block of 64 ids. `scan`: one workgroup per page turns the
+// blocks' counts into where each block's draws start, and the page's count.
+// `scatter`: each block writes its sections' draws there, in id order, so a
+// page's draws come in the same order every frame (atomics alone would order
+// them as the GPU schedules, and where faces of two sections meet at the same
+// depth the later draw keeps the pixel). Nothing here computes with floats: the
+// origins are the CPU's bits, copied, and the frustum test adds integers the
+// CPU computed.
 
 struct Params {
     // Ids to test, records `apply` writes, the arena pages the counts and
-    // regions cover, and where the regions and the chosen ids' bits start in
-    // `tables`.
+    // regions cover, and where the regions start in `tables`.
     ids: u32,
     updates: u32,
     pages: u32,
     regions: u32,
-    mask: u32,
-    pad0: u32,
-    pad1: u32,
-    pad2: u32,
+    // Bits 3j, 3j + 1 and 3j + 2: frustum plane j's x, y and z are at least 0.
+    signs: u32,
+    // The render distance in columns, and the camera's column.
+    near: i32,
+    cam_x: i32,
+    cam_z: i32,
     // The tables' first column: x, 0, z, 0.
     first: vec4<i32>,
     // Their entries along x, y and z, and 0.
     cells: vec4<u32>,
+    // Each frustum plane's w term, its margin in, then 0, 0.
+    w: array<vec4<i32>, 2>,
+    // Cave culling's graph (occlusion.rs `Reach`): from x, from z, radius, lowest
+    // section y; its height in sections and the level's; REACH and SKY; 0.
+    reach: vec4<i32>,
+    reach_height: i32,
+    reach_sections: i32,
+    flags: u32,
+    pad: u32,
 }
 
 // gpu_culling.rs `Record`.
@@ -32,8 +44,8 @@ struct Section {
     // Section x, y (from the level's bottom), z, and its arena page (-1: a
     // free id).
     key: vec4<i32>,
-    // The first vertex of its solid quads, its solid quads, then two words
-    // unused here.
+    // The first vertex of its solid quads, its solid quads, its box
+    // (gpu_culling.rs `rounded_box`), then a word unused here.
     a: vec4<u32>,
 }
 
@@ -45,9 +57,10 @@ struct Update {
 
 @group(0) @binding(0) var<uniform> params: Params;
 @group(0) @binding(1) var<storage, read_write> sections: array<Section>;
-// gpu_culling.rs `GpuCulling::prepare`: the origins' f32 bits along x, y and
-// z, each page's region of `draws` (its first draw and its size), then a bit
-// per id the CPU's walk chose.
+// gpu_culling.rs `tables`: the origins' f32 bits along x, y and z (n of them);
+// per frustum plane its terms for those origins, n each; per plane and axis its
+// terms for the 32 box codes; then each page's region of `draws` (its first
+// draw and its size).
 @group(0) @binding(2) var<storage, read> tables: array<u32>;
 @group(0) @binding(3) var<storage, read> updates: array<Update>;
 // Sections kept, draws, each page's draws, then per block of ids and page its
@@ -59,6 +72,9 @@ struct Update {
 @group(0) @binding(6) var<storage, read_write> origins: array<vec4<u32>>;
 // Per id its page + 1 when it is drawn this frame, else 0.
 @group(0) @binding(7) var<storage, read_write> runs: array<u32>;
+// occlusion.rs `Reach::bits`: whether the search reached each cell of its box,
+// a bit each (32 a word, lowest first).
+@group(0) @binding(8) var<storage, read> reached_cells: array<u32>;
 
 // gfx.rs `section_instance`'s w for a whole section: 1 / mesher::UV_STEPS.
 const STEP_BITS: u32 = 0x38000000u;
@@ -68,6 +84,13 @@ const ROW: u32 = 65535u;
 const BLOCK: u32 = 64u;
 // Counts before the pages'.
 const STATS: u32 = 2u;
+// gpu_culling.rs `rounded_box` for a box past what its codes hold: no plane
+// rejects it.
+const UNBOUNDED: u32 = 0x80000000u;
+// In `params.flags`: cave culling's graph is in `params.reach`, and its search
+// reached the box's top layer (the sky band).
+const REACH: u32 = 1u;
+const SKY: u32 = 2u;
 
 // The count of `block`'s draws in `page` (`cull`), then where they start (`scan`).
 fn block_count(block: u32, page: u32) -> u32 {
@@ -80,9 +103,69 @@ fn region(page: u32) -> vec2<u32> {
     return vec2<u32>(tables[at], tables[at + 1u]);
 }
 
-// The CPU's walk chose it (gpu_culling.rs `GpuCulling::choose`).
-fn chosen(id: u32) -> bool {
-    return ((tables[params.mask + id / 32u] >> (id % 32u)) & 1u) != 0u;
+// streaming.rs `in_view_distance` around the camera's column. A gap at or past
+// the distance cannot pass, so testing it first keeps the squares in range.
+fn near(x: i32, z: i32) -> bool {
+    let r = params.near;
+    let gx = max(abs(x - params.cam_x) - 1, 0);
+    let gz = max(abs(z - params.cam_z) - 1, 0);
+    if gx >= r || gz >= r {
+        return false;
+    }
+    return gx * gx + gz * gz < r * r;
+}
+
+// occlusion.rs `Occlusion::contains` (`Graph::contains`): with no graph, or with
+// cave culling off, every section; in the searched box, whether the search
+// reached it; above a clamped box, over its columns and within the level, the
+// sky band (all of it or none); else none. `Reach::contains` on the CPU.
+fn reached(key: vec3<i32>) -> bool {
+    if (params.flags & REACH) == 0u {
+        return true;
+    }
+    let r = params.reach.z;
+    let dx = key.x - params.reach.x;
+    let dz = key.z - params.reach.y;
+    let dy = key.y - params.reach.w;
+    if dx < -r || dx > r || dz < -r || dz > r || dy < 0 {
+        return false;
+    }
+    if dy >= params.reach_height {
+        return (params.flags & SKY) != 0u && key.y >= 0 && key.y <= params.reach_sections;
+    }
+    let i = u32(((dz + r) * (2 * r + 1) + dx + r) * params.reach_height + dy);
+    return ((reached_cells[i >> 5u] >> (i & 31u)) & 1u) != 0u;
+}
+
+fn term(at: u32) -> i32 {
+    return bitcast<i32>(tables[at]);
+}
+
+// gfx.rs `Frustum::intersects` for the box `b` of the section in cell `c` of the
+// tables, in integers (gpu_culling.rs `tables`): it keeps every box the CPU keeps.
+fn in_frustum(c: vec3<u32>, b: u32) -> bool {
+    if (b & UNBOUNDED) != 0u {
+        return true;
+    }
+    let nx = params.cells.x;
+    let ny = params.cells.y;
+    let n = nx + ny + params.cells.z;
+    for (var j = 0u; j < 6u; j++) {
+        // The box's codes at the corner the plane looks at.
+        let s = params.signs >> (3u * j);
+        let kx = (b >> select(0u, 15u, (s & 1u) != 0u)) & 31u;
+        let ky = (b >> select(5u, 20u, (s & 2u) != 0u)) & 31u;
+        let kz = (b >> select(10u, 25u, (s & 4u) != 0u)) & 31u;
+        let origin_terms = n + j * n;
+        let code_terms = 7u * n + 96u * j;
+        let sum = params.w[j / 4u][j % 4u] + term(origin_terms + c.x)
+            + term(origin_terms + nx + c.y) + term(origin_terms + nx + ny + c.z)
+            + term(code_terms + kx) + term(code_terms + 32u + ky) + term(code_terms + 64u + kz);
+        if sum < 0 {
+            return false;
+        }
+    }
+    return true;
 }
 
 // One invocation per changed record; the CPU lists each id once.
@@ -97,19 +180,20 @@ fn apply(@builtin(global_invocation_id) gid: vec3<u32>) {
 @compute @workgroup_size(64)
 fn cull(@builtin(global_invocation_id) gid: vec3<u32>) {
     let id = gid.y * (ROW * BLOCK) + gid.x;
+    // Past the table's end the records are stale: the CPU never writes them free.
     if id >= params.ids {
         return;
     }
     runs[id] = 0u;
     let s = sections[id];
-    if s.key.w < 0 || s.a.y == 0u || !chosen(id) {
+    if s.key.w < 0 || s.a.y == 0u || !near(s.key.x, s.key.z) || !reached(s.key.xyz) {
         return;
     }
     let page = u32(s.key.w);
     // The tables hold every column within the distance; a key before their
     // first wraps past their end.
     let c = vec3<u32>(s.key.xyz - params.first.xyz);
-    if page >= params.pages || any(c >= params.cells.xyz) {
+    if page >= params.pages || any(c >= params.cells.xyz) || !in_frustum(c, s.a.z) {
         return;
     }
     let nx = params.cells.x;

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

@@ -1,8 +1,10 @@
 //! HDR output (Horizon setting, off by default): the frame renders exactly as
-//! without it, into an 8-bit target in vanilla's gamma space, and one pass
-//! (`hdr.wgsl`) writes it to an HDR10 or scRGB swapchain at the player's paper
-//! white, expanding the world's highlights towards their peak brightness. The
-//! world is copied aside before the hand and HUD so only it is expanded.
+//! without it, in vanilla's gamma space, into a 16-bit target when HDR output
+//! was on when the renderer was made, else an 8-bit one
+//! (`Renderer::frame_format`), and one pass (`hdr.wgsl`) writes it to an HDR10
+//! or scRGB swapchain at the player's paper white, expanding the world's
+//! highlights towards their peak brightness. The world is copied aside before
+//! the hand and HUD so only it is expanded.
 
 /// The swapchain HDR output presents to.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -301,7 +303,7 @@ impl Hdr {
         }
     }
 
-    /// The 8-bit frame every pass draws into this frame, sized like the window.
+    /// The frame every pass draws into this frame, sized like the window.
     pub fn frame(&mut self, device: &wgpu::Device, size: [u32; 2]) -> wgpu::Texture {
         if self.targets.as_ref().is_none_or(|t| t.size != size) {
             let texture = |label, usage| {

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

@@ -0,0 +1,223 @@
+//! Every render pipeline's stage interface against the weakest GPUs' limit (#8195).
+//!
+//! OpenGL 3.3 drivers (a GeForce 9100M G) allow `max_inter_stage_shader_variables` = 15, and wgpu
+//! counts the fragment stage's built-in inputs (`front_facing`, `sample_index`, ...) against it.
+//! A pipeline over that limit panics at start-up on such a GPU, with no way to run the game, so
+//! this checks the shaders with naga, without a GPU.
+
+use std::path::{Path, PathBuf};
+
+/// `Limits::downlevel_defaults().max_inter_stage_shader_variables`, the least a GPU offers.
+const LIMIT: u32 = 15;
+
+/// One entry point's variables: the user-defined `@location`s and the built-ins wgpu counts.
+#[derive(Debug, PartialEq, Eq)]
+struct Interface {
+    entry: String,
+    /// Vertex outputs or fragment inputs, user-defined.
+    user: u32,
+    /// The fragment stage's `front_facing`, `sample_index`, `sample_mask` and `primitive_index`
+    /// inputs, which wgpu counts as one variable each; 0 for a vertex stage.
+    built_ins: u32,
+}
+
+impl Interface {
+    fn total(&self) -> u32 {
+        self.user + self.built_ins
+    }
+}
+
+/// The bindings an argument or a result carries, a struct's members flattened.
+fn bindings(
+    module: &naga::Module,
+    binding: &Option<naga::Binding>,
+    ty: naga::Handle<naga::Type>,
+) -> Vec<naga::Binding> {
+    if let Some(binding) = binding {
+        return vec![binding.clone()];
+    }
+    match &module.types[ty].inner {
+        naga::TypeInner::Struct { members, .. } => {
+            members.iter().filter_map(|m| m.binding.clone()).collect()
+        }
+        _ => Vec::new(),
+    }
+}
+
+fn is_location(binding: &naga::Binding) -> bool {
+    matches!(binding, naga::Binding::Location { .. })
+}
+
+/// The stage interface of every vertex and fragment entry point of `source`.
+fn interfaces(source: &str) -> Vec<Interface> {
+    let module = naga::front::wgsl::parse_str(source).unwrap();
+    let mut out = Vec::new();
+    for entry in &module.entry_points {
+        let function = &entry.function;
+        let (user, built_ins) = match entry.stage {
+            naga::ShaderStage::Vertex => {
+                let outputs: Vec<_> = function
+                    .result
+                    .iter()
+                    .flat_map(|r| bindings(&module, &r.binding, r.ty))
+                    .collect();
+                (outputs.iter().filter(|b| is_location(b)).count(), 0)
+            }
+            naga::ShaderStage::Fragment => {
+                let inputs: Vec<_> = function
+                    .arguments
+                    .iter()
+                    .flat_map(|a| bindings(&module, &a.binding, a.ty))
+                    .collect();
+                let built_ins = inputs
+                    .iter()
+                    .filter(|b| {
+                        matches!(
+                            b,
+                            naga::Binding::BuiltIn(
+                                naga::BuiltIn::FrontFacing
+                                    | naga::BuiltIn::SampleIndex
+                                    | naga::BuiltIn::SampleMask
+                                    | naga::BuiltIn::PrimitiveIndex
+                            )
+                        )
+                    })
+                    .count();
+                (inputs.iter().filter(|b| is_location(b)).count(), built_ins)
+            }
+            _ => continue,
+        };
+        out.push(Interface {
+            entry: entry.name.clone(),
+            user: user as u32,
+            built_ins: built_ins as u32,
+        });
+    }
+    out
+}
+
+/// The shaders as the renderer assembles them, by the `.wgsl` files each is made of.
+fn composed() -> Vec<(&'static str, Vec<&'static str>, String)> {
+    let entity = crate::overlay::wgsl_constants() + include_str!("../entity.wgsl");
+    vec![
+        ("entity", vec!["entity.wgsl"], entity.clone()),
+        (
+            "static entity",
+            vec!["entity.wgsl", "static_entity.wgsl"],
+            entity.clone() + include_str!("../static_entity.wgsl"),
+        ),
+        (
+            "improved transparency clouds",
+            vec!["entity.wgsl", "oit.wgsl", "oit_clouds.wgsl"],
+            entity.clone() + include_str!("../oit.wgsl") + include_str!("../oit_clouds.wgsl"),
+        ),
+        (
+            "improved transparency features",
+            vec!["entity.wgsl", "oit.wgsl", "oit_features.wgsl"],
+            entity + include_str!("../oit.wgsl") + include_str!("../oit_features.wgsl"),
+        ),
+        (
+            "improved transparency world",
+            vec!["terrain.wgsl", "oit.wgsl", "oit_world.wgsl"],
+            include_str!("../terrain.wgsl").to_owned()
+                + include_str!("../oit.wgsl")
+                + include_str!("../oit_world.wgsl"),
+        ),
+        (
+            "visibility buffer",
+            vec!["terrain.wgsl", "visbuffer.wgsl"],
+            include_str!("../terrain.wgsl").to_owned() + include_str!("../visbuffer.wgsl"),
+        ),
+        (
+            "improved transparency world border",
+            vec!["border.wgsl", "oit.wgsl", "oit_border.wgsl"],
+            include_str!("../border.wgsl").to_owned()
+                + include_str!("../oit.wgsl")
+                + include_str!("../oit_border.wgsl"),
+        ),
+    ]
+}
+
+fn wgsl_files(dir: &Path, out: &mut Vec<PathBuf>) {
+    for entry in std::fs::read_dir(dir).unwrap().flatten() {
+        let path = entry.path();
+        if path.is_dir() {
+            wgsl_files(&path, out);
+        } else if path.extension().is_some_and(|e| e == "wgsl") {
+            out.push(path);
+        }
+    }
+}
+
+/// Every shader: the assembled ones, and each `.wgsl` file that stands alone. A file that does
+/// not (it needs another's declarations) must be part of an assembled one, so that a new shader
+/// cannot slip past the audit.
+fn audited() -> Vec<(String, Vec<Interface>)> {
+    let composed = composed();
+    let mut files = Vec::new();
+    wgsl_files(
+        &Path::new(env!("CARGO_MANIFEST_DIR")).join("src"),
+        &mut files,
+    );
+    files.sort();
+    let mut out: Vec<(String, Vec<Interface>)> = composed
+        .iter()
+        .map(|(name, _, source)| ((*name).to_owned(), interfaces(source)))
+        .collect();
+    for file in files {
+        let name = file.file_name().unwrap().to_string_lossy().into_owned();
+        let source = std::fs::read_to_string(&file).unwrap();
+        let alone = naga::front::wgsl::parse_str(&source).is_ok();
+        let part = composed.iter().any(|(_, parts, _)| parts.contains(&&*name));
+        assert!(
+            alone || part,
+            "{name} needs other files' declarations: add its assembly to `composed`"
+        );
+        if alone {
+            out.push((name, interfaces(&source)));
+        }
+    }
+    out
+}
+
+#[test]
+fn no_pipeline_exceeds_the_weakest_gpus_inter_stage_limit() {
+    let mut over = Vec::new();
+    for (shader, entries) in audited() {
+        for e in entries {
+            if e.total() > LIMIT {
+                over.push(format!(
+                    "{shader}::{}: {} user-defined + {} built-in = {} > {LIMIT}",
+                    e.entry,
+                    e.user,
+                    e.built_ins,
+                    e.total()
+                ));
+            }
+        }
+    }
+    assert!(over.is_empty(), "over the limit:\n{}", over.join("\n"));
+}
+
+/// The audit counts what wgpu counts (the failure of #8195: 15 user-defined + `FrontFacing`).
+#[test]
+fn a_front_facing_input_counts_against_the_limit() {
+    let source = "struct Io { @builtin(position) p: vec4<f32>, @location(0) a: vec4<f32>, @location(1) b: f32 }
+        @vertex fn vs() -> Io { return Io(vec4<f32>(0.0), vec4<f32>(0.0), 0.0); }
+        @fragment fn fs(in: Io, @builtin(front_facing) f: bool) -> @location(0) vec4<f32> { return in.a; }";
+    assert_eq!(
+        interfaces(source),
+        vec![
+            Interface {
+                entry: "vs".into(),
+                user: 2,
+                built_ins: 0
+            },
+            Interface {
+                entry: "fs".into(),
+                user: 2,
+                built_ins: 1
+            },
+        ]
+    );
+}

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

@@ -63,6 +63,9 @@ pub(super) struct Tile {
     /// place until they have faded in (from the job's end, the instant), so
     /// no hole shows through them.
     previous: Option<(SectionGpu, Option<Instant>)>,
+    /// Its slot in occlusion culling's results (`cull::TILE`), kept while
+    /// meshes of the same tile replace one another.
+    pub cull_slot: u32,
 }
 
 /// How long a tile takes to fade in over the ones it replaces.
@@ -160,6 +163,18 @@ impl Tile {
             None => &mut self.mesh,
         }
     }
+    /// The box occlusion culling tests (`cull::Cull`), around its origin: its
+    /// mesh's bounds grown by a block, while that mesh is the one drawn
+    /// whole (no stand-in, no fade). A fading tile's dither moves its depth
+    /// toward the camera (terrain.wgsl's `fade_depth`), out of the box.
+    pub fn cull_bounds(&self, fade: u32) -> Option<[[f32; 3]; 2]> {
+        (fade == 0 && self.previous.is_none()).then(|| {
+            [
+                (self.bounds.min - 1.0).to_array(),
+                (self.bounds.max + 1.0).to_array(),
+            ]
+        })
+    }
     /// 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))
@@ -192,6 +207,10 @@ impl Renderer {
     /// its old mesh stands in while they fade in. A new one waits for the rest of its job
     /// (`upload_lods`), then fades in.
     pub fn upload_lod(&mut self, key: TileKey, mesh: &SectionMesh, keep: bool) {
+        if let Some(copies) = &mut self.capture_copies {
+            copies.tile(key, mesh);
+        }
+        let old_slot = self.lods.get(&key).map(|tile| tile.cull_slot);
         let (shown, previous) = match self.lods.remove(&key) {
             Some(old) if old.dying.is_none() => match old.previous {
                 Some(previous) => {
@@ -212,6 +231,12 @@ impl Renderer {
         };
         match Bounds::mesh(mesh).zip(self.upload_mesh(mesh)) {
             Some((bounds, mesh)) => {
+                let cull_slot = old_slot.unwrap_or_else(|| {
+                    self.lod_cull_free.pop().unwrap_or_else(|| {
+                        self.lod_cull_next += 1;
+                        self.lod_cull_next - 1
+                    })
+                });
                 self.lods.insert(
                     key,
                     Tile {
@@ -221,6 +246,7 @@ impl Renderer {
                         dying: None,
                         alone: false,
                         previous,
+                        cull_slot,
                     },
                 );
             }
@@ -228,6 +254,7 @@ impl Renderer {
                 if let Some((previous, _)) = previous {
                     self.release_mesh(previous);
                 }
+                self.lod_cull_free.extend(old_slot);
             }
         }
     }
@@ -240,12 +267,19 @@ impl Renderer {
     }
 
     pub fn remove_lod(&mut self, key: TileKey) {
+        if let Some(copies) = &mut self.capture_copies {
+            copies.forget_tile(key);
+        }
         if let Some(tile) = self.lods.remove(&key) {
+            self.lod_cull_free.push(tile.cull_slot);
             self.release_tile(tile);
         }
     }
 
     pub fn clear_lods(&mut self) {
+        if let Some(copies) = &mut self.capture_copies {
+            copies.clear_tiles();
+        }
         self.lod_pending = None;
         // No far terrain left to fade out over.
         for (key, since) in std::mem::take(&mut self.lod_leaving) {
@@ -260,6 +294,8 @@ impl Renderer {
         for (_, tile) in std::mem::take(&mut self.lods) {
             self.release_tile(tile);
         }
+        self.lod_cull_free.clear();
+        self.lod_cull_next = 0;
         self.set_lod_cutout(Default::default());
     }
 
@@ -437,6 +473,15 @@ impl Renderer {
         }
     }
 
+    /// The tiles drawn for good, not fading out (`render-capture`).
+    pub(super) fn standing_lods(&self) -> FxHashSet<TileKey> {
+        self.lods
+            .iter()
+            .filter(|(_, tile)| tile.dying.is_none())
+            .map(|(&key, _)| key)
+            .collect()
+    }
+
     /// The chunk columns the resident tiles now leave out (`Lod::take_cutout`).
     /// Removed sections they no longer leave out are released.
     pub fn set_lod_cutout(&mut self, cutout: crate::fast_hash::FxHashSet<(i32, i32)>) {

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

@@ -41,17 +41,28 @@ struct HorizonMaterialOut {
     @location(10) @interpolate(flat) emission: f32,
     // terrain.wgsl's `emission`, for HDR output's mark.
     @location(11) @interpolate(flat) hdr_code: u32,
+    // The point on the flat face (`position` without `[displacement]`'s relief), how much of
+    // that relief it has (`MaterialInput.displaced`) and the face's normal (0 when the
+    // fragment finds it).
+    @location(12) base: vec3<f32>,
+    @location(13) displaced: f32,
+    @location(14) @interpolate(flat) normal: vec3<f32>,
 }
 fn horizon_material_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f32>,
     light: vec2<u32>, origin: vec3<f32>) -> HorizonMaterialOut {
     let pos = horizon_material_displace(position + origin, uv, layer, color, light);
+    return horizon_material_out(pos, uv, layer, color, vec2<f32>(light));
+}
+// `light`: sky, block, 16 per level.
+fn horizon_material_out(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f32>,
+    light: vec2<f32>) -> HorizonMaterialOut {
     var out: HorizonMaterialOut;
     out.clip = horizon_terrain_globals.view_proj * vec4(pos, 1.0);
     out.uv = uv;
     out.layer = layer;
     out.tint = vec4(color.rgb, 1.0);
-    let block = max(f32(light.y), horizon_terrain_dynamic_block_light(pos));
-    let sky = f32(light.x);
+    let block = max(light.y, horizon_terrain_dynamic_block_light(pos));
+    let sky = light.x;
     // 16 per level, 15 levels.
     out.light = min(vec2(block, sky) / 240.0, vec2(1.0));
     out.lightmap = horizon_terrain_sample_lightmap(sky / 16.0, block / 16.0).rgb;
@@ -73,6 +84,9 @@ fn horizon_material_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color
     // Codes above 4 are the same tiers, shining all over rather than in their bright parts.
     let tier = select(out.hdr_code, out.hdr_code - 4u, out.hdr_code > 4u);
     out.emission = select(min(f32(tier) * 7.0 / 15.0, 1.0), 0.0, tier == 0u);
+    out.base = pos;
+    out.displaced = 0.0;
+    out.normal = vec3(0.0);
     return out;
 }
 @vertex fn horizon_material_vs(
@@ -142,15 +156,17 @@ fn horizon_material_color(in: HorizonMaterialOut, translucent: bool) -> vec4<f32
     horizon_block_lod = max(0.5 * log2(max(footprint, 1e-8)), 0.0);
     // 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);
+    // `[displacement]`'s grid hands down its face's normal: its relief is the pack's to shade.
+    let normal = select(horizon_material_normal(in.position), in.normal,
+        dot(in.normal, in.normal) > 0.5);
     horizon_material_face_normal = normal;
     horizon_surface = vec4<f32>(0.0);
-    let tangent = horizon_material_tangent(in.position, in.uv, normal);
+    let tangent = horizon_material_tangent(in.base, in.uv, normal);
     return material(MaterialInput(albedo, in.tint, in.light, in.lightmap, in.position, in.uv,
         translucent, horizon_sprite_tags(in.layer & 0x7fffu),
         horizon_sprite_material(in.layer & 0x7fffu), in.clip.xy / frame.resolution,
         in.face, fluid, in.emission, normal, tangent,
-        horizon_terrain_native_colored_light(in.position))).color;
+        horizon_terrain_native_colored_light(in.position), in.displaced)).color;
 }
 var<private> horizon_material_face_normal: vec3<f32>;
 struct HorizonMaterialSolid {
@@ -176,6 +192,13 @@ fn horizon_material_mark(in: HorizonMaterialOut, texel: vec4<f32>) -> f32 {
     return 1.0;
 }
 @fragment fn horizon_material_fs_solid(in: HorizonMaterialOut) -> HorizonMaterialSolid {
+    // `[displacement]`'s grid draws these pixels.
+    if length(in.base) < horizon_displace_distance - 0.05 && horizon_displaced_layer(in.layer) {
+        discard;
+    }
+    return horizon_material_solid(in);
+}
+fn horizon_material_solid(in: HorizonMaterialOut) -> HorizonMaterialSolid {
     let color = horizon_material_color(in, false);
     let texel = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu);
     // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout.
@@ -196,6 +219,37 @@ fn horizon_material_mark(in: HorizonMaterialOut, texel: vec4<f32>) -> f32 {
 }
 ";
 
+/// `[displacement]`'s grid (gfx/displace.rs): one instance a quad the pick chose, its corners
+/// read from the copy of the arena, each of its cells two triangles moved along the face's
+/// normal by the pack's `displacement`, measured from the texture's mean height so that the
+/// face's edges, pinned there, meet their neighbours whatever their relief.
+const DISPLACED_ENTRIES: &str = "
+@vertex fn horizon_material_vs_displaced(@builtin(vertex_index) v: u32,
+    @builtin(instance_index) instance: u32) -> HorizonMaterialOut {
+    let p = horizon_displace_point(v, instance);
+    var out = horizon_material_out(p.position, p.uv, p.layer, p.color, p.light);
+    out.base = p.base;
+    out.displaced = p.near;
+    out.normal = p.normal;
+    return out;
+}
+@fragment fn horizon_material_fs_displaced(in: HorizonMaterialOut) -> HorizonMaterialSolid {
+    if length(in.base) >= horizon_displace_distance + 0.05 {
+        discard;
+    }
+    return horizon_material_solid(in);
+}
+";
+
+/// What the material's displaced pipeline is built against: `[displacement]`'s values and
+/// its group 1.
+pub struct DisplacedShape<'a> {
+    pub distance: f32,
+    pub cells: u32,
+    pub steps: bool,
+    pub layout: &'a wgpu::BindGroupLayout,
+}
+
 /// What terrain pipelines are built against: the renderer's layouts and constants.
 pub struct TerrainShape<'a> {
     /// The terrain's group 0.
@@ -227,6 +281,8 @@ pub struct NativeMaterial {
     pub solid: wgpu::RenderPipeline,
     pub translucent: wgpu::RenderPipeline,
     pub flat: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>,
+    /// `[displacement]`'s grid of the solid terrain near the camera (gfx/displace.rs).
+    pub displaced: Option<wgpu::RenderPipeline>,
     /// The stage calls `set_surface`: its solid pipelines also write the surface target.
     pub writes_surface: bool,
 }
@@ -290,9 +346,10 @@ fn shader_source(
     tags: &[(u32, u32)],
     materials: &[(u32, u32)],
     vertex: bool,
+    displaced: bool,
 ) -> String {
     format!(
-        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{}{}{ENTRIES}",
+        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{}{}{ENTRIES}{}{}",
         vanilla_terrain(),
         if vertex {
             DISPLACE_PACK
@@ -300,7 +357,13 @@ fn shader_source(
             DISPLACE_VANILLA
         },
         layer_table("horizon_sprite_tags", tags),
-        layer_table("horizon_sprite_material", materials)
+        layer_table("horizon_sprite_material", materials),
+        super::displace::RELIEF,
+        if displaced {
+            super::displace::GRID.to_owned() + DISPLACED_ENTRIES
+        } else {
+            String::new()
+        }
     )
 }
 
@@ -310,8 +373,9 @@ fn module(
     tags: &[(u32, u32)],
     materials: &[(u32, u32)],
     vertex: bool,
+    displaced: bool,
 ) -> Result<naga::Module, String> {
-    let text = shader_source(&stage.source, tags, materials, vertex);
+    let text = shader_source(&stage.source, tags, materials, vertex, displaced);
     naga::front::wgsl::parse_str(&text)
         .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))
 }
@@ -326,9 +390,16 @@ impl NativeMaterial {
         constants: &[(String, f64)],
         fog: bool,
         vertex: bool,
+        displaced: Option<&DisplacedShape<'_>>,
     ) -> Result<Self, String> {
         let writes_surface = horizon_shader_api::stages::calls_set_surface(&stage.source);
-        let module = module(stage, shape.sprite_tags, shape.sprite_materials, vertex)?;
+        let module = module(
+            stage,
+            shape.sprite_tags,
+            shape.sprite_materials,
+            vertex,
+            displaced.is_some(),
+        )?;
         let mut constants = present_constants(&module, constants);
         let sprite_names = [
             "horizon_terrain_SPRITE_ARRAYS",
@@ -336,6 +407,14 @@ impl NativeMaterial {
         ];
         constants.extend(sprite_names.into_iter().zip(shape.sprites));
         constants.push(("horizon_material_fog", f64::from(u8::from(fog))));
+        constants.push((
+            "horizon_displace_distance",
+            displaced.map_or(0.0, |d| f64::from(d.distance)),
+        ));
+        if let Some(d) = displaced {
+            constants.push(("horizon_displace_cells", f64::from(d.cells)));
+            constants.push(("horizon_displace_steps", f64::from(u8::from(d.steps))));
+        }
         let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
         let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some(&stage.label),
@@ -411,7 +490,7 @@ impl NativeMaterial {
                     module: &module,
                     entry_point: Some(fragment),
                     compilation_options: options,
-                    targets: if fragment == "horizon_material_fs_solid" && writes_surface {
+                    targets: if fragment != "horizon_material_fs_translucent" && writes_surface {
                         &solid_targets
                     } else {
                         &solid_targets[..1]
@@ -453,6 +532,16 @@ impl NativeMaterial {
                 ),
             )
         });
+        // The grid's corners come from its group 1, not from vertex buffers.
+        let displaced = displaced.map(|d| {
+            pipeline(
+                &layout(Some(d.layout)),
+                "horizon_material_vs_displaced",
+                &[],
+                "horizon_material_fs_displaced",
+                None,
+            )
+        });
         if let Some(e) = pollster::block_on(scope.pop()) {
             return Err(format!("{}: {e}", stage.file));
         }
@@ -460,6 +549,7 @@ impl NativeMaterial {
             solid,
             translucent,
             flat,
+            displaced,
             writes_surface,
         })
     }
@@ -515,7 +605,7 @@ mod tests {
         let tags = [(7, 1), (3, 1), (9, 2)];
         let materials = [(5, 1000)];
         assert!(layer_table("t", &tags).contains("case 3u, 7u: { return 1u; }"));
-        let module = module(&stage, &tags, &materials, false).unwrap();
+        let module = module(&stage, &tags, &materials, false, false).unwrap();
         let info = naga::valid::Validator::new(
             naga::valid::ValidationFlags::all(),
             naga::valid::Capabilities::all(),
@@ -524,7 +614,13 @@ mod tests {
         .unwrap_or_else(|e| {
             panic!(
                 "{}",
-                e.emit_to_string(&shader_source(&stage.source, &tags, &materials, false))
+                e.emit_to_string(&shader_source(
+                    &stage.source,
+                    &tags,
+                    &materials,
+                    false,
+                    false
+                ))
             )
         });
         let entries: Vec<&str> = module
@@ -546,4 +642,39 @@ mod tests {
             [("gain", 1.5)]
         );
     }
+
+    #[test]
+    fn the_displaced_grid_validates_with_a_pack() {
+        let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\
+            [material]\nfile = \"material.wgsl\"\n[displacement]\n";
+        let material = "fn material(input: MaterialInput) -> Surface {\n    \
+                return Surface(input.albedo * (1.0 - 0.5 * input.displaced));\n}\n\
+            fn displacement(input: DisplacementInput) -> f32 {\n    \
+                return (1.0 - input.height) * 0.125 * f32(input.material + 1u);\n}\n";
+        let files = [(MANIFEST, manifest), ("material.wgsl", material)]
+            .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec()))
+            .into();
+        let mut report = check(&Pack::from_files(files).unwrap()).unwrap();
+        let stage = report.stages.remove(0);
+        let materials = [(5, 1000)];
+        let module = module(&stage, &[], &materials, false, true).unwrap();
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::all(),
+        )
+        .validate(&module)
+        .unwrap_or_else(|e| {
+            let text = shader_source(&stage.source, &[], &materials, false, true);
+            panic!("{}", e.emit_to_string(&text))
+        });
+        for entry in [
+            "horizon_material_vs_displaced",
+            "horizon_material_fs_displaced",
+        ] {
+            assert!(
+                module.entry_points.iter().any(|e| e.name == entry),
+                "{entry}"
+            );
+        }
+    }
 }

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

@@ -3,9 +3,10 @@
 
 use horizon_shader_api::{Report, StageKind};
 
-use super::native_material::{NativeMaterial, TerrainShape};
+use super::displace::Displacement;
+use super::native_material::{DisplacedShape, NativeMaterial, TerrainShape};
 use super::native_post::{NativeFrame, NativePost};
-use super::native_shadow::NativeShadow;
+use super::native_shadow::{NativeShadow, ShadowGrid};
 use super::native_sky::NativeSky;
 use super::pack_timing::PassTiming;
 
@@ -21,6 +22,8 @@ pub struct NativePack {
     pub weather: Option<wgpu::RenderPipeline>,
     /// The draw of the shadow map the stages read, if the pack asks for one.
     pub shadow: Option<NativeShadow>,
+    /// `[displacement]`'s grid, while it is on and the resource packs have height maps.
+    pub displacement: Option<Displacement>,
     /// `[[particle_lights]]`.
     pub particle_lights: Vec<horizon_shader_api::manifest::ParticleLight>,
     /// `[[lights]]`, for the colour of held and dropped items' light.
@@ -29,6 +32,33 @@ pub struct NativePack {
     pub timing: Option<PassTiming>,
 }
 
+/// Whether the option `id` (a bool, or a number above 0) is on, or there is none to ask.
+fn option_on(constants: &[(String, f64)], id: Option<&String>) -> bool {
+    id.is_none_or(|id| {
+        constants
+            .iter()
+            .find(|(k, _)| k == id)
+            .is_none_or(|(_, v)| *v != 0.0)
+    })
+}
+
+/// `[displacement]`'s cells: the value of its `cells_option`, if any.
+fn chosen_cells(
+    d: &horizon_shader_api::manifest::Displacement,
+    options: &[horizon_shader_api::manifest::PackOption],
+    constants: &[(String, f64)],
+) -> u32 {
+    let chosen = d.cells_option.as_ref().and_then(|id| {
+        let option = options.iter().find(|o| o.id == *id)?;
+        let horizon_shader_api::manifest::OptionKind::Choice { values, .. } = &option.kind else {
+            return None;
+        };
+        let (_, index) = constants.iter().find(|(k, _)| k == id)?;
+        values.get(*index as usize)?.parse().ok()
+    });
+    chosen.unwrap_or(d.cells)
+}
+
 impl NativePack {
     /// The pack of the checked stages `report` with the option values `constants`, drawing
     /// onto the world's targets as `terrain` describes; the sky reads the terrain's group 0.
@@ -49,11 +79,48 @@ impl NativePack {
             .as_ref()
             .map(|settings| super::native_shadow::fitted(device, settings));
         let mut frame = NativeFrame::new(device, settings.as_ref(), textures, lights, terrain.pbr);
+        // `[displacement]`, unless its option is off; nothing to displace without heights.
+        let displacement = report
+            .manifest
+            .displacement
+            .as_ref()
+            .filter(|d| option_on(constants, d.option.as_ref()))
+            .filter(|_| terrain.pbr.is_some())
+            .map(|d| {
+                // No more cells than the height maps have texels.
+                let texels = terrain.pbr.map_or(16, |p| p[0].width());
+                let cells = chosen_cells(d, &report.manifest.options, constants)
+                    .min(texels)
+                    .max(1);
+                let steps =
+                    d.steps_option.is_some() && option_on(constants, d.steps_option.as_ref());
+                Displacement::new(
+                    device,
+                    d.distance,
+                    cells,
+                    steps,
+                    &frame.pbr[0],
+                    report.shadow.is_some(),
+                )
+            });
         let shadow = report
             .shadow
             .as_ref()
             .map(|s| {
                 let vertex = report.stages.iter().find(|s| s.kind == StageKind::Vertex);
+                // `[displacement]`'s grid casts too, from the material's module.
+                let material = report.stages.iter().find(|s| s.kind == StageKind::Material);
+                let grid = displacement.as_ref().and_then(|d| {
+                    let picks = d.shadow.as_ref()?;
+                    Some(ShadowGrid {
+                        distance: d.distance,
+                        cells: picks.cells,
+                        steps: picks.steps,
+                        material: material?,
+                        layout: &d.draw_layout,
+                        normals: &frame.pbr[0],
+                    })
+                });
                 NativeShadow::new(
                     device,
                     terrain,
@@ -61,6 +128,7 @@ impl NativePack {
                     &s.solid_materials,
                     vertex,
                     constants,
+                    grid,
                 )
             })
             .transpose()?;
@@ -71,12 +139,7 @@ impl NativePack {
             .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)
-            });
+            && option_on(constants, option);
         let fog = report.material_fog;
         let keeps = |key: fn(&horizon_shader_api::Stage) -> Option<bool>| {
             report.sky.as_ref().and_then(key).unwrap_or(true)
@@ -119,7 +182,22 @@ impl NativePack {
             .iter()
             .find(|s| s.kind == StageKind::Material)
             .map(|stage| {
-                NativeMaterial::new(device, terrain, &frame, stage, constants, fog, has_vertex)
+                let displaced = displacement.as_ref().map(|d| DisplacedShape {
+                    distance: d.distance,
+                    cells: d.view.cells,
+                    steps: d.view.steps,
+                    layout: &d.draw_layout,
+                });
+                NativeMaterial::new(
+                    device,
+                    terrain,
+                    &frame,
+                    stage,
+                    constants,
+                    fog,
+                    has_vertex,
+                    displaced.as_ref(),
+                )
             })
             .transpose()?;
         let post = (!post.is_empty())
@@ -148,6 +226,7 @@ impl NativePack {
             vanilla_stars,
             weather,
             shadow,
+            displacement,
             timing: None,
         };
         Ok((pack, labels))

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

@@ -122,7 +122,7 @@ pub struct NativeFrame {
     pub opaque_color: wgpu::Texture,
     /// The resource packs' LabPBR maps (bindings 12 and 13: normals, specular), a blank 1x1
     /// without them.
-    pbr: [wgpu::TextureView; 2],
+    pub(super) pbr: [wgpu::TextureView; 2],
     /// The material stage's `reflection` (binding 1): this frame's water mirror, else
     /// `blank`; and its sampler (binding 2).
     reflection: wgpu::TextureView,
@@ -623,7 +623,8 @@ fn texture_entry(binding: u32, sample_type: wgpu::TextureSampleType) -> wgpu::Bi
 fn pbr_entry(binding: u32) -> wgpu::BindGroupLayoutEntry {
     wgpu::BindGroupLayoutEntry {
         binding,
-        visibility: wgpu::ShaderStages::FRAGMENT,
+        // `[displacement]`'s grid moves its corners by the heights (gfx/displace.rs).
+        visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
         ty: wgpu::BindingType::Texture {
             sample_type: wgpu::TextureSampleType::Float { filterable: true },
             view_dimension: wgpu::TextureViewDimension::D2Array,

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

@@ -23,6 +23,9 @@ struct HorizonShadowOut {
     @location(1) @interpolate(flat) layer: u32,
     @location(2) tint: vec3<f32>,
     @location(3) @interpolate(flat) fluid: u32,
+    // The point on the flat face, camera-relative (`[displacement]`'s grid takes it over near
+    // the camera).
+    @location(4) base: vec3<f32>,
 }
 // `color` is the vertex colour: the tint, and the fluid flag in its alpha's high nibble
 // (mesher.rs's `fluid_face`).
@@ -37,6 +40,7 @@ fn horizon_shadow_vertex(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<
     out.tint = color.rgb;
     let high = u32(round(color.a * 255.0)) >> 4u;
     out.fluid = u32(high >= 8u && (high & 7u) < 6u);
+    out.base = pos;
     return out;
 }
 @vertex fn horizon_shadow_vs(
@@ -58,6 +62,10 @@ fn horizon_shadow_vertex(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<
     return horizon_shadow_vertex(pos, atlas, layer, color);
 }
 @fragment fn horizon_shadow_fs(in: HorizonShadowOut) {
+    if horizon_shadow_taken(in.base, in.layer) { discard; }
+    horizon_shadow_cutout(in);
+}
+fn horizon_shadow_cutout(in: HorizonShadowOut) {
     // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout.
     let alpha = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu).a;
     if alpha < 0.5 && (in.layer & 0x8000u) == 0u && !horizon_shadow_solid(in.layer & 0x7fffu) { discard; }
@@ -105,6 +113,45 @@ struct HorizonEntityShadowOut {
 }
 ";
 
+/// No `[displacement]` grid: the flat terrain casts everywhere.
+const UNTAKEN: &str = "
+fn horizon_shadow_taken(base: vec3<f32>, layer: u32) -> bool {
+    return false;
+}
+";
+
+/// `[displacement]`'s grid in the shadow map (gfx/displace.rs), cast in the flat quads' place.
+/// The height maps join the pass's frame group.
+const GRID_ENTRIES: &str = "
+@group(3) @binding(12) var horizon_pbr_normals: texture_2d_array<f32>;
+fn horizon_shadow_taken(base: vec3<f32>, layer: u32) -> bool {
+    return length(base) < horizon_displace_distance - 0.05 && horizon_displaced_layer(layer);
+}
+@vertex fn horizon_shadow_vs_displaced(@builtin(vertex_index) v: u32,
+    @builtin(instance_index) instance: u32) -> HorizonShadowOut {
+    let p = horizon_displace_point(v, instance);
+    var out = horizon_shadow_vertex(p.position, p.uv, p.layer, p.color);
+    out.base = p.base;
+    return out;
+}
+@fragment fn horizon_shadow_fs_displaced(in: HorizonShadowOut) {
+    if length(in.base) >= horizon_displace_distance + 0.05 { discard; }
+    horizon_shadow_cutout(in);
+}
+";
+
+/// What the shadow pass's grid is built from: `[displacement]`'s values, the material stage
+/// (whose module holds `displacement` and the vertex stage), group 1's layout and the height
+/// maps.
+pub struct ShadowGrid<'a> {
+    pub distance: f32,
+    pub cells: u32,
+    pub steps: bool,
+    pub material: &'a horizon_shader_api::check::CheckedStage,
+    pub layout: &'a wgpu::BindGroupLayout,
+    pub normals: &'a wgpu::TextureView,
+}
+
 /// `shadow_color`'s format.
 const SHADOW_COLOR: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
 
@@ -326,6 +373,8 @@ pub struct NativeShadow {
     /// The entities' draw, with the entities' group 0 (`ENTITY_ENTRIES`).
     pub entity: wgpu::RenderPipeline,
     pub group: wgpu::BindGroup,
+    /// `[displacement]`'s grid (gfx/displace.rs's shadow list).
+    pub displaced: Option<wgpu::RenderPipeline>,
 }
 
 /// The entity draw's shader.
@@ -418,17 +467,36 @@ fn shadow_solid(materials: &[(u32, u32)], solid: &[u32]) -> String {
 }
 
 /// The shadow pass's shader: the frame, Horizon's terrain, and the entries, with the layers
-/// `solid` of `shadow_solid`.
-fn shader_source(solid: &str, vertex: Option<&str>, materials: &[(u32, u32)]) -> String {
-    let (head, displace) = match vertex {
-        Some(stage) => (
-            stage.to_owned()
-                + &super::native_material::layer_table("horizon_sprite_material", materials),
+/// `solid` of `shadow_solid`. Under `[displacement]` (`grid`: the material stage's source, which
+/// holds the vertex stage and `displacement`), its grid too.
+fn shader_source(
+    solid: &str,
+    vertex: Option<&str>,
+    materials: &[(u32, u32)],
+    grid: Option<&str>,
+) -> String {
+    let table = super::native_material::layer_table("horizon_sprite_material", materials);
+    let (head, displace) = match (grid, vertex) {
+        (Some(material), _) => (
+            format!(
+                "{material}{}{table}{}{}{GRID_ENTRIES}",
+                horizon_shader_api::stages::PBR_STUB,
+                super::displace::RELIEF,
+                super::displace::GRID,
+            ),
+            if vertex.is_some() {
+                super::native_material::DISPLACE_PACK
+            } else {
+                super::native_material::DISPLACE_VANILLA
+            },
+        ),
+        (None, Some(stage)) => (
+            format!("{stage}{table}{UNTAKEN}"),
             super::native_material::DISPLACE_PACK,
         ),
-        None => (
+        (None, None) => (
             format!(
-                "{}@group({GROUP}) @binding(0) var<uniform> frame: Frame;\n{}",
+                "{}@group({GROUP}) @binding(0) var<uniform> frame: Frame;\n{}{UNTAKEN}",
                 FrameInputs::WGSL.wgsl(),
                 horizon_shader_api::stages::SHADOW_HELPERS,
             ),
@@ -452,11 +520,13 @@ impl NativeShadow {
         solid_materials: &[u32],
         vertex: Option<&horizon_shader_api::check::CheckedStage>,
         constants: &[(String, f64)],
+        grid: Option<ShadowGrid<'_>>,
     ) -> Result<Self, String> {
         let text = shader_source(
             &shadow_solid(shape.sprite_materials, solid_materials),
             vertex.map(|s| s.source.as_str()),
             shape.sprite_materials,
+            grid.as_ref().map(|g| g.material.source.as_str()),
         );
         let module = naga::front::wgsl::parse_str(&text)
             .map_err(|e| format!("shadow pass: {}", e.emit_to_string(&text)))?;
@@ -465,31 +535,59 @@ impl NativeShadow {
             ("horizon_terrain_SPRITE_ARRAYS", shape.sprites[0]),
             ("horizon_terrain_SPRITE_SPLIT", shape.sprites[1]),
         ]);
+        if let Some(g) = &grid {
+            constants.extend([
+                ("horizon_displace_distance", f64::from(g.distance)),
+                ("horizon_displace_cells", f64::from(g.cells)),
+                ("horizon_displace_steps", f64::from(u8::from(g.steps))),
+            ]);
+        }
         let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
         let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some("Native shader pack shadow"),
             source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)),
         });
+        // The frame alone, and under `[displacement]` the height maps its grid moves by.
+        let frame_entry = wgpu::BindGroupLayoutEntry {
+            binding: 0,
+            visibility: wgpu::ShaderStages::VERTEX,
+            ty: wgpu::BindingType::Buffer {
+                ty: wgpu::BufferBindingType::Uniform,
+                has_dynamic_offset: false,
+                min_binding_size: wgpu::BufferSize::new(size_of::<FrameInputs>() as u64),
+            },
+            count: None,
+        };
+        let normals_entry = wgpu::BindGroupLayoutEntry {
+            binding: 12,
+            visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+            ty: wgpu::BindingType::Texture {
+                sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                view_dimension: wgpu::TextureViewDimension::D2Array,
+                multisampled: false,
+            },
+            count: None,
+        };
+        let layout_entries: Vec<_> = std::iter::once(frame_entry)
+            .chain(grid.is_some().then_some(normals_entry))
+            .collect();
         let frame_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
             label: Some("Native shader pack shadow frame"),
-            entries: &[wgpu::BindGroupLayoutEntry {
-                binding: 0,
-                visibility: wgpu::ShaderStages::VERTEX,
-                ty: wgpu::BindingType::Buffer {
-                    ty: wgpu::BufferBindingType::Uniform,
-                    has_dynamic_offset: false,
-                    min_binding_size: wgpu::BufferSize::new(size_of::<FrameInputs>() as u64),
-                },
-                count: None,
-            }],
+            entries: &layout_entries,
         });
+        let group_entries: Vec<_> = std::iter::once(wgpu::BindGroupEntry {
+            binding: 0,
+            resource: frame.buffer.as_entire_binding(),
+        })
+        .chain(grid.as_ref().map(|g| wgpu::BindGroupEntry {
+            binding: 12,
+            resource: wgpu::BindingResource::TextureView(g.normals),
+        }))
+        .collect();
         let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
             label: Some("Native shader pack shadow frame"),
             layout: &frame_layout,
-            entries: &[wgpu::BindGroupEntry {
-                binding: 0,
-                resource: frame.buffer.as_entire_binding(),
-            }],
+            entries: &group_entries,
         });
         let layout = |flat: Option<&wgpu::BindGroupLayout>| {
             let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] =
@@ -519,10 +617,11 @@ impl NativeShadow {
             blend: None,
             write_mask: wgpu::ColorWrites::ALL,
         })];
-        let pipeline = |layout: &wgpu::PipelineLayout,
-                        vertex: &str,
-                        buffers: &[Option<wgpu::VertexBufferLayout<'_>>],
-                        translucent: bool| {
+        let pipeline_with = |layout: &wgpu::PipelineLayout,
+                             vertex: &str,
+                             buffers: &[Option<wgpu::VertexBufferLayout<'_>>],
+                             fragment: &str| {
+            let translucent = fragment == "horizon_shadow_fs_translucent";
             let options = wgpu::PipelineCompilationOptions {
                 constants: &constants,
                 ..Default::default()
@@ -556,11 +655,7 @@ impl NativeShadow {
                 multisample: Default::default(),
                 fragment: Some(wgpu::FragmentState {
                     module: &module,
-                    entry_point: Some(if translucent {
-                        "horizon_shadow_fs_translucent"
-                    } else {
-                        "horizon_shadow_fs"
-                    }),
+                    entry_point: Some(fragment),
                     compilation_options: options,
                     targets: if translucent { &color_target } else { &[] },
                 }),
@@ -568,6 +663,17 @@ impl NativeShadow {
                 cache: None,
             })
         };
+        let pipeline = |layout: &wgpu::PipelineLayout,
+                        vertex: &str,
+                        buffers: &[Option<wgpu::VertexBufferLayout<'_>>],
+                        translucent: bool| {
+            let fragment = if translucent {
+                "horizon_shadow_fs_translucent"
+            } else {
+                "horizon_shadow_fs"
+            };
+            pipeline_with(layout, vertex, buffers, fragment)
+        };
         let instanced = layout(None);
         let solid = pipeline(
             &instanced,
@@ -595,6 +701,15 @@ impl NativeShadow {
         let flat = flat_pipeline(false);
         let flat_translucent = flat_pipeline(true);
         let entity = entity_pipeline(device, shape.entities, &frame_layout);
+        // The grid's corners come from its group 1, not from vertex buffers.
+        let displaced = grid.as_ref().map(|g| {
+            pipeline_with(
+                &layout(Some(g.layout)),
+                "horizon_shadow_vs_displaced",
+                &[],
+                "horizon_shadow_fs_displaced",
+            )
+        });
         if let Some(e) = pollster::block_on(scope.pop()) {
             return Err(format!("shadow pass: {e}"));
         }
@@ -605,6 +720,7 @@ impl NativeShadow {
             flat_translucent,
             entity,
             group,
+            displaced,
         })
     }
 }
@@ -616,7 +732,7 @@ mod tests {
     #[test]
     fn the_shadow_shader_validates() {
         for materials in [&[][..], &[(3, 7), (4, 8), (9, 7)][..]] {
-            let text = shader_source(&shadow_solid(materials, &[7]), None, materials);
+            let text = shader_source(&shadow_solid(materials, &[7]), None, materials, None);
             let module = naga::front::wgsl::parse_str(&text).unwrap();
             naga::valid::Validator::new(
                 naga::valid::ValidationFlags::all(),
@@ -627,6 +743,47 @@ mod tests {
         }
     }
 
+    #[test]
+    fn the_shadow_shader_with_the_displaced_grid_validates() {
+        use horizon_shader_api::{MANIFEST, Pack, StageKind, check};
+        let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\
+            [material]\nfile = \"material.wgsl\"\n[shadow]\n[displacement]\n";
+        let material = "fn material(input: MaterialInput) -> Surface {\n    \
+                return Surface(input.albedo);\n}\n\
+            fn displacement(input: DisplacementInput) -> f32 {\n    \
+                return (1.0 - input.height) * 0.125;\n}\n";
+        let files = [(MANIFEST, manifest), ("material.wgsl", material)]
+            .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec()))
+            .into();
+        let report = check(&Pack::from_files(files).unwrap()).unwrap();
+        let stage = report
+            .stages
+            .iter()
+            .find(|s| s.kind == StageKind::Material)
+            .unwrap();
+        let materials = [(3, 7)];
+        let text = shader_source(
+            &shadow_solid(&materials, &[7]),
+            None,
+            &materials,
+            Some(&stage.source),
+        );
+        let module = naga::front::wgsl::parse_str(&text)
+            .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::all(),
+        )
+        .validate(&module)
+        .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
+        for entry in ["horizon_shadow_vs_displaced", "horizon_shadow_fs_displaced"] {
+            assert!(
+                module.entry_points.iter().any(|e| e.name == entry),
+                "{entry}"
+            );
+        }
+    }
+
     #[test]
     fn only_the_layers_of_solid_ids_lose_their_cutouts() {
         let materials = [(3, 7), (4, 8), (9, 7)];

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

@@ -12,6 +12,10 @@
 //! for the next one. A section meshed in between propagates into the graph the
 //! frame has (vanilla's partial update), so what it opens shows at once; what
 //! it closes goes at the next full search.
+//!
+//! GPU culling (gfx/gpu_culling.rs) answers as `contains` does from a copy of
+//! the graph (`Reach`): the cells it reached, kept as bits too, sent again
+//! whenever the generation moves, which it does whenever an answer may change.
 use super::SectionKey;
 use crate::fast_hash::FxHashSet;
 use crate::mesher::ALL_VISIBLE;
@@ -129,6 +133,10 @@ struct Graph {
     /// (`Node.sourceDirections`, as the faces rather than the steps); none for
     /// the camera's.
     entered: Vec<u8>,
+    /// `REACHED` of each cell again, a bit each at `index` (32 a word, lowest
+    /// bit first): the GPU's copy (`Occlusion::reach`), written with it
+    /// (`set_reached`).
+    bits: Vec<u32>,
     /// Whether any section in the searched top layer was reached. Sections
     /// above a clamped box use this conservative sky-band answer.
     sky_reached: bool,
@@ -177,6 +185,13 @@ impl Graph {
             false
         }
     }
+    /// Cell `i` is reached, having travelled `directions` (`REACHED` among
+    /// them): the one writer of `REACHED`, so `bits` say what `directions` do.
+    fn set_reached(&mut self, i: usize, directions: u8) {
+        debug_assert!(directions & REACHED != 0);
+        self.directions[i] = directions;
+        self.bits[i / 32] |= 1 << (i % 32);
+    }
     /// The full search from the camera (vanilla's `scheduleFullUpdate`).
     fn search(
         &mut self,
@@ -220,6 +235,8 @@ impl Graph {
         let size = side * side * self.height as usize;
         self.directions.clear();
         self.directions.resize(size, 0);
+        self.bits.clear();
+        self.bits.resize(size.div_ceil(32), 0);
         self.entered.clear();
         self.entered.resize(size, 0);
         self.sky_reached = false;
@@ -243,7 +260,7 @@ impl Graph {
         queue.clear();
         if (0..columns.sections).contains(&from.1) {
             let start = self.index(from).expect("camera inside the searched box");
-            self.directions[start] = REACHED;
+            self.set_reached(start, REACHED);
             queue.push_back(start as u32);
         } else {
             self.seed_outside(camera, queue);
@@ -294,7 +311,7 @@ impl Graph {
             let i = self
                 .index((self.from.0 + dx, y, self.from.2 + dz))
                 .expect("seed inside the searched box");
-            self.directions[i] = directions;
+            self.set_reached(i, directions);
             // Entered through the face opposite the travel (`sourceDirection`).
             self.entered[i] = 1 << (travel ^ 1);
             queue.push_back(i as u32);
@@ -304,14 +321,15 @@ impl Graph {
     /// every face their entry faces connect to, away from the camera. A step
     /// into a section already reached adds the face it enters through.
     /// `full`: the search from `camera` (`rays` holds its lines), not a
-    /// partial update.
+    /// partial update. Whether it reached a cell it had not.
     fn propagate(
         &mut self,
         queue: &mut VecDeque<u32>,
         camera: DVec3,
         full: bool,
         vis: impl Fn(usize, SectionKey) -> u64,
-    ) {
+    ) -> bool {
+        let mut grew = false;
         let eye = (
             (camera.x.floor() as i32) >> 4,
             (camera.y.floor() as i32 - self.min_y) >> 4,
@@ -365,14 +383,16 @@ impl Graph {
                     }
                 }
                 if self.directions[n] & REACHED == 0 {
-                    self.directions[n] = directions | 1 << d;
+                    self.set_reached(n, directions | 1 << d);
                     self.entered[n] = 1 << (d ^ 1);
                     queue.push_back(n as u32);
+                    grew = true;
                 } else {
                     self.entered[n] |= 1 << (d ^ 1);
                 }
             }
         }
+        grew
     }
     /// Vanilla's distant step test: from the corner of `key` that the step `d`
     /// picks, walk towards the camera in section diagonals while farther than
@@ -472,6 +492,42 @@ impl Graph {
     }
 }
 
+/// The graph `Occlusion::contains` reads, for GPU culling's copy
+/// (gfx/gpu_culling.rs): its searched box (`Graph::index`), the level's height
+/// in sections, whether the search reached the box's top layer (the sky band
+/// above a clamped box), and its cells' `REACHED` as bits.
+#[derive(Clone, Copy)]
+pub struct Reach<'a> {
+    /// `Occlusion::generation` when it was taken.
+    pub generation: u64,
+    pub from_x: i32,
+    pub from_z: i32,
+    pub radius: i32,
+    pub y0: i32,
+    pub height: i32,
+    pub sections: i32,
+    pub sky_reached: bool,
+    pub bits: &'a [u32],
+}
+
+#[cfg(test)]
+impl Reach<'_> {
+    /// gpu_culling.wgsl's `reached`, statement for statement: what
+    /// `Graph::contains` answers.
+    pub fn contains(&self, key: SectionKey) -> bool {
+        let r = self.radius;
+        let (dx, dz, dy) = (key.0 - self.from_x, key.2 - self.from_z, key.1 - self.y0);
+        if dx < -r || dx > r || dz < -r || dz > r || dy < 0 {
+            return false;
+        }
+        if dy >= self.height {
+            return self.sky_reached && (0..=self.sections).contains(&key.1);
+        }
+        let i = (((dz + r) * (2 * r + 1) + dx + r) * self.height + dy) as usize;
+        (self.bits[i / 32] >> (i % 32)) & 1 != 0
+    }
+}
+
 /// `Mth.floor` for coordinates inside the world, without a libm call (the
 /// x86-64 baseline has no rounding instruction).
 fn floor(x: f64) -> i32 {
@@ -518,6 +574,14 @@ impl Worker {
     }
 }
 
+/// A new value for `Occlusion::generation`, unique in the process: a copy made
+/// from an older `Occlusion` (another level's) never matches. As gfx.rs
+/// `next_block_entity_revision`.
+fn next_generation() -> u64 {
+    static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
+    NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+}
+
 pub struct Occlusion {
     /// The render thread's copy, for partial updates (and searches when the
     /// worker is gone).
@@ -545,6 +609,8 @@ pub struct Occlusion {
     changed_late: Vec<SectionKey>,
     vis: Vec<u64>,
     queue: VecDeque<u32>,
+    /// Changes whenever `contains` may answer differently (`generation`).
+    generation: u64,
 }
 
 impl Occlusion {
@@ -564,6 +630,7 @@ impl Occlusion {
             changed_late: Vec::new(),
             vis: Vec::new(),
             queue: VecDeque::new(),
+            generation: next_generation(),
         }
     }
     pub fn set(&mut self, key: SectionKey, vis: u64) {
@@ -608,9 +675,11 @@ impl Occlusion {
         self.edits.clear();
         self.edits.push(Edit::Clear);
         self.dirty = true;
-        // Another world: the old graph says nothing about it.
+        // Another world: the old graph says nothing about it. Without one, every
+        // section was visible already, and stays so.
         if let Some(graph) = self.graph.take() {
             self.spare = graph;
+            self.generation = next_generation();
         }
         self.searched = None;
         self.discard = self.running.is_some();
@@ -623,6 +692,38 @@ impl Occlusion {
     pub fn contains(&self, key: SectionKey) -> bool {
         self.graph.as_ref().is_none_or(|g| g.contains(key))
     }
+    /// Changes whenever `contains` may answer differently: a search landed, a
+    /// partial update reached more sections, or the graph went.
+    #[cfg(any(test, debug_assertions))]
+    pub fn generation(&self) -> u64 {
+        self.generation
+    }
+    /// The graph `contains` reads; `None` while every section counts as
+    /// visible.
+    pub fn reach(&self) -> Option<Reach<'_>> {
+        self.graph.as_ref().map(|g| Reach {
+            generation: self.generation,
+            from_x: g.from.0,
+            from_z: g.from.2,
+            radius: g.radius,
+            y0: g.y0,
+            height: g.height,
+            sections: g.sections,
+            sky_reached: g.sky_reached,
+            bits: &g.bits,
+        })
+    }
+    /// The bits `reach` exports are the cells' `REACHED`, cell for cell.
+    #[cfg(any(test, debug_assertions))]
+    pub fn reach_is_exact(&self) -> bool {
+        self.graph.as_ref().is_none_or(|g| {
+            g.bits.len() == g.directions.len().div_ceil(32)
+                && g.directions
+                    .iter()
+                    .enumerate()
+                    .all(|(i, &d)| (d & REACHED != 0) == ((g.bits[i / 32] >> (i % 32)) & 1 != 0))
+        })
+    }
     /// Take a finished search, propagate changed sections into the graph,
     /// and start a search when sections changed or the camera moved to
     /// another section. Never waits for the worker.
@@ -642,6 +743,7 @@ impl Occlusion {
             && let Some(graph) = self.graph.take()
         {
             self.spare = graph;
+            self.generation = next_generation();
         }
     }
     fn start(&mut self, camera: DVec3, radius: i32) {
@@ -713,6 +815,7 @@ impl Occlusion {
         if let Some(old) = self.graph.replace(graph) {
             self.spare = old;
         }
+        self.generation = next_generation();
     }
     /// Vanilla's `runPartialUpdate`: what changed sections now connect to.
     fn propagate_changes(&mut self, camera: DVec3) {
@@ -729,7 +832,9 @@ impl Occlusion {
             }
         }
         let columns = &self.columns;
-        graph.propagate(&mut self.queue, camera, false, |_, key| columns.get(key));
+        if graph.propagate(&mut self.queue, camera, false, |_, key| columns.get(key)) {
+            self.generation = next_generation();
+        }
     }
     /// Wait for the running search: tests, and A/B timing of the old
     /// blocking search.
@@ -1405,4 +1510,197 @@ mod tests {
             "enclosed cave does not see the sky"
         );
     }
+
+    /// `contains` over the columns `radius` + 3 around `from`, from two
+    /// sections below the level to two above it, checked against the graph
+    /// `reach` exports: `None` exactly without a graph, the same answer for
+    /// every key, nothing past its box, its bits its cells' `REACHED`, and its
+    /// sky band reached exactly when a bit of its top layer is.
+    fn answers(o: &Occlusion, from: SectionKey, radius: i32) -> Vec<bool> {
+        let reach = o.reach();
+        assert_eq!(reach.is_some(), o.graph.is_some(), "a graph exported");
+        assert!(o.reach_is_exact(), "the bits are the cells'");
+        if let Some(g) = &o.graph {
+            let height = g.height as usize;
+            let mut top = (height - 1..g.directions.len()).step_by(height);
+            let sky = top.any(|i| (g.bits[i / 32] >> (i % 32)) & 1 != 0);
+            assert_eq!(g.sky_reached, sky, "the sky band");
+        }
+        let past = |key: SectionKey| {
+            o.graph.as_ref().is_some_and(|g| {
+                (key.0 - g.from.0).abs() > g.radius
+                    || (key.2 - g.from.2).abs() > g.radius
+                    || !(g.y0..=g.sections).contains(&key.1)
+            })
+        };
+        let mut answers = Vec::new();
+        for x in from.0 - radius - 3..=from.0 + radius + 3 {
+            for z in from.2 - radius - 3..=from.2 + radius + 3 {
+                for y in -2..=o.columns.sections + 1 {
+                    let key = (x, y, z);
+                    let contains = o.contains(key);
+                    assert_eq!(reach.is_none_or(|r| r.contains(key)), contains, "{key:?}");
+                    assert!(!(contains && past(key)), "{key:?} past the box");
+                    answers.push(contains);
+                }
+            }
+        }
+        answers
+    }
+
+    /// The graph `reach` exports answers as `contains` (`answers`): walled in,
+    /// opened by a partial update, cleared; over clamped boxes, the sky band
+    /// above them reached or not (a closed cave); from above the world. The
+    /// search, the partial update and `clear` each change the generation, and
+    /// another level's graph never repeats one.
+    #[test]
+    fn the_exported_graph_answers_as_contains() {
+        let mut o = Occlusion::new(0, 4);
+        let first = o.generation();
+        answers(&o, (0, 1, 0), 3);
+        for (dx, dy, dz) in STEPS {
+            o.set((dx, 1 + dy, dz), 0);
+        }
+        o.settle(at((0, 1, 0)), 3);
+        assert_ne!(o.generation(), first, "a search landed");
+        let walled = answers(&o, (0, 1, 0), 3);
+        let searched = o.generation();
+        o.set((0, 1, 1), ALL_VISIBLE);
+        o.update(at((0, 1, 0)), 3);
+        assert_ne!(o.generation(), searched, "a partial update reached more");
+        assert_ne!(answers(&o, (0, 1, 0), 3), walled);
+        let opened = o.generation();
+        o.clear();
+        assert_ne!(o.generation(), opened, "the graph went");
+        answers(&o, (0, 1, 0), 3);
+        // Another level's graph never takes one of this one's generations, or
+        // the pass would keep its copy of this one.
+        let mut other = Occlusion::new(0, 4);
+        other.settle(at((0, 1, 0)), 3);
+        assert_ne!(other.generation(), searched, "another level's graph");
+
+        let (mut clamped, mut band) = (0, [0; 2]);
+        let mut check = |mut o: Occlusion, camera: DVec3, radius: i32| {
+            o.settle(camera, radius);
+            answers(&o, o.columns.section_of(camera), radius);
+            let g = o.graph.as_ref().expect("searched");
+            if g.height < o.columns.sections + 2 {
+                clamped += 1;
+                // The first section above the box, over the camera's column.
+                band[usize::from(o.contains((g.from.0, g.y0 + g.height, g.from.2)))] += 1;
+            }
+        };
+        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);
+                check(o, at((0, 2, 0)) + DVec3::new(3.3, -5.7, 1.9), radius);
+            }
+        }
+        let mut cave = Occlusion::new(0, 24);
+        for (dx, dy, dz) in STEPS {
+            cave.set((dx, 1 + dy, dz), 0);
+        }
+        check(cave, at((0, 1, 0)), 4);
+        let mut above = Occlusion::new(0, 24);
+        random_world(&mut above, 7, 900, 6);
+        check(above, DVec3::new(3.3, 400.0, -5.6), 6);
+        assert!(
+            clamped > 0 && band[0] > 0 && band[1] > 0,
+            "{clamped} clamped, the band above hidden and seen {band:?}"
+        );
+    }
+
+    /// Whenever an answer of `contains` changes, so does the generation: over
+    /// 300 random steps, each a section set (open, closed or anything between),
+    /// a column removed, the camera moved to another section (now and then
+    /// above or below the world), or now and then another world, after a
+    /// `clear` or a teleport that drops every column (`remove_columns`), each
+    /// followed by a frame's `update` or a settled search; then an update from
+    /// a section the graph never reached. The exported graph answers as
+    /// `contains` after every step.
+    #[test]
+    fn every_change_of_the_answers_changes_the_generation() {
+        let mut seed = 0x0bad_5eed_u64;
+        let mut next = || {
+            seed ^= seed << 13;
+            seed ^= seed >> 7;
+            seed ^= seed << 17;
+            seed
+        };
+        let (spread, radius, around) = (5, 3, (0, 0, 0));
+        let offset = DVec3::new(3.3, -5.7, 1.9);
+        let mut o = Occlusion::new(0, 24);
+        random_world(&mut o, 0x2545_f491, 400, spread);
+        let mut camera = at((0, 2, 0)) + offset;
+        o.settle(camera, radius);
+        let mut last = (o.generation(), answers(&o, around, spread + radius));
+        let mut changed = 0;
+        for step in 0..300 {
+            let r = next();
+            let key = (
+                (r % 11) as i32 - spread,
+                ((r >> 8) % 7) as i32,
+                ((r >> 16) % 11) as i32 - spread,
+            );
+            match r >> 24 & 15 {
+                0..=7 => {
+                    let vis = match r >> 28 & 3 {
+                        0 => ALL_VISIBLE,
+                        1 => 0,
+                        _ => next() & ALL_VISIBLE,
+                    };
+                    o.set(key, vis);
+                }
+                8 | 9 => o.remove_column(key.0, key.2),
+                10..=13 => {
+                    let y = match r >> 32 & 7 {
+                        0 => 30,
+                        1 => -3,
+                        _ => key.1,
+                    };
+                    camera = at((key.0, y, key.2)) + offset;
+                }
+                _ if r >> 36 & 7 == 0 => {
+                    o.clear();
+                    random_world(&mut o, next(), 400, spread);
+                }
+                _ if r >> 36 & 7 == 1 => {
+                    // A teleport: every column goes at once.
+                    let all: FxHashSet<_> = o.columns.map.keys().copied().collect();
+                    o.remove_columns(&all);
+                    random_world(&mut o, next(), 400, spread);
+                }
+                _ => {}
+            }
+            if r >> 40 & 1 == 0 {
+                o.update(camera, radius);
+            } else {
+                o.settle(camera, radius);
+            }
+            let now = (o.generation(), answers(&o, around, spread + radius));
+            if now.1 != last.1 {
+                assert_ne!(
+                    now.0, last.0,
+                    "step {step}: answers changed, the generation not"
+                );
+                changed += 1;
+            }
+            last = now;
+        }
+        assert!(changed >= 50, "{changed} steps changed answers");
+        // Walled in, then past the wall: the graph never reached the camera's
+        // section, and goes until the next search lands. (The first settle may
+        // land a search that started before the wall.)
+        for (dx, dy, dz) in STEPS {
+            o.set((dx, 1 + dy, dz), 0);
+        }
+        o.settle(at((0, 1, 0)), radius);
+        o.settle(at((0, 1, 0)), radius);
+        let walled = (o.generation(), answers(&o, around, spread + radius));
+        assert!(!o.contains((3, 1, 0)), "past the wall");
+        o.update(at((3, 1, 0)), radius);
+        assert_ne!(answers(&o, around, spread + radius), walled.1);
+        assert_ne!(o.generation(), walled.0, "the graph went");
+    }
 }

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

@@ -194,6 +194,8 @@ pub(super) struct Draw {
     /// The pack's shadow program draws it into the shadow map too.
     pub shadow: bool,
     pub slot: u32,
+    /// End portal or gateway faces: drawn with `end_portal.png` bound as the atlas.
+    pub portal: bool,
 }
 
 /// Which entity runs a pack's shadow pass draws (2.4, 3.2).
@@ -375,38 +377,87 @@ impl PackEntities {
                     pack,
                     casts,
                     overlay,
+                    false,
                 );
             }
         }
         let first = spans.first().map_or(entities.len(), |s| s.start as usize);
-        rest.extend_from_slice(&entities[..first.min(entities.len())]);
+        extend_without_portals(rest, &entities[..first.min(entities.len())]);
+        let (mut other, mut portal_faces, mut beam_faces) = (Vec::new(), Vec::new(), Vec::new());
         for (span, range) in runs(entities.len(), spans) {
-            let run = &entities[range];
-            let program = program_of(&span).filter(|&p| {
-                plain(run) || (p == DESTROY && run.iter().all(|v| matches!(v.layer, 11 | 12)))
-            });
-            let pack = program.is_some_and(|p| drawn[p]) && !span.hidden;
-            let casts = program.is_some_and(|p| shadow.cast(&span, p));
-            if !pack && !span.hidden {
-                rest.extend_from_slice(run);
-            }
-            let Some(program) = program.filter(|_| (pack || casts) && !run.is_empty()) else {
-                continue;
+            let whole = &entities[range];
+            // A block entity's run can hold End portal faces and beams beside plain parts (an End
+            // gateway: its cube and its beam): each goes to its own program.
+            // Beacon beams come in a run of their own, at stage NONE (game.rs: no stage of 5.4
+            // is theirs), for gbuffers_beaconbeam.
+            let split = (program_of(&span) == Some(BLOCK) || span.stage == render_stage("NONE"))
+                && whole
+                    .chunks(4)
+                    .any(|q| matches!(q[0].layer & 0xffff, 6 | 9 | 10));
+            let parts: [(&[Vertex], Part); 3] = if split {
+                other.clear();
+                portal_faces.clear();
+                beam_faces.clear();
+                for quad in whole.chunks(4) {
+                    match quad[0].layer & 0xffff {
+                        9 | 10 => portal_faces.extend_from_slice(quad),
+                        6 => beam_faces.extend_from_slice(quad),
+                        _ => other.extend_from_slice(quad),
+                    }
+                }
+                [
+                    (&other, Part::Plain),
+                    (&portal_faces, Part::Portal),
+                    (&beam_faces, Part::Beam),
+                ]
+            } else {
+                [(whole, Part::Plain), (&[], Part::Plain), (&[], Part::Plain)]
             };
-            let start = self.scratch.len() as u32;
-            self.scratch.extend_from_slice(run);
-            if program == DESTROY {
-                project_cracks(&mut self.scratch[start as usize..], crack.0, crack.1);
+            for (run, part) in parts {
+                if run.is_empty() {
+                    continue;
+                }
+                let program = match part {
+                    Part::Portal => Some(BLOCK),
+                    Part::Beam => Some(BEAM),
+                    Part::Plain => program_of(&span).filter(|&p| {
+                        plain(run)
+                            || (p == DESTROY && run.iter().all(|v| matches!(v.layer, 11 | 12)))
+                    }),
+                };
+                let pack = program.is_some_and(|p| drawn[p]) && !span.hidden;
+                let casts = part == Part::Plain && program.is_some_and(|p| shadow.cast(&span, p));
+                if !pack && !span.hidden {
+                    extend_without_portals(rest, run);
+                }
+                let Some(program) = program.filter(|_| pack || casts) else {
+                    continue;
+                };
+                let start = self.scratch.len() as u32;
+                match part {
+                    Part::Beam => beam_segments(run, &mut self.scratch),
+                    _ => self.scratch.extend_from_slice(run),
+                }
+                if program == DESTROY {
+                    project_cracks(&mut self.scratch[start as usize..], crack.0, crack.1);
+                }
+                if part == Part::Portal {
+                    as_portal_texture(&mut self.scratch[start as usize..]);
+                }
+                let vertices = self.scratch.len() as u32 - start;
+                let overlay = self.scratch[start as usize].layer & 0xffff;
+                let portal = part == Part::Portal;
+                self.push_draw(
+                    span,
+                    posed + start,
+                    vertices,
+                    program,
+                    pack,
+                    casts,
+                    overlay,
+                    portal,
+                );
             }
-            self.push_draw(
-                span,
-                posed + start,
-                run.len() as u32,
-                program,
-                pack,
-                casts,
-                run[0].layer & 0xffff,
-            );
         }
         if self.draws.is_empty() && posed == 0 {
             return;
@@ -453,6 +504,7 @@ impl PackEntities {
         pack: bool,
         casts: bool,
         overlay: u32,
+        portal: bool,
     ) {
         let (entity_id, block_id) = match program {
             BLOCK => (0, span.id),
@@ -476,6 +528,7 @@ impl PackEntities {
             pack,
             shadow: casts,
             slot: self.draws.len() as u32,
+            portal,
         });
     }
 }
@@ -504,13 +557,104 @@ fn plain(run: &[Vertex]) -> bool {
         .all(|v| !matches!(v.layer & 0xffff, 2 | 4 | 6 | 9 | 10 | 11 | 12 | 34))
 }
 
+/// What part of a block entity's run goes to which program (`prepare`).
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Part {
+    Plain,
+    Portal,
+    Beam,
+}
+
+/// Beam faces (`block_entity_render::beam`: layer 6, v counting the sprite's repeats up the
+/// beam, the sprite's v range in the light bytes) for a pack: each face cut where its texture
+/// repeats, so every piece holds one copy of the sprite in plain atlas coordinates (at most 64
+/// pieces a face; a taller beam stretches its copies), white light and its colour kept.
+fn beam_segments(run: &[Vertex], out: &mut Vec<Vertex>) {
+    for quad in run.as_chunks::<4>().0 {
+        let wrap = quad[0].light;
+        let (v0, size) = (
+            (wrap & 65535) as f32 / 65535.0,
+            (wrap >> 16) as f32 / 65535.0,
+        );
+        // Corners 0 and 3 at the beam's end (v1), 1 and 2 at its start (v2); 0 and 1 on one
+        // side, 2 and 3 on the other.
+        let (v1, v2) = (quad[0].uv[1], quad[1].uv[1]);
+        if (v1 - v2).abs() < 1e-6 {
+            continue;
+        }
+        let (lo, hi) = (v1.min(v2), v1.max(v2));
+        let first = lo.floor();
+        let repeats = (hi.ceil() - first).max(1.0);
+        let step = (repeats / 64.0).ceil().max(1.0);
+        let pieces = (repeats / step).ceil() as u32;
+        let at = |side: usize, v: f32| {
+            let (a, b) = if side == 0 {
+                (quad[1], quad[0])
+            } else {
+                (quad[2], quad[3])
+            };
+            let t = (v - v2) / (v1 - v2);
+            glam::Vec3::from(a.pos)
+                .lerp(glam::Vec3::from(b.pos), t)
+                .to_array()
+        };
+        for k in 0..pieces {
+            let base = first + k as f32 * step;
+            let (a, b) = (base.max(lo), (base + step).min(hi));
+            if b <= a {
+                continue;
+            }
+            // The end-side corners take the piece's bound nearer v1.
+            let (end_v, start_v) = if v1 > v2 { (b, a) } else { (a, b) };
+            for (i, corner) in quad.iter().enumerate() {
+                let side = usize::from(i >= 2);
+                let v = if i == 0 || i == 3 { end_v } else { start_v };
+                let mut out_v = *corner;
+                out_v.pos = at(side, v);
+                out_v.uv = [corner.uv[0], v0 + (v - base) / step * size];
+                out_v.layer = 0;
+                out_v.light = 0x0000_f0f0;
+                out.push(out_v);
+            }
+        }
+    }
+}
+
+/// `run` added to Horizon's own draw without End portal faces: under a shader pack Horizon's
+/// entity shader would put its screen-projected starfield into the pack's buffers as if they
+/// were its own frame (misplaced where the pack renders at another size), so a portal the pack
+/// does not draw (its programs not there, or not yet) is better left out.
+fn extend_without_portals(rest: &mut Vec<Vertex>, run: &[Vertex]) {
+    for quad in run.chunks(4) {
+        if !quad.iter().all(|v| matches!(v.layer & 0xffff, 6 | 9 | 10)) {
+            rest.extend_from_slice(quad);
+        }
+    }
+}
+
+/// End portal faces for a pack's `gbuffers_block` (block entities): each face textured with the
+/// whole of `end_portal.png`, which the draw binds as the atlas (a texture of its own, so a
+/// pack's own portal effect can wrap it), white, at full light; the pack tells the portal by its
+/// `blockEntityId`.
+fn as_portal_texture(run: &mut [Vertex]) {
+    const CORNERS: [[f32; 2]; 4] = [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]];
+    for (i, v) in run.iter_mut().enumerate() {
+        v.uv = CORNERS[i % 4];
+        v.layer = 0;
+        v.color = 0xFFFF_FFFF;
+        v.light = 0x0000_f0f0;
+    }
+}
+
 /// The programs of entity runs, in the order they draw.
 pub const ENTITY: usize = 0;
 pub const BLOCK: usize = 1;
 pub const TRANSLUCENT: usize = 2;
 pub const PARTICLE: usize = 3;
 pub const DESTROY: usize = 4;
-pub const PROGRAMS: usize = 5;
+/// Beacon and End gateway beams (`gbuffers_beaconbeam`).
+pub const BEAM: usize = 5;
+pub const PROGRAMS: usize = 6;
 
 /// Which program draws `span`'s run, given which of them (or their fallbacks) the pack has;
 /// `None`: Horizon draws it.
@@ -587,11 +731,11 @@ mod tests {
         assert_eq!(drawn_by_pack(&spans[0], all), Some(ENTITY));
         assert_eq!(drawn_by_pack(&spans[1], all), Some(PARTICLE));
         assert_eq!(
-            drawn_by_pack(&spans[1], [true, true, true, false, true]),
+            drawn_by_pack(&spans[1], [true, true, true, false, true, true]),
             None
         );
         assert_eq!(
-            drawn_by_pack(&spans[2], [true, false, true, true, true]),
+            drawn_by_pack(&spans[2], [true, false, true, true, true, true]),
             None
         );
         assert_eq!(drawn_by_pack(&spans[2], all), Some(BLOCK));
@@ -654,6 +798,103 @@ fn project_cracks(vertices: &mut [Vertex], sprite: [f32; 4], atlas: [u32; 2]) {
     }
 }
 
+#[cfg(test)]
+mod portal_beam_tests {
+    use super::*;
+
+    fn quad(layer: u32, light: u32, corners: [([f32; 3], [f32; 2]); 4]) -> [Vertex; 4] {
+        corners.map(|(pos, uv)| Vertex {
+            pos,
+            uv,
+            layer,
+            color: 0xFF20_40FF,
+            light,
+            ..bytemuck::Zeroable::zeroed()
+        })
+    }
+
+    #[test]
+    fn a_beam_face_becomes_one_sprite_copy_per_repeat() {
+        // `block_entity_render::beam`'s corner order: 0 and 3 at the end (v1), 1 and 2 at the
+        // start (v2); the sprite's v range (0.25, height 0.5) in the light bytes.
+        let wrap = (0.25f32 * 65535.0).round() as u32 | ((0.5f32 * 65535.0).round() as u32) << 16;
+        let face = quad(
+            6,
+            wrap,
+            [
+                ([0.0, 3.0, 0.0], [0.9, 3.0]),
+                ([0.0, 0.0, 0.0], [0.9, 0.0]),
+                ([1.0, 0.0, 0.0], [0.1, 0.0]),
+                ([1.0, 3.0, 0.0], [0.1, 3.0]),
+            ],
+        );
+        let mut out = Vec::new();
+        beam_segments(&face, &mut out);
+        assert_eq!(out.len(), 12, "three repeats, three pieces");
+        for (k, piece) in out.chunks(4).enumerate() {
+            let (bottom, top) = (k as f32, k as f32 + 1.0);
+            assert_eq!([piece[0].pos[1], piece[1].pos[1]], [top, bottom]);
+            assert_eq!([piece[2].pos[1], piece[3].pos[1]], [bottom, top]);
+            for v in piece {
+                assert!((0.25 - 1e-4..=0.75 + 1e-4).contains(&v.uv[1]), "{:?}", v.uv);
+                assert_eq!(v.layer, 0);
+                assert_eq!(v.light, 0x0000_f0f0);
+                assert_eq!(v.color, 0xFF20_40FF);
+            }
+            assert!((piece[0].uv[1] - 0.75).abs() < 1e-4 && (piece[1].uv[1] - 0.25).abs() < 1e-4);
+            assert_eq!([piece[0].uv[0], piece[2].uv[0]], [0.9, 0.1]);
+        }
+    }
+
+    #[test]
+    fn a_very_tall_beam_is_cut_into_at_most_64_pieces() {
+        let face = quad(
+            6,
+            0xFFFF_0000,
+            [
+                ([0.0, 2000.0, 0.0], [1.0, 2000.0]),
+                ([0.0, 0.0, 0.0], [1.0, 0.0]),
+                ([1.0, 0.0, 0.0], [0.0, 0.0]),
+                ([1.0, 2000.0, 0.0], [0.0, 2000.0]),
+            ],
+        );
+        let mut out = Vec::new();
+        beam_segments(&face, &mut out);
+        assert!(out.len() / 4 <= 64, "{} pieces", out.len() / 4);
+        let top = out.iter().map(|v| v.pos[1]).fold(f32::MIN, f32::max);
+        let bottom = out.iter().map(|v| v.pos[1]).fold(f32::MAX, f32::min);
+        assert_eq!(
+            (bottom, top),
+            (0.0, 2000.0),
+            "the pieces still span the whole beam"
+        );
+    }
+
+    #[test]
+    fn portal_faces_take_the_whole_portal_texture_at_full_light() {
+        let mut face = quad(9, 0, [([0.0; 3], [0.0; 2]); 4]).to_vec();
+        as_portal_texture(&mut face);
+        let uvs: Vec<[f32; 2]> = face.iter().map(|v| v.uv).collect();
+        assert_eq!(uvs, [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]]);
+        assert!(
+            face.iter()
+                .all(|v| v.layer == 0 && v.color == 0xFFFF_FFFF && v.light == 0x0000_f0f0)
+        );
+    }
+
+    #[test]
+    fn horizon_keeps_no_portal_or_beam_face_under_a_pack() {
+        let mut run = Vec::new();
+        for layer in [0, 6, 9, 10, 2] {
+            run.extend(quad(layer, 0, [([0.0; 3], [0.0; 2]); 4]));
+        }
+        let mut rest = Vec::new();
+        extend_without_portals(&mut rest, &run);
+        let kept: Vec<u32> = rest.chunks(4).map(|q| q[0].layer).collect();
+        assert_eq!(kept, [0, 2]);
+    }
+}
+
 #[cfg(test)]
 mod crack_projection_tests {
     use super::*;

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

@@ -35,7 +35,9 @@ pub(super) fn images(defs: Vec<CustomImage>) -> Vec<PackImage> {
     defs.into_iter()
         .map(|def| PackImage {
             format: format(def.format),
-            dimension: if def.is_3d() {
+            dimension: if def.is_1d() {
+                wgpu::TextureViewDimension::D1
+            } else if def.is_3d() {
                 wgpu::TextureViewDimension::D3
             } else {
                 wgpu::TextureViewDimension::D2
@@ -51,6 +53,15 @@ pub(super) fn images(defs: Vec<CustomImage>) -> Vec<PackImage> {
         .collect()
 }
 
+/// The texture dimension a view of `view` needs.
+fn texture_dimension(view: wgpu::TextureViewDimension) -> wgpu::TextureDimension {
+    match view {
+        wgpu::TextureViewDimension::D1 => wgpu::TextureDimension::D1,
+        wgpu::TextureViewDimension::D3 => wgpu::TextureDimension::D3,
+        _ => wgpu::TextureDimension::D2,
+    }
+}
+
 /// 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;
@@ -85,7 +96,9 @@ pub(super) fn makeable(device: &wgpu::Device, def: &CustomImage) -> Result<(), S
         ));
     }
     let limits = device.limits();
-    let largest = if def.is_3d() {
+    let largest = if def.is_1d() {
+        limits.max_texture_dimension_1d
+    } else if def.is_3d() {
         limits.max_texture_dimension_3d
     } else {
         limits.max_texture_dimension_2d
@@ -128,11 +141,7 @@ pub(super) fn resize_images(
                     },
                     mip_level_count: 1,
                     sample_count: 1,
-                    dimension: if image.dimension == wgpu::TextureViewDimension::D3 {
-                        wgpu::TextureDimension::D3
-                    } else {
-                        wgpu::TextureDimension::D2
-                    },
+                    dimension: texture_dimension(image.dimension),
                     format: image.format,
                     usage: wgpu::TextureUsages::TEXTURE_BINDING | usage,
                     view_formats: &[],
@@ -321,11 +330,7 @@ pub(super) fn stand_ins(
                     },
                     mip_level_count: 1,
                     sample_count: 1,
-                    dimension: if dimension == wgpu::TextureViewDimension::D3 {
-                        wgpu::TextureDimension::D3
-                    } else {
-                        wgpu::TextureDimension::D2
-                    },
+                    dimension: texture_dimension(dimension),
                     format,
                     usage: wgpu::TextureUsages::STORAGE_BINDING
                         | wgpu::TextureUsages::COPY_DST

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

@@ -7,14 +7,17 @@
 //! Every colortex buffer a program reads or writes has two textures, A and B. Programs read
 //! "main" and write "alt", and each buffer a program wrote flips afterwards (6.1.6). The
 //! mapping carries over to the next frame, so a buffer that is not cleared reads back what was
-//! written last (OQ-8). Buffers are cleared at the start of the frame, "main" only.
+//! written last (OQ-8). A cleared buffer has both textures cleared at the start of the frame:
+//! with an odd number of flips a frame, the texture a program writes was "main" the frame before
+//! and may still hold what was stored into it after that frame's clear (Iris 1.11.7 blends onto
+//! the clear value there, probed with a pack of our own).
 //! Pack buffers store rows as GL does (row 0 at the bottom: the translator negates clip y), so
 //! the world is copied in upside down, and its reverse-Z depth becomes GL window depth.
 
 use std::collections::HashMap;
 
 use glam::{DMat4, DVec3};
-use horizon_shaders::{Format, Group, Kind, Post, Val};
+use horizon_shaders::{Format, Group, Kind, Post, SHADOW_COLORS, Val};
 
 use super::pack_draw::DrawUniforms;
 use super::pack_entities::{PROGRAMS, PackEntities};
@@ -28,6 +31,9 @@ const BUFFERS: usize = horizon_shaders::BUFFERS;
 #[cfg(test)]
 mod world_target_tests;
 
+#[cfg(test)]
+mod higher_shadowcolor_tests;
+
 /// The texture behind a pack sampler name.
 #[derive(Clone, Copy, PartialEq)]
 enum Source {
@@ -365,6 +371,8 @@ struct Pass {
     /// Bind groups by the sides read (bits 0–15), the buffers whose mip chain is current (bits
     /// 16–31) and the shadowcolor sides read (bits 32–33).
     groups: HashMap<u64, wgpu::BindGroup>,
+    /// The same for End portal draws, with `end_portal.png` bound as the atlas.
+    portal_groups: HashMap<u64, wgpu::BindGroup>,
     /// (binding, target) of each image: for a buffer, the side its sampler reads.
     images: Vec<(u32, Image)>,
     /// Binds the pack's storage buffers in set 4.
@@ -539,6 +547,10 @@ pub struct PackPost {
     shadow_targets: Option<super::pack_shadow::ShadowTargets>,
     /// What draws terrain from the light (`shadow`), and translucent terrain (`shadow_water`).
     shadow_terrain: Option<Pass>,
+    /// `end_portal.png`'s atlas rect this frame, and a texture of its own copied from it that
+    /// End portal draws bind as their atlas.
+    portal_rect: [f32; 4],
+    portal_texture: Option<([f32; 4], wgpu::TextureView)>,
     shadow_water: Option<Pass>,
     shadow_comp: Vec<Pass>,
     /// Buffers with mipmaps (filterable ones a program asks them for).
@@ -566,6 +578,10 @@ pub struct PackPost {
     composite_pre: u16,
     formats: [wgpu::TextureFormat; BUFFERS],
     clears: [Option<[f32; 4]>; BUFFERS],
+    /// Buffers of a three-channel format, and whether their textures are new: then they get
+    /// alpha 1 before the next frame.
+    rgb: u16,
+    rgb_unset: bool,
     used: u16,
     /// `size.buffer.*`.
     sizes: [Option<horizon_shaders::BufferSize>; BUFFERS],
@@ -650,6 +666,33 @@ fn texture_format(f: Format, features: wgpu::Features) -> wgpu::TextureFormat {
     }
 }
 
+/// The SNORM wgpu format of SNORM pack format `f`, where this adapter can render to it. Iris
+/// stores such a buffer clamped to [-1, 1] and quantised to its bits; elsewhere the half floats of
+/// [`texture_format`] stand in.
+fn snorm_format(
+    f: Format,
+    features: wgpu::Features,
+    adapter: &wgpu::Adapter,
+) -> Option<wgpu::TextureFormat> {
+    use wgpu::TextureFormat as T;
+    let format = match (f.kind, f.bits, f.channels) {
+        (Kind::Snorm, 8, 1) => T::R8Snorm,
+        (Kind::Snorm, 8, 2) => T::Rg8Snorm,
+        (Kind::Snorm, 8, _) => T::Rgba8Snorm,
+        (Kind::Snorm, 16, 1) => T::R16Snorm,
+        (Kind::Snorm, 16, 2) => T::Rg16Snorm,
+        (Kind::Snorm, 16, _) => T::Rgba16Snorm,
+        _ => return None,
+    };
+    let mut needs = wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES;
+    if f.bits == 16 {
+        needs |= wgpu::Features::TEXTURE_FORMAT_16BIT_NORM;
+    }
+    let renders = (adapter.get_texture_format_features(format).allowed_usages)
+        .contains(wgpu::TextureUsages::RENDER_ATTACHMENT);
+    (features.contains(needs) && renders).then_some(format)
+}
+
 /// The texture behind sampler `name` in a program of the shadow buffers (`shadow_space`: buffer
 /// n is shadowcolor n) or of the others, when the shadow pass runs (`shadow_pass`). `shadow` is
 /// `shadowtex1` when the program also declares `watershadow` (6.3).
@@ -666,11 +709,7 @@ fn fits(ty: &str, sample_type: wgpu::TextureSampleType) -> bool {
 }
 
 fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool) -> Source {
-    let shadow_color = match name {
-        "shadowcolor" | "shadowcolor0" => Some(0),
-        "shadowcolor1" => Some(1),
-        _ => None,
-    };
+    let shadow_color = horizon_shaders::shadow_color(name);
     let shadow_depth = match name {
         "shadowtex0" | "watershadow" | "shadowtex0HW" => Some(0),
         "shadowtex1" | "shadowtex1HW" => Some(1),
@@ -1039,6 +1078,8 @@ struct Resources<'a> {
     gpu: Gpu,
     /// The buffers whose format can be bound as an image.
     storable: u16,
+    /// The buffers of a three-channel format (`rgb`): they have no alpha to write, and read 1.
+    rgb: u16,
     /// The stage (`texture.<stage>`) of the programs built so far, and the buffers one of them
     /// flipped: a `texture.<stage>.colortexN` no longer stands in for buffer N in the stage's
     /// later programs, which read what was written, as in Iris. `final` continues
@@ -1061,7 +1102,7 @@ fn bindings(
     buffers: &[u32],
     geometry: Option<&Geometry<'_>>,
     formats: &[wgpu::TextureFormat; BUFFERS],
-    shadow: Option<&[wgpu::TextureFormat; 2]>,
+    shadow: Option<&[wgpu::TextureFormat; SHADOW_COLORS]>,
     notes: &mut Vec<String>,
     pack: &Resources<'_>,
 ) -> Option<(
@@ -1253,7 +1294,9 @@ fn bindings(
             notes.push(format!("{name}: `{}` has format {}", i.name, i.format));
             return None;
         };
-        let dimension = if i.ty.ends_with("3D") {
+        let dimension = if i.ty.ends_with("1D") {
+            wgpu::TextureViewDimension::D1
+        } else if i.ty.ends_with("3D") {
             wgpu::TextureViewDimension::D3
         } else {
             wgpu::TextureViewDimension::D2
@@ -1381,7 +1424,7 @@ fn build_pass(
     device: &wgpu::Device,
     p: horizon_shaders::PostProgram,
     formats: &[wgpu::TextureFormat; BUFFERS],
-    shadow: Option<&[wgpu::TextureFormat; 2]>,
+    shadow: Option<&[wgpu::TextureFormat; SHADOW_COLORS]>,
     screen: wgpu::TextureFormat,
     notes: &mut Vec<String>,
     geometry: Option<&Geometry<'_>>,
@@ -1392,7 +1435,7 @@ fn build_pass(
     let features = device.features();
     // The frame's uniforms, then the pack's custom ones.
     let index = |name: &str| {
-        pack_uniforms::index(name).or_else(|| {
+        pack_uniforms::index_in(name, geometry.is_some()).or_else(|| {
             let k = custom.iter().position(|c| c == name)?;
             Some(pack_uniforms::NAMES.len() + k)
         })
@@ -1441,6 +1484,12 @@ fn build_pass(
         } else if let Some(&buffer) = p.buffers.get(l) {
             let format = formats[buffer as usize];
             let mut state = target(format);
+            if !p.group.shadow()
+                && pack.rgb & 1 << buffer != 0
+                && let Some(t) = &mut state
+            {
+                t.write_mask = wgpu::ColorWrites::COLOR;
+            }
             if let (Some(t), Some(b)) = (
                 &mut state,
                 p.buffer_blends
@@ -1605,6 +1654,7 @@ fn build_pass(
         atlas: geometry.and_then(|g| g.atlas.clone()),
         ids: geometry.is_some_and(|g| g.ids.is_some()),
         groups: HashMap::new(),
+        portal_groups: HashMap::new(),
         copies: image_buffers(&images) & reads,
         reads: reads | image_buffers(&images),
         buffers: !interface.buffers.is_empty(),
@@ -1638,7 +1688,7 @@ fn build_compute(
     group: Group,
     c: horizon_shaders::ComputeProgram,
     formats: &[wgpu::TextureFormat; BUFFERS],
-    shadow: Option<&[wgpu::TextureFormat; 2]>,
+    shadow: Option<&[wgpu::TextureFormat; SHADOW_COLORS]>,
     notes: &mut Vec<String>,
     custom: &[String],
     pack: &Resources<'_>,
@@ -1739,6 +1789,7 @@ fn build_compute(
         atlas: None,
         ids: false,
         groups: HashMap::new(),
+        portal_groups: HashMap::new(),
         buffers: !interface.buffers.is_empty(),
         images,
         compute: Vec::new(),
@@ -1763,16 +1814,26 @@ impl PackPost {
         // What the pack's shaders need of its storage buffers, before its parts move out.
         let minimums = post.buffer_minimums();
         let features = device.features();
-        let formats: [wgpu::TextureFormat; BUFFERS] =
-            std::array::from_fn(|i| texture_format(post.config.buffers[i].format, features));
+        let formats: [wgpu::TextureFormat; BUFFERS] = std::array::from_fn(|i| {
+            let f = post.config.buffers[i].format;
+            snorm_format(f, features, adapter).unwrap_or_else(|| texture_format(f, features))
+        });
         let sky_clear = Some(&post.config.buffers[0])
             .filter(|b| b.clear)
             .and_then(|b| b.clear_color);
+        // A three-channel buffer reads alpha 1 whatever is written or cleared, as in Iris: its
+        // passes leave alpha alone, and its clears and first contents set it to 1.
+        let rgb = (0..BUFFERS)
+            .filter(|&i| post.config.buffers[i].format.channels == 3)
+            .fold(0u16, |m, i| m | 1 << i);
         let clears = std::array::from_fn(|i| {
             let b = &post.config.buffers[i];
             b.clear.then(|| {
-                b.clear_color
-                    .unwrap_or(if i == 1 { [1.0; 4] } else { [0.0; 4] })
+                let mut c = (b.clear_color).unwrap_or(if i == 1 { [1.0; 4] } else { [0.0; 4] });
+                if rgb & 1 << i != 0 {
+                    c[3] = 1.0;
+                }
+                c
             })
         });
         let mut notes = post.notes;
@@ -1784,6 +1845,8 @@ impl PackPost {
         }
         let textures = pack_textures::upload(device, queue, post.textures, &mut notes);
         let shadow_config = post.config.shadow.clone();
+        // shadowcolor2 to 7 only for a pack that names `HIGHER_SHADOWCOLOR`.
+        let shadow_colors = (1u16 << post.shadow_colors) - 1;
         let mut custom = post.custom;
         let custom_names: Vec<String> = custom.uniforms().map(|u| u.0.to_owned()).collect();
         // A first run finds the names neither the frame nor the pack defines.
@@ -1799,13 +1862,14 @@ impl PackPost {
         let mut used = 1u16;
         let draws = DrawUniforms::new(device);
         // The shadow buffers' formats when the shadow pass runs; their programs see them as
-        // buffers 0 and 1.
-        let shadow_formats: Option<[wgpu::TextureFormat; 2]> = post.shadow_pass.then(|| {
-            std::array::from_fn(|n| texture_format(shadow_config.colors[n].format, features))
-        });
+        // buffers 0 to 7.
+        let shadow_formats: Option<[wgpu::TextureFormat; SHADOW_COLORS]> =
+            post.shadow_pass.then(|| {
+                std::array::from_fn(|n| texture_format(shadow_config.colors[n].format, features))
+            });
         let shadow_space: [wgpu::TextureFormat; BUFFERS] = std::array::from_fn(|i| {
             shadow_formats
-                .filter(|_| i < 2)
+                .filter(|_| i < SHADOW_COLORS)
                 .map_or(formats[i], |f| f[i])
         });
         let (mut storage, mut copied, mut image_copied, mut snapshotted) = (0u16, 0u16, 0u64, 0u64);
@@ -1873,6 +1937,7 @@ impl PackPost {
             indices: indices.as_ref(),
             gpu,
             storable,
+            rgb,
             released: std::cell::Cell::new(("", 0)),
             stand_ins: &stand_ins,
         };
@@ -2020,6 +2085,7 @@ impl PackPost {
             post.entities_translucent,
             post.particles,
             post.damaged_block,
+            post.beacon_beam,
         ];
         let late = [
             false,
@@ -2027,6 +2093,7 @@ impl PackPost {
             post.translucent_late,
             post.particles_late,
             false,
+            true,
         ];
         let shadow_only = (post.shadow_only_player, post.shadow_only_lit_blocks);
         let shadow_programs = [post.shadow_entities, post.shadow_block];
@@ -2242,7 +2309,7 @@ impl PackPost {
                     0
                 };
                 m | own | p.shadow_reads
-            });
+            }) & shadow_colors;
             let depth1 = every_pass()
                 .flat_map(|p| &p.samplers)
                 .any(|s| matches!(s.source, Source::ShadowDepth(1, _)));
@@ -2318,7 +2385,13 @@ impl PackPost {
             }
         });
         let float = wgpu::TextureSampleType::Float { filterable: true };
-        let blit_targets = std::iter::once(target(formats[0]));
+        let mut world_target = target(formats[0]);
+        if rgb & 1 != 0
+            && let Some(t) = &mut world_target
+        {
+            t.write_mask = wgpu::ColorWrites::COLOR;
+        }
+        let blit_targets = std::iter::once(world_target);
         // Cleared by the pass's load operation; the shader writes nothing there.
         let blit_targets: Vec<_> = blit_targets
             .chain(cleared.iter().map(|&b| {
@@ -2425,6 +2498,8 @@ impl PackPost {
             depth2,
             shadow_targets,
             shadow_terrain,
+            portal_rect: [0.0; 4],
+            portal_texture: None,
             shadow_water,
             shadow_comp,
             mipped,
@@ -2443,6 +2518,8 @@ impl PackPost {
             composite_pre: mask(&post.composite_pre),
             formats,
             clears,
+            rgb,
+            rgb_unset: true,
             used,
             storage,
             copied,
@@ -2810,7 +2887,10 @@ impl PackPost {
         let group = self.bind(device, queue, encoder, pass, size);
         let mut cp = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
             label: Some(&pass.name),
-            timestamp_writes: None,
+            timestamp_writes: self
+                .timing
+                .as_mut()
+                .and_then(|t| t.compute_writes(&pass.name)),
         });
         cp.set_pipeline(&pipeline);
         cp.set_bind_group(0, &group, &[]);
@@ -2839,7 +2919,7 @@ impl PackPost {
         // one clearing them.
         let (depth_ops, shadow_ops) = match &mut self.shadow_targets {
             Some(s) if pass.group.shadow() => s.clear_ops(pass.writes.iter().map(|w| w.1)),
-            _ => (super::pack_shadow::load(), [load; 2]),
+            _ => (super::pack_shadow::load(), [load; SHADOW_COLORS]),
         };
         let shadow = self.shadow_targets.as_ref().filter(|_| pass.group.shadow());
         let mut attachments: Vec<Option<wgpu::RenderPassColorAttachment>> = Vec::new();
@@ -3024,6 +3104,42 @@ impl PackPost {
                 continue;
             }
             let group = self.bind(device, queue, encoder, pass, size);
+            // End portal faces bind `end_portal.png` as the atlas, a texture of its own, so packs
+            // that wrap it with their own coordinates sample the portal sprite only.
+            let portal_group = if geometry
+                .draws
+                .iter()
+                .any(|d| d.pack && d.program == program && d.portal)
+                && let Some(atlas) = pass.atlas.clone().or_else(|| self.atlas.clone())
+                && self.portal_rect[2] > 0.0
+            {
+                if self
+                    .portal_texture
+                    .as_ref()
+                    .is_none_or(|(rect, _)| *rect != self.portal_rect)
+                {
+                    pass.portal_groups.clear();
+                    let view = super::pack_weather::copy_sprite(
+                        device,
+                        encoder,
+                        atlas.texture(),
+                        self.portal_rect,
+                    );
+                    self.portal_texture = Some((self.portal_rect, view));
+                }
+                let view = self.portal_texture.as_ref().map(|p| p.1.clone());
+                // `bind` caches groups by a key without the atlas: the portal groups are kept
+                // in a cache of their own, swapped in with the texture.
+                let saved = std::mem::replace(&mut pass.atlas, view);
+                let groups =
+                    std::mem::replace(&mut pass.groups, std::mem::take(&mut pass.portal_groups));
+                let g = self.bind(device, queue, encoder, pass, size);
+                pass.portal_groups = std::mem::replace(&mut pass.groups, groups);
+                pass.atlas = saved;
+                Some(g)
+            } else {
+                None
+            };
             {
                 let mut rp = self.begin(encoder, pass);
                 rp.set_pipeline(pass.render());
@@ -3036,7 +3152,14 @@ impl PackPost {
                 rp.set_bind_group(1, &geometry.table_group, &[]);
                 rp.set_vertex_buffer(0, geometry.vertices());
                 rp.set_index_buffer(geometry.indices.slice(..), wgpu::IndexFormat::Uint32);
+                let mut on_portal = false;
                 for d in draws {
+                    if let Some(portal) = &portal_group
+                        && d.portal != on_portal
+                    {
+                        rp.set_bind_group(0, if d.portal { portal } else { &group }, &[]);
+                        on_portal = d.portal;
+                    }
                     if pass.draw {
                         rp.set_bind_group(2, &geometry.group, &[geometry.offset(d.slot)]);
                     }
@@ -3110,9 +3233,11 @@ impl PackPost {
         entities: &[super::Vertex],
         spans: &[super::pack_draw::EntitySpan],
         crumbling: [f32; 4],
+        portal: [f32; 4],
         rest: &mut Vec<super::Vertex>,
         skin: Option<&super::entity_skin::SkinFrame>,
     ) {
+        self.portal_rect = portal;
         let shadow = self.shadow_casters();
         let Some(e) = &mut self.entities else {
             rest.clear();
@@ -3436,16 +3561,25 @@ impl PackPost {
     }
 
     /// Regenerates the mip chain of buffer `b`'s side that programs read.
-    fn mipmap(&self, encoder: &mut wgpu::CommandEncoder, b: usize) {
+    fn mipmap(&mut self, encoder: &mut wgpu::CommandEncoder, b: usize) {
         let (Some(targets), Some((pipeline, _))) = (&self.targets, self.down.get(&self.formats[b]))
         else {
             return;
         };
         let Some(mips) = &targets.mips[b] else { return };
         let side = &mips[usize::from(self.main & 1 << b != 0)];
+        // Timed as one pass per buffer (its first level), so the pass timer shows the chains.
+        let label = format!("mipmaps colortex{b}");
+        let mut first = true;
         for (attachment, group) in &side.levels {
+            let timestamp_writes = if std::mem::take(&mut first) {
+                self.timing.as_mut().and_then(|t| t.writes(&label))
+            } else {
+                None
+            };
             let mut rp = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                 label: Some("Shader pack mipmap"),
+                timestamp_writes,
                 color_attachments: &[attach(
                     attachment,
                     wgpu::Operations {
@@ -3559,6 +3693,7 @@ impl PackPost {
             return;
         }
         self.setup_pending = true;
+        self.rgb_unset = true;
         let sizes: [[u32; 2]; BUFFERS] =
             std::array::from_fn(|i| self.sizes[i].map_or(size, |s| s.resolve(size)));
         let full_chain = |size: [u32; 2]| 32 - size[0].max(size[1]).max(1).leading_zeros();
@@ -4015,6 +4150,26 @@ impl PackPost {
                 ..Default::default()
             });
         }
+        // Three-channel buffers start out with alpha 1 on both sides: a pass writes the side the
+        // frame's clear didn't touch.
+        if self.rgb_unset {
+            self.rgb_unset = false;
+            let start = wgpu::Operations {
+                load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+                store: wgpu::StoreOp::Store,
+            };
+            for b in (0..BUFFERS).filter(|&b| self.rgb & 1 << b != 0) {
+                for alt in [false, true] {
+                    if let Some(v) = view(self.main, b, alt) {
+                        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                            label: Some("Shader pack three-channel start"),
+                            color_attachments: &[attach(v, start)],
+                            ..Default::default()
+                        });
+                    }
+                }
+            }
+        }
         let clear_op = |b: usize| {
             let c = self.clears[b].unwrap_or_default();
             wgpu::Operations {
@@ -4035,26 +4190,35 @@ impl PackPost {
         // Attachments share a size and stay within the device's count and byte limits.
         let limits = device.limits();
         let max_attachments = (limits.max_color_attachments as usize).min(8);
-        let mut by_size: Vec<([u32; 2], Vec<usize>)> = Vec::new();
-        for &b in &self.other_clears {
+        // The buffers the blit doesn't clear, and the other texture of every cleared buffer.
+        let alt_clears = (0..BUFFERS)
+            .filter(|&b| self.clears[b].is_some() && view(self.main, b, true).is_some())
+            .map(|b| (b, true));
+        let mut by_size: Vec<([u32; 2], Vec<(usize, bool)>)> = Vec::new();
+        for (b, alt) in self
+            .other_clears
+            .iter()
+            .map(|&b| (b, false))
+            .chain(alt_clears)
+        {
             let at = targets.sizes[b];
             match by_size.iter_mut().find(|(s, buffers)| {
                 let bytes = buffers
                     .iter()
-                    .fold(0, |bytes, &b| attachment_bytes(bytes, self.formats[b]));
+                    .fold(0, |bytes, &(b, _)| attachment_bytes(bytes, self.formats[b]));
                 *s == at
                     && buffers.len() < max_attachments
                     && attachment_bytes(bytes, self.formats[b])
                         <= limits.max_color_attachment_bytes_per_sample
             }) {
-                Some((_, l)) => l.push(b),
-                None => by_size.push((at, vec![b])),
+                Some((_, l)) => l.push((b, alt)),
+                None => by_size.push((at, vec![(b, alt)])),
             }
         }
         for (_, chunk) in &by_size {
             let attachments: Vec<_> = chunk
                 .iter()
-                .map(|&b| attach(view(self.main, b, false).expect("used buffer"), clear_op(b)))
+                .map(|&(b, alt)| attach(view(self.main, b, alt).expect("used buffer"), clear_op(b)))
                 .collect();
             encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                 label: Some("Shader pack clear"),
@@ -4087,9 +4251,18 @@ impl PackPost {
             self.blit_group = Some(([world.clone(), world_depth.clone()], group));
         }
         {
+            // The blit leaves a three-channel colortex0's alpha at the 1 it starts with.
+            let world_ops = if self.rgb & 1 != 0 {
+                wgpu::Operations {
+                    load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+                    store: wgpu::StoreOp::Store,
+                }
+            } else {
+                overwrite
+            };
             let mut attachments = vec![attach(
                 view(self.main, 0, false).expect("colortex0"),
-                overwrite,
+                world_ops,
             )];
             for &b in &self.blit_clears {
                 attachments.push(attach(
@@ -4291,6 +4464,9 @@ impl PackPost {
     }
 }
 
+#[cfg(test)]
+mod snorm_tests;
+
 #[cfg(test)]
 #[path = "pack_post/depth_test.rs"]
 mod depth_test;
@@ -4437,6 +4613,7 @@ mod tests {
             indices: None,
             gpu: Gpu::of(&adapter, device.features()),
             storable: 0,
+            rgb: 0,
             released: std::cell::Cell::new(("", 0)),
             stand_ins: &stand_ins,
         };
@@ -4514,6 +4691,7 @@ mod tests {
             indices: None,
             gpu: Gpu::of(&adapter, device.features()),
             storable: 0,
+            rgb: 0,
             released: std::cell::Cell::new(("", 0)),
             stand_ins: &stand_ins,
         };
@@ -4594,6 +4772,169 @@ mod tests {
         );
     }
 
+    /// `blend.<program>` of a composite program blends its output onto what the buffer's side
+    /// holds (Iris 1.11.7, probed: 0.25 over 0.75 with SRC_ALPHA ONE_MINUS_SRC_ALPHA ONE ZERO and
+    /// a source alpha of 0.25 reads 0.625).
+    #[test]
+    fn a_composite_program_blends_onto_its_buffer() {
+        let instance = crate::gfx::test_gpu::instance();
+        let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
+            return;
+        };
+        // A pass's pipeline layout has six bind group slots.
+        let desc = wgpu::DeviceDescriptor {
+            required_limits: adapter.limits(),
+            ..Default::default()
+        };
+        let Ok((device, queue)) = pollster::block_on(adapter.request_device(&desc)) else {
+            return;
+        };
+        let dir = std::env::temp_dir().join(format!("hz-composite-blend-{}", std::process::id()));
+        let shaders = dir.join("shaders");
+        std::fs::create_dir_all(&shaders).unwrap();
+        let file = |name: &str, text: &str| std::fs::write(shaders.join(name), text).unwrap();
+        file(
+            "composite.vsh",
+            "#version 120\nvoid main() { gl_Position = ftransform(); }\n",
+        );
+        file(
+            "composite.fsh",
+            "#version 120\n/* DRAWBUFFERS:3 */\n\
+             void main() { gl_FragData[0] = vec4(0.25, 0.25, 1.0, 0.25); }\n",
+        );
+        let pack = horizon_shaders::Pack::open(&dir).unwrap();
+        let properties = horizon_shaders::Properties::parse(
+            "blend.composite = SRC_ALPHA ONE_MINUS_SRC_ALPHA ONE ZERO\n",
+            &horizon_shaders::Macros::default(),
+        );
+        let mut post = horizon_shaders::load_post(
+            &pack,
+            "",
+            &properties,
+            &horizon_shaders::Macros::standard(),
+            &Default::default(),
+        );
+        std::fs::remove_dir_all(&dir).unwrap();
+        let program = post.programs.remove(0);
+        let buffers = pack_images::Buffers::new(
+            &device,
+            Default::default(),
+            Default::default(),
+            wgpu::ShaderStages::FRAGMENT,
+        );
+        let stand_ins = std::cell::RefCell::new(Vec::new());
+        let pack = Resources {
+            textures: &[],
+            images: &[],
+            left_out: &[],
+            buffers: &buffers,
+            indices: None,
+            gpu: Gpu::of(&adapter, device.features()),
+            storable: 0,
+            rgb: 0,
+            released: std::cell::Cell::new(("", 0)),
+            stand_ins: &stand_ins,
+        };
+        let draws = DrawUniforms::new(&device);
+        let mut notes = Vec::new();
+        let pass = build_pass(
+            &device,
+            program,
+            &[T::Rgba8Unorm; BUFFERS],
+            None,
+            T::Rgba8Unorm,
+            &mut notes,
+            None,
+            &[],
+            &draws.layout,
+            &pack,
+        )
+        .unwrap_or_else(|| panic!("the pass builds: {notes:?}"));
+        // colortex3 holds (0.75, 0.5, 0.25, 0.5) before the pass.
+        let texture = device.create_texture(&wgpu::TextureDescriptor {
+            label: None,
+            size: wgpu::Extent3d {
+                width: 64,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: T::Rgba8Unorm,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+            view_formats: &[],
+        });
+        let view = texture.create_view(&Default::default());
+        let head = [64.0f32, 1.0, 1.0 / 64.0, 1.0];
+        queue.write_buffer(&pass.ubo, 0, bytemuck::cast_slice(&head));
+        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: None,
+            layout: &pass.layout,
+            entries: &[wgpu::BindGroupEntry {
+                binding: 0,
+                resource: pass.ubo.as_entire_binding(),
+            }],
+        });
+        let mut encoder = device.create_command_encoder(&Default::default());
+        let before = wgpu::Color {
+            r: 0.75,
+            g: 0.5,
+            b: 0.25,
+            a: 0.5,
+        };
+        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            color_attachments: &[attach(
+                &view,
+                wgpu::Operations {
+                    load: wgpu::LoadOp::Clear(before),
+                    store: wgpu::StoreOp::Store,
+                },
+            )],
+            ..Default::default()
+        });
+        {
+            // Loaded, as `PackPost::render` attaches a buffer a composite pass writes.
+            let load = wgpu::Operations {
+                load: wgpu::LoadOp::Load,
+                store: wgpu::StoreOp::Store,
+            };
+            let mut rp = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                color_attachments: &[attach(&view, load)],
+                ..Default::default()
+            });
+            rp.set_pipeline(pass.render());
+            rp.set_bind_group(0, &group, &[]);
+            rp.draw(0..6, 0..1);
+        }
+        let read = device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: 256,
+            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+            mapped_at_creation: false,
+        });
+        encoder.copy_texture_to_buffer(
+            texture.as_image_copy(),
+            wgpu::TexelCopyBufferInfo {
+                buffer: &read,
+                layout: wgpu::TexelCopyBufferLayout::default(),
+            },
+            texture.size(),
+        );
+        queue.submit([encoder.finish()]);
+        read.slice(..).map_async(wgpu::MapMode::Read, |_| {});
+        device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+        let texel: Vec<u8> = read.slice(..).get_mapped_range().unwrap()[..4].to_vec();
+        // rgb = 0.25 × src + 0.75 × dst, alpha = the source's.
+        let expected = [0.625, 0.4375, 0.4375, 0.25].map(|v: f32| v * 255.0);
+        for (got, want) in texel.iter().zip(expected) {
+            assert!(
+                (f32::from(*got) - want).abs() <= 1.0,
+                "{texel:?} vs {expected:?}"
+            );
+        }
+    }
+
     #[test]
     fn pack_formats_map_to_renderable_ones() {
         let f = |name| texture_format(Format::parse(name).unwrap(), wgpu::Features::empty());
@@ -4654,3 +4995,6 @@ mod tests {
 
 #[cfg(test)]
 mod destination_tests;
+
+#[cfg(test)]
+mod rgb_alpha_tests;

crates/horizon-client-render/src/gfx/pack_post/destination_tests.rs

@@ -151,14 +151,14 @@ fn pack(
     post
 }
 
-struct Fixture {
-    adapter: wgpu::Adapter,
-    device: wgpu::Device,
-    queue: wgpu::Queue,
+pub(super) struct Fixture {
+    pub(super) adapter: wgpu::Adapter,
+    pub(super) device: wgpu::Device,
+    pub(super) queue: wgpu::Queue,
 }
 
 impl Fixture {
-    fn new() -> Option<Self> {
+    pub(super) fn new() -> Option<Self> {
         let instance = crate::gfx::test_gpu::instance();
         let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
             eprintln!("Post destination test skipped: no GPU adapter");
@@ -198,7 +198,7 @@ impl Fixture {
             .create_view(&Default::default())
     }
 
-    fn build(&self, post: Post) -> PackPost {
+    pub(super) fn build(&self, post: Post) -> PackPost {
         let lightmap = self.texture([1, 1], T::Rgba8Unorm);
         let post = PackPost::new(
             &self.device,
@@ -226,7 +226,7 @@ impl Fixture {
         post
     }
 
-    fn render(&self, post: &mut PackPost, size: [u32; 2]) -> Vec<[u8; 4]> {
+    pub(super) fn render(&self, post: &mut PackPost, size: [u32; 2]) -> Vec<[u8; 4]> {
         let world = self.texture(size, T::Rgba8Unorm);
         let depth = self.texture(size, T::Depth32Float);
         let screen = self.texture(size, T::Rgba8Unorm);
@@ -454,3 +454,70 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
 
 #[path = "clear_budget_tests.rs"]
 mod clear_budget_tests;
+
+/// A cleared buffer written three times a frame flips an odd number of times, so its first write
+/// goes to the texture that was "main" the frame before, which a later program wrote after that
+/// frame's clear. Where that first write discards, Iris 1.11.7 reads the clear value (a probe
+/// pack of our own with these three programs reads 0 there, not the previous frame's 0.25).
+#[test]
+fn a_cleared_buffer_starts_every_frame_cleared_on_both_textures() {
+    let Some(gpu) = Fixture::new() else { return };
+    let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    let mut add = |name: &str, source: &str| {
+        zip.start_file(
+            format!("shaders/{name}"),
+            zip::write::SimpleFileOptions::default(),
+        )
+        .unwrap();
+        zip.write_all(source.as_bytes()).unwrap();
+    };
+    for (program, fragment) in [
+        (
+            "composite",
+            "#version 120\nvarying vec2 uv;\n/* RENDERTARGETS:4 */\n\
+             void main() { if(uv.x>0.5) discard; gl_FragData[0]=vec4(0.5,0.5,0.5,1); }\n",
+        ),
+        (
+            "composite1",
+            "#version 120\nuniform sampler2D colortex4;\nvarying vec2 uv;\n/* RENDERTARGETS:4,5 */\n\
+             void main() { gl_FragData[0]=vec4(0.25,0.25,0.25,1); gl_FragData[1]=texture2D(colortex4,uv); }\n",
+        ),
+        (
+            "composite2",
+            "#version 120\n/* RENDERTARGETS:4 */\nvoid main() { gl_FragData[0]=vec4(0.125,0.125,0.125,1); }\n",
+        ),
+        (
+            "final",
+            "#version 120\nuniform sampler2D colortex5;\nvarying vec2 uv;\n\
+             void main() { gl_FragColor=vec4(texture2D(colortex5,uv).rgb,1); }\n",
+        ),
+    ] {
+        add(&format!("{program}.vsh"), VERTEX);
+        add(&format!("{program}.fsh"), fragment);
+    }
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "both-textures-cleared",
+        zip.finish().unwrap().into_inner(),
+    )
+    .unwrap();
+    let mut macros = horizon_shaders::Macros::standard();
+    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
+    let post = horizon_shaders::load_post(&pack, "", &properties, &macros, &Default::default());
+    let mut post = gpu.build(post);
+    for frame in 0..3 {
+        let actual = gpu.render(&mut post, [16, 16]);
+        let wrong: Vec<_> = (actual.iter().enumerate())
+            .filter(|(n, p)| {
+                let expected = if n % 16 < 8 {
+                    [128, 128, 128, 255]
+                } else {
+                    [0, 0, 0, 255]
+                };
+                p.iter().zip(expected).any(|(a, b)| a.abs_diff(b) > 1)
+            })
+            .map(|(n, p)| (n, *p))
+            .take(4)
+            .collect();
+        assert!(wrong.is_empty(), "frame {frame}: {wrong:?}");
+    }
+}

crates/horizon-client-render/src/gfx/pack_post/higher_shadowcolor_tests.rs

@@ -0,0 +1,82 @@
+//! `HIGHER_SHADOWCOLOR`: shadowcolor2 to 7 are written by shadow programs' directives, read by
+//! them and by the other programs, and cleared to their own colours, as in Iris 1.11.7 (probe
+//! packs p7951a to c; the PR has the readings). The programs here are original and cut down.
+use super::destination_tests::Fixture;
+use super::*;
+use std::io::{Cursor, Write};
+
+const VERTEX: &str = "#version 120\nvarying vec2 uv;\nvoid main() { uv=gl_MultiTexCoord0.xy; gl_Position=ftransform(); }\n";
+
+fn pack() -> Post {
+    let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    let mut add = |name: &str, source: &str| {
+        zip.start_file(
+            format!("shaders/{name}"),
+            zip::write::SimpleFileOptions::default(),
+        )
+        .unwrap();
+        zip.write_all(source.as_bytes()).unwrap();
+    };
+    add("shadowcomp.vsh", VERTEX);
+    add(
+        "shadowcomp.fsh",
+        "#version 120\n/* RENDERTARGETS: 2,7 */\n\
+         void main() { gl_FragData[0]=vec4(0.25,0,0,1); gl_FragData[1]=vec4(0,0.5,0,1); }\n",
+    );
+    // A shadow program reads a higher buffer it didn't write.
+    add("shadowcomp1.vsh", VERTEX);
+    add(
+        "shadowcomp1.fsh",
+        "#version 120\n/* RENDERTARGETS: 3 */\nuniform sampler2D shadowcolor7;\nvarying vec2 uv;\n\
+         void main() { gl_FragData[0]=texture2D(shadowcolor7,uv); }\n",
+    );
+    add("final.vsh", VERTEX);
+    // Pixel column x shows shadowcolor 2, 3, 5 and 6 in turn.
+    add(
+        "final.fsh",
+        "#version 330 compatibility\nconst int shadowMapResolution=16;\n\
+         const vec4 shadowcolor5ClearColor=vec4(0,0,0.75,1);\n\
+         uniform sampler2D shadowcolor2;\nuniform sampler2D shadowcolor3;\n\
+         uniform sampler2D shadowcolor5;\nuniform sampler2D shadowcolor6;\nin vec2 uv;\n\
+         void main() {\n    vec4 c[4] = vec4[4](texture(shadowcolor2,uv), texture(shadowcolor3,uv),\n\
+         texture(shadowcolor5,uv), texture(shadowcolor6,uv));\n\
+             gl_FragColor = c[int(gl_FragCoord.x) % 4];\n}\n",
+    );
+    add(
+        "shaders.properties",
+        "shadow.enabled=true\niris.features.required = HIGHER_SHADOWCOLOR\n",
+    );
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-higher-shadowcolor",
+        zip.finish().unwrap().into_inner(),
+    )
+    .unwrap();
+    let mut macros = horizon_shaders::Macros::standard();
+    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
+    horizon_shaders::load_post(&pack, "", &properties, &macros, &Default::default())
+}
+
+#[test]
+fn higher_shadowcolor_buffers_are_written_read_and_cleared() {
+    let Some(gpu) = Fixture::new() else { return };
+    let mut post = gpu.build(pack());
+    // Two frames: the second starts from the first one's buffers.
+    for frame in 0..2 {
+        let pixels = gpu.render(&mut post, [8, 8]);
+        // shadowcolor2 written red, 3 a copy of 7 (green), 5 its clear colour, 6 white.
+        let expected = [
+            [64, 0, 0, 255],
+            [0, 128, 0, 255],
+            [0, 0, 191, 255],
+            [255; 4],
+        ];
+        for (x, want) in expected.iter().enumerate() {
+            let got = pixels[x];
+            assert!(
+                got.iter().zip(want).all(|(g, w)| g.abs_diff(*w) <= 1),
+                "frame {frame}, column {x}: {got:?}, expected {want:?}; row {:?}",
+                &pixels[..4]
+            );
+        }
+    }
+}

crates/horizon-client-render/src/gfx/pack_post/rgb_alpha_tests.rs

@@ -0,0 +1,100 @@
+//! Three-channel buffers read alpha 1, as in Iris 1.11.7: written with alpha 0, cleared with
+//! alpha 0, or never written. The values come from probe pack p8106 run in Iris (the PR has
+//! them); the programs here are the probe's, cut down.
+use super::destination_tests::Fixture;
+use super::*;
+use std::io::{Cursor, Write};
+
+const VERTEX: &str = "#version 120\nvarying vec2 uv;\nvoid main() { uv=gl_MultiTexCoord0.xy; gl_Position=ftransform(); }\n";
+
+fn pack() -> Post {
+    let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    let mut add = |name: &str, source: &str| {
+        zip.start_file(
+            format!("shaders/{name}"),
+            zip::write::SimpleFileOptions::default(),
+        )
+        .unwrap();
+        zip.write_all(source.as_bytes()).unwrap();
+    };
+    add("composite.vsh", VERTEX);
+    add(
+        "composite.fsh",
+        "#version 120\n/* RENDERTARGETS: 1,5,7 */\n\
+         /*\nconst int colortex0Format = RGB16F;\nconst int colortex1Format = RGB16F;\n\
+         const int colortex2Format = RGB8;\nconst int colortex3Format = RGB32F;\n\
+         const int colortex4Format = RGB32UI;\nconst int colortex5Format = RGBA16F;\n\
+         const int colortex7Format = RGB16;\n*/\n\
+         const vec4 colortex2ClearColor = vec4(0.25, 0.5, 0.75, 0.0);\n\
+         const bool colortex3Clear = false;\n\
+         void main() {\n    gl_FragData[0] = vec4(0.25, 0.5, 0.75, 0.0);\n\
+         gl_FragData[1] = vec4(0.25, 0.5, 0.75, 0.0);\n    gl_FragData[2] = vec4(0.25, 0.5, 0.75, 0.0);\n}\n",
+    );
+    add("composite1.vsh", VERTEX);
+    add(
+        "composite1.fsh",
+        "#version 330 compatibility\n/* RENDERTARGETS: 4 */\nlayout(location = 0) out uvec4 o;\n\
+         void main() { o = uvec4(5u, 6u, 7u, 0u); }\n",
+    );
+    add("final.vsh", VERTEX);
+    // Pixel column x shows buffer x % 8: its alpha in red, its green in green.
+    add(
+        "final.fsh",
+        "#version 330 compatibility\nuniform sampler2D colortex0;\nuniform sampler2D colortex1;\n\
+         uniform sampler2D colortex2;\nuniform sampler2D colortex3;\nuniform usampler2D colortex4;\n\
+         uniform sampler2D colortex5;\nuniform sampler2D colortex7;\n\
+         void main() {\n    ivec2 p = ivec2(gl_FragCoord.xy);\n    vec4 c = vec4(0.0);\n\
+             switch (p.x % 8) {\n\
+             case 0: c = texelFetch(colortex0, p, 0); break;\n\
+             case 1: c = texelFetch(colortex1, p, 0); break;\n\
+             case 2: c = texelFetch(colortex2, p, 0); break;\n\
+             case 3: c = texelFetch(colortex3, p, 0); break;\n\
+             case 4: c = vec4(texelFetch(colortex4, p, 0)) / 12.0; c.a *= 12.0; break;\n\
+             case 5: c = texelFetch(colortex5, p, 0); break;\n\
+             case 7: c = texelFetch(colortex7, p, 0); break;\n\
+             }\n    gl_FragColor = vec4(c.a, c.g, 0.0, 1.0);\n}\n",
+    );
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-rgb-alpha",
+        zip.finish().unwrap().into_inner(),
+    )
+    .unwrap();
+    let mut macros = horizon_shaders::Macros::standard();
+    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
+    let post = horizon_shaders::load_post(&pack, "", &properties, &macros, &Default::default());
+    assert_eq!(post.programs.len(), 3, "{:?}", post.notes);
+    post
+}
+
+#[test]
+fn three_channel_buffers_read_alpha_1() {
+    let Some(gpu) = Fixture::new() else { return };
+    let mut post = gpu.build(pack());
+    // Twice: the second frame reads buffers that a first frame already used.
+    for frame in 0..2 {
+        let pixels = gpu.render(&mut post, [8, 8]);
+        // (alpha, green) per buffer: 0 is the world (black) through the blit; 1, 5 and 7 are
+        // written with alpha 0, 2 is cleared with alpha 0, 3 is never cleared nor written, 4 is
+        // RGB32UI written (5, 6, 7, 0). Only 5 (RGBA16F) keeps the alpha 0 it was given.
+        let expected = [
+            [255, 0],
+            [255, 128],
+            [255, 128],
+            [255, 0],
+            [255, 128],
+            [0, 128],
+            [0, 0],
+            [255, 128],
+        ];
+        let row: Vec<[u8; 2]> = pixels[..8].iter().map(|p| [p[0], p[1]]).collect();
+        for (b, (got, want)) in row.iter().zip(expected).enumerate() {
+            if b == 6 {
+                continue;
+            }
+            assert!(
+                got.iter().zip(want).all(|(g, w)| g.abs_diff(w) <= 1),
+                "frame {frame}, colortex{b}: (alpha, green) {got:?}, expected {want:?}; row {row:?}"
+            );
+        }
+    }
+}

crates/horizon-client-render/src/gfx/pack_post/snorm_tests.rs

@@ -0,0 +1,121 @@
+//! SNORM colortex buffers clamp to [-1, 1] and quantise, as in Iris 1.11.7, where the adapter
+//! renders to SNORM formats. Expected values are those probe pack p8106 read back in Iris (the
+//! PR has them); the programs here are the probe's, cut down. Values that land halfway between
+//! two steps (-0.5 × 127) are left out: GPUs may round them either way.
+use super::destination_tests::Fixture;
+use super::*;
+use std::io::{Cursor, Write};
+
+const VERTEX: &str = "#version 120\nvarying vec2 uv;\nvoid main() { uv=gl_MultiTexCoord0.xy; gl_Position=ftransform(); }\n";
+
+fn pack() -> Post {
+    let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    let mut add = |name: &str, source: &str| {
+        zip.start_file(
+            format!("shaders/{name}"),
+            zip::write::SimpleFileOptions::default(),
+        )
+        .unwrap();
+        zip.write_all(source.as_bytes()).unwrap();
+    };
+    add("composite.vsh", VERTEX);
+    add(
+        "composite.fsh",
+        "#version 120\n/* RENDERTARGETS: 1,2,3 */\n\
+         /*\nconst int colortex1Format = RGBA8_SNORM;\nconst int colortex2Format = RGBA16_SNORM;\n\
+         const int colortex3Format = R16_SNORM;\nconst int colortex4Format = RGBA8_SNORM;\n*/\n\
+         const vec4 colortex4ClearColor = vec4(-1.5, 0.1, 0.3337, 0.0);\n\
+         void main() {\n    gl_FragData[0] = vec4(-1.5, 0.1, 0.3337, 1000.0);\n\
+         gl_FragData[1] = vec4(-1.5, 0.1, 0.3337, 1000.0);\n    gl_FragData[2] = vec4(0.1);\n}\n",
+    );
+    add("final.vsh", VERTEX);
+    // Pixel column x shows component x % 4 of buffer 1 + x / 4, as the bytes of its bits.
+    add(
+        "final.fsh",
+        "#version 330 compatibility\nuniform sampler2D colortex1;\nuniform sampler2D colortex2;\n\
+         uniform sampler2D colortex3;\nuniform sampler2D colortex4;\n\
+         void main() {\n    ivec2 p = ivec2(gl_FragCoord.xy);\n    vec4 c = vec4(0.0);\n\
+             switch (p.x / 4) {\n\
+             case 0: c = texelFetch(colortex1, p, 0); break;\n\
+             case 1: c = texelFetch(colortex2, p, 0); break;\n\
+             case 2: c = texelFetch(colortex3, p, 0); break;\n\
+             case 3: c = texelFetch(colortex4, p, 0); break;\n\
+             }\n    uint u = floatBitsToUint(c[p.x % 4]);\n\
+             gl_FragColor = vec4(uvec4(u >> 24u, u >> 16u, u >> 8u, u) & 255u) / 255.0;\n}\n",
+    );
+    let pack =
+        horizon_shaders::Pack::from_zip_bytes("original-snorm", zip.finish().unwrap().into_inner())
+            .unwrap();
+    let mut macros = horizon_shaders::Macros::standard();
+    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
+    let post = horizon_shaders::load_post(&pack, "", &properties, &macros, &Default::default());
+    assert_eq!(post.programs.len(), 2, "{:?}", post.notes);
+    post
+}
+
+#[test]
+fn snorm_buffers_clamp_and_quantise() {
+    let Some(gpu) = Fixture::new() else { return };
+    // The fixture's device asks for no features; SNORM targets need these.
+    let wanted = wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES
+        | wgpu::Features::TEXTURE_FORMAT_16BIT_NORM;
+    let renders = [
+        wgpu::TextureFormat::Rgba8Snorm,
+        wgpu::TextureFormat::Rgba16Snorm,
+    ]
+    .iter()
+    .all(|&f| {
+        (gpu.adapter.get_texture_format_features(f).allowed_usages)
+            .contains(wgpu::TextureUsages::RENDER_ATTACHMENT)
+    });
+    if !gpu.adapter.features().contains(wanted) || !renders {
+        eprintln!("SNORM test skipped: this adapter doesn't render to SNORM formats");
+        return;
+    }
+    let (device, queue) = pollster::block_on(gpu.adapter.request_device(&wgpu::DeviceDescriptor {
+        required_features: wanted,
+        required_limits: gpu.adapter.limits(),
+        ..Default::default()
+    }))
+    .expect("GPU device with SNORM formats");
+    let gpu = Fixture {
+        adapter: gpu.adapter,
+        device,
+        queue,
+    };
+    let mut post = gpu.build(pack());
+    let pixels = gpu.render(&mut post, [16, 1]);
+    let read: Vec<f32> = pixels
+        .iter()
+        .map(|p| f32::from_bits(u32::from_be_bytes(*p)))
+        .collect();
+    // Iris 1.11.7: RGBA8_SNORM written (-1.5, 0.1, 0.3337, 1000); RGBA16_SNORM the same;
+    // R16_SNORM written 0.1 (G and B read 0, alpha 1); RGBA8_SNORM cleared to
+    // (-1.5, 0.1, 0.3337, 0).
+    let expected = [
+        -1.0,
+        0.102_362_2,
+        0.330_708_7,
+        1.0, //
+        -1.0,
+        0.100_009_2,
+        0.333_689_4,
+        1.0, //
+        0.100_009_2,
+        0.0,
+        0.0,
+        1.0, //
+        -1.0,
+        0.102_362_2,
+        0.330_708_7,
+        0.0,
+    ];
+    for (n, (got, want)) in read.iter().zip(expected).enumerate() {
+        assert!(
+            (got - want).abs() <= 1e-6,
+            "buffer {} component {}: {got}, expected {want}; all {read:?}",
+            1 + n / 4,
+            n % 4
+        );
+    }
+}

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

@@ -1,8 +1,10 @@
 //! A shader pack's shadow buffers (spec 6.3): the shadow map's depth (`shadowtex0`, and
-//! `shadowtex1` without translucent geometry), and the colour buffers `shadowcolor0/1`, each
+//! `shadowtex1` without translucent geometry), and the colour buffers `shadowcolor0` to `7`, each
 //! with two sides that `shadowcomp` programs flip as composite programs flip colortex (6.1.6).
 //! Square, `shadowMapResolution` pixels.
 
+use horizon_shaders::SHADOW_COLORS;
+
 type Ops<T> = wgpu::Operations<T>;
 type Color = wgpu::Color;
 
@@ -34,9 +36,9 @@ pub(super) struct ShadowTargets {
     /// `shadowtex1`: a copy of `shadowtex0` taken before translucent terrain, when read.
     pub depth1: Option<(wgpu::Texture, wgpu::TextureView)>,
     /// Both sides of each shadowcolor buffer used.
-    pub color: [Option<[wgpu::TextureView; 2]>; 2],
+    pub color: [Option<[wgpu::TextureView; 2]>; SHADOW_COLORS],
     /// The clear colour of each buffer cleared every frame.
-    pub clears: [Option<[f32; 4]>; 2],
+    pub clears: [Option<[f32; 4]>; SHADOW_COLORS],
     /// Bit n set: B is shadowcolor n's "main".
     pub main: u16,
     /// Nothing cleared yet this frame: the first pass into the shadow buffers clears them as it
@@ -79,7 +81,7 @@ impl ShadowTargets {
     pub fn new(
         device: &wgpu::Device,
         shadow: &horizon_shaders::Shadow,
-        formats: [wgpu::TextureFormat; 2],
+        formats: [wgpu::TextureFormat; SHADOW_COLORS],
         colors: u16,
         depth1: bool,
     ) -> Self {
@@ -143,12 +145,12 @@ impl ShadowTargets {
     pub fn clear_ops(
         &mut self,
         writes: impl Iterator<Item = usize>,
-    ) -> (Ops<f32>, [Ops<Color>; 2]) {
+    ) -> (Ops<f32>, [Ops<Color>; SHADOW_COLORS]) {
         if !std::mem::take(&mut self.fresh) {
-            return (load(), [load(); 2]);
+            return (load(), [load(); SHADOW_COLORS]);
         }
-        let mut colors = [load(); 2];
-        for n in writes.filter(|&n| n < 2) {
+        let mut colors = [load(); SHADOW_COLORS];
+        for n in writes.filter(|&n| n < SHADOW_COLORS) {
             if let Some(c) = self.clears[n] {
                 colors[n] = clear(c);
                 self.cleared |= 1 << n;
@@ -162,11 +164,12 @@ impl ShadowTargets {
     }
 
     /// Clears what no pass has cleared this frame: all of it when no shadow program drew, the
-    /// cleared shadowcolor buffers the first one did not write.
+    /// cleared shadowcolor buffers the first one did not write. One buffer a pass: eight wide
+    /// formats together would pass the device's bytes-per-sample limit.
     pub fn clear_rest(&mut self, encoder: &mut wgpu::CommandEncoder) {
-        let depth = std::mem::take(&mut self.fresh);
-        let cleared = std::mem::replace(&mut self.cleared, 0b11);
-        let attachments: Vec<_> = (0..2)
+        let mut depth = std::mem::take(&mut self.fresh);
+        let cleared = std::mem::replace(&mut self.cleared, u8::MAX);
+        let attachments = (0..SHADOW_COLORS)
             .filter(|n| cleared & 1 << n == 0)
             .filter_map(|n| {
                 Some(Some(wgpu::RenderPassColorAttachment {
@@ -175,24 +178,30 @@ impl ShadowTargets {
                     resolve_target: None,
                     ops: clear(self.clears[n]?),
                 }))
-            })
-            .collect();
-        if !depth && attachments.is_empty() {
-            return;
+            });
+        let passes: Vec<Vec<_>> = attachments.map(|a| vec![a]).collect();
+        let passes = if passes.is_empty() && depth {
+            vec![Vec::new()]
+        } else {
+            passes
+        };
+        for attachments in &passes {
+            encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("Shader pack shadow clear"),
+                color_attachments: attachments,
+                depth_stencil_attachment: std::mem::take(&mut depth).then_some(
+                    wgpu::RenderPassDepthStencilAttachment {
+                        view: &self.depth.1,
+                        depth_ops: Some(wgpu::Operations {
+                            load: wgpu::LoadOp::Clear(1.0),
+                            store: wgpu::StoreOp::Store,
+                        }),
+                        stencil_ops: None,
+                    },
+                ),
+                ..Default::default()
+            });
         }
-        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: Some("Shader pack shadow clear"),
-            color_attachments: &attachments,
-            depth_stencil_attachment: depth.then_some(wgpu::RenderPassDepthStencilAttachment {
-                view: &self.depth.1,
-                depth_ops: Some(wgpu::Operations {
-                    load: wgpu::LoadOp::Clear(1.0),
-                    store: wgpu::StoreOp::Store,
-                }),
-                stencil_ops: None,
-            }),
-            ..Default::default()
-        });
     }
 
     /// `shadowtex1`: the shadow map as it is now (before translucent geometry).

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

@@ -265,6 +265,13 @@ pub const NAMES: &[&str] = &[
     "playerMood",
     "constantMood",
     "centerDepthSmooth",
+    "alphaTestRef",
+    "entityId",
+    "blockEntityId",
+    "entityColor",
+    GBUFFERS_FOG_MODE,
+    GBUFFERS_FOG_SHAPE,
+    GBUFFERS_CENTER_DEPTH,
     "isRightHanded",
     "is_on_ground",
     "bedrockLevel",
@@ -277,6 +284,13 @@ pub const NAMES: &[&str] = &[
     "cloudHeight",
 ];
 
+/// What programs that draw the game's geometry (gbuffers, shadow) read as `fogMode`,
+/// `fogShape` and `centerDepthSmooth`: no GLSL name can hold a dot, so no pack reads these
+/// directly.
+const GBUFFERS_FOG_MODE: &str = "gbuffers.fogMode";
+const GBUFFERS_FOG_SHAPE: &str = "gbuffers.fogShape";
+const GBUFFERS_CENTER_DEPTH: &str = "gbuffers.centerDepthSmooth";
+
 /// Values carried from frame to frame.
 pub struct FrameUniforms {
     pub values: Vec<Value>,
@@ -472,18 +486,16 @@ impl FrameUniforms {
             });
         }
         let center_depth = self.center_depth.unwrap_or(1.0);
-        // Vanilla fades by the stronger of two linear fogs; a pack gets one: the pair (start
-        // and end together) of the one that is complete nearer (OQ-36). Mixing the nearer start
-        // of one with the nearer end of the other made fog begin at the camera on clear days.
+        // Vanilla fades by the stronger of two linear fogs; a pack gets the environmental one
+        // (`FogData::environmental_start`/`environmental_end`), as Iris 1.11.7 gives it in every
+        // program kind: 0 to 1024 on a clear day, -160 to 768 in rain, -8 to 96 under water, 10
+        // to 96 in the Nether (measured with a probe pack).
         let (fog_color, fog_start, fog_end) = match &frame.fog {
-            Some(f) => {
-                let (start, end) = if f.environmental_end < f.render_distance_end {
-                    (f.environmental_start, f.environmental_end)
-                } else {
-                    (f.render_distance_start, f.render_distance_end)
-                };
-                ([f.color[0], f.color[1], f.color[2]], start, end)
-            }
+            Some(f) => (
+                [f.color[0], f.color[1], f.color[2]],
+                f.environmental_start,
+                f.environmental_end,
+            ),
             None => (frame.sky.fog_color, frame.distance * 0.9, frame.distance),
         };
         let light = shadow_light(frame, &self.shadow);
@@ -545,12 +557,22 @@ impl FrameUniforms {
                 "thunderStrength" => Value::f(&[inputs.thunder]),
                 "fogColor" => Value::f(&fog_color),
                 "skyColor" => Value::f(&frame.sky.sky_color),
-                // GL_LINEAR: vanilla's fog is linear.
-                "fogMode" => Value::i(&[9729]),
+                // Iris 1.11.7, measured: programs that draw no geometry read no fog mode (0) and
+                // shape (-1); those that do read GL_LINEAR and a cylinder (1). The density is 0.
+                "fogMode" => Value::i(&[0]),
+                GBUFFERS_FOG_MODE => Value::i(&[9729]),
                 "fogStart" => Value::f(&[fog_start]),
                 "fogEnd" => Value::f(&[fog_end]),
-                "fogDensity" => Value::f(&[1.0]),
-                "fogShape" => Value::i(&[0]),
+                "fogDensity" => Value::f(&[0.0]),
+                "fogShape" => Value::i(&[-1]),
+                GBUFFERS_FOG_SHAPE => Value::i(&[1]),
+                // Iris 1.11.7 gives gbuffers programs 0 (measured in 16 scenes).
+                GBUFFERS_CENTER_DEPTH => Value::f(&[0.0]),
+                // Outside a draw (gbuffers programs get these per draw), as Iris 1.11.7 gives
+                // them to composite and final programs (measured).
+                "alphaTestRef" => Value::f(&[0.1]),
+                "blockEntityId" => Value::i(&[-1]),
+                "entityColor" => Value::f(&[0.0; 4]),
                 "isEyeInWater" => Value::i(&[inputs.eye_in]),
                 "blindness" => Value::f(&[inputs.blindness]),
                 "nightVision" => Value::f(&[frame.night_vision]),
@@ -690,6 +712,7 @@ fn components(name: &str) -> usize {
         | "skyColor"
         | "endFlashPosition" => 3,
         "eyeBrightness" | "eyeBrightnessSmooth" | "atlasSize" => 2,
+        "entityColor" => 4,
         n if n.starts_with("gbuffer") || n.starts_with("shadow") && n != "shadowAngle" => 16,
         _ => 1,
     }
@@ -700,6 +723,18 @@ pub fn index(name: &str) -> Option<usize> {
     NAMES.iter().position(|n| *n == name)
 }
 
+/// The position in [`NAMES`] of the value a program reads as `name`; `geometry`: the program
+/// draws the game's geometry (gbuffers, shadow), which reads its own fog mode and shape and no
+/// centre depth.
+pub fn index_in(name: &str, geometry: bool) -> Option<usize> {
+    match name {
+        "fogMode" if geometry => index(GBUFFERS_FOG_MODE),
+        "fogShape" if geometry => index(GBUFFERS_FOG_SHAPE),
+        "centerDepthSmooth" if geometry => index(GBUFFERS_CENTER_DEPTH),
+        _ => index(name),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1178,6 +1213,64 @@ mod initial_history_tests {
         }
     }
 
+    fn int(u: &FrameUniforms, at: usize) -> i32 {
+        match u.values[at] {
+            Value::I(v) => v[0],
+            _ => panic!("integer uniform expected"),
+        }
+    }
+
+    /// Iris 1.11.7, read back exactly with a probe pack on a clear day (render distance 12,
+    /// cloud range 64): fogStart 0 and fogEnd 1024 (the environmental fog, not the render
+    /// distance's 172.8 to 192), fogDensity 0; composite and final programs read alphaTestRef
+    /// 0.1, blockEntityId -1, fogMode 0 and fogShape -1.
+    #[test]
+    fn fog_and_draw_uniforms_outside_a_draw_follow_iris() {
+        let hud = HudBatch::new([800, 450]);
+        let mut f = frame(&hud);
+        f.fog = Some(crate::fog::FogData {
+            color: [0.7, 0.8, 1.0, 1.0],
+            environmental_start: 0.0,
+            environmental_end: 1024.0,
+            render_distance_start: 172.8,
+            render_distance_end: 192.0,
+            sky_end: 192.0,
+            cloud_end: 1024.0,
+        });
+        let mut u = FrameUniforms::default();
+        u.update(&f, &PackInputs::default(), [800, 450]);
+        assert_eq!(float(&u, "fogStart")[0], 0.0);
+        assert_eq!(float(&u, "fogEnd")[0], 1024.0);
+        assert_eq!(float(&u, "fogDensity")[0], 0.0);
+        assert_eq!(float(&u, "alphaTestRef")[0], 0.1);
+        assert_eq!(int(&u, index("blockEntityId").unwrap()), -1);
+        assert_eq!(int(&u, index("entityId").unwrap()), 0);
+        assert_eq!(int(&u, index("fogMode").unwrap()), 0);
+        assert_eq!(int(&u, index("fogShape").unwrap()), -1);
+    }
+
+    /// Iris 1.11.7 (probe pack): gbuffers programs read fogMode GL_LINEAR (9729) and fogShape 1
+    /// (cylinder) where composite and final programs read 0 and -1.
+    #[test]
+    fn programs_that_draw_geometry_read_their_own_fog_and_centre_depth() {
+        let hud = HudBatch::new([800, 450]);
+        let mut u = FrameUniforms::default();
+        u.update(&frame(&hud), &PackInputs::default(), [800, 450]);
+        let at = |name, geometry| index_in(name, geometry).unwrap();
+        assert_eq!(int(&u, at("fogMode", true)), 9729);
+        assert_eq!(int(&u, at("fogShape", true)), 1);
+        assert_eq!(int(&u, at("fogMode", false)), 0);
+        assert_eq!(int(&u, at("fogShape", false)), -1);
+        assert_eq!(at("fogStart", true), at("fogStart", false));
+        // Iris 1.11.7 (probe pack): `centerDepthSmooth` reads 0 in gbuffers programs.
+        let depth = |geometry| match u.values[at("centerDepthSmooth", geometry)] {
+            Value::F(v) => v[0],
+            _ => panic!("float uniform expected"),
+        };
+        assert_eq!(depth(true), 0.0);
+        assert_eq!(depth(false), 1.0);
+    }
+
     /// Iris 1.11.7, read frame by frame with a probe pack: eyeBrightnessSmooth falls by half
     /// in 1 s and is rounded down; wetness takes 60 s to rise halfway and 20 s to fall; the
     /// centre depth 0.1 s.

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

@@ -162,7 +162,7 @@ impl PackWeather {
 
 /// A texture holding the atlas's texels under `rect` (normalised x, y, width, height), as
 /// Horizon's weather shader reads them (`weather_texel`).
-fn copy_sprite(
+pub(super) fn copy_sprite(
     device: &wgpu::Device,
     encoder: &mut wgpu::CommandEncoder,
     atlas: &wgpu::Texture,

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

@@ -1,7 +1,8 @@
 //! Screenshots of a swapchain that cannot be copied from. OpenGL's surfaces
 //! offer `RENDER_ATTACHMENT` only, so a frame whose pixels are read back
 //! (the screenshot key, a world's icon) is drawn into a texture that can be,
-//! then drawn onto the swapchain image as a fullscreen triangle.
+//! then drawn onto the swapchain image as a fullscreen triangle. A 16-bit frame
+//! (`Renderer::frame_format`) with HDR output off goes the same way every frame.
 
 /// The texture a frame to read back is drawn into, and the pass that puts it
 /// on the swapchain afterwards.
@@ -15,18 +16,21 @@ pub struct Readback {
 
 impl Readback {
     /// The texture this frame draws into instead of the swapchain image
-    /// `surface`: `None` unless the frame is read back (`screenshot`) and the
-    /// image cannot be copied from.
+    /// `surface`, in the frame's `format`: `None` unless that differs from the
+    /// swapchain's, or the frame is read back (`screenshot`) and the image
+    /// cannot be copied from.
     pub fn target(
         &mut self,
         device: &wgpu::Device,
         surface: &wgpu::Texture,
+        format: wgpu::TextureFormat,
         screenshot: bool,
     ) -> Option<wgpu::Texture> {
-        if !screenshot || surface.usage().contains(wgpu::TextureUsages::COPY_SRC) {
+        if format == surface.format().remove_srgb_suffix()
+            && (!screenshot || surface.usage().contains(wgpu::TextureUsages::COPY_SRC))
+        {
             return None;
         }
-        let format = surface.format().remove_srgb_suffix();
         if self
             .texture
             .as_ref()
@@ -60,22 +64,57 @@ impl Readback {
         if !std::mem::take(&mut self.drawn) {
             return;
         }
-        let Some(texture) = &self.texture else {
+        let Some(texture) = self.texture.clone() else {
             return;
         };
         // The frame's passes write the swapchain through its non-sRGB view
         // (`view_formats`), so the copy goes there unconverted too.
         let format = surface.format().remove_srgb_suffix();
-        if self.blitter.as_ref().is_none_or(|b| b.0 != format) {
-            self.blitter = Some((format, wgpu::util::TextureBlitter::new(device, format)));
-        }
         let target = surface.create_view(&wgpu::TextureViewDescriptor {
             format: Some(format),
             ..Default::default()
         });
-        let source = texture.create_view(&Default::default());
+        self.blit(device, encoder, &texture, &target, format);
+    }
+
+    /// `frame` (a 16-bit frame) in an 8-bit texture of `format`, clamped to 0..1
+    /// as an 8-bit frame holds it, for a screenshot to read back.
+    pub fn unorm_copy(
+        &mut self,
+        device: &wgpu::Device,
+        encoder: &mut wgpu::CommandEncoder,
+        frame: &wgpu::Texture,
+        format: wgpu::TextureFormat,
+    ) -> wgpu::Texture {
+        let copy = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some("Horizon screenshot copy"),
+            size: frame.size(),
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+            view_formats: &[],
+        });
+        let target = copy.create_view(&Default::default());
+        self.blit(device, encoder, frame, &target, format);
+        copy
+    }
+
+    fn blit(
+        &mut self,
+        device: &wgpu::Device,
+        encoder: &mut wgpu::CommandEncoder,
+        source: &wgpu::Texture,
+        target: &wgpu::TextureView,
+        format: wgpu::TextureFormat,
+    ) {
+        if self.blitter.as_ref().is_none_or(|b| b.0 != format) {
+            self.blitter = Some((format, wgpu::util::TextureBlitter::new(device, format)));
+        }
+        let source = source.create_view(&Default::default());
         if let Some((_, blitter)) = &self.blitter {
-            blitter.copy(device, encoder, &source, &target);
+            blitter.copy(device, encoder, &source, target);
         }
     }
 }
@@ -84,6 +123,8 @@ impl Readback {
 mod tests {
     use super::*;
 
+    const F: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8Unorm;
+
     fn device() -> Option<(wgpu::Device, wgpu::Queue)> {
         let instance = crate::gfx::test_gpu::instance();
         let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
@@ -101,7 +142,7 @@ mod tests {
             mip_level_count: 1,
             sample_count: 1,
             dimension: wgpu::TextureDimension::D2,
-            format: wgpu::TextureFormat::Bgra8Unorm,
+            format: F,
             usage,
             view_formats: &[],
         })
@@ -156,7 +197,7 @@ mod tests {
             &device,
             wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
         );
-        let blitter = wgpu::util::TextureBlitter::new(&device, wgpu::TextureFormat::Bgra8Unorm);
+        let blitter = wgpu::util::TextureBlitter::new(&device, F);
         let mut readback = Readback::default();
         let colors = [
             (1.0, [0, 0, 255, 255]),
@@ -173,7 +214,7 @@ mod tests {
             let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
             let mut encoder = device.create_command_encoder(&Default::default());
             let frame = readback
-                .target(&device, &surface, true)
+                .target(&device, &surface, F, true)
                 .unwrap_or_else(|| surface.clone());
             clear(&mut encoder, &frame, color);
             let buffer = crate::gfx::copy_frame(&device, &mut encoder, &frame, [70, 3]);
@@ -205,9 +246,70 @@ mod tests {
             &device,
             wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
         );
-        assert!(readback.target(&device, &readable, true).is_none());
+        assert!(readback.target(&device, &readable, F, true).is_none());
         let surface = texture(&device, wgpu::TextureUsages::RENDER_ATTACHMENT);
-        assert!(readback.target(&device, &surface, false).is_none());
+        assert!(readback.target(&device, &surface, F, false).is_none());
         assert!(readback.texture.is_none() && !readback.drawn);
     }
+
+    /// A 16-bit frame with HDR output off draws into a 16-bit texture of its own, and both
+    /// the swapchain and a screenshot's 8-bit copy get it clamped as an 8-bit frame holds it.
+    fn reaches_an_8_bit_swapchain(
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        format: wgpu::TextureFormat,
+        color: wgpu::Color,
+        expected: [u8; 4],
+    ) {
+        let surface = texture(
+            device,
+            wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+        );
+        let mut readback = Readback::default();
+        let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
+        let mut encoder = device.create_command_encoder(&Default::default());
+        let frame = readback.target(device, &surface, format, false).unwrap();
+        assert_eq!(frame.format(), format);
+        clear(&mut encoder, &frame, color);
+        let copy = readback.unorm_copy(device, &mut encoder, &frame, F);
+        let screenshot = crate::gfx::copy_frame(device, &mut encoder, &copy, [70, 3]);
+        readback.present(device, &mut encoder, &surface);
+        let presented = crate::gfx::copy_frame(device, &mut encoder, &surface, [70, 3]);
+        queue.submit([encoder.finish()]);
+        if let Some(error) = pollster::block_on(scope.pop()) {
+            panic!("{error}");
+        }
+        assert_eq!(last_pixel(device, &screenshot), expected);
+        assert_eq!(last_pixel(device, &presented), expected);
+    }
+
+    /// `Rgba16Unorm`, the frame HDR output draws into where the device can
+    /// (`Renderer::frame_format`).
+    #[test]
+    fn a_16_bit_unorm_frame_reaches_an_8_bit_swapchain() {
+        let instance = crate::gfx::test_gpu::instance();
+        let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
+            return;
+        };
+        let wide = wgpu::Features::TEXTURE_FORMAT_16BIT_NORM
+            | wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES;
+        if !adapter.features().contains(wide) {
+            return;
+        }
+        let descriptor = wgpu::DeviceDescriptor {
+            required_features: wide,
+            ..Default::default()
+        };
+        let Ok((device, queue)) = pollster::block_on(adapter.request_device(&descriptor)) else {
+            return;
+        };
+        let color = wgpu::Color {
+            r: 1.0,
+            g: 0.2,
+            b: 0.0,
+            a: 1.0,
+        };
+        let unorm = wgpu::TextureFormat::Rgba16Unorm;
+        reaches_an_8_bit_swapchain(&device, &queue, unorm, color, [0, 51, 255, 255]);
+    }
 }

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

@@ -17,6 +17,9 @@ struct Column {
     z: i32,
     /// Section y (from the world's bottom) and slot, in no particular order.
     sections: Vec<(i32, u32)>,
+    /// Those of `sections` that are marked (`Resident::insert_marked`), in no
+    /// particular order.
+    marked: Vec<(i32, u32)>,
     /// The lowest and highest section y of `sections`.
     low: i32,
     high: i32,
@@ -36,6 +39,9 @@ pub struct Resident<T> {
     min_y: i32,
     items: Vec<(SectionKey, T)>,
     bounds: Vec<Option<[Vec3; 2]>>,
+    /// Per slot, whether the section is marked: within the render distance,
+    /// `walk` lists only those when `marked_only_near`.
+    marked: Vec<bool>,
     slots: FxHashMap<SectionKey, u32>,
     columns: Vec<Column>,
     column_index: FxHashMap<(i32, i32), u32>,
@@ -47,6 +53,7 @@ impl<T> Default for Resident<T> {
             min_y: crate::chunk::MIN_Y,
             items: Vec::new(),
             bounds: Vec::new(),
+            marked: Vec::new(),
             slots: FxHashMap::default(),
             columns: Vec::new(),
             column_index: FxHashMap::default(),
@@ -65,12 +72,13 @@ impl<T> Resident<T> {
         use std::mem::size_of;
         self.items.capacity() * size_of::<(SectionKey, T)>()
             + self.bounds.capacity() * size_of::<Option<[Vec3; 2]>>()
+            + self.marked.capacity() * size_of::<bool>()
             + self.slots.capacity() * (size_of::<(SectionKey, u32)>() + 1)
             + self.columns.capacity() * size_of::<Column>()
             + self
                 .columns
                 .iter()
-                .map(|c| c.sections.capacity() * size_of::<(i32, u32)>())
+                .map(|c| (c.sections.capacity() + c.marked.capacity()) * size_of::<(i32, u32)>())
                 .sum::<usize>()
             + self.column_index.capacity() * (size_of::<((i32, i32), u32)>() + 1)
     }
@@ -83,14 +91,23 @@ impl<T> Resident<T> {
     pub fn values_mut(&mut self) -> impl Iterator<Item = &mut T> {
         self.items.iter_mut().map(|(_, v)| v)
     }
-    /// Every section's key and value.
+    /// Every section's key, value and bounds.
     #[cfg(debug_assertions)]
-    pub fn iter(&self) -> impl Iterator<Item = (SectionKey, &T)> {
-        self.items.iter().map(|(key, value)| (*key, value))
+    pub fn iter(&self) -> impl Iterator<Item = (SectionKey, &T, Option<[Vec3; 2]>)> {
+        let items = self.items.iter().zip(&self.bounds);
+        items.map(|((key, value), bounds)| (*key, value, *bounds))
     }
-    /// Every section's key and value.
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (SectionKey, &mut T)> {
-        self.items.iter_mut().map(|(key, value)| (*key, value))
+    /// Every section's key, value and bounds.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (SectionKey, &mut T, Option<[Vec3; 2]>)> {
+        let items = self.items.iter_mut().zip(&self.bounds);
+        items.map(|((key, value), bounds)| (*key, value, *bounds))
+    }
+    /// Whether the section at `key` is marked (`insert_marked`).
+    #[cfg(any(test, debug_assertions))]
+    pub fn is_marked(&self, key: SectionKey) -> bool {
+        self.slots
+            .get(&key)
+            .is_some_and(|&slot| self.marked[slot as usize])
     }
     /// `key`'s value, when it is resident.
     pub fn find(&self, key: SectionKey) -> Option<&T> {
@@ -118,6 +135,7 @@ impl<T> Resident<T> {
     pub fn clear(&mut self) {
         self.items.clear();
         self.bounds.clear();
+        self.marked.clear();
         self.slots.clear();
         self.columns.clear();
         self.column_index.clear();
@@ -127,16 +145,31 @@ impl<T> Resident<T> {
     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.
+    /// Adds or replaces `key`'s value with optional tight geometry bounds, unmarked.
+    #[cfg(test)]
     pub fn insert_with_bounds(&mut self, key: SectionKey, value: T, bounds: Option<[Vec3; 2]>) {
+        self.insert_marked(key, value, bounds, false);
+    }
+    /// Adds or replaces `key`'s value with optional tight geometry bounds, and
+    /// whether it is marked: `walk` with `marked_only_near` lists the sections
+    /// within the render distance that are.
+    pub fn insert_marked(
+        &mut self,
+        key: SectionKey,
+        value: T,
+        bounds: Option<[Vec3; 2]>,
+        marked: bool,
+    ) {
         if let Some(&slot) = self.slots.get(&key) {
             self.items[slot as usize].1 = value;
             self.bounds[slot as usize] = bounds;
+            self.mark_slot(slot, marked);
             return;
         }
         let slot = self.items.len() as u32;
         self.items.push((key, value));
         self.bounds.push(bounds);
+        self.marked.push(marked);
         self.slots.insert(key, slot);
         let column = match self.column_index.get(&(key.0, key.2)) {
             Some(&c) => &mut self.columns[c as usize],
@@ -147,6 +180,7 @@ impl<T> Resident<T> {
                     x: key.0,
                     z: key.2,
                     sections: Vec::new(),
+                    marked: Vec::new(),
                     low: key.1,
                     high: key.1,
                 });
@@ -154,15 +188,39 @@ impl<T> Resident<T> {
             }
         };
         column.sections.push((key.1, slot));
+        if marked {
+            column.marked.push((key.1, slot));
+        }
         column.low = column.low.min(key.1);
         column.high = column.high.max(key.1);
     }
-    /// Removes every section of the `gone` columns, the others keeping their order: one
-    /// pass over the store, where `remove` moves a slot and looks its column up for each.
+    /// Marks or unmarks the section in `slot`, in its column's list too.
+    fn mark_slot(&mut self, slot: u32, marked: bool) {
+        let was = std::mem::replace(&mut self.marked[slot as usize], marked);
+        if was == marked {
+            return;
+        }
+        let (x, y, z) = self.items[slot as usize].0;
+        let column = &mut self.columns[self.column_index[&(x, z)] as usize];
+        if marked {
+            column.marked.push((y, slot));
+        } else {
+            let at = column
+                .marked
+                .iter()
+                .position(|s| s.1 == slot)
+                .expect("marked section in its column's list");
+            column.marked.swap_remove(at);
+        }
+    }
+    /// Removes every section of the `gone` columns, the others keeping their order and
+    /// marks: one pass over the store, where `remove` moves a slot and looks its column
+    /// up for each.
     pub fn remove_columns(&mut self, gone: &FxHashSet<(i32, i32)>) -> Vec<T> {
         // Every column (a far teleport): emptied, without a lookup per section.
         if self.columns.iter().all(|c| gone.contains(&(c.x, c.z))) {
             self.bounds.clear();
+            self.marked.clear();
             self.slots.clear();
             self.columns.clear();
             self.column_index.clear();
@@ -173,21 +231,23 @@ impl<T> Resident<T> {
         }
         let items = std::mem::take(&mut self.items);
         let bounds = std::mem::take(&mut self.bounds);
+        let marked = std::mem::take(&mut self.marked);
         self.slots.clear();
         self.columns.clear();
         self.column_index.clear();
         let mut removed = Vec::new();
-        for ((key, value), bounds) in items.into_iter().zip(bounds) {
+        for (((key, value), bounds), marked) in items.into_iter().zip(bounds).zip(marked) {
             if gone.contains(&(key.0, key.2)) {
                 removed.push(value);
             } else {
-                self.insert_with_bounds(key, value, bounds);
+                self.insert_marked(key, value, bounds, marked);
             }
         }
         removed
     }
     pub fn remove(&mut self, key: SectionKey) -> Option<T> {
         let slot = self.slots.remove(&key)?;
+        self.mark_slot(slot, false);
         let c = self.column_index[&(key.0, key.2)] as usize;
         let column = &mut self.columns[c];
         let at = column
@@ -206,8 +266,10 @@ impl<T> Resident<T> {
             column.bounds();
         }
         let _ = self.bounds.swap_remove(slot as usize);
+        let _ = self.marked.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.
+        // The last item now sits in `slot`: point its key and column, and its
+        // column's marked list if it is marked, at it.
         if let Some(&(moved, _)) = self.items.get(slot as usize) {
             let last = self.items.len() as u32;
             self.slots.insert(moved, slot);
@@ -218,6 +280,14 @@ impl<T> Resident<T> {
                 .find(|s| s.1 == last)
                 .expect("moved section in its column");
             entry.1 = slot;
+            if self.marked[slot as usize] {
+                let entry = column
+                    .marked
+                    .iter_mut()
+                    .find(|s| s.1 == last)
+                    .expect("moved marked section in its column's list");
+                entry.1 = slot;
+            }
         }
         Some(value)
     }
@@ -328,6 +398,22 @@ impl<T> Resident<T> {
         reachable: impl Fn(SectionKey) -> bool,
         beyond: impl Fn(i32, i32) -> bool,
         out: &mut Vec<Visible>,
+    ) {
+        self.walk(camera, radius, frustum, reachable, beyond, false, out);
+    }
+    /// `visible`, less the sections within the render distance that are not
+    /// marked (`insert_marked`) when `marked_only_near`, in the same order: GPU
+    /// culling's frames, where the GPU draws those. A column's box spans all of
+    /// its sections either way, so both decide alike on those they share.
+    pub fn walk(
+        &self,
+        camera: DVec3,
+        radius: i32,
+        frustum: &impl Cull,
+        reachable: impl Fn(SectionKey) -> bool,
+        beyond: impl Fn(i32, i32) -> bool,
+        marked_only_near: bool,
+        out: &mut Vec<Visible>,
     ) {
         let from = camera_column(camera);
         for column in &self.columns {
@@ -335,6 +421,14 @@ impl<T> Resident<T> {
             if !near && !beyond(column.x, column.z) {
                 continue;
             }
+            let list = if marked_only_near && near {
+                &column.marked
+            } else {
+                &column.sections
+            };
+            if list.is_empty() {
+                continue;
+            }
             let min = origin((column.x, column.low, column.z), self.min_y, camera).as_vec3();
             let top = origin((column.x, column.high, column.z), self.min_y, camera).as_vec3();
             let max = top + Vec3::splat(16.0);
@@ -351,7 +445,7 @@ impl<T> Resident<T> {
             let xz_sq = dx8 * dx8 + dz8 * dz8;
 
             if inside {
-                for &(y, slot) in &column.sections {
+                for &(y, slot) in list {
                     let key = (column.x, y, column.z);
                     if near && !reachable(key) {
                         continue;
@@ -368,7 +462,7 @@ impl<T> Resident<T> {
                     });
                 }
             } else {
-                for &(y, slot) in &column.sections {
+                for &(y, slot) in list {
                     let key = (column.x, y, column.z);
                     if near && !reachable(key) {
                         continue;
@@ -519,9 +613,10 @@ mod tests {
         assert_eq!(fast, slow);
     }
 
-    /// Every key reaches its value through its slot and column, and every
-    /// column's bounds and sections match the keys.
-    fn check(r: &Resident<u32>, model: &HashMap<SectionKey, u32>) {
+    /// Every key reaches its value and mark through its slot and column, every
+    /// column's bounds and sections match the keys, and its marked list holds
+    /// its marked sections.
+    fn check(r: &Resident<u32>, model: &HashMap<SectionKey, (u32, bool)>) {
         assert_eq!(r.len(), model.len());
         let mut seen = 0;
         for column in &r.columns {
@@ -532,13 +627,24 @@ mod tests {
             for &(y, slot) in &column.sections {
                 let (key, value) = &r.items[slot as usize];
                 assert_eq!(*key, (column.x, y, column.z));
-                assert_eq!(model[key], *value);
+                assert_eq!(model[key], (*value, r.marked[slot as usize]));
                 seen += 1;
             }
+            let mut marked: Vec<(i32, u32)> = column
+                .sections
+                .iter()
+                .copied()
+                .filter(|&(_, slot)| r.marked[slot as usize])
+                .collect();
+            let mut listed = column.marked.clone();
+            marked.sort_unstable();
+            listed.sort_unstable();
+            assert_eq!(listed, marked, "column ({}, {})", column.x, column.z);
         }
         assert_eq!(seen, model.len());
-        for key in model.keys() {
+        for (key, &(_, marked)) in model {
             assert!(r.contains(*key));
+            assert_eq!(r.is_marked(*key), marked, "{key:?}");
         }
     }
 
@@ -546,7 +652,12 @@ mod tests {
     fn slots_and_columns_follow_inserts_and_removals() {
         let mut r = Resident::default();
         let mut model = HashMap::new();
-        // A deterministic mix of inserts, replacements and removals.
+        // Bounds that tell values apart.
+        let bounds = |value: u32| {
+            (!value.is_multiple_of(3)).then(|| [Vec3::splat((value % 5) as f32), Vec3::splat(16.0)])
+        };
+        // A deterministic mix of inserts, replacements and removals, marked at
+        // random: a replacement can mark or unmark its section.
         let mut seed = 0x2545_f491_u32;
         for step in 0..4000u32 {
             seed ^= seed << 13;
@@ -563,47 +674,130 @@ mod tests {
                     .flat_map(|x| (-2..=2).map(move |z| (x, z)))
                     .collect();
                 let mut removed = r.remove_columns(&gone);
-                let mut expected: Vec<u32> = model.drain().map(|(_, v)| v).collect();
+                let mut expected: Vec<u32> = model.drain().map(|(_, (value, _))| value).collect();
                 removed.sort_unstable();
                 expected.sort_unstable();
                 assert_eq!(removed, expected);
                 assert!(r.columns.is_empty() && r.column_index.is_empty());
             } else if (seed >> 12).is_multiple_of(97) {
                 // Whole columns at once: the column of `key` and the next one along x.
+                // The others keep their values, bounds and marks (`check`).
                 let gone: FxHashSet<(i32, i32)> =
                     [(key.0, key.2), (key.0 + 1, key.2)].into_iter().collect();
                 let mut removed = r.remove_columns(&gone);
                 let mut expected: Vec<u32> = model
                     .extract_if(|k: &SectionKey, _| gone.contains(&(k.0, k.2)))
-                    .map(|(_, v)| v)
+                    .map(|(_, (value, _))| value)
                     .collect();
                 removed.sort_unstable();
                 expected.sort_unstable();
                 assert_eq!(removed, expected);
             } else if (seed >> 12).is_multiple_of(3) {
-                assert_eq!(r.remove(key), model.remove(&key));
+                assert_eq!(r.remove(key), model.remove(&key).map(|(value, _)| value));
             } else {
-                r.insert(key, step);
-                model.insert(key, step);
+                let marked = (seed >> 20).is_multiple_of(2);
+                r.insert_marked(key, step, bounds(step), marked);
+                model.insert(key, (step, marked));
             }
             check(&r, &model);
-            // `iter_mut` yields every key once, with its value.
+            // `iter_mut` yields every key once, with its value and bounds.
             let mut seen = HashSet::new();
-            for (key, value) in r.iter_mut() {
-                assert_eq!(*value, model[&key], "{key:?}");
+            for (key, value, b) in r.iter_mut() {
+                assert_eq!(*value, model[&key].0, "{key:?}");
+                assert_eq!(b, bounds(*value), "{key:?}");
                 assert!(seen.insert(key), "{key:?} twice");
             }
             assert_eq!(seen.len(), model.len());
         }
-        for (_, value) in r.iter_mut() {
+        for (_, value, _) in r.iter_mut() {
             *value += 1;
         }
-        for (key, value) in &model {
+        for (key, (value, _)) in &model {
             assert_eq!(r.find(*key), Some(&(value + 1)));
         }
         r.clear();
         assert_eq!(r.len(), 0);
-        assert!(r.columns.is_empty());
+        assert!(r.columns.is_empty() && r.marked.is_empty());
+    }
+
+    /// GPU frames' walk (`walk` with `marked_only_near`) is `visible` less the
+    /// sections within the render distance that are not marked, in the same
+    /// order: with marks at random, bounds reaching out of their cells, short
+    /// columns entirely inside the frustum, cave reach, and columns past the
+    /// distance kept for far terrain (GPU frames have no water mirror,
+    /// `gpu_frame`).
+    #[test]
+    fn the_marked_walk_is_the_walk_less_unmarked_sections_within_the_distance() {
+        let mut r = Resident::default();
+        let mut seed = 0x9e37_79b9_u32;
+        let mut next = || {
+            seed ^= seed << 13;
+            seed ^= seed >> 17;
+            seed ^= seed << 5;
+            seed
+        };
+        for x in -14i32..=14 {
+            for z in -14i32..=14 {
+                // Short columns ahead of the first camera: most lie entirely inside.
+                let rows = if z > 0 && x.abs() <= 12 { 3..6 } else { 0..24 };
+                for y in rows {
+                    let bits = next();
+                    if bits.is_multiple_of(5) {
+                        continue;
+                    }
+                    let bounds = match (bits >> 4) % 4 {
+                        0 => None,
+                        1 => Some([Vec3::splat(-1.5), Vec3::splat(17.5)]),
+                        2 => Some([Vec3::new(0.0, 18.0, 0.0), Vec3::new(16.0, 20.0, 16.0)]),
+                        _ => Some([Vec3::new(2.0, 0.0, 3.0), Vec3::new(14.0, 5.5, 16.0)]),
+                    };
+                    r.insert_marked((x, y, z), (), bounds, (bits >> 8).is_multiple_of(3));
+                }
+            }
+        }
+        let reachable = |k: SectionKey| (3 * k.0 + k.1 + 5 * k.2).rem_euclid(7) != 0;
+        let beyond = |x: i32, z: i32| (x - z).rem_euclid(3) == 0;
+        let projection = super::super::world_projection(70.0, 16.0 / 9.0, 512.0);
+        let (mut kept, mut dropped, mut inside) = (0, 0, 0);
+        for (camera, yaw, pitch) in [
+            (DVec3::new(0.5, -8.0, 0.5), 0.0, 5.0),
+            (DVec3::new(-37.25, 130.5, 21.75), 135.0, 35.0),
+            (DVec3::new(100.0, -60.0, -3.0), 270.0, -80.0),
+            (DVec3::new(8.0, 64.0, 8.0), 45.0, 89.0),
+        ] {
+            let view = Frustum {
+                planes: super::super::frustum(projection * crate::camera::view_matrix(yaw, pitch)),
+            };
+            inside += r
+                .columns
+                .iter()
+                .filter(|c| {
+                    let min = origin((c.x, c.low, c.z), r.min_y, camera).as_vec3();
+                    let top = origin((c.x, c.high, c.z), r.min_y, camera).as_vec3();
+                    view.contains(min, top + Vec3::splat(16.0))
+                })
+                .count();
+            for radius in [3, 7, 12] {
+                let (mut all, mut marked) = (Vec::new(), Vec::new());
+                r.visible(camera, radius, &view, reachable, beyond, &mut all);
+                r.walk(camera, radius, &view, reachable, beyond, true, &mut marked);
+                let from = camera_column(camera);
+                let near = |v: &Visible| in_view_distance(from, radius, v.key.0, v.key.2);
+                let expected: Vec<Visible> = all
+                    .iter()
+                    .copied()
+                    .filter(|v| r.is_marked(v.key) || !near(v))
+                    .collect();
+                assert_eq!(marked, expected, "{camera} {yaw} {pitch} {radius}");
+                kept += marked.len();
+                dropped += all.len() - marked.len();
+            }
+        }
+        assert!(
+            kept > 100 && dropped > 100,
+            "{kept} kept, {dropped} dropped"
+        );
+        assert!(inside > 50, "{inside} columns entirely inside");
     }
 
     /// The old walk (every key of a hash map, sorted by distance, then two

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

@@ -0,0 +1,417 @@
+//! A visibility buffer for solid terrain, opt-in with `HORIZON_VISBUFFER=1` (read once, at
+//! startup): pass 1 rasterises the solid flat draws (near sections and far tiles, phase 1 and,
+//! with occlusion culling, phase 2) writing only depth and the ID of the quad each pixel shows
+//! (`visbuffer.wgsl`'s `vis_id`: arena page and quad); cutout and fading
+//! quads keep their alpha test and dither there, the rest never discard. Pass 2 is one
+//! full-screen draw with up to `PAGE_SLOTS` arena pages bound at once (more pages, more draws)
+//! that reads the quad back from its page and its section's origin (through a copy of every
+//! drawn page's block table in one buffer), and runs terrain.wgsl's
+//! vertex work and solid shading once per pixel with analytic screen gradients. Every solid
+//! pixel is shaded once, however many quads were drawn over it and however small they are.
+//! A draw per page instead made each GPU thread group run the shading once for every page
+//! among its pixels, with most lanes idle: the pages' sections lie all over the screen.
+//!
+//! It runs only in frames drawn flat (`flat`: Metal past `flat::MIN_SECTIONS`, or
+//! `HORIZON_FLAT_DRAWS=1`) and falls back to the normal solid passes in frames with a shader
+//! pack drawing terrain, one of Horizon's own packs with a material stage or a shadow pass, a
+//! pack's surface target, and on the title screen. The water mirror's own pass stays as it is.
+use super::arena::Arena;
+use super::flat::Flat;
+use super::pack_timing::PassTiming;
+
+/// Arena pages one resolve draw reads (`visbuffer.wgsl`'s `vis_page_0`...).
+pub const PAGE_SLOTS: u32 = 16;
+/// Arena pages an ID names (`visbuffer.wgsl`'s `vis_id`): frames with more draw without it.
+pub const MAX_PAGES: u32 = 64;
+/// The resolve binds that many pages, the block tables and the origins by section id.
+const STORAGE_BUFFERS: u32 = PAGE_SLOTS + 2;
+const IDS: wgpu::TextureFormat = wgpu::TextureFormat::R32Uint;
+
+/// Whether the visibility buffer is asked for, and the device binds storage buffers enough.
+pub fn wanted(device: &wgpu::Device) -> bool {
+    std::env::var("HORIZON_VISBUFFER").as_deref() == Ok("1")
+        && device.limits().max_storage_buffers_per_shader_stage >= STORAGE_BUFFERS
+}
+
+pub struct Visbuffer {
+    /// Pass 1 over the quads `fs_opaque` draws (no discard) and the rest.
+    opaque: wgpu::RenderPipeline,
+    cutout: wgpu::RenderPipeline,
+    resolve: wgpu::RenderPipeline,
+    /// Pass 2's group 1: the block tables (binding 0), the origins by section id (1),
+    /// `PAGE_SLOTS` pages' vertices (from 2), the IDs (after them).
+    page_layout: wgpu::BindGroupLayout,
+    /// Every page's block table, page after page (`Flat::blocks_per_page` entries each),
+    /// copied each frame from the drawn pages' own, and its size in pages.
+    blocks: Option<(wgpu::Buffer, u32)>,
+    blocks_per_page: u64,
+    /// The IDs, the size of the world's depth.
+    ids: Option<(wgpu::TextureView, [u32; 2])>,
+}
+
+impl Visbuffer {
+    /// `terrain_layout`: terrain.wgsl's group 0; `flat_layout`: the flat draws' group 1;
+    /// `color`: the world pass's colour format; `constants`: the sprite arrays' pipeline
+    /// constants.
+    pub fn new(
+        device: &wgpu::Device,
+        terrain_layout: &wgpu::BindGroupLayout,
+        flat: &Flat,
+        color: wgpu::TextureFormat,
+        constants: &[(&str, f64)],
+    ) -> Self {
+        let flat_layout = &flat.draw_layout;
+        let blocks_per_page = flat.blocks_per_page();
+        let resolve_constants: Vec<(&str, f64)> = constants
+            .iter()
+            .copied()
+            .chain([("VIS_BLOCKS_PER_PAGE", blocks_per_page as f64)])
+            .collect();
+        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Horizon visibility buffer"),
+            source: wgpu::ShaderSource::Wgsl(
+                (include_str!("../terrain.wgsl").to_owned() + include_str!("../visbuffer.wgsl"))
+                    .into(),
+            ),
+        });
+        let fragment = wgpu::ShaderStages::FRAGMENT;
+        let storage = |binding| wgpu::BindGroupLayoutEntry {
+            binding,
+            visibility: fragment,
+            ty: wgpu::BindingType::Buffer {
+                ty: wgpu::BufferBindingType::Storage { read_only: true },
+                has_dynamic_offset: false,
+                min_binding_size: None,
+            },
+            count: None,
+        };
+        let entries: Vec<_> = (0..2 + PAGE_SLOTS)
+            .map(storage)
+            .chain([wgpu::BindGroupLayoutEntry {
+                binding: 2 + PAGE_SLOTS,
+                visibility: fragment,
+                ty: wgpu::BindingType::Texture {
+                    sample_type: wgpu::TextureSampleType::Uint,
+                    view_dimension: wgpu::TextureViewDimension::D2,
+                    multisampled: false,
+                },
+                count: None,
+            }])
+            .collect();
+        let page_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Visibility buffer pages"),
+            entries: &entries,
+        });
+        let id_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Visibility buffer IDs"),
+            bind_group_layouts: &[Some(terrain_layout), Some(flat_layout)],
+            ..Default::default()
+        });
+        let resolve_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Visibility buffer resolve"),
+            bind_group_layouts: &[Some(terrain_layout), Some(&page_layout)],
+            ..Default::default()
+        });
+        let ids = |label: &'static str, vertex: &'static str, fragment: &'static str| {
+            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: Some(label),
+                layout: Some(&id_layout),
+                vertex: wgpu::VertexState {
+                    module: &module,
+                    entry_point: Some(vertex),
+                    compilation_options: Default::default(),
+                    // `section_corner` reads the arena page (`flat::ARENA_BINDING`).
+                    buffers: &[],
+                },
+                primitive: wgpu::PrimitiveState {
+                    topology: wgpu::PrimitiveTopology::TriangleList,
+                    cull_mode: Some(wgpu::Face::Back),
+                    ..Default::default()
+                },
+                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: &module,
+                    entry_point: Some(fragment),
+                    compilation_options: wgpu::PipelineCompilationOptions {
+                        constants,
+                        ..Default::default()
+                    },
+                    targets: &[Some(wgpu::ColorTargetState {
+                        format: IDS,
+                        blend: None,
+                        write_mask: wgpu::ColorWrites::ALL,
+                    })],
+                }),
+                multiview_mask: None,
+                cache: None,
+            })
+        };
+        let opaque = ids("Visibility buffer opaque", "vs_vis_opaque", "fs_vis_id");
+        let cutout = ids("Visibility buffer cutout", "vs_vis_cutout", "fs_vis_cutout");
+        let resolve = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("Visibility buffer resolve"),
+            layout: Some(&resolve_layout),
+            vertex: wgpu::VertexState {
+                module: &module,
+                entry_point: Some("vs_vis_resolve"),
+                compilation_options: Default::default(),
+                buffers: &[],
+            },
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: &module,
+                entry_point: Some("fs_vis_resolve"),
+                compilation_options: wgpu::PipelineCompilationOptions {
+                    constants: &resolve_constants,
+                    ..Default::default()
+                },
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: color,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        Self {
+            opaque,
+            cutout,
+            resolve,
+            page_layout,
+            blocks: None,
+            blocks_per_page,
+            ids: None,
+        }
+    }
+
+    /// Makes the IDs the world depth's `size`, and the block tables hold the pages `flat`
+    /// draws this frame.
+    pub fn fit(&mut self, device: &wgpu::Device, size: [u32; 2], flat: &Flat) {
+        let pages = flat.calls[..flat.solid_calls]
+            .iter()
+            .map(|c| c.page + 1)
+            .max()
+            .unwrap_or(1);
+        if self.blocks.as_ref().is_none_or(|(_, n)| *n < pages) {
+            let pages = pages.next_power_of_two();
+            let buffer = device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some("Visibility buffer block tables"),
+                size: u64::from(pages) * self.blocks_per_page * 4,
+                usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
+            });
+            self.blocks = Some((buffer, pages));
+        }
+        if self.ids.as_ref().is_some_and(|(_, s)| *s == size) {
+            return;
+        }
+        let texture = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some("Visibility buffer IDs"),
+            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: IDS,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
+            view_formats: &[],
+        });
+        self.ids = Some((texture.create_view(&Default::default()), size));
+    }
+
+    /// Pass 1's render pass over the world's `depth`: the IDs cleared (`clear`, phase 1) or
+    /// kept (phase 2 of occlusion culling).
+    pub fn id_pass<'e>(
+        &self,
+        encoder: &'e mut wgpu::CommandEncoder,
+        depth: &wgpu::TextureView,
+        clear: bool,
+        timing: Option<&mut PassTiming>,
+    ) -> wgpu::RenderPass<'e> {
+        let (ids, _) = self.ids.as_ref().expect("fitted before the world pass");
+        let name = if clear {
+            "Visibility IDs"
+        } else {
+            "Visibility IDs after culling"
+        };
+        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: Some("Horizon visibility buffer"),
+            timestamp_writes: timing.and_then(|t| t.writes(name)),
+            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                view: ids,
+                resolve_target: None,
+                depth_slice: None,
+                ops: wgpu::Operations {
+                    load: if clear {
+                        wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT)
+                    } else {
+                        wgpu::LoadOp::Load
+                    },
+                    store: wgpu::StoreOp::Store,
+                },
+            })],
+            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                view: depth,
+                depth_ops: Some(wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: wgpu::StoreOp::Store,
+                }),
+                stencil_ops: None,
+            }),
+            ..Default::default()
+        })
+    }
+
+    /// Phase 1's solid calls into the IDs, as the normal passes draw them: the opaque
+    /// pipeline over `calls[..pass_calls[0]]`, the cutout one over
+    /// `calls[pass_calls[1]..phase1_calls]` (each leaves out the other's quads).
+    pub fn draw_ids<'a>(
+        &self,
+        pass: &mut wgpu::RenderPass<'_>,
+        flat: &Flat,
+        vertices: impl Fn(u32) -> wgpu::BufferSlice<'a> + Copy,
+    ) {
+        let [opaque, cutout, _] = flat.pass_calls;
+        pass.set_pipeline(&self.opaque);
+        flat.draw_paged(pass, &flat.calls[..opaque], vertices);
+        pass.set_pipeline(&self.cutout);
+        flat.draw_paged(pass, &flat.calls[cutout..flat.phase1_calls], vertices);
+    }
+
+    /// Phase 2's calls as `Flat::flatten_phase2` left them (their first instance is their
+    /// page: `Flat::page_instances`), through both pipelines.
+    pub fn draw_ids_phase2<'a>(
+        &self,
+        pass: &mut wgpu::RenderPass<'_>,
+        flat: &Flat,
+        vertices: impl Fn(u32) -> wgpu::BufferSlice<'a> + Copy,
+    ) {
+        // Phase 2 lists each section's opaque runs first, its cutout runs after.
+        let split = flat.pass_calls[2] - flat.phase1_calls;
+        let total = flat.solid_calls - flat.phase1_calls;
+        pass.set_pipeline(&self.opaque);
+        flat.draw_phase2(pass, 0..split, vertices);
+        pass.set_pipeline(&self.cutout);
+        flat.draw_phase2(pass, split..total, vertices);
+    }
+
+    /// Bytes of its block tables and IDs.
+    pub fn bytes(&self) -> u64 {
+        let blocks = self.blocks.as_ref().map_or(0, |(b, _)| b.size());
+        let ids = self
+            .ids
+            .as_ref()
+            .map_or(0, |(_, [w, h])| u64::from(*w) * u64::from(*h) * 4);
+        blocks + ids
+    }
+
+    /// Pass 2: shades the solid terrain the IDs show into `target`, the world's colour,
+    /// over the sky drawn before. `terrain`: terrain.wgsl's group 0.
+    #[allow(clippy::too_many_arguments)]
+    pub fn resolve(
+        &self,
+        device: &wgpu::Device,
+        encoder: &mut wgpu::CommandEncoder,
+        target: &wgpu::TextureView,
+        terrain: &wgpu::BindGroup,
+        flat: &Flat,
+        arena: &Arena,
+        timing: Option<&mut PassTiming>,
+    ) {
+        let (Some((ids, _)), Some((blocks, _))) = (&self.ids, &self.blocks) else {
+            return;
+        };
+        let mut pages: Vec<u32> = flat.calls[..flat.solid_calls]
+            .iter()
+            .map(|c| c.page)
+            .collect();
+        pages.sort_unstable();
+        pages.dedup();
+        let Some(&any) = pages.first() else {
+            return;
+        };
+        let table = self.blocks_per_page * 4;
+        for &page in &pages {
+            if let Some(from) = flat.block_table(page) {
+                encoder.copy_buffer_to_buffer(from, 0, blocks, u64::from(page) * table, table);
+            }
+        }
+        // Pages in groups of `PAGE_SLOTS` by number: a page's slot is its number's remainder.
+        // Slots no drawn page fills take one that is, which no pixel's ID names.
+        let mut chunks: Vec<u32> = pages.iter().map(|p| p / PAGE_SLOTS).collect();
+        chunks.dedup();
+        let groups: Vec<(u32, wgpu::BindGroup)> = chunks
+            .into_iter()
+            .map(|chunk| {
+                let mut entries = vec![
+                    wgpu::BindGroupEntry {
+                        binding: 0,
+                        resource: blocks.as_entire_binding(),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 1,
+                        resource: flat.origins().as_entire_binding(),
+                    },
+                ];
+                entries.extend((0..PAGE_SLOTS).map(|slot| {
+                    let page = chunk * PAGE_SLOTS + slot;
+                    let page = if pages.binary_search(&page).is_ok() {
+                        page
+                    } else {
+                        any
+                    };
+                    wgpu::BindGroupEntry {
+                        binding: 2 + slot,
+                        resource: arena.buffer(page).as_entire_binding(),
+                    }
+                }));
+                entries.push(wgpu::BindGroupEntry {
+                    binding: 2 + PAGE_SLOTS,
+                    resource: wgpu::BindingResource::TextureView(ids),
+                });
+                let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                    label: Some("Visibility buffer pages"),
+                    layout: &self.page_layout,
+                    entries: &entries,
+                });
+                (chunk, group)
+            })
+            .collect();
+        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: Some("Horizon visibility buffer resolve"),
+            timestamp_writes: timing.and_then(|t| t.writes("Visibility resolve")),
+            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                view: target,
+                resolve_target: None,
+                depth_slice: None,
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: wgpu::StoreOp::Store,
+                },
+            })],
+            depth_stencil_attachment: None,
+            ..Default::default()
+        });
+        pass.set_pipeline(&self.resolve);
+        pass.set_bind_group(0, terrain, &[]);
+        // The group of pages goes as the instance: each draw shades the pixels whose quad is
+        // in one of its pages (one draw, up to `PAGE_SLOTS` pages).
+        for (chunk, group) in &groups {
+            pass.set_bind_group(1, group, &[]);
+            pass.draw(0..3, *chunk..*chunk + 1);
+        }
+    }
+}

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

@@ -128,6 +128,44 @@ impl EntityCullingMode {
     }
 }
 
+/// Particle visibility strategy, independent of Entity Culling.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum ParticleCullingMode {
+    #[default]
+    Off,
+    Synchronous,
+    Asynchronous,
+}
+impl ParticleCullingMode {
+    pub const ALL: [ParticleCullingMode; 3] = [
+        ParticleCullingMode::Off,
+        ParticleCullingMode::Synchronous,
+        ParticleCullingMode::Asynchronous,
+    ];
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Off => "off",
+            Self::Synchronous => "sync",
+            Self::Asynchronous => "async",
+        }
+    }
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Off => "Off",
+            Self::Synchronous => "Synchronous",
+            Self::Asynchronous => "Asynchronous",
+        }
+    }
+    fn parse(s: &str) -> Self {
+        match s {
+            "synchronous" | "sync" => Self::Synchronous,
+            "asynchronous" | "async" => Self::Asynchronous,
+            "off" => Self::Off,
+            _ => Self::default(),
+        }
+    }
+}
+
 /// How the swapchain presents frames.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum PresentMode {
@@ -333,6 +371,13 @@ pub enum LeafCullingMode {
     /// Every leaf face, as vanilla's fancy leaves draw them.
     #[default]
     Off,
+    /// Drops a face between two leaves when the leaf it faces has a leaf or
+    /// a full opaque cube behind it too: that face only shows through two
+    /// cutout layers. The faces behind the outer layer stay, so a crown
+    /// looks the same from outside. The faced leaf must be in the section
+    /// (as `Hollow`), so the block behind it is at most a border cell of the
+    /// next section, whose edits remesh this one.
+    Hidden,
     /// Leaves surrounded on all six sides by leaves or full opaque cubes draw
     /// in the opaque layer, so their cutouts no longer show the layers behind.
     Solid,
@@ -344,8 +389,9 @@ pub enum LeafCullingMode {
     Hollow,
 }
 impl LeafCullingMode {
-    pub const ALL: [LeafCullingMode; 4] = [
+    pub const ALL: [LeafCullingMode; 5] = [
         LeafCullingMode::Off,
+        LeafCullingMode::Hidden,
         LeafCullingMode::Solid,
         LeafCullingMode::SolidAggressive,
         LeafCullingMode::Hollow,
@@ -353,6 +399,7 @@ impl LeafCullingMode {
     pub fn name(self) -> &'static str {
         match self {
             LeafCullingMode::Off => "off",
+            LeafCullingMode::Hidden => "hidden",
             LeafCullingMode::Solid => "solid",
             LeafCullingMode::SolidAggressive => "solid_aggressive",
             LeafCullingMode::Hollow => "hollow",
@@ -361,6 +408,7 @@ impl LeafCullingMode {
     pub fn label(self) -> &'static str {
         match self {
             LeafCullingMode::Off => "Off",
+            LeafCullingMode::Hidden => "Hidden Faces",
             LeafCullingMode::Solid => "Solid",
             LeafCullingMode::SolidAggressive => "Solid Aggressive",
             LeafCullingMode::Hollow => "Hollow",
@@ -473,6 +521,17 @@ pub fn translucent_batching_offered() -> bool {
     TRANSLUCENT_BATCHING_OFFERED.load(std::sync::atomic::Ordering::Relaxed)
 }
 
+static SMOOTH_GRADIENTS_OFFERED: std::sync::atomic::AtomicBool =
+    std::sync::atomic::AtomicBool::new(false);
+/// Whether the device can draw, blend and filter the 16-bit frame (`Graphics::hdr_smooth_gradients`):
+/// set when the renderer starts. Where it can't, the settings grey its switch out.
+pub fn offer_smooth_gradients(on: bool) {
+    SMOOTH_GRADIENTS_OFFERED.store(on, std::sync::atomic::Ordering::Relaxed);
+}
+pub fn smooth_gradients_offered() -> bool {
+    SMOOTH_GRADIENTS_OFFERED.load(std::sync::atomic::Ordering::Relaxed)
+}
+
 /// The farthest LOD Distance, in chunks, on integrated GPUs other than
 /// Apple's: they share the CPU's memory bandwidth, and past it far terrain
 /// costs them more frame time than it is worth.
@@ -551,6 +610,8 @@ pub struct Graphics {
     pub cave_culling: bool,
     /// Skip drawing entities hidden behind opaque terrain, synchronously or asynchronously.
     pub entity_culling: EntityCullingMode,
+    /// Skip particles outside the view or hidden behind opaque terrain.
+    pub particle_culling: ParticleCullingMode,
     /// Terrain leaf faces inside a canopy (see [`LeafCullingMode`]); `Off` draws
     /// vanilla's fancy leaves. Ignored with a resource pack that may replace
     /// the vanilla leaf models ([`Graphics::leaf_culling_effective`]).
@@ -634,6 +695,11 @@ pub struct Graphics {
     /// `batchTranslucent`: `translucentBatching`, which every save wrote as false while it was
     /// off by default and had no switch, stays ignored.
     pub translucent_batching: bool,
+    /// Smooth Gradients (HDR page, on by default): with HDR output on, the frame is drawn in
+    /// 16 bits, so dark gradients don't band (`Renderer::frame_format`). Read when a renderer
+    /// is made (start, resource-pack reload), like `translucent_batching`, where it is offered
+    /// (`smooth_gradients_offered`).
+    pub hdr_smooth_gradients: bool,
     /// The shader pack picked in `shaderpacks/` (`shader_pack_list`); empty: none. Its key is
     /// not `shaderPack`, which versions before the clean-room rewrite saved and which stays
     /// ignored.
@@ -648,6 +714,7 @@ impl Default for Graphics {
             blue_map: crate::bluemap::Settings::default(),
             cave_culling: true,
             entity_culling: EntityCullingMode::Off,
+            particle_culling: ParticleCullingMode::Off,
             leaf_culling: LeafCullingMode::Off,
             cache_shulker_boxes: false,
             // Sign text has used its renderer cache independently of the new model caches.
@@ -685,6 +752,7 @@ impl Default for Graphics {
             shadow_cache: false,
             api: GraphicsApi::Auto,
             translucent_batching: true,
+            hdr_smooth_gradients: true,
             shader_pack: String::new(),
         }
     }
@@ -741,6 +809,7 @@ impl Graphics {
                 "blueMapAutoDetect" => g.blue_map.auto_detect = flag(g.blue_map.auto_detect),
                 "caveCulling" => g.cave_culling = flag(g.cave_culling),
                 "entityCulling" => g.entity_culling = EntityCullingMode::parse(value),
+                "particleCulling" => g.particle_culling = ParticleCullingMode::parse(value),
                 "leafCulling" => g.leaf_culling = LeafCullingMode::parse(value),
                 "blockEntityCache" => {
                     let enabled = flag(false);
@@ -815,6 +884,7 @@ impl Graphics {
                 "batteryMode" => g.battery = flag(g.battery),
                 "shadowCache" => g.shadow_cache = flag(g.shadow_cache),
                 "batchTranslucent" => g.translucent_batching = flag(g.translucent_batching),
+                "hdrSmoothGradients" => g.hdr_smooth_gradients = flag(g.hdr_smooth_gradients),
                 "graphicsApi" => g.api = GraphicsApi::from_name(value).unwrap_or_default(),
                 "pickedShaderPack" => g.shader_pack = value.to_owned(),
                 "overlay" => {
@@ -831,12 +901,13 @@ impl Graphics {
     }
     pub fn serialize(&self) -> String {
         let mut text = format!(
-            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nleafCulling:{}\nblockEntityCacheShulkerBoxes:{}\nblockEntityCacheSigns:{}\nblockEntityCacheDecoratedPots:{}\nblockEntityCacheBells:{}\nblockEntityCacheChests:{}\nblockEntityCacheBanners:{}\nblockEntityCacheCopperGolemStatues:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\ntextureBudgetMiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\nditherCutoutMips:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nscreenshotQuality:{}\nframeGeneration:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\nbatchTranslucent:{}\n",
+            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nparticleCulling:{}\nleafCulling:{}\nblockEntityCacheShulkerBoxes:{}\nblockEntityCacheSigns:{}\nblockEntityCacheDecoratedPots:{}\nblockEntityCacheBells:{}\nblockEntityCacheChests:{}\nblockEntityCacheBanners:{}\nblockEntityCacheCopperGolemStatues:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\ntextureBudgetMiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\nditherCutoutMips:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nscreenshotQuality:{}\nframeGeneration:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\nbatchTranslucent:{}\nhdrSmoothGradients:{}\n",
             self.preset.name(),
             self.lod_distance,
             self.far_detail.name(),
             bool_text(self.cave_culling),
             self.entity_culling.name(),
+            self.particle_culling.name(),
             self.leaf_culling.name(),
             bool_text(self.cache_shulker_boxes),
             bool_text(self.cache_signs),
@@ -881,6 +952,7 @@ impl Graphics {
             self.api.name(),
             self.shader_pack,
             bool_text(self.translucent_batching),
+            bool_text(self.hdr_smooth_gradients),
         );
         text += &self.blue_map.serialize();
         text
@@ -896,6 +968,11 @@ impl Graphics {
     pub fn save(&self, dir: &Path) {
         let _ = fs::write(dir.join(FILE), self.serialize());
     }
+    /// Whether a renderer made now draws its frame in 16 bits (`Renderer::new`'s `wide_frame`):
+    /// HDR on, with Smooth Gradients.
+    pub fn wide_frame(&self) -> bool {
+        self.hdr && self.hdr_smooth_gradients
+    }
     /// Paper white, in nits: the player's, or on Auto the desktop's SDR white as the
     /// system reports it, else 203 (BT.2408's reference white).
     pub fn paper_white_nits(&self) -> u32 {
@@ -1015,6 +1092,7 @@ mod tests {
             },
             cave_culling: false,
             entity_culling: EntityCullingMode::Synchronous,
+            particle_culling: ParticleCullingMode::Asynchronous,
             leaf_culling: LeafCullingMode::SolidAggressive,
             cache_shulker_boxes: true,
             cache_signs: true,
@@ -1051,6 +1129,7 @@ mod tests {
             shadow_cache: true,
             api: GraphicsApi::Dx12,
             translucent_batching: false,
+            hdr_smooth_gradients: false,
             shader_pack: "Golden Hour".into(),
         };
         assert_eq!(Graphics::parse(&g.serialize()), g);
@@ -1061,6 +1140,16 @@ mod tests {
             };
             assert_eq!(Graphics::parse(&graphics.serialize()), graphics);
         }
+        for mode in ParticleCullingMode::ALL {
+            let graphics = Graphics {
+                particle_culling: mode,
+                ..Graphics::default()
+            };
+            assert_eq!(
+                Graphics::parse(&graphics.serialize()).particle_culling,
+                mode
+            );
+        }
         assert_eq!(
             Graphics::parse("entityCulling:true\n").entity_culling,
             EntityCullingMode::Synchronous
@@ -1082,6 +1171,10 @@ mod tests {
         // off by default, not a choice.
         assert!(Graphics::default().translucent_batching);
         assert!(!Graphics::parse("batchTranslucent:false\n").translucent_batching);
+        // Smooth Gradients is on, and draws a 16-bit frame only with HDR on.
+        assert!(Graphics::default().hdr_smooth_gradients && !Graphics::default().wide_frame());
+        assert!(Graphics::parse("hdr:true\n").wide_frame());
+        assert!(!Graphics::parse("hdr:true\nhdrSmoothGradients:false\n").wide_frame());
         assert!(Graphics::parse("translucentBatching:false\n").translucent_batching);
         // 0 is Auto; anything else is a peak the slider reaches.
         assert_eq!(Graphics::parse("hdrPeak:0\n").hdr_peak, 0);

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

@@ -209,7 +209,29 @@ pub fn button(
     }
     let color = if live { WHITE } else { MUTED };
     let ty = y + ((h - 8.0) / 2.0).floor();
-    ui::centered_text(batch, atlas, label, x + 2.0, ty, w - 4.0, color);
+    scrolling_label(batch, atlas, label, [x + 2.0, ty, w - 4.0], (y, h), color);
+}
+/// A widget label of `[left, y, width]` inside the widget's `(top, height)`: centred when it fits,
+/// else slid (vanilla `AbstractWidget.extractScrollingStringOverContents`) and clipped to the box.
+fn scrolling_label(
+    batch: &mut HudBatch,
+    atlas: &HudAtlas,
+    text: &Text,
+    [left, y, width]: [f32; 3],
+    (top, height): (f32, f32),
+    color: u32,
+) {
+    ui::scrolling_text(
+        batch,
+        atlas,
+        text,
+        left,
+        left + width,
+        top,
+        top + height,
+        y,
+        color,
+    );
 }
 /// A slider: its value over a thin track filled in the accent up to the handle at `position`.
 pub fn slider(
@@ -222,7 +244,14 @@ pub fn slider(
 ) {
     let [x, y, w, h] = rect;
     let color = if live { WHITE } else { MUTED };
-    ui::centered_text(batch, atlas, value, x + 2.0, y + 1.0, w - 4.0, color);
+    scrolling_label(
+        batch,
+        atlas,
+        value,
+        [x + 2.0, y + 1.0, w - 4.0],
+        (y, h),
+        color,
+    );
     let line = y + h - 3.0;
     let at = x + (position.clamp(0.0, 1.0) * (w - 4.0)).round();
     fill(batch, atlas, [x, line, w, 2.0], TRACK);
@@ -260,7 +289,7 @@ pub fn cycler(
         (true, true) => WHITE,
         (true, false) => SOFT,
     };
-    batch.text_styled(atlas, value, x + 9.0, ty, color, true);
+    scrolling_label(batch, atlas, value, [x + 9.0, ty, w - 18.0], (y, h), color);
 }
 /// A screen's title, centred at the top (split-screen profiles).
 pub fn title(batch: &mut HudBatch, atlas: &HudAtlas, text: &Text) {
@@ -271,3 +300,76 @@ pub fn title(batch: &mut HudBatch, atlas: &HudAtlas, text: &Text) {
 pub fn cost_color(cost: Cost) -> u32 {
     hex(cost.rgb(), 255)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn atlas() -> HudAtlas {
+        HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")).unwrap()
+    }
+
+    fn x_span(batch: &HudBatch, plain: &HudBatch) -> (f32, f32) {
+        let label = |v: &&crate::hud::HudVertex| !plain.vertices.iter().any(|p| p.pos == v.pos);
+        batch
+            .vertices
+            .iter()
+            .filter(label)
+            .map(|v| v.pos[0])
+            .fold((f32::INFINITY, f32::NEG_INFINITY), |(lo, hi), x| {
+                (lo.min(x), hi.max(x))
+            })
+    }
+
+    /// A label wider than its widget slides inside the widget's box instead of being cut by
+    /// characters; a short one stays centred.
+    #[test]
+    fn long_labels_stay_in_the_widget_and_short_ones_centred() {
+        let atlas = atlas();
+        let rect = [10.0, 20.0, 100.0, 20.0];
+        let long = Text::literal("Graphics API: Prefer Vulkan (Experimental)");
+        assert!(atlas.font.width_text(&long.resolved()) > rect[2]);
+        let short = Text::literal("Done");
+        let short_w = atlas.font.width_text(&short.resolved());
+        let draws: [(&str, fn(&mut HudBatch, &HudAtlas, [f32; 4], &Text)); 3] = [
+            ("button", |b, a, r, t| {
+                button(b, a, r, t, (false, true, false))
+            }),
+            ("slider", |b, a, r, t| {
+                slider(b, a, r, t, 0.5, (false, true))
+            }),
+            ("cycler", |b, a, r, t| cycler(b, a, r, t, (false, true))),
+        ];
+        for (name, draw) in draws {
+            let mut plain = HudBatch::new([640, 480]);
+            draw(&mut plain, &atlas, rect, &Text::empty());
+            let base = plain.vertices.len();
+            let mut batch = HudBatch::new([640, 480]);
+            draw(&mut batch, &atlas, rect, &long);
+            assert!(batch.vertices.len() > base, "{name}: long label drawn");
+            // The widget's own fill, track and handle also draw: only the label's vertices count.
+            let label = batch
+                .vertices
+                .iter()
+                .filter(|v| !plain.vertices.iter().any(|p| p.pos == v.pos));
+            for v in label {
+                assert!(
+                    (rect[0]..=rect[0] + rect[2]).contains(&v.pos[0])
+                        && (rect[1]..=rect[1] + rect[3]).contains(&v.pos[1]),
+                    "{name}: {:?} outside the widget",
+                    v.pos
+                );
+            }
+            // The label's own glyphs (past the widget's fill) start centred.
+            let mut batch = HudBatch::new([640, 480]);
+            draw(&mut batch, &atlas, rect, &short);
+            let (lo, hi) = x_span(&batch, &plain);
+            let middle = (lo + hi) / 2.0;
+            let want = rect[0] + rect[2] / 2.0;
+            assert!(
+                (middle - want).abs() <= short_w / 2.0 + 2.0 && (middle - want).abs() < 3.0,
+                "{name}: centre {middle}, want {want}"
+            );
+        }
+    }
+}

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

@@ -7,7 +7,7 @@
 use crate::{
     graphics::{
         EntityCullingMode, FarDetail, FrameGeneration, GraphicsApi, LeafCullingMode, Overlay,
-        Pacing, PresentMode, Preset, Upscaling,
+        Pacing, ParticleCullingMode, PresentMode, Preset, Upscaling,
     },
     graphics_style::{self as style, Cost},
     hud::{HudAtlas, HudBatch},
@@ -66,6 +66,7 @@ pub enum H {
     BlueMapRadius,
     CaveCulling,
     EntityCulling,
+    ParticleCulling,
     LeafCulling,
     CacheShulkerBoxes,
     CacheSigns,
@@ -103,6 +104,7 @@ pub enum H {
     ShadowCache,
     GraphicsApi,
     TranslucentBatching,
+    HdrSmoothGradients,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -379,6 +381,11 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
                             None,
                             "Hides entities behind opaque blocks.",
                         ),
+                        h(
+                            H::ParticleCulling,
+                            None,
+                            "Skips offscreen, subpixel and terrain-hidden particles.",
+                        ),
                         h(
                             H::LeafCulling,
                             Saves,
@@ -490,6 +497,11 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
                             None,
                             "Lava, fire and sunlight shine brighter than white. Needs an HDR display.",
                         ),
+                        h(
+                            H::HdrSmoothGradients,
+                            Low,
+                            "16-bit frame: dark skies and shadows don't band. A bit more VRAM. Next start.",
+                        ),
                         h(
                             H::HdrCalibrate,
                             None,
@@ -620,6 +632,9 @@ fn description(item: Item, s: &Settings, text: &'static str) -> &'static str {
         },
         (Item::Horizon(H::LeafCulling), _) => match s.horizon.leaf_culling {
             LeafCullingMode::Off => "Every leaf face. Vanilla's fancy leaves.",
+            LeafCullingMode::Hidden => {
+                "Drops leaf faces behind two leaf layers: faster, same crowns."
+            }
             LeafCullingMode::Solid => {
                 "Leaves fully inside a canopy draw solid: fewer see-through layers."
             }
@@ -628,6 +643,15 @@ fn description(item: Item, s: &Settings, text: &'static str) -> &'static str {
             }
             LeafCullingMode::Hollow => "Drops faces between leaves: faster, but gaps look through.",
         },
+        (Item::Horizon(H::ParticleCulling), _) => match s.horizon.particle_culling {
+            ParticleCullingMode::Off => "Draws every particle.",
+            ParticleCullingMode::Synchronous => {
+                "Skips offscreen, subpixel and terrain-hidden particles."
+            }
+            ParticleCullingMode::Asynchronous => {
+                "Skips offscreen, subpixel and terrain-hidden particles with less render-thread work."
+            }
+        },
         _ => text,
     }
 }
@@ -719,6 +743,7 @@ impl H {
             ),
             H::CaveCulling => labelled("Cave Culling", on_off(g.cave_culling)),
             H::EntityCulling => labelled("Entity Culling", g.entity_culling.label()),
+            H::ParticleCulling => labelled("Particle Culling", g.particle_culling.label()),
             H::LeafCulling => labelled("Leaf Culling", g.leaf_culling.label()),
             H::CacheShulkerBoxes => labelled("Shulker Boxes", on_off(g.cache_shulker_boxes)),
             H::CacheSigns => labelled("Signs", on_off(g.cache_signs)),
@@ -805,12 +830,16 @@ impl H {
             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()),
-            // Greyed out where the device can't (`Item::blocked`): Off, as it is there,
-            // while the saved value waits for a device that can.
+            // These two are greyed out where the device can't (`Item::blocked`): Off, as
+            // they are there, while the saved value waits for a device that can.
             H::TranslucentBatching => labelled(
                 "Translucent Batching",
                 on_off(g.translucent_batching && crate::graphics::translucent_batching_offered()),
             ),
+            H::HdrSmoothGradients => labelled(
+                "Smooth Gradients",
+                on_off(g.hdr_smooth_gradients && crate::graphics::smooth_gradients_offered()),
+            ),
             H::Overlay => labelled(
                 "Performance Overlay",
                 match g.overlay {
@@ -871,6 +900,9 @@ impl H {
             H::EntityCulling => {
                 g.entity_culling = step(&EntityCullingMode::ALL, g.entity_culling, back)
             }
+            H::ParticleCulling => {
+                g.particle_culling = step(&ParticleCullingMode::ALL, g.particle_culling, back)
+            }
             H::LeafCulling => {
                 g.leaf_culling = step(&LeafCullingMode::ALL, g.leaf_culling, back);
             }
@@ -920,6 +952,7 @@ impl H {
             H::ShadowCache => g.shadow_cache = !g.shadow_cache,
             H::GraphicsApi => g.api = step(GraphicsApi::choices(), g.api, back),
             H::TranslucentBatching => g.translucent_batching = !g.translucent_batching,
+            H::HdrSmoothGradients => g.hdr_smooth_gradients = !g.hdr_smooth_gradients,
             H::Pacing => {
                 g.pacing = match g.pacing {
                     Pacing::Efficient => Pacing::Precise,
@@ -951,7 +984,8 @@ impl Item {
     /// folder, a display swapped for an SDR one: the renderer leaves HDR off there, and
     /// the saved values wait for an HDR display), and its sliders do something only
     /// while it is on; Translucent Batching switches only where the device can batch
-    /// (`graphics::translucent_batching_offered`), its saved value waiting for one that can.
+    /// (`graphics::translucent_batching_offered`), its saved value waiting for one that can,
+    /// and Smooth Gradients only where it can draw the 16-bit frame, the same way.
     fn blocked(self, s: &Settings) -> Option<&'static str> {
         if !self.available() {
             return Some("This feature is not yet available in Horizon.");
@@ -963,16 +997,23 @@ impl Item {
                 | H::HdrBlackLevel
                 | H::HdrPeak
                 | H::HdrPaperWhite
-                | H::HdrUiBrightness,
+                | H::HdrUiBrightness
+                | H::HdrSmoothGradients,
             ) if !crate::graphics::hdr_offered() => {
                 Some("Your display or system doesn't offer HDR output.")
             }
+            Item::Horizon(H::HdrSmoothGradients)
+                if !crate::graphics::smooth_gradients_offered() =>
+            {
+                Some("Your GPU or graphics API doesn't support it.")
+            }
             Item::Horizon(
                 H::HdrCalibrate
                 | H::HdrBlackLevel
                 | H::HdrPeak
                 | H::HdrPaperWhite
-                | H::HdrUiBrightness,
+                | H::HdrUiBrightness
+                | H::HdrSmoothGradients,
             ) if !s.horizon.hdr => Some("Turn HDR on to use it."),
             Item::Horizon(H::TranslucentBatching)
                 if !crate::graphics::translucent_batching_offered() =>
@@ -1010,6 +1051,9 @@ impl Item {
             Item::Horizon(H::BatteryMode) => g.battery,
             Item::Horizon(H::ShadowCache) => g.shadow_cache,
             Item::Horizon(H::TranslucentBatching) => g.translucent_batching,
+            Item::Horizon(H::HdrSmoothGradients) => {
+                g.hdr_smooth_gradients && crate::graphics::smooth_gradients_offered()
+            }
             Item::Vanilla(Opt::ViewBobbing) => s.view_bobbing,
             Item::Vanilla(Opt::Vsync) => s.vsync,
             Item::Vanilla(Opt::Fullscreen) => s.fullscreen,
@@ -1076,6 +1120,7 @@ impl Item {
                     | H::ShadowCache
                     | H::GraphicsApi
                     | H::TranslucentBatching
+                    | H::HdrSmoothGradients
             ) | Item::Vanilla(
                 Opt::GuiScale
                     | Opt::Fullscreen
@@ -1902,6 +1947,7 @@ impl GraphicsUi {
         framebuffer: [i32; 2],
         drag: bool,
         right: bool,
+        shift: bool,
     ) -> Vec<Action> {
         self.keep(s);
         let (cols, lines, content) = self.layout(s, w, h);
@@ -1979,7 +2025,7 @@ impl GraphicsUi {
             return Vec::new();
         }
         self.focus = Some(Target::Item(item));
-        let actions = self.activate(s, item, false, framebuffer, Some((x, &cols)));
+        let actions = self.activate(s, item, shift, framebuffer, Some((x, &cols)));
         self.mark(&actions);
         actions
     }
@@ -2358,7 +2404,15 @@ mod tests {
         [cols.list_x, ui.row_y(&cols, &line), cols.list_w, style::ROW]
     }
     fn press(ui: &mut GraphicsUi, s: &mut Settings, (x, y): (f32, f32)) -> Vec<Action> {
-        ui.click(s, (x, y), SIZE, FB, false, false)
+        ui.click(s, (x, y), SIZE, FB, false, false, false)
+    }
+    fn press_shift(
+        ui: &mut GraphicsUi,
+        s: &mut Settings,
+        (x, y): (f32, f32),
+        shift: bool,
+    ) -> Vec<Action> {
+        ui.click(s, (x, y), SIZE, FB, false, false, shift)
     }
 
     #[test]
@@ -2449,7 +2503,15 @@ mod tests {
         assert!(y >= 0.0 && x + w <= size.0);
         // Undo, over Done, stays clear of the page list.
         assert!(cols.button(1)[1] >= y + h);
-        ui.click(&mut s, (x + w / 2.0, y + h / 2.0), size, FB, false, false);
+        ui.click(
+            &mut s,
+            (x + w / 2.0, y + h / 2.0),
+            size,
+            FB,
+            false,
+            false,
+            false,
+        );
         let (_, lines, _) = ui.layout(&s, size.0, size.1);
         assert_eq!(ui.current(&lines), Some(Page::Hdr));
     }
@@ -2566,7 +2628,7 @@ mod tests {
         );
         assert_eq!(H::ChunkUpdates.slider(&s), Some(1.0));
         assert_eq!(
-            ui.click(&mut s, (-100.0, -100.0), SIZE, FB, true, false),
+            ui.click(&mut s, (-100.0, -100.0), SIZE, FB, true, false, false),
             [Action::SliderDrag]
         );
         assert_eq!(H::ChunkUpdates.slider(&s), Some(0.0));
@@ -2574,6 +2636,31 @@ mod tests {
         assert!(!ui.release());
     }
 
+    #[test]
+    fn smooth_gradients_wait_for_a_device_that_draws_the_16_bit_frame() {
+        let _offer = HDR_OFFER.lock().unwrap_or_else(|e| e.into_inner());
+        crate::graphics::offer_hdr(true);
+        let mut s = Settings::default();
+        s.horizon.hdr = true;
+        let item = Item::Horizon(H::HdrSmoothGradients);
+        // Where the device can't, the saved On reads Off.
+        crate::graphics::offer_smooth_gradients(false);
+        assert_eq!(
+            item.blocked(&s),
+            Some("Your GPU or graphics API doesn't support it.")
+        );
+        assert_eq!(item.label(&s).plain(), "Smooth Gradients: Off");
+        assert_eq!(item.switch(&s), Some(false));
+        assert!(s.horizon.hdr_smooth_gradients);
+        // Where it can, it waits only for HDR, like the rest of the page.
+        crate::graphics::offer_smooth_gradients(true);
+        assert_eq!(item.blocked(&s), None);
+        assert_eq!(item.label(&s).plain(), "Smooth Gradients: On");
+        assert_eq!(item.switch(&s), Some(true));
+        s.horizon.hdr = false;
+        assert_eq!(item.blocked(&s), Some("Turn HDR on to use it."));
+    }
+
     #[test]
     fn hdr_waits_for_a_display_that_offers_it_and_its_sliders_for_the_switch() {
         let _offer = HDR_OFFER.lock().unwrap_or_else(|e| e.into_inner());
@@ -2638,7 +2725,7 @@ mod tests {
         let (cols, _, content) = ui.layout(&s, SIZE.0, SIZE.1);
         let x = cols.bar_x() + 2.0;
         let drag = |ui: &mut GraphicsUi, s: &mut Settings, y, drag| {
-            ui.click(s, (x, y), SIZE, FB, drag, false)
+            ui.click(s, (x, y), SIZE, FB, drag, false, false)
         };
         assert!(drag(&mut ui, &mut s, cols.top + 5.0, false).is_empty());
         drag(&mut ui, &mut s, cols.top + 15.0, true);
@@ -2658,13 +2745,13 @@ mod tests {
         let mut ui = GraphicsUi::default();
         let (cols, ..) = ui.layout(&s, SIZE.0, SIZE.1);
         let x = cols.bar_x() + 2.0;
-        ui.click(&mut s, (x, cols.top + 5.0), SIZE, FB, false, false);
+        ui.click(&mut s, (x, cols.top + 5.0), SIZE, FB, false, false, false);
         assert!(ui.scroll.held());
         // A 130-high GUI leaves the list under the 40 px the scroller's thumb needs.
         let short = (SIZE.0, 130.0);
         assert!(!Columns::of(short.0, short.1).scrolls());
         assert!(
-            ui.click(&mut s, (x, 80.0), short, FB, true, false)
+            ui.click(&mut s, (x, 80.0), short, FB, true, false, false)
                 .is_empty()
         );
         assert!(!ui.scroll.held());
@@ -2974,6 +3061,92 @@ mod tests {
         assert_eq!(item.label(&s).plain(), "Entity Culling: Asynchronous");
     }
 
+    #[test]
+    fn particle_culling_modes_are_opt_in_and_cycle_from_its_row() {
+        let mut s = Settings::default();
+        let item = Item::Horizon(H::ParticleCulling);
+        assert_eq!(s.horizon.particle_culling, ParticleCullingMode::Off);
+        assert_eq!(item.label(&s).plain(), "Particle Culling: Off");
+        for mode in ParticleCullingMode::ALL {
+            s.horizon.particle_culling = mode;
+            for preset in Preset::ALL {
+                crate::graphics::apply_preset(preset, &mut s);
+                assert_eq!(s.horizon.particle_culling, mode);
+            }
+            assert_eq!(
+                crate::graphics::Graphics::parse(&s.horizon.serialize()).particle_culling,
+                mode
+            );
+        }
+        s.horizon.particle_culling = ParticleCullingMode::Off;
+        let mut ui = GraphicsUi::default();
+        let r = row(&mut ui, &s, item);
+        for (mode, label) in [
+            (ParticleCullingMode::Synchronous, "Synchronous"),
+            (ParticleCullingMode::Asynchronous, "Asynchronous"),
+            (ParticleCullingMode::Off, "Off"),
+        ] {
+            s.horizon.preset = Preset::Balanced;
+            assert_eq!(
+                press(&mut ui, &mut s, (r[0] + 4.0, r[1] + 4.0)),
+                [Action::ButtonClick, Action::Changed]
+            );
+            assert_eq!(s.horizon.particle_culling, mode);
+            assert_eq!(s.horizon.preset, Preset::Custom);
+            assert_eq!(item.label(&s).plain(), format!("Particle Culling: {label}"));
+        }
+    }
+
+    #[test]
+    fn graphics_cycle_button_cycles_forward_and_shift_click_cycles_backward_with_wrapping() {
+        let mut s = Settings::default();
+        let item = Item::Horizon(H::EntityCulling);
+        let mut ui = GraphicsUi::default();
+        let r = row(&mut ui, &s, item);
+        let at = (r[0] + 4.0, r[1] + 4.0);
+
+        // 1. Feature without shift (normal click): cycles forward (+1)
+        assert_eq!(s.horizon.entity_culling, EntityCullingMode::Off);
+        assert_eq!(
+            press_shift(&mut ui, &mut s, at, false),
+            [Action::ButtonClick, Action::Changed]
+        );
+        assert_eq!(s.horizon.entity_culling, EntityCullingMode::Synchronous);
+
+        assert_eq!(
+            press_shift(&mut ui, &mut s, at, false),
+            [Action::ButtonClick, Action::Changed]
+        );
+        assert_eq!(s.horizon.entity_culling, EntityCullingMode::Asynchronous);
+
+        // 3. Wrap-around forward (at max value, normal click wraps to min / 0)
+        assert_eq!(
+            press_shift(&mut ui, &mut s, at, false),
+            [Action::ButtonClick, Action::Changed]
+        );
+        assert_eq!(s.horizon.entity_culling, EntityCullingMode::Off);
+
+        // 4. Wrap-around backward (at min / 0, shift-click wraps to max)
+        assert_eq!(
+            press_shift(&mut ui, &mut s, at, true),
+            [Action::ButtonClick, Action::Changed]
+        );
+        assert_eq!(s.horizon.entity_culling, EntityCullingMode::Asynchronous);
+
+        // 2. Feature with shift: cycles backward (-1)
+        assert_eq!(
+            press_shift(&mut ui, &mut s, at, true),
+            [Action::ButtonClick, Action::Changed]
+        );
+        assert_eq!(s.horizon.entity_culling, EntityCullingMode::Synchronous);
+
+        assert_eq!(
+            press_shift(&mut ui, &mut s, at, true),
+            [Action::ButtonClick, Action::Changed]
+        );
+        assert_eq!(s.horizon.entity_culling, EntityCullingMode::Off);
+    }
+
     /// Translucent Batching: a switch on the Advanced page, on by default, no part of a
     /// preset, and greyed out, reading Off, where the device can't batch.
     #[test]
@@ -3031,7 +3204,7 @@ mod tests {
         let item = Item::Horizon(H::LeafCulling);
         assert_eq!(item.switch(&s), None);
         assert_eq!(item.label(&s).plain(), "Leaf Culling: Off");
-        for label in ["Solid", "Solid Aggressive", "Hollow", "Off"] {
+        for label in ["Hidden Faces", "Solid", "Solid Aggressive", "Hollow", "Off"] {
             item.cycle(&mut s, false, FB);
             assert_eq!(item.label(&s).plain(), format!("Leaf Culling: {label}"));
             assert_eq!(
@@ -3050,7 +3223,12 @@ mod tests {
             .unwrap();
         assert_eq!(culling.0, Page::Performance);
         let block: Vec<Item> = culling.1.iter().map(|r| r.item).collect();
-        for h in [H::CaveCulling, H::EntityCulling, H::LeafCulling] {
+        for h in [
+            H::CaveCulling,
+            H::EntityCulling,
+            H::ParticleCulling,
+            H::LeafCulling,
+        ] {
             assert!(block.contains(&Item::Horizon(h)), "{h:?}");
         }
         // The block-entity caches are the group after it, in this order.
@@ -3101,7 +3279,7 @@ mod tests {
             press(&mut ui, &mut s, (r[0] + 4.0, r[1] + 4.0)),
             [Action::ButtonClick, Action::Changed]
         );
-        assert_eq!(s.horizon.leaf_culling, LeafCullingMode::Solid);
+        assert_eq!(s.horizon.leaf_culling, LeafCullingMode::Hidden);
         assert_eq!(s.horizon.preset, Preset::Custom);
     }
 
@@ -3266,36 +3444,47 @@ mod tests {
         let mut s = Settings::default();
         s.horizon.leaf_culling = LeafCullingMode::Hollow;
         s.horizon.entity_culling = EntityCullingMode::Asynchronous;
-        for (code, leaf, entity, leaf_text) in [
+        s.horizon.particle_culling = ParticleCullingMode::Asynchronous;
+        for (code, leaf, entity, leaf_text, particle, particle_text) in [
             (
                 "de_de",
                 "Laub-Culling: Hohl",
                 "Objekt-Culling: Asynchron",
                 "Lässt Flächen zwischen Blättern weg: schneller, aber Lücken sind durchsichtig.",
+                "Partikel-Culling: Asynchron",
+                "Überspringt Partikel außerhalb des Bildes, unterhalb eines Pixels oder hinter Terrain und entlastet den Render-Thread.",
             ),
             (
                 "pl_pl",
                 "Pomijanie liści: Puste",
                 "Pomijanie bytów: Asynchroniczne",
                 "Pomija ściany między liśćmi: szybciej, ale luki są przezroczyste.",
+                "Pomijanie cząsteczek: Asynchroniczne",
+                "Pomija cząsteczki poza ekranem, mniejsze niż piksel i zasłonięte przez teren, odciążając wątek renderowania.",
             ),
             (
                 "uk_ua",
                 "Відсікання листя: Порожнє",
                 "Відсік. сутностей: Асинхронно",
                 "Прибирає грані між листям: швидше, але прогалини прозорі.",
+                "Відсікання частинок: Асинхронно",
+                "Пропускає частинки поза екраном, менші за піксель і закриті місцевістю, зменшуючи роботу потоку рендерингу.",
             ),
             (
                 "zh_cn",
                 "树叶剔除: 镂空",
                 "实体剔除: 异步",
                 "省略树叶之间的面：更快，但缝隙会透视。",
+                "粒子剔除: 异步",
+                "跳过屏幕外、小于一个像素和被地形遮挡的粒子，减少渲染线程的工作量。",
             ),
             (
                 "fr_fr",
                 "Occlusion feuillage: Creux",
                 "Occlusion des entités: Asynchrone",
                 "Supprime les faces entre feuilles : plus rapide, mais on voit à travers les trous.",
+                "Occlusion des particules: Asynchrone",
+                "Ignore les particules hors écran, trop petites ou masquées par le terrain avec moins de travail sur le thread de rendu.",
             ),
         ] {
             let (shown, _) = lang::scoped(lang::Language::load(&[], code), || {
@@ -3304,11 +3493,19 @@ mod tests {
                     item(H::LeafCulling).label(&s).plain(),
                     item(H::EntityCulling).label(&s).plain(),
                     lang::get(description(item(H::LeafCulling), &s, "")),
+                    item(H::ParticleCulling).label(&s).plain(),
+                    lang::get(description(item(H::ParticleCulling), &s, "")),
                 )
             });
             assert_eq!(
                 shown,
-                (leaf.into(), entity.into(), leaf_text.into()),
+                (
+                    leaf.into(),
+                    entity.into(),
+                    leaf_text.into(),
+                    particle.into(),
+                    particle_text.into(),
+                ),
                 "{code}"
             );
         }

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

@@ -58,6 +58,14 @@ fn shows_world(c: vec3<f32>, w: vec3<f32>) -> bool {
     return f <= 1.01 && f > 0.02 && all(abs(c - f * w) <= 0.03 * w + 1.0 / 255.0);
 }
 
+// A texel with its alpha as an 8-bit frame holds it. A 16-bit frame
+// (Renderer::frame_format) keeps alpha between 8-bit steps, where the marks below
+// would read differently (an alpha of 0.001 would count as the hand); its colour
+// keeps the gradients 8 bits would band. On an 8-bit frame nothing changes.
+fn frame_texel(v: vec4<f32>) -> vec4<f32> {
+    return vec4(saturate(v.rgb), round(saturate(v.a) * 255.0) / 255.0);
+}
+
 // Linear BT.709 to BT.2020 (ITU-R BT.2087), columns first.
 const BT709_TO_BT2020 = mat3x3<f32>(
     vec3(0.6274, 0.0691, 0.0164),
@@ -152,7 +160,7 @@ fn calibration_nits(p: vec2<f32>, size: vec2<f32>) -> f32 {
         }
         return vec4(nits / 80.0, 1.0);
     }
-    let f = textureLoad(frame, at, 0);
+    let f = frame_texel(textureLoad(frame, at, 0));
     let c = f.rgb;
     // What covers the world here (Hdr::keep_world): nothing at 0, the hand at
     // 1/255 (Hdr::mark_hand: drawn at the world's brightness), else the HUD or a
@@ -162,7 +170,7 @@ fn calibration_nits(p: vec2<f32>, size: vec2<f32>) -> f32 {
     let ui = select(f.a, 0.0, hand);
     // Gamma 2.2, as SDR displays and the compositors' SDR paths decode it.
     var light = pow(max(c, vec3(0.0)), vec3(2.2));
-    let w = textureLoad(world, at, 0);
+    let w = frame_texel(textureLoad(world, at, 0));
     // The world's alpha is below 0.75 on light sources, the sun and the moon
     // (terrain.wgsl, entity.wgsl): only those shine, and only where nothing was
     // drawn over them since: grey text over the white sun still looks like the sun

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

@@ -96,6 +96,9 @@ pub struct HudAtlas {
     /// A resource pack's own `core/text` shader for the GUI's text, translated;
     /// none draws the text natively.
     pub text_shader: Option<std::sync::Arc<horizon_shaders::CoreProgram>>,
+    /// A resource pack's own `core/rendertype_lines` shader for the block outline, translated;
+    /// none draws the outline natively.
+    pub lines_shader: Option<std::sync::Arc<horizon_shaders::CoreProgram>>,
     /// The packs' OptiFine random entity textures, whose variants this atlas packs.
     pub random_textures: horizon_optifine::random_textures::RandomTextures,
     /// Their emissive overlays (`_e`), packed here too.
@@ -813,6 +816,13 @@ impl HudAtlas {
     pub fn build_over_with_image(root: &Path, defaults: &Path, mod_image: bool) -> Result<Self> {
         let mut atlas = Self::pack(root, defaults, WALKED_TEXTURE_FOLDERS, true, mod_image)?;
         atlas.text_shader = pack_text::load(root, defaults);
+        atlas.lines_shader = pack_text::load_core(
+            root,
+            defaults,
+            "rendertype_lines",
+            &[],
+            &crate::gfx::core_lines::GLUE,
+        );
         Ok(atlas)
     }
     /// Empty slots written at run time: map textures (game/maps.rs), the
@@ -941,6 +951,7 @@ impl HudAtlas {
             glint_armor: (vec![0; 4], 1, 1),
             white,
             text_shader: None,
+            lines_shader: None,
             random_textures: Default::default(),
             emissive: Default::default(),
             blinks: Default::default(),
@@ -1384,6 +1395,7 @@ impl HudAtlas {
             glint,
             glint_armor,
             text_shader: None,
+            lines_shader: None,
             random_textures,
             emissive,
             blinks,
@@ -2996,8 +3008,14 @@ mod tests {
     }
     /// A resource root holding one animated block texture: a strip of two
     /// 16x16 frames, red then blue, whose mcmeta starts on the blue one.
+    /// Each call gets its own folder: tests run side by side, and one adds
+    /// a strip of its own that another would otherwise find.
     fn animated_root() -> PathBuf {
-        let root = std::env::temp_dir().join(format!("horizon-atlas-anim-{}", std::process::id()));
+        static NEXT: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+        let n = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        let root =
+            std::env::temp_dir().join(format!("horizon-atlas-anim-{}-{n}", std::process::id()));
+        let _ = fs::remove_dir_all(&root);
         let block = root.join("assets/minecraft/textures/block");
         fs::create_dir_all(&block).unwrap();
         write_strip(

crates/horizon-client-render/src/hud/pack_text.rs

@@ -29,36 +29,47 @@ const GLUE: Glue = Glue {
     vertex_id: "hz_vertex_id()",
 };
 
-const VERTEX: &str = "assets/minecraft/shaders/core/text.vsh";
-const FRAGMENT: &str = "assets/minecraft/shaders/core/text.fsh";
-
-/// The packs' text shader over `defaults` (the game's own resources, which have vanilla's and
-/// its includes), when a pack replaces either stage.
+/// The packs' text shader, when a pack replaces either stage.
 pub(super) fn load(root: &Path, defaults: &Path) -> Option<Arc<CoreProgram>> {
+    load_core(root, defaults, "text", &["IS_GUI"], &GLUE)
+}
+
+/// The packs' core shader `name` (`shaders/core/<name>.vsh` and `.fsh`) over `defaults` (the
+/// game's own resources, which have vanilla's and its includes), when a pack replaces either
+/// stage.
+pub(super) fn load_core(
+    root: &Path,
+    defaults: &Path,
+    name: &str,
+    defines: &[&str],
+    glue: &Glue,
+) -> Option<Arc<CoreProgram>> {
     if root == defaults {
         return None;
     }
     let read = |base: &Path, path: &str| std::fs::read_to_string(base.join(path)).ok();
     let own =
         |path: &str| read(root, path).filter(|text| read(defaults, path).as_ref() != Some(text));
-    let (own_vertex, own_fragment) = (own(VERTEX), own(FRAGMENT));
+    let vertex_path = format!("assets/minecraft/shaders/core/{name}.vsh");
+    let fragment_path = format!("assets/minecraft/shaders/core/{name}.fsh");
+    let (own_vertex, own_fragment) = (own(&vertex_path), own(&fragment_path));
     if own_vertex.is_none() && own_fragment.is_none() {
         return None;
     }
-    let vertex = own_vertex.or_else(|| read(defaults, VERTEX))?;
-    let fragment = own_fragment.or_else(|| read(defaults, FRAGMENT))?;
+    let vertex = own_vertex.or_else(|| read(defaults, &vertex_path))?;
+    let fragment = own_fragment.or_else(|| read(defaults, &fragment_path))?;
     let include = |id: &str| {
         let (namespace, path) = id.split_once(':')?;
         let path = format!("assets/{namespace}/{path}");
         read(root, &path).or_else(|| read(defaults, &path))
     };
-    match horizon_shaders::translate_core(&vertex, &fragment, &["IS_GUI"], &include, &GLUE) {
+    match horizon_shaders::translate_core(&vertex, &fragment, defines, &include, glue) {
         Ok(program) => {
-            log::info!("the resource pack's text shader draws the GUI's text");
+            log::info!("the resource pack's {name} shader is used");
             Some(Arc::new(program))
         }
         Err(e) => {
-            log::warn!("the resource pack's text shader is not used: {e}");
+            log::warn!("the resource pack's {name} shader is not used: {e}");
             None
         }
     }

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

@@ -38,10 +38,27 @@ const QUEUED_PER_SAMPLER: usize = 32;
 const MAX_REFRESHED: usize = 64;
 /// Threads that sample far tiles beside the mesher. Sampling is the cold-load
 /// bottleneck (each task evaluates a shared density lattice for 256 columns),
-/// so medium machines use half their cores, not a quarter.
+/// so medium machines use two thirds of their cores, not half.
+///
+/// The mesher has little to do until tiles are sampled, so its threads sit
+/// idle through the part of a cold build that waits on sampling. Measured on
+/// a 12-thread machine building 4336 tiles at LOD distance 256, from the game
+/// answering the control socket until every target tile is sampled, four runs
+/// a configuration:
+///
+/// | samplers / meshers | sampling | whole build |
+/// |---|---|---|
+/// | 6 / 5 (before) | 15.0 s | 23.9 s |
+/// | 8 / 3 | 11.8 s | 18.6 s |
+/// | 9 / 2 | 10.6 s | 19.1 s |
+///
+/// Nine samplers finish sampling sooner still, but leave the mesher two
+/// threads and the whole build ends later. The cap keeps a large machine
+/// from starving its mesher, and `meshing_threads` keeps the frame and the
+/// ticks a core either way.
 fn sampling_threads(cores: usize) -> usize {
     if cores >= 8 {
-        (cores / 2).min(8)
+        (cores * 2 / 3).min(8)
     } else {
         (cores / 4).clamp(1, 3)
     }
@@ -69,6 +86,9 @@ const WORLD_START: i32 = 1024 * 16;
 /// How many tile widths away from the camera a tile of the world-wide terrain
 /// splits (`Plan::visit`: cells then span about 1/48 of the distance).
 const WORLD_SPLIT: i32 = 3;
+/// A split tile stays split until its distance passes the threshold by this
+/// ratio (`Plan::visit`): 1 / 0.95.
+const RETURN: (i64, i64) = (20, 19);
 /// The farthest `Plan` reaches, in chunks.
 pub const MAX_CHUNKS: u32 = 1 << 22;
 /// The coarsest tile level whose chunks are generated in full (trees,
@@ -176,7 +196,11 @@ pub struct Column {
 }
 impl Column {
     /// Reduce an entire horizontal footprint, rather than inflating its corner
-    /// column (a single leaf used to become a whole distant tree-sized slab).
+    /// column. A height is drawn where any column of the footprint holds a
+    /// block there, in the material most of them hold: anything joined to
+    /// the ground stays joined at every width. Drawing only heights most of
+    /// the footprint held dropped trunks (one column of 16 or 256) under the
+    /// crowns they hold up, and the crowns hung in the air as slabs.
     pub fn reduced(columns: &[Column; 256], x: usize, z: usize, width: usize) -> Self {
         if width == 1 {
             return columns[z * 16 + x].clone();
@@ -200,7 +224,7 @@ impl Column {
         let mut bottom = MIN_Y as i16;
         for (y, material, change) in events {
             if bottom < y {
-                if occupied * 2 >= (width * width) as i32
+                if occupied > 0
                     && let Some(&((state, biome), _)) =
                         votes.iter().max_by_key(|&(material, count)| {
                             (*count, std::cmp::Reverse((material.0.0, material.1)))
@@ -272,39 +296,6 @@ impl Column {
             self.spans.push(span);
         }
     }
-    /// Open water and its floor lit as open sky, as the seed's far columns
-    /// are: a chunk's own light fades a level per block of water, so the
-    /// chunks a player passed drew a darker band through the seed's sea.
-    /// The water is one span again.
-    fn light_open_water(&mut self, kinds: &[u8]) {
-        // Water; lava glows.
-        self.light_open_water_where(|state| {
-            let kind = kinds.get(state.0 as usize).copied().unwrap_or(0);
-            kind & FLUID != 0 && kind >> 4 == 0
-        });
-    }
-    /// [`Column::light_open_water`] for a caller that knows which states are
-    /// water without `BlockFacts`: the save decoder, whose palette already
-    /// names water apart from lava. Saved columns skipping this lit their
-    /// water a level darker per block, which drew a band through the sea
-    /// where they met the generator's columns.
-    pub fn light_open_water_where(&mut self, is_water: impl Fn(BlockStateId) -> bool) {
-        let water = |span: &Span| is_water(span.state);
-        if !self.spans.last().is_some_and(water) {
-            return;
-        }
-        let floor = self
-            .spans
-            .iter()
-            .rposition(|span| !water(span))
-            .unwrap_or(0);
-        for (i, mut span) in std::mem::take(&mut self.spans).into_iter().enumerate() {
-            if i >= floor {
-                span.light |= 0xf0;
-            }
-            self.push(span);
-        }
-    }
     /// `kinds`: `state_kinds`, per block state; `water`: `water_source(kinds)`,
     /// what blocks holding water (kelp, seagrass, waterlogged ones) are drawn as.
     fn from_chunk(
@@ -369,7 +360,6 @@ impl Column {
                 });
             }
         }
-        column.light_open_water(kinds);
         let mut water = None;
         for span in column.spans.iter().rev() {
             if kind(span.state) & FLUID != 0 {
@@ -670,20 +660,36 @@ impl Plan {
         }
         // Keep distant cells small on screen; finest tiles retain individual
         // blocks. Reduced keeps them twice as large (a quarter of the cells).
-        let split = if previous.split.contains(&key) { 10 } else { 8 };
+        let held = previous.split.contains(&key);
+        let split = if held { 10 } else { 8 };
         // Beyond the old 1024-chunk limit the cells are as large as `reduced`'s:
         // the whole world is 22 levels, not all of them worth full cells.
-        let threshold = key.size()
-            * if key.distance(camera) >= WORLD_START {
+        let world = key.distance(camera) >= WORLD_START;
+        let threshold = i64::from(key.size())
+            * i64::from(if world {
                 WORLD_SPLIT
             } else if reduced {
                 split / 2
             } else {
                 split
-            };
+            });
+        // The 8 to 10 band above is wide already. The ring of full detail
+        // around the camera and the world-wide threshold have none: a tile
+        // split last plan stays split until it is 5% past them, or it
+        // flickered between two levels as the camera moved a block to and
+        // fro across the line.
+        let hold = |bound: i64| {
+            if held {
+                bound * RETURN.0 / RETURN.1
+            } else {
+                bound
+            }
+        };
+        let distance = i64::from(key.distance(camera));
         if key.level > 0
-            && (key.distance(camera) < detail * 16 + 16
-                || key.distance(camera).max(self.elevation) < threshold)
+            && (distance < hold(i64::from(detail) * 16 + 16)
+                || distance.max(i64::from(self.elevation))
+                    < if world { hold(threshold) } else { threshold })
         {
             self.split.insert(key);
             for child in key.children() {
@@ -823,6 +829,10 @@ struct Snapshot {
     samples: FxHashMap<TileKey, Arc<Vec<Column>>>,
     saved: Saved,
     reduced: Reduced,
+    /// The plan's tiles, to tell terrain not drawn yet from terrain out of
+    /// range (`Snapshot::planned_leaf`).
+    nodes: FxHashSet<TileKey>,
+    split: FxHashSet<TileKey>,
 }
 /// One column of a mesh input, by reference into the snapshot. Mesh jobs used
 /// to clone all 256 columns of a tile (each with its own span allocation);
@@ -853,6 +863,8 @@ struct EdgeSource {
     start: i32,
     end: i32,
     column: ColumnSource,
+    /// Planned but not drawn yet (`mesh::EdgeColumn::unknown`).
+    unknown: bool,
 }
 struct MeshInput {
     /// The tile's samples, with `overrides` replacing some of them.
@@ -885,6 +897,7 @@ impl MeshInput {
                     start: edge.start,
                     end: edge.end,
                     column: edge.column.get(),
+                    unknown: edge.unknown,
                 })
                 .collect()
         })
@@ -1011,6 +1024,18 @@ struct Shared {
     approximate: AtomicBool,
     /// On small machines, hold queued far meshing while near terrain loads.
     mesh_held: AtomicBool,
+    /// The near terrain is loading: the far threads step behind it
+    /// (`horizon_threads::far_terrain_behind`) and come back once it is in.
+    near_loading: AtomicBool,
+}
+/// Puts the calling far terrain thread behind the near terrain while it
+/// loads, and back once it is in. `behind`: where the thread is now.
+fn step_behind(shared: &Shared, behind: &mut bool) {
+    let loading = shared.near_loading.load(Ordering::Relaxed);
+    if loading != *behind {
+        horizon_threads::far_terrain_behind(loading);
+        *behind = loading;
+    }
 }
 /// A background worker, sampling and meshing threads, and a bounded queue of
 /// sample jobs (`sample_jobs`). Only the current view's quadtree and a
@@ -1139,6 +1164,7 @@ impl Lod {
             stop: AtomicBool::new(false),
             approximate: AtomicBool::new(false),
             mesh_held: AtomicBool::new(false),
+            near_loading: AtomicBool::new(false),
         });
         let worker = shared.clone();
         let (tx, results) = mpsc::channel();
@@ -1158,7 +1184,8 @@ impl Lod {
                     thread::Builder::new()
                         .name("Far meshing".into())
                         .spawn(move || {
-                            horizon_threads::behind_server();
+                            horizon_threads::far_terrain_current();
+                            let mut behind = true;
                             let mut mesher = mesh::Mesher::default();
                             loop {
                                 let job = {
@@ -1189,6 +1216,7 @@ impl Lod {
                                     }
                                     continue;
                                 }
+                                step_behind(&shared, &mut behind);
                                 let keep_finer = !job.finer.is_empty();
                                 let input = job.snapshot.mesh_input(job.key, job.finer);
                                 let columns = input.columns();
@@ -1244,7 +1272,8 @@ impl Lod {
                     .name("Far terrain".into())
                     .spawn(move || {
                         // Ticks and frames come first (horizon_threads).
-                        horizon_threads::behind_server();
+                        horizon_threads::far_terrain_current();
+                        let mut behind = true;
                         let mut sampler = source.sampler();
                         let count = sampling_threads(cores);
                         let mut sampling = Vec::new();
@@ -1258,7 +1287,8 @@ impl Lod {
                                 thread::Builder::new()
                                     .name("Far sampling".into())
                                     .spawn(move || {
-                                        horizon_threads::behind_server();
+                                        horizon_threads::far_terrain_current();
+                                        let mut behind = true;
                                         loop {
                                             let key = {
                                                 let mut jobs = shared.jobs.lock().unwrap();
@@ -1281,6 +1311,7 @@ impl Lod {
                                                     jobs = shared.wake.wait(jobs).unwrap();
                                                 }
                                             };
+                                            step_behind(&shared, &mut behind);
                                             let [x, _, z] = key.origin();
                                             sample.set_approximate(
                                                 shared.approximate.load(Ordering::Relaxed),
@@ -1346,6 +1377,7 @@ impl Lod {
                                 }
                             };
                             let Some(job) = job else { continue };
+                            step_behind(&worker, &mut behind);
                             let done = match job {
                                 Job::Observe(key) => {
                                     let chunk = worker.observed.lock().unwrap().remove(&key);
@@ -2091,6 +2123,7 @@ impl Lod {
             self.held_sample_at = std::time::Instant::now();
         }
         self.near_loading = loading;
+        self.shared.near_loading.store(loading, Ordering::Relaxed);
         let held = self.held();
         if self.shared.mesh_held.swap(held, Ordering::Release) && !held {
             self.shared.mesh_wake.notify_all();
@@ -2223,7 +2256,7 @@ impl Lod {
     /// Rebuilds the quadtree and the selection it implies. Only runs when the
     /// planned area changes (a chunk boundary), never per finished sample.
     fn replan(&mut self, camera: [i32; 2], detail: i32, distance: u32, elevation: i32) {
-        self.plan = Plan::with_previous(
+        let plan = Plan::with_previous(
             camera,
             detail,
             distance,
@@ -2231,6 +2264,17 @@ impl Lod {
             elevation,
             self.reduced_detail,
         );
+        // A tile that leaves the range before it was drawn stops being
+        // unknown to its neighbours (`Snapshot::planned_leaf`): they remesh
+        // with walls against it, as against any terrain out of range.
+        let gone: Vec<_> = self
+            .plan
+            .nodes
+            .iter()
+            .filter(|key| !plan.nodes.contains(key) && !self.ready.contains_key(key))
+            .copied()
+            .collect();
+        self.plan = plan;
         self.ready.retain(|key, _| self.plan.nodes.contains(key));
         // Queued tiles the view left are not sampled (a running one is
         // dropped when it finishes, `finish_sample`).
@@ -2254,6 +2298,9 @@ impl Lod {
         for key in standins {
             self.refresh_path(key);
         }
+        for key in gone {
+            self.mark_side_neighbors_of(key);
+        }
     }
     /// Recomputes every active tile after a plan change, then marks only the
     /// tiles whose selection changed (plus their neighbours).
@@ -2559,6 +2606,8 @@ impl Lod {
                 .collect(),
             saved: self.saved.clone(),
             reduced: self.reduced.clone(),
+            nodes: self.plan.nodes.clone(),
+            split: self.plan.split.clone(),
         });
         let covered = Arc::new(self.covered.clone());
         let mut queued = self.shared.mesh_jobs.lock().unwrap();
@@ -2706,6 +2755,8 @@ impl Lod {
                 .collect(),
             saved: self.saved.clone(),
             reduced: self.reduced.clone(),
+            nodes: self.plan.nodes.clone(),
+            split: self.plan.split.clone(),
         }
     }
     #[cfg(test)]
@@ -2777,6 +2828,23 @@ impl Snapshot {
         }
         None
     }
+    /// Whether block column (wx, wz) lies in a planned tile that is not
+    /// split, whatever drew it (nothing, here): the finest planned tile
+    /// there. Past a split tile's out-of-range children, or past the plan,
+    /// there is no terrain to wait for.
+    fn planned_leaf(&self, wx: i32, wz: i32) -> bool {
+        (0..=MAX_LEVEL)
+            .map(|level| {
+                let size = 16 << level;
+                TileKey {
+                    x: wx.div_euclid(size),
+                    z: wz.div_euclid(size),
+                    level,
+                }
+            })
+            .find(|key| self.nodes.contains(key))
+            .is_some_and(|key| !self.split.contains(&key))
+    }
     fn mesh_input(&self, key: TileKey, finer: Vec<TileKey>) -> MeshInput {
         let stride = key.size() / CELLS as i32;
         let [ox, _, oz] = key.origin();
@@ -2800,9 +2868,12 @@ impl Snapshot {
                     2 => (ox + offset, oz - 1),
                     _ => (ox + offset, oz + key.size()),
                 };
-                let (column, neighbor_stride) = self
-                    .neighbor_source(wx, wz)
-                    .unwrap_or((ColumnSource::Empty, stride));
+                // Nothing drawn across the edge: still to come when planned,
+                // so no wall is drawn against it; empty past the plan.
+                let (column, neighbor_stride, unknown) = match self.neighbor_source(wx, wz) {
+                    Some((column, stride)) => (column, stride, false),
+                    None => (ColumnSource::Empty, stride, self.planned_leaf(wx, wz)),
+                };
                 let coordinate = if direction < 2 { wz } else { wx };
                 let width = (neighbor_stride - coordinate.rem_euclid(neighbor_stride))
                     .min(key.size() - offset);
@@ -2810,6 +2881,7 @@ impl Snapshot {
                     start: offset,
                     end: offset + width,
                     column,
+                    unknown,
                 });
                 offset += width;
             }
@@ -3148,6 +3220,27 @@ mod tests {
         assert!(after.nodes.len() < 16000);
     }
     #[test]
+    fn a_split_tile_stays_split_a_little_past_the_detail_ring() {
+        // Detail 40 puts the ring of full detail at 656 blocks, past where
+        // level 2 tiles split by their width (8 * 64 = 512): the ring alone
+        // splits this one, 640 blocks away.
+        let tile = TileKey {
+            x: 10,
+            z: 0,
+            level: 2,
+        };
+        let before = Plan::new([0, 0], 40, 256);
+        assert!(before.split.contains(&tile));
+        // 670 blocks: past the ring, inside 5% of it.
+        let held = Plan::with_previous([-30, 0], 40, 256, &before, 0, false);
+        assert!(held.split.contains(&tile));
+        // Not held without having been split: it was never in the ring.
+        assert!(!Plan::new([-30, 0], 40, 256).split.contains(&tile));
+        // 700 blocks: past the margin.
+        let gone = Plan::with_previous([-60, 0], 40, 256, &before, 0, false);
+        assert!(!gone.split.contains(&tile));
+    }
+    #[test]
     fn reduced_material_votes_ignore_light_and_retain_exposure() {
         let mut columns: [Column; 256] = std::array::from_fn(|_| Column::default());
         for i in 0..16 {
@@ -3185,49 +3278,6 @@ mod tests {
         );
     }
     #[test]
-    fn open_water_and_its_floor_are_lit_as_the_seed_lights_them() {
-        let span = |min, max, state, light| Span {
-            min,
-            max,
-            state: BlockStateId(state),
-            biome: 0,
-            light,
-        };
-        // 0 air, 1 stone, 2 water, 3 lava.
-        let kinds = [AIR, KEPT, KEPT | FLUID, KEPT | FLUID | 15 << 4];
-        // A chunk's own light: a cave, the floor, water fading a level a block.
-        let mut sea = Column {
-            surface: None,
-            spans: vec![
-                span(30, 40, 1, 0),
-                span(40, 48, 1, 0x10 | 2 << 12),
-                span(48, 61, 2, 0x20),
-                span(61, 62, 2, 0xe0),
-                span(62, 63, 2, 0xf0),
-            ]
-            .into(),
-        };
-        sea.light_open_water(&kinds);
-        assert_eq!(
-            sea.spans,
-            [
-                span(30, 40, 1, 0),
-                span(40, 48, 1, 0xf0 | 2 << 12),
-                span(48, 63, 2, 0xf0)
-            ]
-        );
-        // Land, and lava, keep their light.
-        for top in [1, 3] {
-            let mut column = Column {
-                surface: None,
-                spans: vec![span(40, 50, 2, 0x20), span(50, 63, top, 0x80)].into(),
-            };
-            let before = column.spans.clone();
-            column.light_open_water(&kinds);
-            assert_eq!(column.spans, before);
-        }
-    }
-    #[test]
     fn nearly_full_blocks_are_kept() {
         assert!(nearly_full("minecraft:powder_snow"));
         assert!(nearly_full("minecraft:dirt_path"));
@@ -3262,7 +3312,7 @@ mod tests {
         assert_eq!(kelp.surface.unwrap().height, 40);
     }
     #[test]
-    fn coarse_voxels_reduce_the_area_instead_of_inflating_one_leaf() {
+    fn coarse_voxels_keep_what_any_column_holds_so_crowns_stay_on_trunks() {
         let span = |min, max, state| Span {
             min,
             max,
@@ -3274,8 +3324,8 @@ mod tests {
             surface: None,
             spans: vec![span(0, 4, 1)].into(),
         });
-        columns[0].spans.push(span(8, 10, 2));
-        assert_eq!(Column::reduced(&columns, 0, 0, 4).spans, [span(0, 4, 1)]);
+        // One trunk column under a crown over the whole footprint.
+        columns[0].spans.push(span(4, 12, 2));
         for z in 0..4 {
             for x in 0..4 {
                 columns[z * 16 + x].spans.push(span(12, 14, 3));
@@ -3283,17 +3333,20 @@ mod tests {
         }
         assert_eq!(
             Column::reduced(&columns, 0, 0, 4).spans,
-            [span(0, 4, 1), span(12, 14, 3)]
+            [span(0, 4, 1), span(4, 12, 2), span(12, 14, 3)]
         );
         assert_eq!(Column::reduced(&columns, 0, 0, 1), columns[0]);
         let reduced = ReducedColumns::new(Arc::new(columns));
         assert_eq!(
-            reduced.get(0, 0, 1).spans,
-            [span(0, 4, 1), span(8, 10, 2), span(12, 14, 3)]
+            reduced.get(0, 0, 4).spans,
+            [span(0, 4, 1), span(4, 12, 2), span(12, 14, 3)]
         );
-        assert_eq!(reduced.get(0, 0, 4).spans, [span(0, 4, 1), span(12, 14, 3)]);
         assert_eq!(reduced.get(4, 8, 4).spans, [span(0, 4, 1)]);
-        assert_eq!(reduced.get(0, 0, 16).spans, [span(0, 4, 1)]);
+        assert_eq!(
+            reduced.get(0, 0, 16).spans,
+            [span(0, 4, 1), span(4, 12, 2), span(12, 14, 3)],
+            "a crown over one corner of a wide cell still sits on its trunk"
+        );
     }
     /// Detail read before a refresh over its chunk is dropped (asked
     /// again); elsewhere, or read after, it is kept.
@@ -3999,9 +4052,22 @@ mod tests {
     }
     #[test]
     fn extra_sampling_threads_only_on_large_machines() {
-        assert_eq!([1, 2, 4, 8, 11].map(sampling_threads), [1, 1, 1, 4, 5]);
-        assert_eq!([12, 16, 64].map(sampling_threads), [6, 8, 8]);
-        assert_eq!([2, 8, 12, 16].map(meshing_threads), [1, 3, 5, 7]);
+        // Small machines are unchanged: a quarter of their cores, never more
+        // than three, so the near chunks and the frame keep theirs.
+        assert_eq!([1, 2, 4].map(sampling_threads), [1, 1, 1]);
+        // From eight, two thirds rather than half, still capped at eight.
+        assert_eq!([8, 11, 12].map(sampling_threads), [5, 7, 8]);
+        assert_eq!([16, 64].map(sampling_threads), [8, 8]);
+        assert_eq!([2, 8, 12, 16].map(meshing_threads), [1, 2, 3, 7]);
+        // From four cores up the two pools together leave one for the frame
+        // and the ticks. Below that both clamp to one and there is nothing
+        // to spare, which is the existing behaviour.
+        for cores in [4usize, 8, 11, 12, 16, 64] {
+            assert!(
+                sampling_threads(cores) + meshing_threads(cores) < cores,
+                "{cores} cores leaves nothing for the frame"
+            );
+        }
     }
 
     /// Review point 3 on #4747: a result from a batch that is no longer the
@@ -4060,6 +4126,87 @@ mod tests {
         assert_eq!(meshes.len(), 2, "a tile that left the view is dropped");
     }
 
+    /// A neighbour inside the plan that is not drawn yet is unknown, not
+    /// empty, and its arrival remeshes the tile that faced it. One past the
+    /// planned range is still empty.
+    #[test]
+    fn a_planned_neighbor_that_is_not_ready_is_unknown_not_empty() {
+        let mut lod = Lod::scheduler_for_test();
+        let a = TileKey {
+            x: 0,
+            z: 0,
+            level: 0,
+        };
+        let b = TileKey {
+            x: 1,
+            z: 0,
+            level: 0,
+        };
+        lod.plan = Plan::default();
+        lod.plan.roots = vec![a, b];
+        lod.plan.nodes.extend([a, b]);
+        lod.finish_sample(a, vec![Column::default(); CELLS * CELLS]);
+        assert!(lod.active.contains(&a));
+        let sides = |lod: &Lod| {
+            let input = lod.snapshot().mesh_input(a, Vec::new());
+            [0, 1].map(|side| {
+                input.neighbors[side]
+                    .iter()
+                    .map(|edge| (edge.unknown, matches!(edge.column, ColumnSource::Tile(..))))
+                    .collect::<Vec<_>>()
+            })
+        };
+        let [west, east] = sides(&lod);
+        assert!(west.iter().all(|&edge| edge == (false, false)), "range end");
+        assert!(east.iter().all(|&edge| edge == (true, false)), "planned");
+
+        // Its arrival draws the neighbour and remeshes the tile facing it.
+        lod.dirty.clear();
+        lod.finish_sample(b, vec![Column::default(); CELLS * CELLS]);
+        assert!(lod.dirty.contains_key(&a), "the tile facing it is remeshed");
+        let [_, east] = sides(&lod);
+        assert!(east.iter().all(|&edge| edge == (false, true)), "drawn");
+
+        // Past a split tile's out-of-range child there is nothing to wait for.
+        let parent = TileKey {
+            x: 4,
+            z: 4,
+            level: 1,
+        };
+        lod.plan.nodes.insert(parent);
+        lod.plan.split.insert(parent);
+        lod.plan.nodes.extend(parent.children().into_iter().take(3));
+        let snapshot = lod.snapshot();
+        let [x, _, z] = parent.origin();
+        assert!(snapshot.planned_leaf(x + 1, z + 1), "a planned leaf");
+        assert!(!snapshot.planned_leaf(x + 17, z + 17), "no child planned");
+        assert!(!snapshot.planned_leaf(x - 40, z), "outside the plan");
+    }
+
+    #[test]
+    fn a_planned_neighbor_leaving_the_range_unready_remeshes_the_tile_that_waited() {
+        let mut lod = Lod::scheduler_for_test();
+        let a = TileKey {
+            x: 0,
+            z: 0,
+            level: 0,
+        };
+        let b = TileKey {
+            x: 1,
+            z: 0,
+            level: 0,
+        };
+        lod.plan = Plan::default();
+        lod.plan.roots = vec![a, b];
+        lod.plan.nodes.extend([a, b]);
+        lod.finish_sample(a, vec![Column::default(); CELLS * CELLS]);
+        lod.dirty.clear();
+        // A range of one chunk around (-10, 0) keeps `a` and drops `b`.
+        lod.replan([-10, 0], 0, 1, 0);
+        assert!(lod.plan.nodes.contains(&a) && !lod.plan.nodes.contains(&b));
+        assert!(lod.dirty.contains_key(&a), "its east wall is drawn now");
+    }
+
     #[test]
     fn far_meshing_holds_while_small_machine_near_terrain_loads() {
         let mut lod = Lod::scheduler_for_test();

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

@@ -16,6 +16,9 @@ pub(super) struct EdgeColumn<'a> {
     pub start: i32,
     pub end: i32,
     pub column: &'a Column,
+    /// The neighbour is planned but not drawn yet: its terrain is not known
+    /// to be empty, so the sides facing it are left out, not drawn as walls.
+    pub unknown: bool,
 }
 
 #[derive(Clone, Copy)]
@@ -319,6 +322,7 @@ fn mesh_columns_with_neighbors(
                 start: row as i32 * stride,
                 end: (row as i32 + 1) * stride,
                 column,
+                unknown: false,
             })
             .collect()
     });
@@ -347,13 +351,17 @@ fn heightmap(column: &Column, mut fluid: impl FnMut(&Span) -> bool) -> Column {
         ..*span
     };
     let mut spans = Spans::with_capacity(2);
-    match below.last() {
-        Some(under) if fluid(top) => {
-            spans.push(ground(under));
-            spans.push(*top);
-        }
-        _ if fluid(top) => spans.push(*top),
-        _ => spans.push(ground(top)),
+    if !fluid(top) {
+        spans.push(ground(top));
+    } else if let Some(under) = below.iter().rev().find(|&span| !fluid(span)) {
+        // Shaded water is a span per light level; the bed is under all of it.
+        spans.push(ground(under));
+        spans.push(Span {
+            min: under.max,
+            ..*top
+        });
+    } else {
+        spans.push(*top);
     }
     Column {
         surface: column.surface,
@@ -396,6 +404,7 @@ fn mesh_columns_with_edges(
                     start: edge.start,
                     end: edge.end,
                     column,
+                    unknown: edge.unknown,
                 })
                 .collect()
         });
@@ -660,6 +669,9 @@ fn mesh_columns_with_edges(
                                 // A coarse face can meet several finer columns.
                                 // Clip each interval independently to avoid missing walls.
                                 for (i, edge) in neighbors[edge_side].iter().enumerate() {
+                                    if edge.unknown {
+                                        continue;
+                                    }
                                     let start = u0.max(edge.start as f32);
                                     let end = u1.min(edge.end as f32);
                                     if start < end {
@@ -785,6 +797,70 @@ mod refinement_tests {
         }
         assert_eq!(area, (parent.size() * parent.size() - 256) as f32);
     }
+    /// A neighbour that is still to come draws no wall against it; an empty
+    /// one (out of range) does.
+    #[test]
+    fn unknown_neighbor_leaves_its_side_out() {
+        let key = TileKey {
+            x: 0,
+            z: 0,
+            level: 0,
+        };
+        let columns = vec![
+            Column {
+                surface: None,
+                spans: vec![Span {
+                    min: 0,
+                    max: 8,
+                    state: BlockStateId(1),
+                    biome: 0,
+                    light: 240,
+                }]
+                .into()
+            };
+            256
+        ];
+        let columns: Vec<&Column> = columns.iter().collect();
+        let empty = Column::default();
+        let east_quads = |unknown: bool| {
+            let edge = |column| EdgeColumn {
+                start: 0,
+                end: 16,
+                column,
+                unknown,
+            };
+            let neighbors = [Vec::new(), vec![edge(&empty)], Vec::new(), Vec::new()];
+            let mesh = mesh_columns_with_edges(
+                key,
+                &columns,
+                &FxHashSet::default(),
+                None,
+                &neighbors,
+                &[],
+                |_, _, _| Material {
+                    faces: [
+                        Some(Paint {
+                            layer: 1,
+                            light: 240,
+                            color: u32::MAX,
+                            translucent: false,
+                        }),
+                        None,
+                    ],
+                    fluid: 0,
+                    opaque: true,
+                },
+            );
+            mesh.solid
+                .as_chunks::<4>()
+                .0
+                .iter()
+                .filter(|quad| quad.iter().all(|v| v.pos[0] == 16.0))
+                .count()
+        };
+        assert!(east_quads(false) > 0, "a wall faces the empty neighbour");
+        assert_eq!(east_quads(true), 0, "none faces the unknown one");
+    }
 }
 
 /// The tile's columns with the gaps no open air reaches filled with the
@@ -1442,6 +1518,7 @@ mod tests {
             start: 0,
             end: CELLS as i32,
             column: &hill_column,
+            unknown: false,
         };
         let neighbors = [vec![hill()], vec![hill()], vec![hill()], vec![hill()]];
         let fill = |columns: &[Column]| -> Vec<Vec<Span>> {
@@ -1583,6 +1660,7 @@ mod tests {
                 start: 0,
                 end: 32,
                 column: &columns[0],
+                unknown: false,
             }]
         });
         // One fine column is lower than both the coarse cell and its sibling.
@@ -1596,16 +1674,19 @@ mod tests {
                 start: 0,
                 end: 1,
                 column: &columns[0],
+                unknown: false,
             },
             EdgeColumn {
                 start: 1,
                 end: 2,
                 column: &low,
+                unknown: false,
             },
             EdgeColumn {
                 start: 2,
                 end: 32,
                 column: &columns[0],
+                unknown: false,
             },
         ];
         let columns: Vec<&Column> = columns.iter().collect();

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

@@ -6,6 +6,7 @@
 mod fluid;
 mod leaf_culling;
 mod lighting;
+pub mod packed;
 mod sides;
 use crate::connected::{Pick, TileLayer};
 use crate::{
@@ -265,6 +266,12 @@ pub struct SectionMesh {
     /// model order before.
     pub sides: Sides,
     pub translucent: Vec<TerrainVertex>,
+    /// `solid` in the compact layout (`packed`), when the renderer reads it and it is
+    /// smaller; empty otherwise. Made by `sort_solid`.
+    pub packed: Vec<[u32; 6]>,
+    /// The tint of each solid quad as the mesher multiplied it (`packed::UNKNOWN_TINT` where
+    /// it does not say), for `packed`; dropped once that is made.
+    pub(crate) solid_tints: Vec<u32>,
     /// VisGraph: bit `a * 6 + b` is set when faces `a` and `b` (Direction
     /// order) are connected through non-opaque blocks.
     pub visibility: u64,
@@ -290,6 +297,8 @@ impl Default for SectionMesh {
             solid: Vec::new(),
             sides: Sides::default(),
             translucent: Vec::new(),
+            packed: Vec::new(),
+            solid_tints: Vec::new(),
             visibility: ALL_VISIBLE,
             block_entities: Vec::new(),
             lights: Vec::new(),
@@ -322,6 +331,8 @@ impl SectionMesh {
     pub fn clear(&mut self) {
         self.solid.clear();
         self.translucent.clear();
+        self.packed.clear();
+        self.solid_tints.clear();
         self.block_entities.clear();
         self.lights.clear();
         self.sprite_layers.clear();
@@ -333,15 +344,27 @@ impl SectionMesh {
     pub(crate) fn capacity_bytes(&self) -> usize {
         self.solid.capacity() * std::mem::size_of::<TerrainVertex>()
             + self.translucent.capacity() * std::mem::size_of::<TerrainVertex>()
+            + self.packed.capacity() * std::mem::size_of::<[u32; 6]>()
+            + self.solid_tints.capacity() * std::mem::size_of::<u32>()
             + self.block_entities.capacity() * std::mem::size_of::<([i32; 3], u32)>()
             + self.lights.capacity() * std::mem::size_of::<([i32; 3], u32)>()
             + self.sprite_layers.capacity() * std::mem::size_of::<u16>()
     }
     /// Sorts the solid quads by the side they face, for the renderer to
     /// leave out those facing away from the eye (`sides`).
+    /// Then lays them out compactly (`packed`) while the renderer reads that.
     pub fn sort_solid(&mut self) {
-        self.sides = sides::sort(&mut self.solid);
+        let quads = self.solid.len() / 4;
+        if !self.solid_tints.is_empty() {
+            self.solid_tints.resize(quads, packed::UNKNOWN_TINT);
+        }
+        self.sides = sides::sort_tinted(&mut self.solid, &mut self.solid_tints);
         self.bounds = self.compute_bounds();
+        self.packed.clear();
+        if packed::packing() && quads > 0 && self.solid_tints.len() == quads {
+            self.packed = packed::layout(&self.solid, &self.solid_tints);
+        }
+        self.solid_tints.clear();
     }
 
     /// Computes the tight axis-aligned bounding box [min, max] of actual terrain geometry vertices.
@@ -1519,12 +1542,24 @@ impl Mesher<'_> {
                         let other = &info[neighbor as usize];
                         // LeavesBlock.skipRendering with opaque leaves.
                         let opaque_leaves = !self.cutout_leaves && state.leaves && other.leaves;
-                        let hollow_leaf = self.leaf_culling == LeafCullingMode::Hollow
-                            && state.leaves
-                            && other.leaves
-                            && leaf_culling::in_section(x + dx, y + dy, z + dz);
+                        let culled_leaf = match self.leaf_culling {
+                            LeafCullingMode::Hollow | LeafCullingMode::Hidden => {
+                                state.leaves
+                                    && other.leaves
+                                    && leaf_culling::in_section(x + dx, y + dy, z + dz)
+                                    && (self.leaf_culling == LeafCullingMode::Hollow
+                                        || leaf_culling::backed(
+                                            pad,
+                                            info,
+                                            region,
+                                            base_y,
+                                            [x + 2 * dx, y + 2 * dy, z + 2 * dz],
+                                        ))
+                            }
+                            _ => false,
+                        };
                         visible[d as usize] = !opaque_leaves
-                            && !hollow_leaf
+                            && !culled_leaf
                             && self
                                 .visibility
                                 .should_render_face(
@@ -1770,8 +1805,8 @@ impl Mesher<'_> {
             TileLayer::Skip | TileLayer::Default => own,
         };
         match pick {
-            Pick::Keep => self.quad(out, solid_leaves, own, corners.map(|c| c.0)),
-            Pick::Tile(t) => self.quad(out, solid_leaves, tile(t), corners.map(|c| c.0)),
+            Pick::Keep => self.quad(out, solid_leaves, own, corners.map(|c| c.0), tint),
+            Pick::Tile(t) => self.quad(out, solid_leaves, tile(t), corners.map(|c| c.0), tint),
             Pick::Quarters(tiles) => {
                 let cuts = cuts(&corners);
                 for s in cuts.windows(2) {
@@ -1779,7 +1814,8 @@ impl Mesher<'_> {
                         let piece = [(s[0], t[0]), (s[1], t[0]), (s[1], t[1]), (s[0], t[1])]
                             .map(|(s, t)| bilinear(&corners, s, t));
                         let quarter = quarter_of(&piece);
-                        self.quad(out, solid_leaves, tile(tiles[quarter]), piece.map(|c| c.0));
+                        let piece = piece.map(|c| c.0);
+                        self.quad(out, solid_leaves, tile(tiles[quarter]), piece, tint);
                     }
                 }
             }
@@ -1823,7 +1859,7 @@ impl Mesher<'_> {
                 for t in cuts.windows(2) {
                     let piece = [(s[0], t[0]), (s[1], t[0]), (s[1], t[1]), (s[0], t[1])]
                         .map(|(s, t)| bilinear(&whole, s, t).0);
-                    self.quad_as(out, false, tile, piece, false);
+                    self.quad_as(out, false, tile, piece, false, tint);
                 }
             }
         }
@@ -1836,8 +1872,9 @@ impl Mesher<'_> {
         solid_leaves: bool,
         tile: TileLayer,
         v: [TerrainVertex; 4],
+        tint: Option<u32>,
     ) {
-        self.quad_as(out, solid_leaves, tile, v, true);
+        self.quad_as(out, solid_leaves, tile, v, true, tint);
     }
     /// Whether [`Mesher::quad`] draws `tile` in the translucent pass.
     fn translucent(&self, tile: TileLayer) -> bool {
@@ -1856,7 +1893,8 @@ impl Mesher<'_> {
         }
     }
     /// [`Mesher::quad`], with the sprite's own translucency (`translucent_layers`) counted only
-    /// when `by_sprite`: an overlay's pass is its rule's.
+    /// when `by_sprite`: an overlay's pass is its rule's. `tint`: what its grey levels were
+    /// multiplied by, for the compact layout (`packed`).
     fn quad_as(
         &self,
         out: &mut SectionMesh,
@@ -1864,6 +1902,7 @@ impl Mesher<'_> {
         tile: TileLayer,
         mut v: [TerrainVertex; 4],
         by_sprite: bool,
+        tint: Option<u32>,
     ) {
         let TileLayer::Layer {
             layer,
@@ -1897,6 +1936,12 @@ impl Mesher<'_> {
             vertex.layer = layer;
         }
         target.extend(v);
+        if !translucent {
+            // Quads other code put in `solid` (lava) have no tint known.
+            let quad = out.solid.len() / 4 - 1;
+            out.solid_tints.resize(quad, packed::UNKNOWN_TINT);
+            out.solid_tints.push(tint.unwrap_or(packed::WHITE));
+        }
     }
 }
 /// The cuts of a `ctm_compact` face, in quad parameters, without allocating: the first `.1`

crates/horizon-client-render/src/mesher/leaf_culling.rs

@@ -12,7 +12,9 @@
 //! Aggressive` runs a multi-source breadth-first search from leaves touching
 //! openings, solidifying leaves with a single open face to thin the canopy shell
 //! by one layer. `Hollow` directly drops faces shared between two leaves within
-//! the section, preserving boundaries and cavity faces.
+//! the section, preserving boundaries and cavity faces. `Hidden` drops only
+//! those whose faced leaf has another leaf or an opaque cube behind it
+//! ([`backed`]), so the layer seen through the canopy's outer holes stays.
 
 use super::{B, Info, P, Padded, pi};
 use crate::{blocks::RenderShape, chunk::Chunk, graphics::LeafCullingMode};
@@ -229,6 +231,21 @@ pub(super) fn in_section(x: i32, y: i32, z: i32) -> bool {
     (0..16).contains(&x) && (0..16).contains(&y) && (0..16).contains(&z)
 }
 
+/// `Hidden`: whether the padded cell `[x, y, z]`, the one behind a faced leaf,
+/// is a leaf or a full opaque cube. A cell without real data never is.
+#[inline]
+pub(super) fn backed(
+    pad: &Padded,
+    info: &[Info],
+    region: &[[Option<&Chunk>; 3]; 3],
+    base_y: i32,
+    [x, y, z]: [i32; 3],
+) -> bool {
+    info.get(pad.blocks[pi(x, y, z)] as usize)
+        .is_some_and(|state| state.leaves || state.opaque_cube)
+        && known(region, base_y, x, y, z)
+}
+
 /// Whether the padded cell `(x, y, z)` has real block data. A missing chunk
 /// does not count: `Padded::fill` copies the centre's edge column into it, which
 /// would make a canopy look enclosed. A Y outside the column counts as unknown

crates/horizon-client-render/src/mesher/packed.rs

@@ -0,0 +1,343 @@
+//! The compact layout of a section's solid quads in the arena: most of them are whole faces
+//! of a block's cube on the block grid, and those take one 24-byte record each instead of
+//! four 24-byte vertices. terrain.wgsl's `section_corner` expands a record into the very
+//! vertex words `TerrainVertex` would hold (`packed_vertex` here is the same on the CPU, and
+//! a record is kept only when it gives back the quad's four vertices bit for bit), so every
+//! pass draws the same picture from either layout.
+//!
+//! A mesh's solid range is then one record per quad in mesh order (so `Sides` and the draws
+//! count quads as before), padding to a multiple of 4 slots, and the quads no record fits as
+//! their four vertices: their record holds the distance to those (`FULL`). A record:
+//!
+//! - word 0: the tint (0xRRGGBB as the mesher multiplies it) and the colour's alpha byte;
+//! - word 1: each corner's grey level before the tint;
+//! - word 2: the UV rectangle in 1/32 of the sprite (u0, u1, v0, v1, 6 bits each) and, per
+//!   corner, which edge of it its u and v take;
+//! - word 3: the layer, and corner 0's light (sky and block light over 4, 6 bits each);
+//! - word 4: corners 1 and 2's light;
+//! - word 5: corner 3's light, the face (block x, y, z, the axis it faces along, which side
+//!   of the block, and where and which way its corners go round), and `FULL` clear.
+use super::TerrainVertex;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// A solid quad's tint the mesher does not know (fluids): only untinted colours pack.
+pub const UNKNOWN_TINT: u32 = u32::MAX;
+/// The tint of an untinted quad, whose colour is its grey level.
+pub const WHITE: u32 = 0xFF_FFFF;
+/// Word 5's bit of a quad kept as four vertices; word 0 is then the slots from the record
+/// to its first vertex.
+pub const FULL: u32 = 1 << 31;
+/// The draws' base vertex of a compact mesh: `PACKED_BASE + 4 * slot + corner` is a corner of
+/// the quad whose record is at `slot`; below it, vertex indices name vertices.
+pub const PACKED_BASE: u32 = 1 << 28;
+
+/// Whether meshes sorted from now on get the compact layout: set by the renderer while its
+/// passes read it (no shader pack).
+static PACK: AtomicBool = AtomicBool::new(false);
+
+pub fn pack_quads(on: bool) {
+    PACK.store(on, Ordering::Relaxed);
+}
+
+pub fn packing() -> bool {
+    PACK.load(Ordering::Relaxed)
+}
+
+/// The order corners go round a face: (du, dw) of each step.
+const ROUND: [[u32; 2]; 4] = [[0, 0], [1, 0], [1, 1], [0, 1]];
+
+/// `quad`'s record, if one gives back its four vertices exactly. `tint`: what the mesher
+/// multiplied its grey levels by (`UNKNOWN_TINT` when it does not say).
+pub fn pack_quad(quad: &[TerrainVertex; 4], tint: u32) -> Option<[u32; 6]> {
+    // Corners on the block grid of the section.
+    let mut p = [[0u32; 3]; 4];
+    for (to, v) in p.iter_mut().zip(quad) {
+        for (c, &x) in to.iter_mut().zip(&v.pos) {
+            if !(0.0..=16.0).contains(&x) || x.fract() != 0.0 {
+                return None;
+            }
+            *c = x as u32;
+        }
+    }
+    let axis = (0..3).find(|&a| p.iter().all(|c| c[a] == p[0][a]))?;
+    let (u, w) = ((axis + 1) % 3, (axis + 2) % 3);
+    let lo = [u, w].map(|k| p.iter().map(|c| c[k]).min().unwrap_or(0));
+    if lo.iter().any(|&l| l > 15) {
+        return None;
+    }
+    let mut steps = [0u32; 4];
+    for (step, c) in steps.iter_mut().zip(&p) {
+        let d = [c[u] - lo[0], c[w] - lo[1]];
+        *step = ROUND.iter().position(|r| *r == d)? as u32;
+    }
+    let (start, dir) = (0..8u32).map(|n| (n & 3, n >> 2)).find(|&(start, dir)| {
+        (0..4u32).all(|i| {
+            let step = if dir == 1 { 4 - i } else { i };
+            steps[i as usize] == (start + step) & 3
+        })
+    })?;
+    let plane = p[0][axis];
+    let mut block = [0u32; 3];
+    block[axis] = plane.min(15);
+    block[u] = lo[0];
+    block[w] = lo[1];
+    let side = plane - block[axis];
+    let orient = block[0]
+        | block[1] << 4
+        | block[2] << 8
+        | (axis as u32) << 12
+        | side << 14
+        | start << 15
+        | dir << 17;
+    // UVs in 1/32 of the sprite, at most two values each way.
+    let mut ranges = [[u32::MAX, 0u32]; 2];
+    let mut uvs = [[0u32; 2]; 4];
+    for (uv, v) in uvs.iter_mut().zip(quad) {
+        for k in 0..2 {
+            let raw = u32::from(v.uv[k]);
+            if raw & 1023 != 0 {
+                return None;
+            }
+            uv[k] = raw >> 10;
+            ranges[k] = [ranges[k][0].min(uv[k]), ranges[k][1].max(uv[k])];
+        }
+    }
+    let mut select = 0u32;
+    for (i, uv) in uvs.iter().enumerate() {
+        for k in 0..2 {
+            if uv[k] == ranges[k][1] && uv[k] != ranges[k][0] {
+                select |= 1 << (2 * i + k);
+            } else if uv[k] != ranges[k][0] {
+                return None;
+            }
+        }
+    }
+    let rect = ranges[0][0] | ranges[0][1] << 6 | ranges[1][0] << 12 | ranges[1][1] << 18;
+    // Light in steps of 4 (smooth light averages four levels of 16).
+    let mut light = [0u32; 4];
+    for (l, v) in light.iter_mut().zip(quad) {
+        let (sky, block) = (u32::from(v.light & 0xFF), u32::from(v.light >> 8));
+        if sky & 3 != 0 || block & 3 != 0 {
+            return None;
+        }
+        *l = sky >> 2 | (block >> 2) << 6;
+    }
+    // The colour: each channel the grey level times the tint's, over 255.
+    let tint = if tint == UNKNOWN_TINT {
+        WHITE
+    } else {
+        tint & WHITE
+    };
+    let alpha = quad[0].color & 0xFF00_0000;
+    let mut grays = 0u32;
+    for (i, v) in quad.iter().enumerate() {
+        grays |= gray_of(v.color, tint)? << (8 * i);
+    }
+    let words = [
+        tint | alpha,
+        grays,
+        rect | select << 24,
+        u32::from(quad[0].layer) | light[0] << 16,
+        light[1] | light[2] << 12,
+        light[3] | orient << 12,
+    ];
+    let exact = (0..4).all(|c| {
+        let (a, b) = (packed_vertex(&words, c), quad[c]);
+        bytemuck::bytes_of(&a) == bytemuck::bytes_of(&b)
+    });
+    exact.then_some(words)
+}
+
+/// The tint's channels, as the mesher takes them for red, green and blue.
+fn channels(tint: u32) -> [u32; 3] {
+    [tint >> 16 & 255, tint >> 8 & 255, tint & 255]
+}
+
+/// A grey level that `tint` turns into `color`'s red, green and blue.
+fn gray_of(color: u32, tint: u32) -> Option<u32> {
+    let want = [color & 255, color >> 8 & 255, color >> 16 & 255];
+    let t = channels(tint);
+    let gives = |g: u32| (0..3).all(|k| g * t[k] / 255 == want[k]);
+    let k = (0..3).max_by_key(|&k| t[k]).unwrap_or(0);
+    if t[k] == 0 {
+        return gives(0).then_some(0);
+    }
+    let lo = (want[k] * 255).div_ceil(t[k]);
+    let hi = ((want[k] * 255 + 254) / t[k]).min(255);
+    (lo..=hi).find(|&g| gives(g))
+}
+
+/// Corner `corner` of the quad `words` holds, as terrain.wgsl's `packed_corner` expands it.
+pub fn packed_vertex(words: &[u32; 6], corner: usize) -> TerrainVertex {
+    let [w0, w1, w2, w3, w4, w5] = *words;
+    let orient = w5 >> 12 & 0x3_FFFF;
+    let block = [orient & 15, orient >> 4 & 15, orient >> 8 & 15];
+    let axis = (orient >> 12 & 3) as usize;
+    let side = orient >> 14 & 1;
+    let (start, dir) = (orient >> 15 & 3, orient >> 17 & 1);
+    let i = corner as u32;
+    let step = (start + if dir == 1 { 4 - i } else { i }) & 3;
+    let [du, dw] = ROUND[step as usize];
+    let mut pos = block;
+    pos[axis] += side;
+    pos[(axis + 1) % 3] += du;
+    pos[(axis + 2) % 3] += dw;
+    let select = w2 >> 24;
+    let us = select >> (2 * i) & 1;
+    let vs = select >> (2 * i + 1) & 1;
+    let uv = [w2 >> (6 * us) & 63, w2 >> (12 + 6 * vs) & 63].map(|k| (k << 10) as u16);
+    let light = [w3 >> 16, w4, w4 >> 12, w5][corner] & 0xFFF;
+    let light = ((light & 63) << 2 | (light >> 6 & 63) << 10) as u16;
+    let g = w1 >> (8 * i) & 255;
+    let [r, gr, b] = channels(w0).map(|t| g * t / 255);
+    TerrainVertex {
+        pos: pos.map(|c| c as f32),
+        uv,
+        layer: (w3 & 0xFFFF) as u16,
+        light,
+        color: r | gr << 8 | b << 16 | (w0 & 0xFF00_0000),
+    }
+}
+
+/// The compact layout of sorted solid quads with their tints (`SectionMesh::packed`), or
+/// nothing when it would be no smaller than their vertices.
+pub fn layout(solid: &[TerrainVertex], tints: &[u32]) -> Vec<[u32; 6]> {
+    let quads = solid.as_chunks::<4>().0;
+    let records: Vec<Option<[u32; 6]>> = quads
+        .iter()
+        .zip(tints)
+        .map(|(q, &t)| pack_quad(q, t))
+        .collect();
+    let n = quads.len();
+    let packed = records.iter().filter(|r| r.is_some()).count();
+    let full = n - packed;
+    let pad = if full > 0 {
+        n.next_multiple_of(4) - n
+    } else {
+        0
+    };
+    if n + pad + 4 * full >= 4 * n {
+        return Vec::new();
+    }
+    let mut out = Vec::with_capacity(n + pad + 4 * full);
+    let mut next = n + pad;
+    for (i, record) in records.iter().enumerate() {
+        out.push(record.unwrap_or_else(|| {
+            let at = next;
+            next += 4;
+            [(at - i) as u32, 0, 0, 0, 0, FULL]
+        }));
+    }
+    out.resize(n + pad, [0; 6]);
+    for (q, record) in quads.iter().zip(&records) {
+        if record.is_none() {
+            out.extend(
+                q.iter()
+                    .map(|v| bytemuck::cast::<TerrainVertex, [u32; 6]>(*v)),
+            );
+        }
+    }
+    out
+}
+
+/// Quads `layout` gave a record of their own.
+pub fn packed_quads(layout: &[[u32; 6]], quads: usize) -> usize {
+    layout
+        .iter()
+        .take(quads)
+        .filter(|w| w[5] & FULL == 0)
+        .count()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const TINT: u32 = 0x7F_B238;
+
+    /// An opaque colour the mesher makes of grey level `g` times `tint`.
+    fn tinted(g: u32, tint: u32) -> u32 {
+        let [r, gr, b] = channels(tint).map(|t| g * t / 255);
+        r | gr << 8 | b << 16 | 0xFF00_0000
+    }
+
+    /// The top face of block (3, 15, 5), corners in `order`: tinted, smooth lit, with
+    /// ambient occlusion darkening its corners differently.
+    fn top(order: [usize; 4]) -> [TerrainVertex; 4] {
+        let pos = [
+            [3.0, 16.0, 5.0],
+            [3.0, 16.0, 6.0],
+            [4.0, 16.0, 6.0],
+            [4.0, 16.0, 5.0],
+        ];
+        let uv = [[0, 0], [16 << 10, 0], [16 << 10, 16 << 10], [0, 16 << 10]];
+        let grays = [200, 180, 160, 200];
+        order.map(|i| TerrainVertex {
+            pos: pos[i],
+            uv: uv[i],
+            layer: 7,
+            light: 0xF0 | 0x40 << 8,
+            color: tinted(grays[i], TINT),
+        })
+    }
+
+    fn same(a: &TerrainVertex, b: &TerrainVertex) -> bool {
+        bytemuck::bytes_of(a) == bytemuck::bytes_of(b)
+    }
+
+    #[test]
+    fn a_whole_cube_face_takes_one_record_either_way_round() {
+        for order in [[0, 1, 2, 3], [2, 3, 0, 1], [0, 3, 2, 1]] {
+            let quad = top(order);
+            let words = pack_quad(&quad, TINT).expect("a whole face on the block grid packs");
+            for (corner, v) in quad.iter().enumerate() {
+                assert!(
+                    same(&packed_vertex(&words, corner), v),
+                    "{order:?} corner {corner}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn quads_off_the_grid_or_the_steps_keep_their_vertices() {
+        // Half a block up: a slab's top.
+        let mut slab = top([0, 1, 2, 3]);
+        for v in &mut slab {
+            v.pos[1] = 8.5;
+        }
+        assert!(pack_quad(&slab, TINT).is_none());
+        // A UV between the 1/32 steps.
+        let mut uv = top([0, 1, 2, 3]);
+        uv[2].uv[0] += 1;
+        assert!(pack_quad(&uv, TINT).is_none());
+        // Light between the steps of 4.
+        let mut light = top([0, 1, 2, 3]);
+        light[1].light += 1;
+        assert!(pack_quad(&light, TINT).is_none());
+    }
+
+    #[test]
+    fn a_quad_without_a_record_points_at_its_own_vertices() {
+        let mut odd = top([0, 1, 2, 3]);
+        for v in &mut odd {
+            v.pos[1] = 8.5;
+        }
+        let mut solid: Vec<TerrainVertex> = Vec::new();
+        for _ in 0..4 {
+            solid.extend(top([0, 1, 2, 3]));
+        }
+        solid.extend(odd);
+        let out = layout(&solid, &[TINT; 5]);
+        // Five records, padded to eight slots, then the odd quad's four vertices.
+        assert_eq!(out.len(), 12);
+        assert_eq!(packed_quads(&out, 5), 4);
+        assert_eq!(out[4][5], FULL);
+        let at = 4 + out[4][0] as usize;
+        for (slot, v) in out[at..at + 4].iter().zip(&odd) {
+            assert!(same(&bytemuck::cast::<[u32; 6], TerrainVertex>(*slot), v));
+        }
+        // Nothing smaller to gain: no layout at all.
+        assert!(layout(&odd, &[TINT]).is_empty());
+    }
+}

crates/horizon-client-render/src/mesher/sides.rs

@@ -74,7 +74,7 @@ fn slot(grouped: bool, n: usize) -> (usize, bool) {
 
 /// Where each part of each bucket of a mesh's solid quads ends, and the
 /// planes that tell whether a bucket can face the eye.
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct Sides {
     /// The solid quads up to the end of each part of each bucket, in mesh
     /// order (`slot`).
@@ -205,13 +205,21 @@ fn bucket(quad: &[TerrainVertex; 4]) -> usize {
 /// cutout quads are also ordered front to back within each axis-facing
 /// bucket; quads that tie keep the mesher's order (the quad's index ends its
 /// sort key), so coplanar overlays still draw over their base.
-pub fn sort(solid: &mut Vec<TerrainVertex>) -> Sides {
-    sort_parts(solid, GROUPED.load(Ordering::Relaxed))
+#[cfg(test)]
+fn sort(solid: &mut Vec<TerrainVertex>) -> Sides {
+    sort_tinted(solid, &mut Vec::new())
+}
+
+/// `sort`, moving each quad's tint in `tints` (one per quad, or none) with it.
+pub fn sort_tinted(solid: &mut Vec<TerrainVertex>, tints: &mut Vec<u32>) -> Sides {
+    let grouped = GROUPED.load(Ordering::Relaxed);
+    SORT_SCRATCH.with_borrow_mut(|scratch| sort_with(solid, tints, grouped, scratch))
 }
 
 /// `sort`, with all the opaque parts first when `grouped`.
+#[cfg(test)]
 fn sort_parts(solid: &mut Vec<TerrainVertex>, grouped: bool) -> Sides {
-    SORT_SCRATCH.with_borrow_mut(|scratch| sort_with(solid, grouped, scratch))
+    SORT_SCRATCH.with_borrow_mut(|scratch| sort_with(solid, &mut Vec::new(), grouped, scratch))
 }
 
 /// `sort`'s buffers, kept by each meshing thread so sorting a mesh allocates
@@ -222,6 +230,7 @@ struct SortScratch {
     slots: Vec<u8>,
     keys: Vec<u64>,
     sorted: Vec<[TerrainVertex; 4]>,
+    tints: Vec<u32>,
 }
 thread_local! {
     static SORT_SCRATCH: std::cell::RefCell<SortScratch> = Default::default();
@@ -233,9 +242,15 @@ fn total_order_key(v: f32) -> u32 {
     (bits ^ (((bits >> 31) as u32) >> 1) as i32) as u32 ^ 0x8000_0000
 }
 
-fn sort_with(solid: &mut Vec<TerrainVertex>, grouped: bool, scratch: &mut SortScratch) -> Sides {
+fn sort_with(
+    solid: &mut Vec<TerrainVertex>,
+    tints: &mut Vec<u32>,
+    grouped: bool,
+    scratch: &mut SortScratch,
+) -> Sides {
     let (quads, rest) = solid.as_chunks::<4>();
     debug_assert!(rest.is_empty(), "solid vertices come in quads");
+    let quads_len = quads.len();
     let cutout = |q: &[TerrainVertex; 4]| q[0].layer & OPAQUE_LAYER == 0;
     // Each quad's part, by its place in mesh order (`slot`).
     let position = |b: usize, cutout: bool| match grouped {
@@ -297,6 +312,12 @@ fn sort_with(solid: &mut Vec<TerrainVertex>, grouped: bool, scratch: &mut SortSc
         sorted.extend(keys.iter().map(|&k| quads[(k & 0xFF_FFFF) as usize]));
         solid.clear();
         solid.extend_from_slice(sorted.as_flattened());
+        if tints.len() == quads_len {
+            let sorted_tints = &mut scratch.tints;
+            sorted_tints.clear();
+            sorted_tints.extend(keys.iter().map(|&k| tints[(k & 0xFF_FFFF) as usize]));
+            std::mem::swap(tints, sorted_tints);
+        }
     }
     Sides {
         ends: slot_ends,

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

@@ -99,9 +99,14 @@ pub(crate) fn prepare_with_models(
         .filter(|name| registry.default_state(name).is_some())
         .map(|name| name.strip_prefix("minecraft:").unwrap_or(name))
         .collect();
-    let mut catalog =
-        StateModels::from_facts_with_models(root, registry, &blocks, sprites, &facts, models)?;
-    catalog.bake_standalone(root, sprites, models, standalone())?;
+    let mut catalog = {
+        let _step = crate::spans::startup::step("core.bake_states");
+        StateModels::from_facts_with_models(root, registry, &blocks, sprites, &facts, models)?
+    };
+    {
+        let _step = crate::spans::startup::step("core.bake_standalone");
+        catalog.bake_standalone(root, sprites, models, standalone())?;
+    }
     let mut placements = Vec::new();
     let mut states = Vec::new();
     for (index, (name, properties)) in GALLERY.iter().enumerate() {

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

@@ -6,7 +6,7 @@
 // the depth bounds stage, which sees the unfaded alpha.
 fn oit_cloud_color(in: Out, front: bool, fade: bool) -> vec4<f32> {
     let color = textureSample(atlas, atlas_sampler, in.uv) * select(in.back_color, in.color, front);
-    let faded = 1.0 - linear_fog(in.spherical, 0.0, globals.fog_ends.y);
+    let faded = 1.0 - linear_fog(in.fog_distance.x, 0.0, globals.fog_ends.y);
     return vec4(color.rgb, color.a * select(1.0, faded, fade));
 }
 @fragment fn fs_oit_cloud_bounds(in: Out, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {

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

@@ -289,6 +289,7 @@ impl Opt {
                 "options.modelPart.right_pants_leg",
                 "options.modelPart.hat",
             ][i],
+            Opt::SkinLayers3d => "horizon.options.three_d_skin_layers",
             Opt::MainHand => "options.mainHand",
             Opt::AllowServerListing => "options.allowServerListing",
             Opt::RealmsNotifications => "options.realmsNotifications.button",
@@ -729,6 +730,11 @@ impl Opt {
             } else {
                 "options.key.hold"
             }),
+            Opt::SkinLayers3d => tr(if s.extras.three_d_skin_layers {
+                "options.on"
+            } else {
+                "options.off"
+            }),
             Opt::ToggleAttack => tr(if s.toggle_attack {
                 "options.key.toggle"
             } else {
@@ -1013,6 +1019,7 @@ impl Opt {
             Opt::ChunkBuilder => s.prioritize_chunk_updates = next(s.prioritize_chunk_updates, 3),
             Opt::ToggleCrouch => s.toggle_crouch = !s.toggle_crouch,
             Opt::ToggleSprint => s.toggle_sprint = !s.toggle_sprint,
+            Opt::SkinLayers3d => s.extras.three_d_skin_layers = !s.extras.three_d_skin_layers,
             Opt::ToggleAttack => s.toggle_attack = !s.toggle_attack,
             Opt::ToggleUse => s.toggle_use = !s.toggle_use,
             Opt::AutoJump => s.auto_jump = !s.auto_jump,
@@ -2612,6 +2619,8 @@ impl OptionsUi {
             Page::Skin => {
                 // SkinCustomizationScreen: the seven layers, then Main Hand.
                 let mut opts: Vec<Opt> = (0..MODEL_PART_KEYS.len()).map(Opt::ModelPart).collect();
+                // Horizon's own: the outer layer as real pixels, not one box.
+                opts.push(Opt::SkinLayers3d);
                 opts.push(Opt::MainHand);
                 pairs(&opts)
             }
@@ -3595,6 +3604,12 @@ impl OptionsUi {
             let pointer_over = ui::hovered(cursor, wd.x, wd.y, wd.w, wd.h)
                 && (!wd.list || cursor.1 >= top && cursor.1 < bottom);
             let hover = pointer_over || is_focused;
+            // The tooltip is the pointer's (`setTooltip`, drawn while hovered);
+            // a keyboard-focused widget keeps it against the widget
+            // (`MenuTooltipPositioner`). Focus a mouse click leaves behind
+            // does not: the description goes when the mouse leaves, like
+            // vanilla's.
+            let tip_hover = pointer_over || (is_focused && self.focus_from_keyboard);
             // A pack's option: its label within the widget (the name shortened), and on hover
             // the whole label when it was, then what the pack says of it.
             let shader = s.shader_options.as_ref();
@@ -3609,7 +3624,7 @@ impl OptionsUi {
             let fitted = shader.zip(option).map(|(o, name)| {
                 o.option_label_within(name, wd.w - 8.0, |t| atlas.font.width_text(t))
             });
-            if hover && let Some(o) = shader {
+            if tip_hover && let Some(o) = shader {
                 let comment = match (&wd.kind, option) {
                     (_, Some(name)) => o.comment(&format!("option.{name}")),
                     (
@@ -3641,7 +3656,7 @@ impl OptionsUi {
                     tooltip_rect = (!pointer_over).then_some([wd.x, wd.y, wd.w, wd.h]);
                 }
             }
-            if hover && let Some(tip) = tooltip_text(s, wd) {
+            if tip_hover && let Some(tip) = tooltip_text(s, wd) {
                 tooltip = Some(match &wd.kind {
                     // The duplicate keybinds tooltip keeps its own lines.
                     WKind::Button {
@@ -3907,9 +3922,9 @@ impl OptionsUi {
                 };
                 return self.bind_mouse(s, button);
             }
-            let actions = self
-                .graphics
-                .click(s, (x, y), size, framebuffer, drag, right);
+            let actions =
+                self.graphics
+                    .click(s, (x, y), size, framebuffer, drag, right, self.shift);
             return self.graphics_events(s, actions);
         }
         if self.page() == Page::Packs {
@@ -4102,13 +4117,13 @@ impl OptionsUi {
                         }
                         Act::Done => events.extend(self.back(s)),
                         Act::Cycle(opt) => {
-                            events.extend(self.cycle_option(s, opt, right, framebuffer));
+                            events.extend(self.cycle_option(s, opt, self.shift, framebuffer));
                         }
                         Act::Extra(item) => {
                             if let Some(name) = item.key_name() {
                                 self.selected_key = Some(name);
                             } else {
-                                item.cycle(&mut s.extras, right);
+                                item.cycle(&mut s.extras, self.shift);
                                 events.push(Event::Changed);
                             }
                         }
@@ -6010,6 +6025,65 @@ mod tests {
         assert_eq!(s.file.fullscreen_resolution, None);
     }
 
+    #[test]
+    fn a_clicked_extras_tooltip_leaves_with_the_pointer() {
+        let atlas = atlas();
+        let mut s = Settings::default();
+        let mut ui = OptionsUi::default();
+        ui.show(Page::Extras);
+        let (widgets, _, _, _) = ui.layout(&s, 480.0, 480.0);
+        let extra = widgets
+            .iter()
+            .find(|w| {
+                matches!(
+                    &w.kind,
+                    WKind::Button {
+                        act: Act::Extra(item),
+                        ..
+                    } if !matches!(item, crate::extras::Item::SortKey)
+                )
+            })
+            .unwrap();
+        ui.click(
+            &mut s,
+            &atlas,
+            extra.x + 1.0,
+            extra.y + 1.0,
+            (480.0, 480.0),
+            [960, 540],
+            false,
+            false,
+        );
+        // The pointer is still on the clicked widget: it carries the
+        // description (`setTooltip`, drawn while hovered).
+        let mut on = HudBatch::new([480, 480]);
+        ui.draw(
+            &s,
+            &mut on,
+            &atlas,
+            (extra.x + extra.w / 2.0, extra.y + extra.h / 2.0),
+        );
+        // The pointer moved off: the description goes with it. A mouse
+        // focus a click left behind (the look-up keeps the click's widget,
+        // `focus_from_keyboard` false) does not keep the tooltip against
+        // the widget, like vanilla's `MenuTooltipPositioner` does for a
+        // keyboard focus.
+        let mut off = HudBatch::new([480, 480]);
+        ui.draw(
+            &s,
+            &mut off,
+            &atlas,
+            (extra.x + extra.w + 40.0, extra.y + extra.h + 40.0),
+        );
+        assert!(
+            off.vertices.len() < on.vertices.len(),
+            "a click left {} tooltip vertices behind when the pointer left ({} vs {})",
+            on.vertices.len() - off.vertices.len(),
+            on.vertices.len(),
+            off.vertices.len(),
+        );
+    }
+
     #[test]
     fn exclusive_fullscreen_and_its_tooltips_follow_the_option() {
         let mut s = Settings::default();
@@ -7853,4 +7927,146 @@ mod tests {
         assert!(events.contains(&Event::Changed));
         assert!(s.extras.music_off.is_empty());
     }
+
+    #[test]
+    fn options_cycle_button_cycles_forward_and_shift_click_cycles_backward_with_wrapping() {
+        let atlas = atlas();
+        let mut s = Settings::default();
+        let mut ui = OptionsUi::default();
+        ui.show(Page::Chat);
+        let size = (480.0, 480.0);
+        let (widgets, _, _, _) = ui.layout(&s, size.0, size.1);
+        let button = widgets
+            .iter()
+            .find(|wd| {
+                matches!(
+                    wd.kind,
+                    WKind::Button {
+                        active: true,
+                        act: Act::Cycle(Opt::ChatVisibility),
+                        ..
+                    }
+                )
+            })
+            .expect("ChatVisibility must be a cycle button");
+        let (x, y) = (button.x + 1.0, button.y + 1.0);
+
+        // Initial chat_visibility is 0
+        assert_eq!(s.chat_visibility, 0);
+
+        // 1. Feature without shift (normal click): cycles forward (+1)
+        assert_eq!(
+            ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false),
+            vec![Event::ButtonClick, Event::Changed]
+        );
+        assert_eq!(s.chat_visibility, 1);
+
+        assert_eq!(
+            ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false),
+            vec![Event::ButtonClick, Event::Changed]
+        );
+        assert_eq!(s.chat_visibility, 2);
+
+        // 3. Wrap-around forward (at max value, normal click wraps to min / 0)
+        assert_eq!(
+            ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false),
+            vec![Event::ButtonClick, Event::Changed]
+        );
+        assert_eq!(s.chat_visibility, 0);
+
+        // 4. Wrap-around backward (at min / 0, shift-click wraps to max)
+        ui.shift = true;
+        assert_eq!(
+            ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false),
+            vec![Event::ButtonClick, Event::Changed]
+        );
+        assert_eq!(s.chat_visibility, 2);
+
+        // 2. Feature with shift: cycles backward (-1)
+        assert_eq!(
+            ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false),
+            vec![Event::ButtonClick, Event::Changed]
+        );
+        assert_eq!(s.chat_visibility, 1);
+
+        assert_eq!(
+            ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false),
+            vec![Event::ButtonClick, Event::Changed]
+        );
+        assert_eq!(s.chat_visibility, 0);
+        ui.shift = false;
+
+        // Also test Opt::Particles on Page::Video
+        ui.show(Page::Video);
+        let (widgets, _, _, _) = ui.layout(&s, size.0, size.1);
+        let button = widgets
+            .iter()
+            .find(|wd| {
+                matches!(
+                    wd.kind,
+                    WKind::Button {
+                        active: true,
+                        act: Act::Cycle(Opt::Particles),
+                        ..
+                    }
+                )
+            })
+            .expect("Particles must be a cycle button");
+        let (px, py) = (button.x + 1.0, button.y + 1.0);
+
+        // Initial particles is 0
+        assert_eq!(s.particles, 0);
+
+        // Forward
+        ui.click(&mut s, &atlas, px, py, size, [854, 480], false, false);
+        assert_eq!(s.particles, 1);
+        ui.click(&mut s, &atlas, px, py, size, [854, 480], false, false);
+        assert_eq!(s.particles, 2);
+        // Wrap forward
+        ui.click(&mut s, &atlas, px, py, size, [854, 480], false, false);
+        assert_eq!(s.particles, 0);
+
+        // Wrap backward with shift
+        ui.shift = true;
+        ui.click(&mut s, &atlas, px, py, size, [854, 480], false, false);
+        assert_eq!(s.particles, 2);
+        // Backward with shift
+        ui.click(&mut s, &atlas, px, py, size, [854, 480], false, false);
+        assert_eq!(s.particles, 1);
+        ui.click(&mut s, &atlas, px, py, size, [854, 480], false, false);
+        assert_eq!(s.particles, 0);
+        ui.shift = false;
+
+        // Also verify Act::Extra on Page::Extras
+        ui.show(Page::Extras);
+        let (widgets, _, _, _) = ui.layout(&s, size.0, size.1);
+        if let Some(extra_btn) = widgets.iter().find(|wd| {
+            matches!(
+                wd.kind,
+                WKind::Button {
+                    active: true,
+                    act: Act::Extra(crate::extras::Item::CosmeticsOthers),
+                    ..
+                }
+            )
+        }) {
+            let (ex, ey) = (extra_btn.x + 1.0, extra_btn.y + 1.0);
+            use horizon_cosmetics::prefs::Others;
+            assert_eq!(s.extras.cosmetics_others, Others::Shown);
+
+            // Forward
+            ui.click(&mut s, &atlas, ex, ey, size, [854, 480], false, false);
+            assert_eq!(s.extras.cosmetics_others, Others::NameTags);
+
+            // Backward with shift
+            ui.shift = true;
+            ui.click(&mut s, &atlas, ex, ey, size, [854, 480], false, false);
+            assert_eq!(s.extras.cosmetics_others, Others::Shown);
+
+            // Wrap-around backward with shift
+            ui.click(&mut s, &atlas, ex, ey, size, [854, 480], false, false);
+            assert_eq!(s.extras.cosmetics_others, Others::Hidden);
+            ui.shift = false;
+        }
+    }
 }

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

@@ -19,6 +19,7 @@ use horizon_core::{
 };
 use horizon_world::block_collision::BlockCollisionRegistry;
 use std::{
+    array,
     collections::{HashMap, HashSet},
     path::Path,
 };
@@ -47,6 +48,9 @@ pub struct ParticleOptions {
     /// `GeyserParticleOptions.waterBlocks` and `GeyserBaseParticleOptions`'
     /// `waterBlocks` and `burstImpulseBase` (0 where the type has none).
     pub geyser: Option<(i32, f32)>,
+    /// `VibrationParticleOption`: the listener the signal flies to and its
+    /// arrival time in ticks (`ParticleEngine::vibration` is the same particle).
+    pub vibration: Option<([f64; 3], i32)>,
     /// A native mod's own particle type, by its namespaced name (`mymod:spark`):
     /// `SimpleParticleType` plus the provider `particles/<name>.json` names.
     pub mod_particle: Option<String>,
@@ -62,6 +66,7 @@ impl ParticleOptions {
             trail: None,
             item: None,
             geyser: None,
+            vibration: None,
             mod_particle: None,
         }
     }
@@ -87,6 +92,13 @@ impl ParticleOptions {
             ..Self::simple(ty)
         }
     }
+    /// `VibrationParticleOption(destination, arrivalInTicks)`.
+    pub fn vibration(dest: [f64; 3], ticks: i32) -> Self {
+        Self {
+            vibration: Some((dest, ticks)),
+            ..Self::simple(ParticleType::Vibration)
+        }
+    }
     /// `ItemParticleOption`: the stack's layer particle sprites (`BreakingItemParticle`).
     pub fn item(layers: Vec<String>) -> Self {
         Self {
@@ -516,7 +528,7 @@ pub fn breaking_position(
         }
     }
     // Vanilla consumes all three doubles before replacing the hit-face coordinate.
-    let mut p = std::array::from_fn(|i| {
+    let mut p = array::from_fn(|i| {
         f64::from(pos[i])
             + random.next_double() * (bounds[i + 3] - bounds[i] - f64::from(0.2f32))
             + f64::from(0.1f32)
@@ -648,18 +660,16 @@ pub fn destroy_positions(
     mut emit: impl FnMut([f64; 3], [f64; 3]),
 ) {
     for b in boxes {
-        let widths: [f64; 3] = std::array::from_fn(|i| (b[i + 3] - b[i]).min(1.0));
+        let widths: [f64; 3] = array::from_fn(|i| (b[i + 3] - b[i]).min(1.0));
         let counts: [usize; 3] = widths.map(|w| ((w / 0.25).ceil() as usize).max(2));
         for x in 0..counts[0] {
             for y in 0..counts[1] {
                 for z in 0..counts[2] {
                     let cells = [x, y, z];
                     let relative: [f64; 3] =
-                        std::array::from_fn(|i| (cells[i] as f64 + 0.5) / counts[i] as f64);
+                        array::from_fn(|i| (cells[i] as f64 + 0.5) / counts[i] as f64);
                     emit(
-                        std::array::from_fn(|i| {
-                            f64::from(pos[i]) + (relative[i] * widths[i] + b[i])
-                        }),
+                        array::from_fn(|i| f64::from(pos[i]) + (relative[i] * widths[i] + b[i])),
                         relative.map(|v| v - 0.5),
                     );
                 }
@@ -740,7 +750,7 @@ pub fn on_block_faces_between(
         let count = random.next_int_bound(max - min + 1).unwrap_or(0) + min;
         for _ in 0..count {
             // getRandomSpeedRanges, then spawnParticleOnFace with step factor 0.55.
-            let speed: [f64; 3] = std::array::from_fn(|_| next_double_between(random, -0.5, 0.5));
+            let speed: [f64; 3] = array::from_fn(|_| next_double_between(random, -0.5, 0.5));
             let mut p = [0.0; 3];
             let mut v = [0.0; 3];
             for i in 0..3 {
@@ -769,12 +779,12 @@ pub fn along_axis(
 ) {
     let count = random.next_int_bound(max - min + 1).unwrap_or(0) + min;
     for _ in 0..count {
-        let p: [f64; 3] = std::array::from_fn(|i| {
+        let p: [f64; 3] = array::from_fn(|i| {
             f64::from(pos[i])
                 + 0.5
                 + next_double_between(random, -1.0, 1.0) * if i == axis { 0.5 } else { 0.125 }
         });
-        let v: [f64; 3] = std::array::from_fn(|i| {
+        let v: [f64; 3] = array::from_fn(|i| {
             if i == axis {
                 next_double_between(random, -1.0, 1.0)
             } else {
@@ -1257,6 +1267,113 @@ impl ParticleLightCache {
     }
 }
 
+const PARTICLE_SECTION_CACHE_SIZE: usize = 128;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum SectionFrustumResult {
+    Outside,
+    Intersects,
+    Inside,
+}
+
+#[derive(Clone, Copy)]
+struct CachedSectionFrustum {
+    section: [i32; 3],
+    radius_quarters: i32,
+    result: SectionFrustumResult,
+}
+
+struct ParticleSectionFrustumCache {
+    entries: [Option<CachedSectionFrustum>; PARTICLE_SECTION_CACHE_SIZE],
+}
+
+impl Default for ParticleSectionFrustumCache {
+    fn default() -> Self {
+        Self {
+            entries: [None; PARTICLE_SECTION_CACHE_SIZE],
+        }
+    }
+}
+
+impl ParticleSectionFrustumCache {
+    fn result(
+        &mut self,
+        world: [f64; 3],
+        camera: DVec3,
+        radius: f64,
+        frustum: &crate::gfx::Frustum,
+    ) -> SectionFrustumResult {
+        let Some(section) = world_section(world) else {
+            return SectionFrustumResult::Intersects;
+        };
+        if !radius.is_finite() || radius < 0.0 || radius * 4.0 > f64::from(i32::MAX) {
+            return SectionFrustumResult::Intersects;
+        }
+        let radius_quarters = (radius * 4.0).ceil() as i32;
+        let hash = (section[0] as u32).wrapping_mul(73_856_093)
+            ^ (section[1] as u32).wrapping_mul(19_349_663)
+            ^ (section[2] as u32).wrapping_mul(83_492_791)
+            ^ (radius_quarters as u32).wrapping_mul(2_654_435_761);
+        let slot = hash as usize & (PARTICLE_SECTION_CACHE_SIZE - 1);
+        if let Some(entry) = self.entries[slot]
+            && entry.section == section
+            && entry.radius_quarters == radius_quarters
+        {
+            return entry.result;
+        }
+
+        let pad = f64::from(radius_quarters) * 0.25;
+        let camera = camera.to_array();
+        let min = array::from_fn(|axis| f64::from(section[axis]) * 16.0 - pad - camera[axis]);
+        let max = array::from_fn(|axis| min[axis] + 16.0 + 2.0 * pad);
+        let result = if min.into_iter().chain(max).any(|v| !v.is_finite()) {
+            SectionFrustumResult::Intersects
+        } else {
+            let min = FVec3::from_array(min.map(|v| v as f32));
+            let max = FVec3::from_array(max.map(|v| v as f32));
+            if !min.is_finite() || !max.is_finite() {
+                SectionFrustumResult::Intersects
+            } else if frustum.contains(min, max) {
+                SectionFrustumResult::Inside
+            } else if frustum.intersects(min, max) {
+                SectionFrustumResult::Intersects
+            } else {
+                SectionFrustumResult::Outside
+            }
+        };
+        self.entries[slot] = Some(CachedSectionFrustum {
+            section,
+            radius_quarters,
+            result,
+        });
+        result
+    }
+}
+
+fn world_section(position: [f64; 3]) -> Option<[i32; 3]> {
+    let mut block = [0; 3];
+    for axis in 0..3 {
+        let value = position[axis].floor();
+        if !value.is_finite() || value < f64::from(i32::MIN) || value > f64::from(i32::MAX) {
+            return None;
+        }
+        block[axis] = value as i32;
+    }
+    Some([block[0] >> 4, block[1] >> 4, block[2] >> 4])
+}
+
+fn below_half_pixel(radius: f64, distance_squared: f64, pixel_focal_length: f32) -> bool {
+    let projected_limit = 4.0 * radius * f64::from(pixel_focal_length);
+    radius.is_finite()
+        && radius >= 0.0
+        && distance_squared.is_finite()
+        && distance_squared > 0.0
+        && pixel_focal_length.is_finite()
+        && pixel_focal_length > 0.0
+        && projected_limit.is_finite()
+        && projected_limit * projected_limit < distance_squared
+}
+
 /// `ClientExplosionTracker.ExplosionInfo`.
 #[derive(Clone, Copy, Debug)]
 struct TrackedExplosion {
@@ -1435,15 +1552,14 @@ impl ParticleEngine {
         self.particles.clear();
         self.pending.clear();
     }
-    /// A vibration signal flying from `from` to `to` in `ticks`
-    /// (`VibrationParticleOption`).
-    pub fn vibration(&mut self, from: [f64; 3], to: [f64; 3], ticks: i32) {
+    /// `VibrationSignalParticle`'s body: the signal leaves `from` aimed at the
+    /// listener at `to` and lands there in `ticks`.
+    fn vibration_particle(from: [f64; 3], to: [f64; 3], ticks: i32) -> Particle {
         let mut q = Particle::blank(ParticleType::Vibration, from);
         q.size = 0.3;
         q.lifetime = ticks;
         q.has_physics = false;
         q.light = Light::Block15;
-        q.set = self.set_of(ParticleType::Vibration);
         let d = [from[0] - to[0], from[1] - to[1], from[2] - to[2]];
         let rot = d[0].atan2(d[2]) as f32;
         let pitch = d[1].atan2((d[0] * d[0] + d[2] * d[2]).sqrt()) as f32;
@@ -1454,6 +1570,14 @@ impl ParticleEngine {
             pitch,
             pitch_o: pitch,
         };
+        q
+    }
+    /// A vibration signal flying from `from` to `to` in `ticks`
+    /// (`VibrationParticleOption`), as the client's own vibration system
+    /// (`VibrationSystem.Ticker`) spawns one.
+    pub fn vibration(&mut self, from: [f64; 3], to: [f64; 3], ticks: i32) {
+        let mut q = Self::vibration_particle(from, to, ticks);
+        q.set = self.set_of(ParticleType::Vibration);
         self.pending.push(q);
     }
     /// `ParticleEngine.add` (via `particlesToAdd`, applied on the next tick).
@@ -1533,7 +1657,7 @@ impl ParticleEngine {
         for _ in 0..128 {
             let r = &mut self.level_random;
             let t = r.next_double();
-            let velocity = std::array::from_fn(|_| f64::from((r.next_float() - 0.5) * 0.2));
+            let velocity = array::from_fn(|_| f64::from((r.next_float() - 0.5) * 0.2));
             let position = [
                 to[0] + t * (from[0] - to[0]) + (r.next_double() - 0.5) + 0.5,
                 to[1] + t * (from[1] - to[1]) + r.next_double() - 0.5,
@@ -1561,7 +1685,7 @@ impl ParticleEngine {
         for _ in 0..128 {
             let r = &mut self.level_random;
             let t = r.next_double();
-            let velocity = std::array::from_fn(|_| f64::from((r.next_float() - 0.5) * 0.2));
+            let velocity = array::from_fn(|_| f64::from((r.next_float() - 0.5) * 0.2));
             // Mth.lerp(t, to, from).
             let position = [
                 to[0] + t * (from[0] - to[0]) + (r.next_double() - 0.5) * WIDTH * 2.0,
@@ -2758,8 +2882,16 @@ impl ParticleEngine {
                 }
                 q
             }
-            // Vibration signals are created by `vibration`, aimed at a listener.
-            T::Vibration => return None,
+            // VibrationSignalParticle.Provider: `VibrationParticleOption` carries
+            // the listener the signal flies to and its arrival time; the sprite
+            // is the set's own draw from the engine's random.
+            T::Vibration => {
+                let (dest, ticks) = o.vibration?;
+                let mut q = Self::vibration_particle(p, dest, ticks);
+                q.set = set;
+                q.sprite = self.sprite_from_set(ty);
+                q
+            }
             // ShriekParticle.
             T::Shriek => {
                 let mut q = Particle::moving(r, ty, p, [0.0; 3]);
@@ -4365,8 +4497,7 @@ impl ParticleEngine {
             .filter(|p| p.rgba[3] > 0.0)
             .filter_map(|p| {
                 let (_, rgb, reach) = shining.iter().find(|(ty, ..)| *ty == p.ty)?;
-                let at =
-                    std::array::from_fn(|i| p.previous[i] + (p.position[i] - p.previous[i]) * f);
+                let at = array::from_fn(|i| p.previous[i] + (p.position[i] - p.previous[i]) * f);
                 Some((at, *rgb, *reach, p.rgba[3].clamp(0.0, 1.0)))
             })
             .collect()
@@ -4381,11 +4512,70 @@ impl ParticleEngine {
         partial: f32,
         light_at: &dyn Fn([i32; 3]) -> u8,
         out: &mut Vec<Vertex>,
+    ) {
+        self.render_inner::<false>(
+            camera,
+            yaw,
+            pitch,
+            partial,
+            0.0,
+            None,
+            &mut |_, _| false,
+            light_at,
+            out,
+        );
+    }
+
+    /// Render particles after rejecting view-frustum misses and any particles
+    /// the caller proves hidden behind opaque terrain.
+    pub fn render_culled(
+        &self,
+        camera: DVec3,
+        yaw: f32,
+        pitch: f32,
+        partial: f32,
+        pixel_focal_length: f32,
+        culling_enabled: bool,
+        frustum: Option<&crate::gfx::Frustum>,
+        mut occluded: impl FnMut([f64; 3], [f64; 3]) -> bool,
+        light_at: &dyn Fn([i32; 3]) -> u8,
+        out: &mut Vec<Vertex>,
+    ) {
+        if !culling_enabled {
+            self.render(camera, yaw, pitch, partial, light_at, out);
+            return;
+        }
+        self.render_inner::<true>(
+            camera,
+            yaw,
+            pitch,
+            partial,
+            pixel_focal_length,
+            frustum,
+            &mut occluded,
+            light_at,
+            out,
+        );
+    }
+
+    fn render_inner<const CULL: bool>(
+        &self,
+        camera: DVec3,
+        yaw: f32,
+        pitch: f32,
+        partial: f32,
+        pixel_focal_length: f32,
+        frustum: Option<&crate::gfx::Frustum>,
+        occluded: &mut dyn FnMut([f64; 3], [f64; 3]) -> bool,
+        light_at: &dyn Fn([i32; 3]) -> u8,
+        out: &mut Vec<Vertex>,
     ) {
         // Camera.setRotation: rotationYXZ(PI - yRot, -xRot, 0).
         let base = Quat::from_rotation_y(std::f32::consts::PI - yaw.to_radians())
             * Quat::from_rotation_x(-pitch.to_radians());
         let mut light_cache = ParticleLightCache::default();
+        let mut section_cache =
+            (CULL && frustum.is_some()).then(ParticleSectionFrustumCache::default);
         for p in &self.particles {
             if p.no_render {
                 continue;
@@ -4397,6 +4587,39 @@ impl ParticleEngine {
             {
                 continue;
             }
+            if CULL && matches!(p.behaviour, Behaviour::Shriek { delay } if delay > 0) {
+                continue;
+            }
+            let culled_geometry = if CULL {
+                let a = f64::from(partial);
+                let world = array::from_fn(|i| p.previous[i] + (p.position[i] - p.previous[i]) * a);
+                let center = (DVec3::from_array(world) - camera).as_vec3();
+                let size = p.quad_size(partial);
+                // Every generated quad vertex is sqrt(2) * size from its center,
+                // including the rotated two-quad particle types.
+                let radius = f64::from(size.abs()) * std::f64::consts::SQRT_2 + 0.05;
+                if let (Some(frustum), Some(section_cache)) = (frustum, section_cache.as_mut()) {
+                    match section_cache.result(world, camera, radius, frustum) {
+                        SectionFrustumResult::Outside => continue,
+                        SectionFrustumResult::Intersects
+                            if !frustum.intersects_sphere(center, radius as f32) =>
+                        {
+                            continue;
+                        }
+                        SectionFrustumResult::Inside | SectionFrustumResult::Intersects => {}
+                    }
+                }
+                let distance_squared = f64::from(center.length_squared());
+                if below_half_pixel(radius, distance_squared, pixel_focal_length) {
+                    continue;
+                }
+                if occluded(world.map(|v| v - radius), world.map(|v| v + radius)) {
+                    continue;
+                }
+                Some((center, size))
+            } else {
+                None
+            };
             // `SubmitNodeCollection.submitQuadParticleGroup`: the translucent
             // layer draws after translucent terrain, so a crumb of stained
             // glass cannot hide the glass behind it (`getLayer`).
@@ -4412,19 +4635,20 @@ impl ParticleEngine {
                 },
             };
             let Some(r) = rect else { continue };
-            let a = f64::from(partial);
-            let pos = DVec3::new(
-                p.previous[0] + (p.position[0] - p.previous[0]) * a,
-                p.previous[1] + (p.position[1] - p.previous[1]) * a,
-                p.previous[2] + (p.position[2] - p.previous[2]) * a,
-            ) - camera;
-            let center = pos.as_vec3();
+            let (center, size) = culled_geometry.unwrap_or_else(|| {
+                let a = f64::from(partial);
+                let pos = DVec3::new(
+                    p.previous[0] + (p.position[0] - p.previous[0]) * a,
+                    p.previous[1] + (p.position[1] - p.previous[1]) * a,
+                    p.previous[2] + (p.position[2] - p.previous[2]) * a,
+                ) - camera;
+                (pos.as_vec3(), p.quad_size(partial))
+            });
             let rotation = if p.roll != 0.0 {
                 base * Quat::from_rotation_z(p.o_roll + (p.roll - p.o_roll) * partial)
             } else {
                 base
             };
-            let size = p.quad_size(partial);
             let mut alpha = p.rgba[3];
             // OverlayParticle.extract: the flash fades as it pulses.
             if p.ty == ParticleType::Flash {
@@ -4438,7 +4662,7 @@ impl ParticleEngine {
             match p.behaviour {
                 // ShriekParticle.extract: two tilted quads, fading out.
                 Behaviour::Shriek { delay } => {
-                    if delay > 0 {
+                    if !CULL && delay > 0 {
                         continue;
                     }
                     alpha = 1.0 - ((p.age as f32 + partial) / p.lifetime as f32).clamp(0.0, 1.0);
@@ -4481,7 +4705,7 @@ impl ParticleEngine {
                 // DustColorTransitionParticle.lerpColors.
                 Behaviour::Transition { from, to } => {
                     let t = (p.age as f32 + partial) / (p.lifetime as f32 + 1.0);
-                    rgb = std::array::from_fn(|i| from[i] + (to[i] - from[i]) * t);
+                    rgb = array::from_fn(|i| from[i] + (to[i] - from[i]) * t);
                 }
                 _ => {}
             }
@@ -4616,6 +4840,86 @@ mod tests {
         assert_eq!(reads.get(), 3);
     }
 
+    #[test]
+    fn subpixel_culling_uses_the_frame_projection_and_fails_open() {
+        assert!(below_half_pixel(0.01, 41.0_f64.powi(2), 1_000.0));
+        assert!(!below_half_pixel(0.01, 40.0_f64.powi(2), 1_000.0));
+        assert!(!below_half_pixel(0.01, 41.0_f64.powi(2), 0.0));
+        assert!(!below_half_pixel(0.01, f64::NAN, 1_000.0));
+        assert!(!below_half_pixel(f64::NAN, 41.0_f64.powi(2), 1_000.0));
+
+        for distance in [0.25_f32, 1.0, 8.0, 40.0, 128.0] {
+            for radius in [0.01, 0.05, 0.2] {
+                let center = FVec3::new(distance, distance * 0.3, -distance * 0.8);
+                let old = 2.0 * radius * 900.0 / f64::from(center.length()) < 0.5;
+                assert_eq!(
+                    below_half_pixel(radius, f64::from(center.length_squared()), 900.0),
+                    old
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn disabled_culled_render_matches_the_regular_particle_path() {
+        let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
+        let sprite = "test:smoke".to_owned();
+        engine.atlas.insert(
+            sprite.clone(),
+            (
+                Rect {
+                    u0: 0.0,
+                    v0: 0.0,
+                    u1: 1.0,
+                    v1: 1.0,
+                    w: 16,
+                    h: 16,
+                },
+                false,
+            ),
+        );
+        let mut random = LegacyRandom::new(7);
+        let mut particle =
+            Particle::moving(&mut random, ParticleType::Smoke, [0.0, 0.0, -3.0], [0.0; 3]);
+        particle.sprite = Sprite::Named(sprite);
+        engine.particles.push(particle);
+
+        let light_at = |_: [i32; 3]| 0xf0;
+        let mut regular = Vec::new();
+        engine.render(DVec3::ZERO, 0.0, 0.0, 0.5, &light_at, &mut regular);
+        let mut disabled = Vec::new();
+        engine.render_culled(
+            DVec3::ZERO,
+            0.0,
+            0.0,
+            0.5,
+            900.0,
+            false,
+            None,
+            |_, _| panic!("disabled culling must not query particle visibility"),
+            &light_at,
+            &mut disabled,
+        );
+
+        let attributes = |vertices: &[Vertex]| {
+            vertices
+                .iter()
+                .map(|vertex| {
+                    (
+                        vertex.pos,
+                        vertex.uv,
+                        vertex.layer,
+                        vertex.color,
+                        vertex.light,
+                        vertex.normal,
+                        vertex.glint_uv,
+                    )
+                })
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(attributes(&disabled), attributes(&regular));
+    }
+
     #[test]
     fn a_mod_particles_json_becomes_its_sprite_set() {
         let dir =
@@ -5176,6 +5480,41 @@ mod tests {
         }
         assert_eq!(engine.pending.len(), 1010);
     }
+    /// `VibrationSignalParticle.Provider.createParticle`: the provider path
+    /// the client's packet handler reaches (`add_with`) makes the signal from
+    /// the option's destination and arrival time, where it used to refuse it.
+    #[test]
+    fn a_vibration_option_makes_the_signal_its_provider_draws() {
+        let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
+        let options = ParticleOptions::vibration([10.5, 70.5, -3.5], 20);
+        // Within the camera's 32 blocks, so only the provider decides.
+        engine.add_with(&options, [0.5, 1.5, 0.5], [0.0; 3], false, false);
+        assert_eq!(engine.made().get("vibration"), Some(&1));
+        let q = engine.pending.first().expect("the signal is made");
+        assert_eq!(q.ty, ParticleType::Vibration);
+        assert_eq!(q.lifetime, 20);
+        assert!((q.size - 0.3).abs() < 1e-6);
+        assert!(!q.has_physics);
+        match &q.behaviour {
+            Behaviour::Vibration {
+                dest, rot, pitch, ..
+            } => {
+                assert_eq!(*dest, [10.5, 70.5, -3.5]);
+                // The constructor aims it from where it starts at the listener.
+                let d: [f64; 3] = [0.5 - 10.5, 1.5 - 70.5, 0.5 + 3.5];
+                assert!((*rot - d[0].atan2(d[2]) as f32).abs() < 1e-6);
+                let flat = (d[0] * d[0] + d[2] * d[2]).sqrt();
+                assert!((*pitch - d[1].atan2(flat) as f32).abs() < 1e-6);
+            }
+            _ => panic!("a vibration signal"),
+        }
+        // Only `VibrationParticleOption` carries a listener; a bare type has none.
+        let bare = ParticleOptions::simple(ParticleType::Vibration);
+        assert!(
+            engine.make(&bare, [0.0; 3], [0.0; 3], 1).is_none(),
+            "no destination, no signal"
+        );
+    }
     #[test]
     fn particle_names_round_trip() {
         for &ty in ParticleType::ALL {

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

@@ -490,7 +490,7 @@ pub struct Globals {
 
 impl Globals {
     /// The std140 block: `ivec3, float, vec3, float, vec2, int, int`.
-    fn bytes(&self, size: [u32; 2], menu_blur_radius: i32) -> [u8; 48] {
+    pub(crate) fn bytes(&self, size: [u32; 2], menu_blur_radius: i32) -> [u8; 48] {
         let mut out = Vec::with_capacity(48);
         for v in self.camera_block_pos {
             out.extend_from_slice(&v.to_le_bytes());

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

@@ -337,23 +337,28 @@ impl Settings {
             .parent()
             .map(crate::gamepad::PadSettings::load)
             .unwrap_or_default();
-        let extras = path
+        let extras_text = path
             .parent()
-            .map(crate::extras::Extras::load)
+            .and_then(|dir| fs::read_to_string(dir.join(crate::extras::FILE)).ok())
             .unwrap_or_default();
+        let mut extras = crate::extras::Extras::parse(&extras_text);
         // The enabled mods are the game folder's, shared by its players (`--player-dir`).
         let mods = path
             .parent()
             .map(|dir| crate::mod_list::ModList::load(&crate::logging::shared_dir(dir)))
             .unwrap_or_default();
         let settings = match fs::read(path) {
-            Ok(bytes) => Self {
-                horizon,
-                controller,
-                extras,
-                mods,
-                ..Self::parse(&String::from_utf8_lossy(&bytes))
-            },
+            Ok(bytes) => {
+                let text = String::from_utf8_lossy(&bytes);
+                extras.read_old_options(&extras_text, &text);
+                Self {
+                    horizon,
+                    controller,
+                    extras,
+                    mods,
+                    ..Self::parse(&text)
+                }
+            }
             Err(_) => Self {
                 horizon,
                 controller,
@@ -808,6 +813,8 @@ pub enum Opt {
     PadKeyboard,
     /// `options.modelPart.*`: one skin layer (index into `options_file::MODEL_PARTS`).
     ModelPart(usize),
+    /// 3D skin layers: the player's outer layer as extruded slabs.
+    SkinLayers3d,
     MainHand,
     AllowServerListing,
     RealmsNotifications,
@@ -844,6 +851,31 @@ mod tests {
         );
     }
     #[test]
+    fn three_d_skin_layers_move_from_options_txt_to_the_extras_file() {
+        // #8091 wrote the switch into options.txt; a player who had it on keeps
+        // it, and the next options.txt is vanilla's again.
+        let dir = std::env::temp_dir().join(format!(
+            "horizon-skin-layers-{}-{:?}",
+            std::process::id(),
+            std::thread::current().id()
+        ));
+        fs::create_dir_all(&dir).unwrap();
+        fs::write(dir.join("options.txt"), "fov:0.5\nthreeDSkinLayers:true\n").unwrap();
+        let s = Settings::load(&dir.join("options.txt"));
+        assert!(s.extras.three_d_skin_layers);
+        assert_eq!(s.fov, 90.0);
+        assert!(!s.serialize().contains("threeDSkinLayers"));
+        assert!(crate::extras::Extras::parse(&s.extras.serialize()).three_d_skin_layers);
+        // Once horizon-extras.txt has its own line, a stale options.txt one is ignored.
+        fs::write(dir.join(crate::extras::FILE), "threeDSkinLayers:false\n").unwrap();
+        assert!(
+            !Settings::load(&dir.join("options.txt"))
+                .extras
+                .three_d_skin_layers
+        );
+        let _ = fs::remove_dir_all(&dir);
+    }
+    #[test]
     fn an_option_set_keeps_horizon_files() {
         let mut s = Settings::parse("fov:70\n");
         s.mods.enabled.insert("zoom".into());

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

@@ -814,6 +814,17 @@ pub struct Downloader {
 /// without end; the disk cache holds everything it drops.
 const MAX_SKIN_IMAGES: usize = 1024;
 impl Downloader {
+    /// The decoded 64×64 RGBA image an atlas location holds, when it is
+    /// still in memory (3D skin layers builds its geometry from it, and the
+    /// disk cache backs whatever was dropped).
+    pub fn image(&self, location: &str) -> Option<&[u8]> {
+        self.images.get(location).map(Vec::as_slice)
+    }
+    /// Keeps a decoded image under `location` for the images read back later
+    /// (a launcher's offline skin, which skips `queue`).
+    pub fn remember_image(&mut self, location: &str, rgba: &[u8]) {
+        self.remember(location.to_owned(), rgba.to_vec());
+    }
     pub fn new(root: std::path::PathBuf) -> Self {
         let (send, done) = std::sync::mpsc::channel();
         Self {

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

@@ -18,8 +18,15 @@ thread_local! {
     static HERE: Cell<bool> = const { Cell::new(false) };
     /// How many timed spans the thread is inside: the next span's [`Span::depth`].
     static DEPTH: Cell<u8> = const { Cell::new(0) };
+    /// What this thread's slowest steps were busy with since it last took them ([`note`]).
+    static NOTES: RefCell<Vec<(f32, String)>> = const { RefCell::new(Vec::new()) };
 }
 
+/// The shortest step a [`note`] keeps, in milliseconds.
+pub const NOTE_MS: f32 = 10.0;
+/// The notes a thread keeps between two [`take_notes`]: its slowest steps.
+const NOTES_KEPT: usize = 3;
+
 /// A named timing: wall milliseconds and the thread's CPU milliseconds in it.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct Span {
@@ -83,6 +90,36 @@ pub fn time<T>(name: &'static str, f: impl FnOnce() -> T) -> T {
     });
     out
 }
+/// Notes that one step inside a span took `ms` milliseconds doing `what` (one player's
+/// packets, say), when this thread records spans and the step took at least [`NOTE_MS`]: a
+/// span says where a slow tick went, its notes whose doing it was. Only the slowest few are
+/// kept, and `what` is built only for a step that is.
+pub fn note(ms: f32, what: impl FnOnce() -> String) {
+    if ms < NOTE_MS || !recording_here() {
+        return;
+    }
+    NOTES.with(|n| {
+        let mut n = n.borrow_mut();
+        if n.len() >= NOTES_KEPT {
+            let Some((i, _)) = n
+                .iter()
+                .enumerate()
+                .filter(|(_, (kept, _))| *kept < ms)
+                .min_by(|a, b| a.1.0.total_cmp(&b.1.0))
+            else {
+                return;
+            };
+            n.swap_remove(i);
+        }
+        n.push((ms, what()));
+    });
+}
+/// This thread's notes ([`note`]), slowest first; clears them.
+pub fn take_notes() -> Vec<(f32, String)> {
+    let mut notes = NOTES.with(|n| std::mem::take(&mut *n.borrow_mut()));
+    notes.sort_by(|a, b| b.0.total_cmp(&a.0));
+    notes
+}
 /// Consecutive steps of one function timed as spans: each [`Laps::lap`] records the time since
 /// the previous one (or since [`laps`]) under its name. Nothing is read while spans are off.
 pub struct Laps(Option<(Instant, Option<Duration>)>);
@@ -404,6 +441,41 @@ pub mod startup {
 #[cfg(test)]
 mod tests {
     use super::Span;
+    use std::sync::{Mutex, MutexGuard};
+
+    /// Spans on for every thread ([`super::enable`]) is process-wide: a test that turns them on
+    /// would make another, run beside it, record what it expects left out. Those tests take
+    /// this lock.
+    fn spans_switch() -> MutexGuard<'static, ()> {
+        static SWITCH: Mutex<()> = Mutex::new(());
+        SWITCH.lock().unwrap_or_else(|e| e.into_inner())
+    }
+
+    /// A slow tick's notes are its slowest steps, slowest first; short steps and steps on a
+    /// thread that records no spans leave none.
+    #[test]
+    fn notes_keep_the_slowest_steps() {
+        let _switch = spans_switch();
+        super::record_here(false);
+        super::note(500.0, || "unrecorded".into());
+        assert!(super::take_notes().is_empty());
+        super::record_here(true);
+        for (ms, what) in [
+            (12.0, "a"),
+            (900.0, "b"),
+            (3.0, "short"),
+            (40.0, "c"),
+            (11.0, "d"),
+            (60.0, "e"),
+        ] {
+            super::note(ms, || what.into());
+        }
+        let notes: Vec<(f32, String)> = super::take_notes();
+        super::record_here(false);
+        let names: Vec<&str> = notes.iter().map(|(_, w)| w.as_str()).collect();
+        assert_eq!(names, ["b", "e", "c"]);
+        assert!(super::take_notes().is_empty(), "taking them clears them");
+    }
 
     /// Spans of one name add up; a span the thread spent mostly waiting
     /// shows its CPU time after the wall time, short ones are left out.
@@ -515,6 +587,7 @@ mod tests {
     /// Laps record the steps between them while spans are on, and nothing while off.
     #[test]
     fn laps_time_consecutive_steps() {
+        let _switch = spans_switch();
         let _ = super::take();
         let mut off = super::laps();
         off.lap("unseen");

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

@@ -1,7 +1,7 @@
 //! Splitscreen's profile page (Horizon's Splitscreen setting): a joining player picks a profile,
 //! or makes one, before entering P1's world, and a player in it switches to another from its
 //! pause menu (Splitscreen Settings), playing on until the new one can join. A profile is a name
-//! (kept in the game folder), with its own options. The
+//! (instance-local offline names and the launcher's Microsoft accounts), with its own options. The
 //! game fills the list when the page opens (`filled`), takes the choice, and says why a pick
 //! can't play (`refused`). Built from vanilla's widgets.
 use crate::{
@@ -56,10 +56,12 @@ pub fn wrap(text: &str, max: f32, width: impl Fn(&str) -> f32) -> Vec<String> {
 pub struct SplitProfiles {
     /// The game filled the page since it opened.
     pub filled: bool,
-    /// The profiles; those playing now (none can be picked twice); and the one this player plays
-    /// as (switching; none while joining).
+    /// The profiles; those playing now (none can be picked twice); the signed-in Microsoft
+    /// accounts among them; and the one this player plays as (switching; none while joining).
     pub names: Vec<String>,
     pub taken: Vec<String>,
+    pub accounts: Vec<String>,
+    pub offline_accounts: Vec<String>,
     pub current: Option<String>,
     /// Why the last pick can't play (an online server, an expired sign-in), until the next.
     pub refused: Option<String>,
@@ -127,7 +129,7 @@ impl SplitProfiles {
     }
 
     fn editable(&self, name: &str) -> bool {
-        !self.taken.contains(&name.to_owned())
+        !self.accounts.contains(&name.to_owned()) && !self.taken.contains(&name.to_owned())
     }
 
     fn buttons(&self, w: f32, h: f32) -> Vec<Button> {
@@ -179,24 +181,34 @@ impl SplitProfiles {
             .skip(self.page() * SHOWN)
             .take(SHOWN)
         {
+            let microsoft = self.accounts.contains(name);
             let mut label = name.clone();
+            if microsoft {
+                label.push_str(&if self.offline_accounts.contains(name) {
+                    tr("horizon.splitscreen.profiles.offline", " (Offline)")
+                } else {
+                    tr("horizon.splitscreen.profiles.microsoft", " (Microsoft)")
+                });
+            }
             if self.current.as_ref() == Some(name) {
                 label.push_str(&tr("horizon.splitscreen.profiles.you", " - you"));
             }
             let y = 44.0 + (i % SHOWN) as f32 * 24.0;
             buttons.push((
-                [x, y, 176.0, 20.0],
+                [x, y, if microsoft { 200.0 } else { 176.0 }, 20.0],
                 label,
                 !self.taken.contains(name),
                 Target::Profile(i),
             ));
-            buttons.push((
-                [x + 180.0, y, 20.0, 20.0],
-                tr("horizon.splitscreen.profiles.forget_named", "Forget %s")
-                    .replacen("%s", name, 1),
-                self.editable(name),
-                Target::Remove(i),
-            ));
+            if !microsoft {
+                buttons.push((
+                    [x + 180.0, y, 20.0, 20.0],
+                    tr("horizon.splitscreen.profiles.forget_named", "Forget %s")
+                        .replacen("%s", name, 1),
+                    self.editable(name),
+                    Target::Remove(i),
+                ));
+            }
         }
         let mut y = 52.0 + self.names.len().min(SHOWN) as f32 * 24.0;
         if self.names.len() > SHOWN {
@@ -322,6 +334,19 @@ impl SplitProfiles {
         for ([x, y, bw, bh], label, enabled, target) in &buttons {
             let hover = ui::hovered(cursor, *x, *y, *bw, *bh);
             let remove = matches!(target, Target::Remove(_));
+            if hover && let Target::Profile(i) = target {
+                let name = &self.names[*i];
+                if self.accounts.contains(name) {
+                    tip = Some(if self.offline_accounts.contains(name) {
+                        tr(
+                            "horizon.splitscreen.profiles.sign_in",
+                            "Sign in again in the launcher",
+                        )
+                    } else {
+                        tr("horizon.splitscreen.profiles.online", "Microsoft online")
+                    });
+                }
+            }
             let mut text = Text::literal(if remove { "" } else { label });
             if matches!(target, Target::Forget) {
                 text = text.with_color(0xFF5555);
@@ -584,14 +609,31 @@ mod tests {
             names: (0..11).map(|i| format!("Player{i}")).collect(),
             ..Default::default()
         };
+        p.accounts = vec!["Player10".into()];
         press(&mut p, &atlas, "Next");
         press(&mut p, &atlas, "Next");
-        press(&mut p, &atlas, "Player10");
+        press(&mut p, &atlas, "Player10 (Microsoft)");
         assert_eq!(p.take_choice(), Some(Some("Player10".into())));
         press(&mut p, &atlas, "Previous");
         assert!(p.buttons(427.0, 240.0).iter().any(|b| b.1 == "Player4"));
     }
 
+    #[test]
+    fn unavailable_accounts_are_marked_and_cannot_be_forgotten() {
+        let mut p = SplitProfiles {
+            names: vec!["Cal".into()],
+            accounts: vec!["Cal".into()],
+            offline_accounts: vec!["Cal".into()],
+            ..Default::default()
+        };
+        assert!(!p.editable("Cal"));
+        let buttons = p.buttons(427.0, 240.0);
+        assert!(buttons.iter().any(|b| b.1 == "Cal (Offline)" && b.2));
+        assert!(!buttons.iter().any(|b| b.1 == "Forget Cal"));
+        press(&mut p, &atlas(), "Cal (Offline)");
+        assert_eq!(p.take_choice(), Some(Some("Cal".into())));
+    }
+
     #[test]
     fn profile_names_are_player_names() {
         assert!(valid_name("Steve_2"));

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

@@ -62,6 +62,15 @@ impl SpriteAnimation {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+struct StillKey {
+    frame: u64,
+    pbr: u64,
+    side: u32,
+    settings: [u32; 2],
+    flags: [bool; 4],
+}
+
 #[derive(Default)]
 pub struct Sprites {
     /// Edge length of every array layer and the layers' current frames, set
@@ -90,7 +99,7 @@ pub struct Sprites {
     /// Still textures by their pixels, their LabPBR maps and mip settings: mods copy vanilla's
     /// textures under their own names, and one layer serves them all (the GPU's array may
     /// hold as few as 2048).
-    still: std::collections::HashMap<(Vec<u8>, u64, u32, [u32; 2], [bool; 4]), u32>,
+    still: std::collections::HashMap<StillKey, u32>,
     /// Decoded textures kept on disk between launches ([`Sprites::with_disk_cache`]).
     disk: Option<crate::sprite_cache::SpriteCache>,
     /// Textures [`Sprites::prefetch`] decoded ahead of their insert, by sprite name or
@@ -647,18 +656,20 @@ impl Sprites {
         };
         let still = (animation.is_none() && frames.len() == 1).then(|| {
             use std::hash::{Hash, Hasher};
+            let mut frame = std::collections::hash_map::DefaultHasher::new();
+            frames[0].hash(&mut frame);
             let mut maps = std::collections::hash_map::DefaultHasher::new();
             pbr.hash(&mut maps);
-            (
-                frames[0].clone(),
-                maps.finish(),
+            StillKey {
+                frame: frame.finish(),
+                pbr: maps.finish(),
                 side,
-                [
+                settings: [
                     settings.strategy as u32,
                     settings.alpha_cutoff_bias.to_bits(),
                 ],
-                [settings.has_transparent, settings.item, opaque, translucent],
-            )
+                flags: [settings.has_transparent, settings.item, opaque, translucent],
+            }
         });
         if let Some(&same) = still.as_ref().and_then(|k| self.still.get(k)) {
             self.layers.insert(name.to_owned(), same);

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

@@ -1224,6 +1224,14 @@ impl Streaming {
                 world.layout().sections() as i32,
             );
         }
+        // `ChunkTaskPriorityQueue.release` for each of them (`ChunkTaskDispatcher`'s
+        // `release(col, true)` from the chunk's unload): the jobs still queued for a
+        // column go with it instead of running for a level they no longer belong to.
+        if !gone.is_empty()
+            && let Ok(mut queue) = self.shared.queue.lock()
+        {
+            release_columns(&mut queue, gone);
+        }
         let mut chunks = Vec::with_capacity(gone.len());
         for &(x, z) in gone {
             self.lit.remove(&(x, z));
@@ -2879,6 +2887,25 @@ fn rank_again(queue: &mut BinaryHeap<Queued>, distance: impl Fn(i32, i32) -> i64
     }
     *queue = BinaryHeap::from(jobs);
 }
+/// `ChunkTaskPriorityQueue.release(pos, clearQueue=true)`: the jobs queued for the
+/// `gone` columns are dropped, so a view that moved or shrank does not wait behind the
+/// generation of the chunks it left. A job without a column (a save, meshes to free)
+/// stays, as vanilla keeps the tasks of a chunk that is still loaded. Returns how many
+/// jobs went.
+fn release_columns(queue: &mut BinaryHeap<Queued>, gone: &FxHashSet<(i32, i32)>) -> usize {
+    if queue.is_empty() || gone.is_empty() {
+        return 0;
+    }
+    let queued = std::mem::take(queue).into_vec();
+    let before = queued.len();
+    let kept: Vec<Queued> = queued
+        .into_iter()
+        .filter(|job| !job.at.is_some_and(|at| gone.contains(&at)))
+        .collect();
+    let released = before - kept.len();
+    *queue = BinaryHeap::from(kept);
+    released
+}
 /// Whether the 3x3 a light job for (x, z) reads is all there: every
 /// neighbour a finished column, or a decorated proto chunk past the area
 /// (the last FULL ring lights against neighbours at FEATURES, as
@@ -3310,6 +3337,59 @@ mod tests {
         assert_eq!(queue.pop().and_then(|q| q.at), Some((20, 0)));
     }
 
+    /// `ChunkTaskPriorityQueue.release`: a column that unloaded keeps no queued job, so
+    /// a teleport or a smaller render distance does not spend its workers on the world
+    /// it left; the other columns' jobs and the jobs without a column (saves, meshes to
+    /// free) stay, in the same order.
+    #[test]
+    fn a_released_column_keeps_no_queued_job() {
+        let generate = |x, z, priority, order| Queued {
+            priority,
+            at: Some((x, z)),
+            bias: 0,
+            order,
+            job: Job::Generate(x, z),
+        };
+        let save = |order| Queued {
+            priority: i64::MIN,
+            at: None,
+            bias: 0,
+            order,
+            job: Job::Save(Vec::new()),
+        };
+        let queued = || {
+            BinaryHeap::from(vec![
+                generate(0, 0, 0, 1),
+                generate(0, 0, 4, 2),
+                generate(1, 0, 8, 3),
+                generate(9, 9, 12, 4),
+                save(5),
+            ])
+        };
+        let pops = |mut queue: BinaryHeap<Queued>| {
+            std::iter::from_fn(move || queue.pop())
+                .map(|q| q.at)
+                .collect::<Vec<_>>()
+        };
+        // Nothing goes for a column that is still loaded, or for nothing at all.
+        let mut queue = queued();
+        assert_eq!(release_columns(&mut queue, &FxHashSet::default()), 0);
+        assert_eq!(
+            release_columns(&mut queue, &[(20, 20)].into_iter().collect()),
+            0
+        );
+        assert_eq!(queue.len(), 5);
+        // Both of (0, 0)'s jobs go, its neighbour's and the save stay.
+        let gone: FxHashSet<(i32, i32)> = [(0, 0)].into_iter().collect();
+        assert_eq!(release_columns(&mut queue, &gone), 2);
+        assert_eq!(pops(queue), [None, Some((1, 0)), Some((9, 9))]);
+        // Every column leaving at once: only the jobs without one are left.
+        let mut queue = queued();
+        let all: FxHashSet<(i32, i32)> = [(0, 0), (1, 0), (9, 9)].into_iter().collect();
+        assert_eq!(release_columns(&mut queue, &all), 4);
+        assert_eq!(pops(queue), [None]);
+    }
+
     /// The light and mesh stages submit bounded work, the nearest first:
     /// what exceeds the room stays dirty, to be chosen again — from the
     /// current centre — as capacity frees. Submitted whole, the queue once

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

@@ -32,13 +32,14 @@ struct Globals {
     // triangle's volume with the camera; then each rim vertex's normal against the apex.
     sunrise_fan: array<vec4<f32>, 32>,
     // x: Options.textureFiltering (0 none, 1 RGSS, 2 anisotropic), y: the sprite arrays' width
-    // in texels (vanilla's TextureSize).
+    // in texels (vanilla's TextureSize), z: the mip level at which a sprite is one texel when
+    // the views reach it, else 0 (`rotated_grid`).
     filtering: vec4<f32>,
     // HDR output's tier windows (hdr.rs `Hdr::windows`): x..w low to very bright,
     // [0] where the lift starts, [1] where it is full.
     hdr_windows: array<vec4<f32>, 2>,
     // HDR lighting: x how strongly the sky lights the world now (`Sky::sky_light_factor`),
-    // y what the sky and fog get: the same, but none under water.
+    // y what the sky and fog get: the same, but none under water; z 1 with HDR output on.
     hdr_light: vec4<f32>,
 }
 @group(0) @binding(0) var<uniform> globals: Globals;
@@ -124,12 +125,34 @@ fn sample_rgss(uv: vec2<f32>, layer: u32, pixel: vec2<f32>, du: vec2<f32>, dv: v
     let max_texel = max(texel_screen.x, texel_screen.y);
     let min_pixel = min(pixel.x, pixel.y);
     let blend = smoothstep(min_pixel, min_pixel * 2.0, max_texel);
+    // Only the side of the mix that has weight is sampled: near texels (blend 0) take
+    // sample_nearest's one tap alone, far ones (blend 1) the rotated grid alone.
+    if blend <= 0.0 {
+        return sample_nearest(uv, layer, pixel, du, dv, texel_screen, tiled);
+    }
+    let rgss = rotated_grid(uv, layer, pixel, du, dv);
+    if blend >= 1.0 {
+        return rgss;
+    }
+    return mix(sample_nearest(uv, layer, pixel, du, dv, texel_screen, tiled), rgss, blend);
+}
+fn rotated_grid(uv: vec2<f32>, layer: u32, pixel: vec2<f32>, du: vec2<f32>,
+                dv: vec2<f32>) -> vec4<f32> {
+    let min_pixel = min(pixel.x, pixel.y);
     let du_len = length(du);
     let dv_len = length(dv);
     let effective = sqrt(min(du_len, dv_len) * max(du_len, dv_len));
     let exact = max(0.0, log2(effective / min_pixel));
     let low = floor(exact);
     let mip_blend = fract(exact);
+    // From this level on the sprite is a single texel (0: the views stop before one is), and
+    // the sampler clamps any level past it to it: there every tap reads the same value, so
+    // one tap gives the four's mean. Distant tiles sit there.
+    let single = globals.filtering.z;
+    if single > 0.0 && low >= single {
+        return sprite_level(uv, layer, low);
+    }
+    let high_single = single > 0.0 && low + 1.0 >= single;
     var offsets = array<vec2<f32>, 4>(
         vec2(0.125, 0.375), vec2(-0.125, -0.375), vec2(0.375, -0.125), vec2(-0.375, 0.125));
     var sum_low = vec4(0.0);
@@ -137,10 +160,14 @@ fn sample_rgss(uv: vec2<f32>, layer: u32, pixel: vec2<f32>, du: vec2<f32>, dv: v
     for (var i = 0; i < 4; i++) {
         let p = uv + offsets[i] * pixel;
         sum_low += sprite_level(p, layer, low);
-        sum_high += sprite_level(p, layer, low + 1.0);
+        if !high_single {
+            sum_high += sprite_level(p, layer, low + 1.0);
+        }
     }
-    let rgss = mix(sum_low * 0.25, sum_high * 0.25, mip_blend);
-    return mix(sample_nearest(uv, layer, pixel, du, dv, texel_screen, tiled), rgss, blend);
+    if high_single {
+        sum_high = 4.0 * sprite_level(uv, layer, low + 1.0);
+    }
+    return mix(sum_low * 0.25, sum_high * 0.25, mip_blend);
 }
 // Distant terrain tiles (lod/mesh.rs) count their UVs in blocks past 1: each block takes the
 // sprite again, as separate faces would under the clamped sampler. Sprite UVs in [0, 1] stay.
@@ -148,10 +175,13 @@ fn tile_uv(uv: vec2<f32>) -> vec2<f32> {
     return uv - max(ceil(uv) - 1.0, vec2(0.0));
 }
 fn sprite(tiled: vec2<f32>, layer: u32) -> vec4<f32> {
-    // terrain.fsh's two sampling paths: sampleRGSS for RGSS, sampleNearest otherwise.
     // The gradients come from the unwrapped UV, so the mip level holds across block seams.
-    let du = dpdx(tiled);
-    let dv = dpdy(tiled);
+    return sprite_at(tiled, layer, dpdx(tiled), dpdy(tiled));
+}
+// `sprite` with the unwrapped UV's screen gradients given: the visibility buffer's resolve
+// (visbuffer.wgsl) works them out from the quad, as its neighbours may be other quads.
+fn sprite_at(tiled: vec2<f32>, layer: u32, du: vec2<f32>, dv: vec2<f32>) -> vec4<f32> {
+    // terrain.fsh's two sampling paths: sampleRGSS for RGSS, sampleNearest otherwise.
     let uv = tile_uv(tiled);
     // The wrap shifts a face's UVs by whole blocks, so half of one tells a tile's face from a
     // block's (whose UVs stay inside its sprite).
@@ -320,8 +350,10 @@ fn fade_code(w: f32) -> u32 {
 // (`mesher::Part`): first the quads with no cutout that are not fading, through
 // `fs_opaque`, which never discards, so a tiled GPU (Apple's) keeps hiding the pixels
 // behind them; then the rest through `fs_solid`. One discard anywhere in a pipeline's shader turned that hiding off for
-// all the terrain it drew. A quad the pass leaves out is decided before any of the
-// vertex's work and lies outside the clip volume: it makes no pixel.
+// all the terrain it drew. The draw lists give each pass only its own part; a mesh that
+// was not sorted (`Sides::unsorted`) gives both passes all of its quads, so each pass
+// still leaves out the other's: decided before any of the vertex's work, outside the
+// clip volume, it makes no pixel.
 fn opaque_quad(layer: u32, w: f32) -> bool {
     return (layer & 0x8000u) != 0u && fade_code(w) == 0u;
 }
@@ -366,6 +398,134 @@ fn left_out() -> TerrainOut {
     return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
         origin.w);
 }
+// Solid section draws that read their vertices from the arena page (gfx.rs's `pulled`
+// pipelines; `mesher/packed.rs`): a draw's vertex indices below PACKED_BASE name vertices
+// (`TerrainVertex`, six words, as `TERRAIN_ATTRIBUTES` reads them), from PACKED_BASE on a
+// corner of the quad whose record is at that slot (`PACKED_BASE + 4 * slot + corner`).
+// Either way they come out as the six words of the vertex, so the work after is the same.
+// Binding 19: visbuffer.wgsl, in the same module, takes 2 to 18 of its own group 1.
+@group(1) @binding(19) var<storage, read> arena_page: array<vec2<u32>>;
+const PACKED_BASE: u32 = 0x10000000u;
+// A vertex's words: position bits, then UV, layer with light, colour.
+struct ArenaCorner {
+    p: vec3<u32>,
+    r: vec3<u32>,
+}
+fn arena_vertex(v: u32) -> ArenaCorner {
+    let a = arena_page[v * 3u];
+    let b = arena_page[v * 3u + 1u];
+    let c = arena_page[v * 3u + 2u];
+    return ArenaCorner(vec3(a.x, a.y, b.x), vec3(b.y, c.x, c.y));
+}
+// `packed::packed_vertex`: corner `corner` of the record whose words are lo (0 to 2) and
+// hi (3 to 5).
+fn packed_corner(lo: vec3<u32>, hi: vec3<u32>, corner: u32) -> ArenaCorner {
+    let orient = (hi.z >> 12u) & 0x3ffffu;
+    let block = vec3(orient & 15u, (orient >> 4u) & 15u, (orient >> 8u) & 15u);
+    let axis = (orient >> 12u) & 3u;
+    let side = (orient >> 14u) & 1u;
+    let start = (orient >> 15u) & 3u;
+    let dir = (orient >> 17u) & 1u;
+    let step = (start + select(corner, 4u - corner, dir == 1u)) & 3u;
+    let du = select(0u, 1u, step == 1u || step == 2u);
+    let dw = select(0u, 1u, step >= 2u);
+    var pos = block;
+    pos[axis] = block[axis] + side;
+    pos[(axis + 1u) % 3u] = block[(axis + 1u) % 3u] + du;
+    pos[(axis + 2u) % 3u] = block[(axis + 2u) % 3u] + dw;
+    let sel = lo.z >> 24u;
+    let us = (sel >> (2u * corner)) & 1u;
+    let vs = (sel >> (2u * corner + 1u)) & 1u;
+    let u = (lo.z >> (6u * us)) & 63u;
+    let v = (lo.z >> (12u + 6u * vs)) & 63u;
+    var light = hi.z;
+    if corner == 0u {
+        light = hi.x >> 16u;
+    } else if corner == 1u {
+        light = hi.y;
+    } else if corner == 2u {
+        light = hi.y >> 12u;
+    }
+    light &= 0xfffu;
+    let packed_light = ((light & 63u) << 2u) | (((light >> 6u) & 63u) << 10u);
+    let g = (lo.y >> (8u * corner)) & 255u;
+    let t = lo.x;
+    let color = (g * ((t >> 16u) & 255u) / 255u) | ((g * ((t >> 8u) & 255u) / 255u) << 8u)
+        | ((g * (t & 255u) / 255u) << 16u) | (t & 0xff000000u);
+    return ArenaCorner(bitcast<vec3<u32>>(vec3<f32>(pos)),
+        vec3((u << 10u) | (v << 26u), (hi.x & 0xffffu) | (packed_light << 16u), color));
+}
+// A solid draw's vertex `vertex`, and the slot its block is found by (`block_slots`, 256
+// slots a block): the vertex's own, or its quad's record's. `packed`: it has a record.
+struct SectionCorner {
+    c: ArenaCorner,
+    slot: u32,
+    packed: bool,
+}
+fn section_corner(vertex: u32) -> SectionCorner {
+    if vertex < PACKED_BASE {
+        return SectionCorner(arena_vertex(vertex), vertex, false);
+    }
+    let slot = (vertex - PACKED_BASE) >> 2u;
+    let corner = vertex & 3u;
+    let a = arena_page[slot * 3u];
+    let b = arena_page[slot * 3u + 1u];
+    let c = arena_page[slot * 3u + 2u];
+    // `packed::FULL`: the quad's four vertices, word 0 slots on.
+    if (c.y & 0x80000000u) != 0u {
+        return SectionCorner(arena_vertex(slot + a.x + corner), slot, true);
+    }
+    return SectionCorner(packed_corner(vec3(a.x, a.y, b.x), vec3(b.y, c.x, c.y), corner), slot,
+        true);
+}
+// The colour as the vertex fetch converts a Unorm8x4 attribute, bit for bit (Apple's M1:
+// times 1/255; `unpack4x8unorm` and the correctly rounded c / 255 each differ from it for
+// some bytes, and moved a few pixels' colour or alpha cutout).
+fn unorm8x4(c: u32) -> vec4<f32> {
+    return vec4<f32>(vec4(c & 255u, (c >> 8u) & 255u, (c >> 16u) & 255u, c >> 24u))
+        * (1.0 / 255.0);
+}
+fn corner_layer(c: ArenaCorner) -> u32 {
+    return c.r.y & 0xffffu;
+}
+fn corner_vertex(c: ArenaCorner, origin: vec4<f32>) -> TerrainOut {
+    let uv = vec2(c.r.x & 0xffffu, c.r.x >> 16u);
+    let light = vec2((c.r.y >> 16u) & 0xffu, c.r.y >> 24u);
+    return terrain_vertex(bitcast<vec3<f32>>(c.p), terrain_uv(uv, origin.w), corner_layer(c),
+        unorm8x4(c.r.z), light, origin.xyz, origin.w);
+}
+@vertex fn vs_section(@builtin(vertex_index) vertex: u32,
+    @location(5) origin: vec4<f32>) -> TerrainOut {
+    return corner_vertex(section_corner(vertex).c, origin);
+}
+@vertex fn vs_section_opaque(@builtin(vertex_index) vertex: u32,
+    @location(5) origin: vec4<f32>) -> TerrainOut {
+    let s = section_corner(vertex);
+    if !opaque_quad(corner_layer(s.c), origin.w) { return left_out(); }
+    return corner_vertex(s.c, origin);
+}
+@vertex fn vs_section_cutout(@builtin(vertex_index) vertex: u32,
+    @location(5) origin: vec4<f32>) -> TerrainOut {
+    let s = section_corner(vertex);
+    if opaque_quad(corner_layer(s.c), origin.w) { return left_out(); }
+    return corner_vertex(s.c, origin);
+}
+@vertex fn vs_section_flat(@builtin(vertex_index) vertex: u32) -> TerrainOut {
+    let s = section_corner(vertex);
+    return corner_vertex(s.c, slot_origins[block_slots[s.slot >> 8u]]);
+}
+@vertex fn vs_section_flat_opaque(@builtin(vertex_index) vertex: u32) -> TerrainOut {
+    let s = section_corner(vertex);
+    let origin = slot_origins[block_slots[s.slot >> 8u]];
+    if !opaque_quad(corner_layer(s.c), origin.w) { return left_out(); }
+    return corner_vertex(s.c, origin);
+}
+@vertex fn vs_section_flat_cutout(@builtin(vertex_index) vertex: u32) -> TerrainOut {
+    let s = section_corner(vertex);
+    let origin = slot_origins[block_slots[s.slot >> 8u]];
+    if opaque_quad(corner_layer(s.c), origin.w) { return left_out(); }
+    return corner_vertex(s.c, origin);
+}
 // HDR lighting: how far a surface's light carries it above paper white, 0 to 1. Only the
 // strongest light does, so dark stays as dark as in SDR; sky light by how the face meets the sun.
 fn hdr_scene(block: f32, sky: f32, facing: f32) -> f32 {
@@ -448,7 +608,9 @@ fn hdr_mark(tier: u32, y: f32) -> f32 {
 }
 // `fs_solid` for the opaque pass (`opaque_quad`): no fade, no cutout, no discard.
 @fragment fn fs_opaque(in: TerrainOut) -> @location(0) vec4<f32> {
-    hdr_normal = normalize(cross(dpdy(in.local), dpdx(in.local)));
+    if globals.hdr_light.z != 0.0 {
+        hdr_normal = normalize(cross(dpdy(in.local), dpdx(in.local)));
+    }
     let texel = sprite(in.uv, in.layer & 0x7fffu);
     var color = texel * in.color;
     color = mix(globals.fog_color * vec4(1.0, 1.0, 1.0, color.a), color, in.visibility);
@@ -463,7 +625,9 @@ fn hdr_mark(tier: u32, y: f32) -> f32 {
 fn solid_color(in: TerrainOut) -> vec4<f32> {
     let dx = dpdx(in.local);
     let dy = dpdy(in.local);
-    hdr_normal = normalize(cross(dy, dx));
+    if globals.hdr_light.z != 0.0 {
+        hdr_normal = normalize(cross(dy, dx));
+    }
     if faded(in.fade, in.local, dx, dy) { discard; }
     // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout.
     let texel = sprite(in.uv, in.layer & 0x7fffu);
@@ -475,6 +639,11 @@ fn solid_color(in: TerrainOut) -> vec4<f32> {
 }
 // The rest of a solid pixel's colour once it is kept: emission and fog.
 fn solid_finish(in: TerrainOut, texel: vec4<f32>, color: vec4<f32>) -> vec4<f32> {
+    return solid_finish_at(in, texel, color, dpdx(in.uv), dpdy(in.uv));
+}
+// `solid_finish` with the UV's screen gradients given (`sprite_at`).
+fn solid_finish_at(in: TerrainOut, texel: vec4<f32>, color: vec4<f32>, du: vec2<f32>,
+                   dv: vec2<f32>) -> vec4<f32> {
     // Below 0.75, alpha tells HDR output (hdr.wgsl) a light source's pixel
     // shines, at which tier (mesher::hdr_tier) and how much (hdr_mark), by the
     // texel's own brightness, so its light level and face shading don't change
@@ -482,27 +651,31 @@ fn solid_finish(in: TerrainOut, texel: vec4<f32>, color: vec4<f32>) -> vec4<f32>
     // parts, or all of it. Nothing else reads the frame's alpha.
     // Fog turns a far surface into the fog's colour: it takes the fog's light with it, or a
     // fully fogged mountain would stand out from the fog behind it.
-    let fogged = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
-        linear_fog(in.cylindrical, globals.fog.z, globals.fog.w)) * globals.fog_color.a;
-    var emissive = hdr_scene_alpha(mix(hdr_scene(in.scene.x, in.scene.y, hdr_facing()),
-        globals.hdr_light.y, fogged));
-    if in.emission > 0u {
-        // A light source's own face shines as one or stays as drawn, without the lighting.
-        emissive = 1.0;
-        let whole = in.emission > 4u;
-        let tier = select(in.emission, in.emission - 4u, whole);
-        let l = in.layer & 0x7fffu;
-        let t = textureLoad(emission_thresholds, vec2(i32(l % SPRITE_SPLIT), i32(l / SPRITE_SPLIT)), 0);
-        let y = brightness(texel.rgb);
-        // All over means all over: the sprite's range is one frame's, and an animated sprite's
-        // other frames dip below it. Fog hides a light source as it hides everything else.
-        if whole || y >= t.r {
-            emissive = hdr_mark(tier, y * (1.0 - fogged));
+    // Without HDR output nothing reads the alpha, so its lighting is not worked out.
+    var emissive = 1.0;
+    if globals.hdr_light.z != 0.0 {
+        let fogged = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
+            linear_fog(in.cylindrical, globals.fog.z, globals.fog.w)) * globals.fog_color.a;
+        emissive = hdr_scene_alpha(mix(hdr_scene(in.scene.x, in.scene.y, hdr_facing()),
+            globals.hdr_light.y, fogged));
+        if in.emission > 0u {
+            // A light source's own face shines as one or stays as drawn, without the lighting.
+            emissive = 1.0;
+            let whole = in.emission > 4u;
+            let tier = select(in.emission, in.emission - 4u, whole);
+            let l = in.layer & 0x7fffu;
+            let t = textureLoad(emission_thresholds, vec2(i32(l % SPRITE_SPLIT), i32(l / SPRITE_SPLIT)), 0);
+            let y = brightness(texel.rgb);
+            // All over means all over: the sprite's range is one frame's, and an animated sprite's
+            // other frames dip below it. Fog hides a light source as it hides everything else.
+            if whole || y >= t.r {
+                emissive = hdr_mark(tier, y * (1.0 - fogged));
+            }
         }
     }
     if in.emissive_layer != 0xffffffffu {
         // The high bit: an OptiFine overlay, drawn cutout (opaque where alpha >= 0.1).
-        var mask = sprite(in.uv, in.emissive_layer & 0x7fffffffu);
+        var mask = sprite_at(in.uv, in.emissive_layer & 0x7fffffffu, du, dv);
         if (in.emissive_layer & 0x80000000u) != 0u {
             mask.a = select(0.0, 1.0, mask.a >= 0.1);
         }

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

@@ -0,0 +1,427 @@
+
+// The visibility buffer for solid terrain (gfx/visbuffer.rs, `HORIZON_VISBUFFER=1`), after
+// terrain.wgsl in one module. Pass 1 rasterises the flat solid draws writing depth and, per
+// pixel, the quad it shows: its arena page and its quad in that page (`vis_id`). Pass 2, one draw for up to 16 pages, runs the shading of `fs_opaque`/`solid_color`
+// once per pixel from that ID: it reads the quad's corners from its page as the vertex shaders
+// do, runs `terrain_vertex` on the
+// triangle the pixel falls in, interpolates its outputs with perspective-correct barycentrics
+// and works out the screen gradients `dpdx`/`dpdy` would give, so the texel, mip level, light
+// and fog come out as in the normal path.
+
+// Bit 31: terrain is here; bit 30: the quad has a record (`mesher/packed.rs`); bits 24 to 29:
+// the arena page (`visbuffer::MAX_PAGES`); bits 0 to 23: the quad's record's slot in the page,
+// else its first vertex over 4 (a page holds at most `arena::PAGE_BYTES` / 24 bytes =
+// 11 184 810 slots, under 2^24).
+fn vis_id(page: u32, s: SectionCorner) -> u32 {
+    let at = 0x80000000u | ((page & 0x3fu) << 24u);
+    if s.packed {
+        return at | 0x40000000u | s.slot;
+    }
+    return at | (s.slot >> 2u);
+}
+
+// `sprite_at` (terrain.wgsl's `sample_rgss` over `sample_nearest`), sampling only what its
+// blends keep: where RGSS has not faded in (the texels span two pixels or more) the nearest
+// texel alone, where it has fully, RGSS alone, and its upper mip level only where it blends one
+// in. A blend of 0 or 1 gives exactly the one side, so the result is `sprite_at`'s; near
+// faces take one tap instead of nine.
+fn vis_sprite(tiled: vec2<f32>, layer: u32, du: vec2<f32>, dv: vec2<f32>) -> vec4<f32> {
+    let uv = tile_uv(tiled);
+    let tiled_face = any(tiled - uv >= vec2(0.5));
+    let pixel = vec2(1.0 / globals.filtering.y);
+    let texel_screen = sqrt(du * du + dv * dv);
+    if u32(globals.filtering.x) != 1u {
+        return sample_nearest(uv, layer, pixel, du, dv, texel_screen, tiled_face);
+    }
+    let max_texel = max(texel_screen.x, texel_screen.y);
+    let min_pixel = min(pixel.x, pixel.y);
+    let blend = smoothstep(min_pixel, min_pixel * 2.0, max_texel);
+    var nearest = vec4(0.0);
+    if blend < 1.0 {
+        nearest = sample_nearest(uv, layer, pixel, du, dv, texel_screen, tiled_face);
+    }
+    if blend <= 0.0 {
+        return nearest;
+    }
+    let du_len = length(du);
+    let dv_len = length(dv);
+    let effective = sqrt(min(du_len, dv_len) * max(du_len, dv_len));
+    let exact = max(0.0, log2(effective / min_pixel));
+    let low = floor(exact);
+    let mip_blend = fract(exact);
+    var offsets = array<vec2<f32>, 4>(
+        vec2(0.125, 0.375), vec2(-0.125, -0.375), vec2(0.375, -0.125), vec2(-0.375, 0.125));
+    var sum_low = vec4(0.0);
+    for (var i = 0; i < 4; i++) {
+        sum_low += sprite_level(uv + offsets[i] * pixel, layer, low);
+    }
+    var rgss = sum_low * 0.25;
+    if mip_blend > 0.0 {
+        var sum_high = vec4(0.0);
+        for (var i = 0; i < 4; i++) {
+            sum_high += sprite_level(uv + offsets[i] * pixel, layer, low + 1.0);
+        }
+        rgss = mix(rgss, sum_high * 0.25, mip_blend);
+    }
+    return mix(nearest, rgss, blend);
+}
+
+struct VisIdOut {
+    @builtin(position) clip: vec4<f32>,
+    @location(0) @interpolate(flat) id: u32,
+}
+// The quads with no cutout that are not fading (`opaque_quad`): no discard, so a tiled GPU
+// keeps hiding what lies behind them. `page`: the draw's instance, its arena page
+// (`Flat::draw_paged`).
+@vertex fn vs_vis_opaque(
+    @builtin(vertex_index) vertex: u32, @builtin(instance_index) page: u32
+) -> VisIdOut {
+    var out: VisIdOut;
+    let s = section_corner(vertex);
+    let origin = slot_origins[block_slots[s.slot >> 8u]];
+    if !opaque_quad(corner_layer(s.c), origin.w) {
+        out.clip = vec4(2.0, 2.0, 2.0, 1.0);
+        return out;
+    }
+    let position = bitcast<vec3<f32>>(s.c.p);
+    out.clip = fade_depth(globals.view_proj * vec4(position + origin.xyz, 1.0), origin.w);
+    out.id = vis_id(page, s);
+    return out;
+}
+@fragment fn fs_vis_id(in: VisIdOut) -> @location(0) u32 {
+    return in.id;
+}
+
+struct VisCutoutOut {
+    @builtin(position) clip: vec4<f32>,
+    @location(0) @interpolate(flat) id: u32,
+    @location(1) uv: vec2<f32>,
+    @location(2) @interpolate(flat) layer: u32,
+    // The vertex colour's alpha (`terrain_vertex`'s `color.a`: the lightmap's).
+    @location(3) alpha: f32,
+    @location(4) @interpolate(flat) fade: u32,
+    @location(5) local: vec3<f32>,
+}
+// The other quads: `solid_color`'s fade dither and alpha cutout, with no shading.
+@vertex fn vs_vis_cutout(
+    @builtin(vertex_index) vertex: u32, @builtin(instance_index) page: u32
+) -> VisCutoutOut {
+    var out: VisCutoutOut;
+    let s = section_corner(vertex);
+    let origin = slot_origins[block_slots[s.slot >> 8u]];
+    let layer = corner_layer(s.c);
+    if opaque_quad(layer, origin.w) {
+        out.clip = vec4(2.0, 2.0, 2.0, 1.0);
+        return out;
+    }
+    let position = bitcast<vec3<f32>>(s.c.p);
+    let uv = vec2(s.c.r.x & 0xffffu, s.c.r.x >> 16u);
+    let light = vec2((s.c.r.y >> 16u) & 0xffu, s.c.r.y >> 24u);
+    let pos = position + origin.xyz;
+    out.clip = fade_depth(globals.view_proj * vec4(pos, 1.0), origin.w);
+    out.id = vis_id(page, s);
+    out.uv = terrain_uv(uv, origin.w);
+    out.layer = layer;
+    let block = max(f32(light.y), dynamic_block_light(pos));
+    out.alpha = sample_lightmap(f32(light.x) / 16.0, block / 16.0).a;
+    out.fade = fade_code(origin.w);
+    out.local = position;
+    return out;
+}
+@fragment fn fs_vis_cutout(in: VisCutoutOut) -> @location(0) u32 {
+    let dx = dpdx(in.local);
+    let dy = dpdy(in.local);
+    if faded(in.fade, in.local, dx, dy) { discard; }
+    let alpha = vis_sprite(in.uv, in.layer & 0x7fffu, dpdx(in.uv), dpdy(in.uv)).a * in.alpha;
+    if alpha < 0.5 && (in.layer & 0x8000u) == 0u { discard; }
+    return in.id;
+}
+
+// Pass 2. Up to 16 arena pages (mesher.rs's TerrainVertex, 24 bytes: position, UV as two u16,
+// layer and light as u16 each, RGBA8 colour), a quad's 96 bytes as six vec4s; at bindings 0 and
+// 1 the block tables of all pages, page after page, `VIS_BLOCKS_PER_PAGE` entries each
+// (`Visbuffer::resolve` copies them from the flat draws' own), and the origins by section id
+// (terrain.wgsl's flat draws); pass 1's IDs.
+override VIS_BLOCKS_PER_PAGE: u32 = 1u;
+@group(1) @binding(2) var<storage, read> vis_page_0: array<vec4<u32>>;
+@group(1) @binding(3) var<storage, read> vis_page_1: array<vec4<u32>>;
+@group(1) @binding(4) var<storage, read> vis_page_2: array<vec4<u32>>;
+@group(1) @binding(5) var<storage, read> vis_page_3: array<vec4<u32>>;
+@group(1) @binding(6) var<storage, read> vis_page_4: array<vec4<u32>>;
+@group(1) @binding(7) var<storage, read> vis_page_5: array<vec4<u32>>;
+@group(1) @binding(8) var<storage, read> vis_page_6: array<vec4<u32>>;
+@group(1) @binding(9) var<storage, read> vis_page_7: array<vec4<u32>>;
+@group(1) @binding(10) var<storage, read> vis_page_8: array<vec4<u32>>;
+@group(1) @binding(11) var<storage, read> vis_page_9: array<vec4<u32>>;
+@group(1) @binding(12) var<storage, read> vis_page_10: array<vec4<u32>>;
+@group(1) @binding(13) var<storage, read> vis_page_11: array<vec4<u32>>;
+@group(1) @binding(14) var<storage, read> vis_page_12: array<vec4<u32>>;
+@group(1) @binding(15) var<storage, read> vis_page_13: array<vec4<u32>>;
+@group(1) @binding(16) var<storage, read> vis_page_14: array<vec4<u32>>;
+@group(1) @binding(17) var<storage, read> vis_page_15: array<vec4<u32>>;
+@group(1) @binding(18) var vis_ids: texture_2d<u32>;
+
+// A quad's 96 bytes, six 16-byte words from `i` on, of the page in `slot`: one switch for
+// all of them, so a thread group whose pixels show several pages walks its cases once.
+struct VisQuad {
+    q: array<vec4<u32>, 6>,
+}
+fn vis_quad(slot: u32, i: u32) -> VisQuad {
+    switch slot {
+        case 0u: {
+            return VisQuad(array(vis_page_0[i], vis_page_0[i + 1u], vis_page_0[i + 2u],
+                vis_page_0[i + 3u], vis_page_0[i + 4u], vis_page_0[i + 5u]));
+        }
+        case 1u: {
+            return VisQuad(array(vis_page_1[i], vis_page_1[i + 1u], vis_page_1[i + 2u],
+                vis_page_1[i + 3u], vis_page_1[i + 4u], vis_page_1[i + 5u]));
+        }
+        case 2u: {
+            return VisQuad(array(vis_page_2[i], vis_page_2[i + 1u], vis_page_2[i + 2u],
+                vis_page_2[i + 3u], vis_page_2[i + 4u], vis_page_2[i + 5u]));
+        }
+        case 3u: {
+            return VisQuad(array(vis_page_3[i], vis_page_3[i + 1u], vis_page_3[i + 2u],
+                vis_page_3[i + 3u], vis_page_3[i + 4u], vis_page_3[i + 5u]));
+        }
+        case 4u: {
+            return VisQuad(array(vis_page_4[i], vis_page_4[i + 1u], vis_page_4[i + 2u],
+                vis_page_4[i + 3u], vis_page_4[i + 4u], vis_page_4[i + 5u]));
+        }
+        case 5u: {
+            return VisQuad(array(vis_page_5[i], vis_page_5[i + 1u], vis_page_5[i + 2u],
+                vis_page_5[i + 3u], vis_page_5[i + 4u], vis_page_5[i + 5u]));
+        }
+        case 6u: {
+            return VisQuad(array(vis_page_6[i], vis_page_6[i + 1u], vis_page_6[i + 2u],
+                vis_page_6[i + 3u], vis_page_6[i + 4u], vis_page_6[i + 5u]));
+        }
+        case 7u: {
+            return VisQuad(array(vis_page_7[i], vis_page_7[i + 1u], vis_page_7[i + 2u],
+                vis_page_7[i + 3u], vis_page_7[i + 4u], vis_page_7[i + 5u]));
+        }
+        case 8u: {
+            return VisQuad(array(vis_page_8[i], vis_page_8[i + 1u], vis_page_8[i + 2u],
+                vis_page_8[i + 3u], vis_page_8[i + 4u], vis_page_8[i + 5u]));
+        }
+        case 9u: {
+            return VisQuad(array(vis_page_9[i], vis_page_9[i + 1u], vis_page_9[i + 2u],
+                vis_page_9[i + 3u], vis_page_9[i + 4u], vis_page_9[i + 5u]));
+        }
+        case 10u: {
+            return VisQuad(array(vis_page_10[i], vis_page_10[i + 1u], vis_page_10[i + 2u],
+                vis_page_10[i + 3u], vis_page_10[i + 4u], vis_page_10[i + 5u]));
+        }
+        case 11u: {
+            return VisQuad(array(vis_page_11[i], vis_page_11[i + 1u], vis_page_11[i + 2u],
+                vis_page_11[i + 3u], vis_page_11[i + 4u], vis_page_11[i + 5u]));
+        }
+        case 12u: {
+            return VisQuad(array(vis_page_12[i], vis_page_12[i + 1u], vis_page_12[i + 2u],
+                vis_page_12[i + 3u], vis_page_12[i + 4u], vis_page_12[i + 5u]));
+        }
+        case 13u: {
+            return VisQuad(array(vis_page_13[i], vis_page_13[i + 1u], vis_page_13[i + 2u],
+                vis_page_13[i + 3u], vis_page_13[i + 4u], vis_page_13[i + 5u]));
+        }
+        case 14u: {
+            return VisQuad(array(vis_page_14[i], vis_page_14[i + 1u], vis_page_14[i + 2u],
+                vis_page_14[i + 3u], vis_page_14[i + 4u], vis_page_14[i + 5u]));
+        }
+        default: {
+            return VisQuad(array(vis_page_15[i], vis_page_15[i + 1u], vis_page_15[i + 2u],
+                vis_page_15[i + 3u], vis_page_15[i + 4u], vis_page_15[i + 5u]));
+        }
+    }
+}
+
+struct VisResolveOut {
+    @builtin(position) clip: vec4<f32>,
+    // The group of 16 pages this draw resolves: its instance (`Visbuffer::resolve`).
+    @location(0) @interpolate(flat) chunk: u32,
+}
+@vertex fn vs_vis_resolve(@builtin(vertex_index) i: u32,
+                          @builtin(instance_index) chunk: u32) -> VisResolveOut {
+    let p = vec2(f32(i32(i & 1u) * 4 - 1), f32(i32(i >> 1u) * 4 - 1));
+    var out: VisResolveOut;
+    out.clip = vec4(p, 0.0, 1.0);
+    out.chunk = chunk;
+    return out;
+}
+
+// A framebuffer position's NDC (the world pass draws to the whole target).
+fn vis_ndc(at: vec2<f32>, size: vec2<f32>) -> vec2<f32> {
+    return vec2(at.x / size.x * 2.0 - 1.0, 1.0 - at.y / size.y * 2.0);
+}
+
+// Perspective-correct barycentrics of the point at NDC `p` on the triangle with clip-space
+// corners a, b, c (x, y, w): homogeneous 2D rasterisation (Olano and Greer). With M the matrix
+// of the corners as columns, the weights are M^-1 (p, 1) normalised, and the rows of M^-1 are
+// the corners' cross products over the determinant, which the normalisation cancels. Corners
+// behind the camera need no clipping. The rows are given (`vis_rows`), as three points share
+// them.
+fn vis_bary(rows: mat3x3<f32>, p: vec2<f32>) -> vec3<f32> {
+    let l = vec3(p, 1.0) * rows;
+    let sum = l.x + l.y + l.z;
+    if abs(sum) < 1e-30 {
+        return vec3(-1.0);
+    }
+    return l / sum;
+}
+fn vis_rows(a: vec3<f32>, b: vec3<f32>, c: vec3<f32>) -> mat3x3<f32> {
+    return mat3x3(cross(b, c), cross(c, a), cross(a, b));
+}
+
+// A corner's `terrain_vertex` from its six words: position, UV, layer and light, colour (the
+// vertex attributes `TERRAIN_ATTRIBUTES` in gfx.rs give: Float32x3, Uint16x2, Uint16, Uint8x2
+// with sky in the low byte, Unorm8x4).
+fn vis_corner(position: vec3<u32>, rest: vec3<u32>, origin: vec4<f32>) -> TerrainOut {
+    let uv = vec2(rest.x & 0xffffu, rest.x >> 16u);
+    let light = vec2((rest.y >> 16u) & 0xffu, rest.y >> 24u);
+    return terrain_vertex(bitcast<vec3<f32>>(position), terrain_uv(uv, origin.w),
+        rest.y & 0xffffu, unpack4x8unorm(rest.z), light, origin.xyz, origin.w);
+}
+
+@fragment fn fs_vis_resolve(in: VisResolveOut) -> @location(0) vec4<f32> {
+    let pixel = vec2<i32>(floor(in.clip.xy));
+    let id = textureLoad(vis_ids, pixel, 0).x;
+    let page = (id >> 24u) & 0x3fu;
+    if (id & 0x80000000u) == 0u || page / 16u != in.chunk {
+        discard;
+    }
+    let slot = page % 16u;
+    let index = id & 0xffffffu;
+    // The quad's first vertex (four of them from a multiple of 4) or its record.
+    var first = 4u * index;
+    var record = false;
+    var lo = vec3(0u);
+    var hi = vec3(0u);
+    if (id & 0x40000000u) != 0u {
+        first = index;
+        // The record's six words from word 6 * index: two 16-byte words from the one it
+        // starts in, at its start or its middle.
+        let w = vis_quad(slot, (6u * index) >> 2u).q;
+        let middle = ((6u * index) & 3u) != 0u;
+        lo = select(w[0].xyz, vec3(w[0].zw, w[1].x), middle);
+        hi = select(vec3(w[0].w, w[1].xy), w[1].yzw, middle);
+        record = (hi.z & 0x80000000u) == 0u;
+        if !record {
+            // `packed::FULL`: its four vertices, word 0 slots on.
+            first = index + lo.x;
+        }
+    }
+    // The quad's block (256 slots: 64 quads of vertices, 256 records) names its section, as
+    // for `vs_section_flat`.
+    let block = select(index >> 6u, index >> 8u, (id & 0x40000000u) != 0u);
+    let origin = slot_origins[block_slots[page * VIS_BLOCKS_PER_PAGE + block]];
+    var p0: vec3<u32>;
+    var r0: vec3<u32>;
+    var p1: vec3<u32>;
+    var r1: vec3<u32>;
+    var p2: vec3<u32>;
+    var r2: vec3<u32>;
+    var p3: vec3<u32>;
+    var r3: vec3<u32>;
+    if record {
+        let c0 = packed_corner(lo, hi, 0u);
+        let c1 = packed_corner(lo, hi, 1u);
+        let c2 = packed_corner(lo, hi, 2u);
+        let c3 = packed_corner(lo, hi, 3u);
+        p0 = c0.p;
+        r0 = c0.r;
+        p1 = c1.p;
+        r1 = c1.r;
+        p2 = c2.p;
+        r2 = c2.r;
+        p3 = c3.p;
+        r3 = c3.r;
+    } else {
+        // Corner k is words 6k to 6k + 5 of the quad's 24.
+        let words = vis_quad(slot, 6u * (first >> 2u)).q;
+        let q0 = words[0];
+        let q1 = words[1];
+        let q2 = words[2];
+        let q3 = words[3];
+        let q4 = words[4];
+        let q5 = words[5];
+        p0 = q0.xyz;
+        r0 = vec3(q0.w, q1.x, q1.y);
+        p1 = vec3(q1.z, q1.w, q2.x);
+        r1 = q2.yzw;
+        p2 = q3.xyz;
+        r2 = vec3(q3.w, q4.x, q4.y);
+        p3 = vec3(q4.z, q4.w, q5.x);
+        r3 = q5.yzw;
+    }
+    let c0 = (globals.view_proj * vec4(bitcast<vec3<f32>>(p0) + origin.xyz, 1.0)).xyw;
+    let c1 = (globals.view_proj * vec4(bitcast<vec3<f32>>(p1) + origin.xyz, 1.0)).xyw;
+    let c2 = (globals.view_proj * vec4(bitcast<vec3<f32>>(p2) + origin.xyz, 1.0)).xyw;
+    let c3 = (globals.view_proj * vec4(bitcast<vec3<f32>>(p3) + origin.xyz, 1.0)).xyw;
+    // The quad's triangles are 0 1 2 and 0 2 3 (`Renderer::quad_indices`, flatten.wgsl),
+    // either side of the diagonal 0 2. Corner 1's weight in 0 1 2 is `vis_bary`'s row
+    // cross(c2, c0) over the sum of the rows, whose sign is that of the triangle's determinant
+    // (the sum is one over the point's w), dot(c1, cross(c2, c0)): the pixel lies in 0 1 2 when
+    // the two agree. A degenerate 0 1 2 (no area, no pixels) leaves it to 0 2 3.
+    let size = vec2<f32>(textureDimensions(vis_ids));
+    let centre = in.clip.xy;
+    let p = vis_ndc(centre, size);
+    let diagonal = cross(c2, c0);
+    let det = dot(c1, diagonal);
+    let second = dot(vec3(p, 1.0), diagonal) * det < 0.0 || det == 0.0;
+    let rows = vis_rows(c0, select(c1, c2, second), select(c2, c3, second));
+    let b = vis_bary(rows, p);
+    // dpdxFine and dpdyFine: the difference to the other pixel of this one's 2x2 quad in its
+    // row and column, odd minus even, over the same triangle's plane.
+    let odd = vec2<f32>(pixel & vec2(1));
+    let toward = vec2(1.0) - 2.0 * odd;
+    let bx = vis_bary(rows, vis_ndc(centre + vec2(toward.x, 0.0), size));
+    let by = vis_bary(rows, vis_ndc(centre + vec2(0.0, toward.y), size));
+    // `terrain_vertex` on the triangle's corners, one at a time into the sums, so that only
+    // one corner's outputs are held at once; the first is the provoking one, whose flat
+    // outputs (layer, emission, fade, emissive layer) the rasteriser keeps.
+    var t = vis_corner(p0, r0, origin);
+    let uv0 = t.uv;
+    t.uv = b.x * uv0;
+    var uv_x = bx.x * uv0;
+    var uv_y = by.x * uv0;
+    t.color = b.x * t.color;
+    t.spherical = b.x * t.spherical;
+    t.cylindrical = b.x * t.cylindrical;
+    t.visibility = b.x * t.visibility;
+    let t1 = vis_corner(select(p1, p2, second), select(r1, r2, second), origin);
+    t.uv += b.y * t1.uv;
+    uv_x += bx.y * t1.uv;
+    uv_y += by.y * t1.uv;
+    t.color += b.y * t1.color;
+    t.spherical += b.y * t1.spherical;
+    t.cylindrical += b.y * t1.cylindrical;
+    t.visibility += b.y * t1.visibility;
+    let t2 = vis_corner(select(p2, p3, second), select(r2, r3, second), origin);
+    t.uv += b.z * t2.uv;
+    uv_x += bx.z * t2.uv;
+    uv_y += by.z * t2.uv;
+    t.color += b.z * t2.color;
+    t.spherical += b.z * t2.spherical;
+    t.cylindrical += b.z * t2.cylindrical;
+    t.visibility += b.z * t2.visibility;
+    let du = (uv_x - t.uv) * toward.x;
+    let dv = (uv_y - t.uv) * toward.y;
+    // HDR output alone reads the light levels and the face's normal (as in `fs_opaque`):
+    // `terrain_vertex` gives them as the block light over 16 and the sky light over 16, and the
+    // section-relative position.
+    if globals.hdr_light.z != 0.0 {
+        let local = array(bitcast<vec3<f32>>(p0), bitcast<vec3<f32>>(select(p1, p2, second)),
+            bitcast<vec3<f32>>(select(p2, p3, second)));
+        // `t.scene` is still the first corner's.
+        t.scene = b.x * t.scene + b.y * t1.scene + b.z * t2.scene;
+        t.local = b.x * local[0] + b.y * local[1] + b.z * local[2];
+        let dlx = (bx.x * local[0] + bx.y * local[1] + bx.z * local[2] - t.local) * toward.x;
+        let dly = (by.x * local[0] + by.y * local[1] + by.z * local[2] - t.local) * toward.y;
+        hdr_normal = normalize(cross(dly, dlx));
+    }
+    // `fs_opaque` and `solid_color` past their discards, which pass 1 already made.
+    let texel = vis_sprite(t.uv, t.layer & 0x7fffu, du, dv);
+    var color = texel * t.color;
+    color = mix(globals.fog_color * vec4(1.0, 1.0, 1.0, color.a), color, t.visibility);
+    return solid_finish_at(t, texel, color, du, dv);
+}

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

@@ -386,6 +386,7 @@ impl World {
             chunk.motion_blocking(x & 15, z & 15, |v| blocks(BlockStateId(v)))
         })
     }
+    #[inline]
     pub fn block(&self, x: i32, y: i32, z: i32) -> BlockStateId {
         self.chunks
             .get(&(x >> 4, z >> 4))

crates/horizon-client/assets/horizon/lang/af_za.json

@@ -0,0 +1,482 @@
+{
+  "horizon.options.controller": "Beheerder",
+  "horizon.options.vibration": "Vibrasie",
+  "horizon.options.adaptive_triggers": "Aanpasbare snellers",
+  "horizon.options.lightbar": "Ligbalk",
+  "horizon.options.look_sensitivity": "Kyksensitiwiteit",
+  "horizon.options.invert_x": "Omgekeerde kyk X",
+  "horizon.options.invert_y": "Omgekeerde kyk Y",
+  "horizon.options.sneak_button": "Sluipknoppie",
+  "horizon.options.move_deadzone": "Bewegingsdooiesone",
+  "horizon.options.look_deadzone": "Kykdooiesone",
+  "horizon.options.button_glyphs": "Knoppie Glyphs",
+  "horizon.options.menu_navigation": "Kieslysnavigasie",
+  "horizon.options.on_screen_keyboard": "Sleutelbord op die skerm",
+  "horizon.options.chat_delay": "Chat Vertraging",
+  "horizon.options.lightbar.health": "Gesondheid",
+  "horizon.options.lightbar.dimension": "Dimensie",
+  "horizon.options.glyphs.auto": "Outo",
+  "horizon.options.menu_focus": "Fokus",
+  "horizon.options.menu_pointer": "Wyser",
+  "horizon.options.keyboard.auto": "Outo",
+  "horizon.options.unavailable": "Hierdie kenmerk is nog nie in Horizon beskikbaar nie.",
+  "horizon.options.search": "Soek instellings...",
+  "horizon.pages.shader_packs": "Shader Pakke",
+  "horizon.pages.shader_options": "Shader Opsies",
+  "horizon.pages.controller": "Beheerderinstellings",
+  "horizon.pages.controller_binds": "Kontroleerder bind",
+  "horizon.pages.extras": "Horizon-ekstras",
+  "horizon.pages.settings": "Horizon-instellings",
+  "horizon.pages.agent": "KI Agent",
+  "horizon.split.leave": "Los",
+  "horizon.pages.split_settings": "Verdeelskerm-instellings",
+  "horizon.pages.split_profiles": "Wie speel?",
+  "horizon.pages.split_setup": "Verdeelskerm-opstelling",
+  "horizon.pages.music": "Musiek",
+  "horizon.pages.music.menu": "Spyskaart",
+  "horizon.pages.music.overworld": "Oorwêreld",
+  "horizon.pages.music.creative": "Kreatief",
+  "horizon.pages.music.underwater": "Onderwater",
+  "horizon.pages.music.end": "Die Einde",
+  "horizon.pages.music.boss": "Baas",
+  "horizon.pages.music.credits": "Krediete",
+  "horizon.pages.music.overworld_biomes": "Oorwêreld biome",
+  "horizon.pages.music.nether_biomes": "Onder biome",
+  "horizon.pages.music.end_biomes": "Eindig biome",
+  "horizon.pages.music.other": "Ander musiek",
+  "horizon.pages.music.empty": "Geen musieksnitte nie: die speletjie se klanke is nie gelaai nie.",
+  "horizon.pages.music.tooltip": "Die ingeboude snitte, volgens situasie: speel nou een, of skakel enige af sodat die speletjie ophou om dit te kies.",
+  "horizon.pages.settings.tooltip": "Horizon se eie instellings: grafika, beheerders, ekstras en mods.",
+  "horizon.pages.graphics.tooltip": "Grafika, eenvoudig: elke instelling sê wat dit kos.",
+  "horizon.pages.graphics_advanced.tooltip": "Elke grafiese instelling, Horizon s'n ingesluit, met wat elkeen kos.",
+  "horizon.pages.controller.tooltip": "Beheerders: hul knoppies, stokke, vibrasie en spyskaartnavigasie.",
+  "horizon.pages.extras.tooltip": "Opsionele toevoegings, alles by verstek af: die speletjie bly vanielje totdat jy een aanskakel.",
+  "horizon.pages.agent.tooltip": "Laat jou eie KI-agent speel: horizon-ctl en MCP-kliënte op hierdie rekenaar.",
+  "horizon.pages.split_profiles.tooltip": "Wie speel: 'n profiel wat in hierdie speletjie-lêergids gehou word.",
+  "horizon.pages.split_setup.tooltip": "Die vensters en monitors, en wie speel waar.",
+  "horizon.pages.shader_packs.tooltip": "Shader-pakke vanaf die shaderpacks-lêergids: Horizon se eie en dié in die shaders/formaat. Een hardloop op 'n slag.",
+  "horizon.pages.mods.tooltip": "Mods gemaak vir Horizon, vanaf die horizon-mods-lêergids. Elkeen loop in 'n sandbox en bly af totdat jy dit aanskakel.",
+  "horizon.pages.open.graphics": "Grafika...",
+  "horizon.pages.open.graphics_advanced": "Gevorderde grafika...",
+  "horizon.pages.open.shader_packs": "Shader-pakke...",
+  "horizon.pages.open.controller": "Beheerderinstellings...",
+  "horizon.pages.open.split_setup": "Verdeelskerm...",
+  "horizon.pages.open.extras": "Ekstras...",
+  "horizon.pages.open.mods": "Modusse...",
+  "horizon.pages.open.agent": "KI Agent...",
+  "horizon.pages.open.horizon_graphics": "Horizon-grafika...",
+  "horizon.pages.open.controller_binds": "Beheerder bind...",
+  "horizon.pages.open.horizon_settings": "Horizon-instellings...",
+  "horizon.pages.open.music": "Musiek...",
+  "horizon.mods.empty": "Geen mods: plaas .hmod-lêers in die horizon-mods-lêergids",
+  "horizon.mods.stopped": " (Gestop)",
+  "horizon.mods.not_built": " (Nie gebou nie)",
+  "horizon.mods.dev": " (Ontwikkelaar)",
+  "horizon.mods.settings": "Instellings",
+  "horizon.mods.in_world": " (los die wêreld om te verander)",
+  "horizon.mods.open_folder": "Maak Mod-lêergids oop",
+  "horizon.shader_packs.empty": "Geen shader packs: plaas dit in die shaderpacks-lêergids",
+  "horizon.shader_options.open": "Shader-opsies...",
+  "horizon.shader_options.profile": "Profiel",
+  "horizon.shader_options.loading": "Lees tans die shader-pakket se opsies...",
+  "horizon.agent.copy_details": "Kopieer verbindingbesonderhede",
+  "horizon.multiplayer.join": "Sluit aan",
+  "horizon.multiplayer.cancel_reconnecting": "Kanselleer Herkoppel",
+  "horizon.multiplayer.join_friend": "Sluit aan by 'n Vriend",
+  "horizon.multiplayer.invite_code": "Uitnodigingskode",
+  "horizon.multiplayer.relay": "Aflos (opsioneel)",
+  "Preset": "Vooraf ingesteld",
+  "LOD Distance": "LOD Afstand",
+  "Far Detail": "Verre Detail",
+  "Cave Culling": "Grotuitdunning",
+  "Entity Culling": "Entiteit Uitdunning",
+  "Upload Budget": "Laai begroting op",
+  "Sky": "Hemel",
+  "Fog": "Mis",
+  "Weather": "Weer",
+  "Animated Textures": "Geanimeerde teksture",
+  "Present Mode": "Aanbiedingsmodus",
+  "Frame Pacing": "Raamtempo",
+  "Worker Threads": "Werkerdrade",
+  "Resolution Scale": "Resolusieskaal",
+  "Upscaling": "Opskaling",
+  "Paper White": "Papier Wit",
+  "Peak Brightness": "Piek helderheid",
+  "Black Level": "Swart vlak",
+  "UI Brightness": "UI Helderheid",
+  "Battery Mode": "Batterymodus",
+  "Graphics API": "Grafiese API",
+  "Translucent Batching": "Deurskynende Batching",
+  "Performance Overlay": "Prestasie-oorleg",
+  "Full Detail Distance": "Volledige detail Afstand",
+  "On": "Aan",
+  "Off": "Af",
+  "Unlimited": "Onbeperk",
+  "Auto": "Outo",
+  "Custom": "Pasgemaak",
+  "Performance": "Prestasie",
+  "Balanced": "Gebalanseerd",
+  "Quality": "Kwaliteit",
+  "Ultra Performance": "Ultra prestasie",
+  "Native": "Inheems",
+  "Full": "Vol",
+  "Reduced": "Verminder",
+  "Efficient": "Doeltreffend",
+  "Precise": "Presies",
+  "Auto (VSync)": "Outo (VSync)",
+  "FIFO": "EIEU",
+  "Mailbox": "Posbus",
+  "Immediate": "Onmiddellik",
+  "FPS and Graph": "FPS en grafiek",
+  "No cost": "Geen koste nie",
+  "Low cost": "Lae koste",
+  "Medium cost": "Medium koste",
+  "High cost": "Hoë koste",
+  "Saves time": "Spaar tyd",
+  "Graphics": "Grafika",
+  "Done": "Klaar",
+  "This feature is not yet available in Horizon.": "Hierdie kenmerk is nog nie in Horizon beskikbaar nie.",
+  "Your display or system doesn't offer HDR output.": "Jou skerm of stelsel bied nie HDR-uitvoer nie.",
+  "Turn HDR on to use it.": "Skakel HDR aan om dit te gebruik.",
+  "Your GPU or graphics API doesn't support it.": "Jou GPU of grafiese API ondersteun dit nie.",
+  "%s chunks": "%s stukke",
+  "%s per frame": "%s per raam",
+  "%s MiB/frame": "%s MiB/raam",
+  "%s KiB/frame": "%s KiB/raam",
+  "Auto (%s)": "Outo (%s)",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Volledige detail terreinreeks. LOD Distance kan plaaslike wêrelde verder uitbrei.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Growwe verre terrein in plaaslike wêrelde. Geïntegreerde GPU's stop by 128 stukke.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "Verminder trek veel terrein growwer: vinniger op hierdie geïntegreerde GPU.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "Verminder trek veel terrein growwer, vir GPU's word dit stadiger.",
+  "Field of view. Wider shows more terrain at once.": "Gesigsveld. Wyer wys meer terrein op een slag.",
+  "Caps frames per second; a cap saves power and heat.": "Caps rame per sekonde; 'n pet spaar krag en hitte.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Wag vir die verversing van die skerm: geen skeur nie, 'n bietjie vertraging.",
+  "Size of menus and the HUD.": "Grootte van spyskaarte en die HUD.",
+  "Sets the options below together. Changing one makes it Custom.": "Stel die opsies hieronder saam. Om een te verander, maak dit Pasgemaak.",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Lava, vuur en sonlig skyn helderder as wit. Benodig 'n HDR-skerm.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Jou skerm is die donkerste swart. 0 vir OLED; LCD's gloei 'n bietjie.",
+  "How bright highlights get. Auto: the peak your system reports.": "Hoe helder hoogtepunte word. Outo: die hoogtepunt wat jou stelsel rapporteer.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "Hoe helder wit papier en spyskaarte lyk. Outo: jou lessenaar is wit.",
+  "How bright the HUD and menus are, against paper white.": "Hoe helder die HUD en spyskaarte is, teenoor papierwit.",
+  "How far mobs, crops and machines keep working. CPU time.": "Hoe ver skare, gewasse en masjiene aanhou werk. SVE tyd.",
+  "How far away mobs and items are drawn, as a share of normal.": "Hoe ver weg skares en items getrek word, as 'n deel van normaal.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Slaan terrein oor wat agter geslote gedeeltes versteek is. Af kos baie.",
+  "Hides entities behind opaque blocks.": "Versteek entiteite agter ondeursigtige blokke.",
+  "No entity occlusion culling.": "Geen entiteit-okklusion uitskot nie.",
+  "CPU occlusion test runs this frame.": "SVE-okklusietoets loop hierdie raam.",
+  "Occlusion checks run on a worker thread.": "Okklusiekontroles loop op 'n werkersdraad.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Maasafdelings per raam opgelaai. Laer is gladder tydens laai.",
+  "Soft shadows in corners. Costs chunk building time only.": "Sagte skaduwees in hoeke. Dit kos slegs 'n stuk boutyd.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "Kleiner kopieë van blokteksture vir verafgeleë terrein: minder glans.",
+  "Blends grass and water colours across biomes when building chunks.": "Vermeng gras en waterkleure oor biome wanneer stukke gebou word.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Wolklaag: af, plat (vinnig) of 3D (fancy).",
+  "How far clouds reach, in chunks.": "Hoe ver wolke reik, in stukke.",
+  "Draws the sky, sun, moon and stars.": "Teken die lug, son, maan en sterre.",
+  "Distance fog. Off shows the edge of the loaded world.": "Afstand mis. Af wys die rand van die gelaaide wêreld.",
+  "Draws rain and snow.": "Trek reën en sneeu.",
+  "How far rain and snow fall around you.": "Hoe ver val reën en sneeu om jou.",
+  "How many particles effects spawn.": "Hoeveel deeltjies effekte kuit.",
+  "Round shadows under mobs and items.": "Ronde skaduwees onder skares en items.",
+  "Leaves with see-through gaps. Off draws them solid.": "Blare met deursigtige gapings. Off trek hulle stewig.",
+  "Sorts water and glass more exactly behind each other.": "Sorteer water en glas meer presies agter mekaar.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Watter stuk herbou wag vir die raam: geen, naby of joune.",
+  "Animates water, lava, fire and other moving textures.": "Animeer water, lawa, vuur en ander bewegende teksture.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Wêreldpixels per skermpiksel. Onder 100% is vinniger op die GPU.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Maak gekartelde rande glad. FXAA: sagter. TAA: gladste, bewegende dinge kan loop.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Maak die wêreld kleiner en herbou dit met TAA. Vinniger, sagter.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "HDR-uitset op 'n HDR-skerm: lawa, vuur en sonlig skyn helderder.",
+  "How frames reach the screen while VSync is off.": "Hoe rame die skerm bereik terwyl VSync af is.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Doeltreffende slaap tot die volgende raam; Presiese draaie, soos vanielje.",
+  "Fills the screen (borderless).": "Vul die skerm (randloos).",
+  "Brightens dark places.": "Verhelder donker plekke.",
+  "Lowers the frame rate when minimised, or idle too.": "Verlaag die raamtempo wanneer dit geminimaliseer word, of ook ledig.",
+  "Sways the view while walking.": "Swaai die uitsig terwyl jy stap.",
+  "Fades newly loaded chunks in.": "Vervaag nuutgelaaide stukke in.",
+  "Darkens the screen's edges.": "Maak die skerm se rande donkerder.",
+  "Shows when the world saves.": "Wys wanneer die wêreld red.",
+  "Shows attack cooldown.": "Toon aanvalafkoeling.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "60 FPS pet (30 in spyskaarte of ongefokus), die helfte van die werkers: minder krag.",
+  "Threads that generate, light and mesh chunks. Next start.": "Drade wat stukke genereer, lig en maas. Volgende begin.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, dan DirectX 12 (Windows) of OpenGL (Linux) waar dit misluk. Volgende begin.",
+  "Water and glass in one buffer: fewer draw calls, a bit more VRAM. Next start.": "Water en glas in een buffer: minder trekoproepe, 'n bietjie meer VRAM. Volgende begin.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Maasdata per raam na die GPU gestuur. Laer is gladder tydens laai.",
+  "Frame rate and frame times over the game, with a graph.": "Raamtempo en raamtye oor die spel, met 'n grafiek.",
+  "horizon.multiplayer.finding_friend": "Soek jou vriend se wêreld...",
+  "horizon.multiplayer.not_signed_in": "Hierdie bediener is in aanlynmodus. Meld aan met jou Microsoft-rekening in die Horizon-lanseerder om daarby aan te sluit.",
+  "horizon.multiplayer.invalid_address": "Ongeldige bedieneradres: %s",
+  "horizon.multiplayer.connected_friend_direct": "Reguit gekoppel aan jou vriend...",
+  "horizon.multiplayer.connected_friend_relay": "Gekoppel aan jou vriend deur die aflos...",
+  "General": "Algemeen",
+  "Advanced": "Gevorderd",
+  "Undo": "Ontdoen",
+  "Search options": "Soek opsies",
+  "Shortcut": "Kortpad",
+  "Distance": "Afstand",
+  "Display": "Vertoon",
+  "Interface": "Koppelvlak",
+  "Sky and weather": "Lug en weer",
+  "Lighting and entities": "Beligting en entiteite",
+  "Textures": "Teksture",
+  "Image": "Beeld",
+  "Chunk loading": "Chunk laai",
+  "Culling": "Uitskot",
+  "Power": "Krag",
+  "Frames": "Rame",
+  "Overlay": "Oorleg",
+  "Output": "Uitset",
+  "Brightness": "Helderheid",
+  "How far you see, the window and the HUD.": "Hoe ver jy sien, die venster en die HUD.",
+  "The sky and weather, lighting, textures and the image.": "Die lug en weer, beligting, teksture en die beeld.",
+  "Chunk loading, culling and power use.": "Chunk laai, uitskot en kraggebruik.",
+  "How frames reach the screen, and the performance overlay.": "Hoe rame die skerm bereik, en die prestasie-oorleg.",
+  "Brighter-than-white output on an HDR display.": "Helderder-as-wit uitset op 'n HDR-skerm.",
+  "Results for \"%s\"": "Resultate vir \"%s\"",
+  "No settings match.": "Geen instellings pas nie.",
+  "horizon.title.not_affiliated": "Nie geaffilieer met Mojang of Microsoft nie",
+  "horizon.extras.header.lighting": "Beligting",
+  "horizon.extras.header.third_person": "Derde persoon",
+  "horizon.extras.header.particles": "Deeltjies",
+  "horizon.extras.header.inventory": "Voorraad",
+  "horizon.extras.header.chat": "Gesels",
+  "horizon.extras.header.multiplayer": "Multispeler",
+  "horizon.extras.header.sound": "Klank",
+  "horizon.extras.header.menus": "Spyskaarte",
+  "horizon.extras.fullbright": "Vol helder",
+  "horizon.extras.dynamic_lights": "Dinamiese ligte",
+  "horizon.extras.own_name_tag": "Eie naamplaatjie",
+  "horizon.extras.hide_block_particles": "Versteek blokbreekdeeltjies",
+  "horizon.extras.auto_reconnect": "Herkoppel outomaties",
+  "horizon.extras.ui_sound_reserve": "Hou kanale vir UI-klanke",
+  "horizon.extras.music_page": "Musiek bladsy",
+  "horizon.extras.mouse_tweaks": "Muis Tweaks kontroles",
+  "horizon.extras.mouse_tweaks_wheel": "Rolwiel beweeg items",
+  "horizon.extras.sort": "Sorteer knoppies",
+  "horizon.extras.sort_key": "Sorteer sleutel",
+  "horizon.extras.no_ai": "Geen KI",
+  "horizon.extras.agent_control": "Agent beheer",
+  "horizon.extras.discord_presence": "Ryk teenwoordigheid op Discord",
+  "horizon.extras.splitscreen": "Verdeelskerm",
+  "horizon.extras.chat_animation": "Glad gesels",
+  "horizon.extras.chat_indicator": "Boodskap aanwyser",
+  "horizon.extras.wheel_cycles_settings": "Rolwiel verander instellings",
+  "horizon.extras.pack_browser": "Hulpbronpakketblaaier",
+  "horizon.extras.fullbright.tooltip": "Wys blokke en entiteite in volle lig, selfs in donker areas.",
+  "horizon.extras.dynamic_lights.tooltip": "Fakkels en ander ligbronne wat vasgehou, laat val word of aan die brand steek, steek die blokke om hulle aan.",
+  "horizon.extras.own_name_tag.tooltip": "Wys jou naam bo jou kop in derde persoon, soos ander spelers dit sien. Versteek wanneer die bediener jou span se name versteek of jy onsigbaar is.",
+  "horizon.extras.hide_block_particles.tooltip": "Versteek die puindeeltjies wat uit 'n gebreekte blok bars en verkrummel van die een wat jy myn. Ander deeltjies bly.",
+  "horizon.extras.auto_reconnect.tooltip": "Sluit weer by 'n bediener aan na 'n verlore verbinding of 'n herbegin, nooit na 'n skop of verbod nie.",
+  "horizon.extras.ui_sound_reserve.tooltip": "Klanke in die wêreld laat 16 van die 247 klankkanale vry, so 'n vloed van hulle ('n groot ontploffing) kan nie kieslysklikke stilmaak nie.",
+  "horizon.extras.music_page.tooltip": "Musiek en Klanke kry 'n Musiek...-bladsy: speel nou enige ingeboude snit, of skakel een af sodat die speletjie ophou om dit te kies. Niks verander totdat jy 'n snit afskakel nie.",
+  "horizon.extras.mouse_tweaks.tooltip": "Regs-sleep plaas een per gleuf, links-sleep versamel die gehou item, Shift + links-sleep skuif elke gleuf.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "Af stuur een item van die gleuf na die ander kant, op bring een terug.",
+  "horizon.extras.sort.tooltip": "Sorteer die voorraad, kiste, vate, eindkiste en shulkerbokse in kreatiewe oortjievolgorde, en voeg stapels saam.",
+  "horizon.extras.sort_key.tooltip": "Sorteer die deel onder die wyser. Klik en druk dan 'n sleutel; Ontvlugting ontbind dit.",
+  "horizon.extras.no_ai.tooltip": "Versteek en skakel elke KI-kenmerk af: agentbeheer, horizon-ctl en die MCP-bedieners. Die lanseerder se skakelaar ook.",
+  "horizon.extras.agent_control.tooltip": "Jou eie KI-agent kan hierdie speletjie deur horizon-ctl of 'n MCP-kliënt speel, slegs op hierdie rekenaar.",
+  "horizon.extras.discord_presence.tooltip": "Wys Playing Horizon op jou Discord-profiel terwyl Discord loop: spyskaarte, enkelspeler of multispeler, die dimensie en die speeltyd. Nooit 'n wêreld se naam of 'n bediener se adres nie.",
+  "Calibrate...": "Kalibreer...",
+  "Calibrate Anyway...": "Kalibreer in elk geval...",
+  "Use Automatic Setup": "Gebruik outomatiese opstelling",
+  "Shortcut: %s": "Kortpad: %s",
+  "Next": "Volgende",
+  "HDR Calibration %s/%s: %s": "HDR-kalibrasie %s/%s: %s",
+  "Sets the three below full screen, one test picture at a time.": "Stel die drie hieronder volskerm, een toetsprent op 'n slag.",
+  "A key that opens this screen from the game. Not bound at first.": "'n Sleutel wat hierdie skerm vanaf die speletjie oopmaak. Eers nie gebonde nie.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "Jou skerm het nie gesê hoe helder dit word nie: kalibreer om dit op te stel.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "Reeds opgestel vir jou vertoning. Kalibreer slegs as HDR verkeerd lyk.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "Plaas Peak Brightness en Paper White terug na jou skerm se opstelling.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "Stel op vir jou vertoning. Los op Auto tensy dit verkeerd lyk.",
+  "Lower it until the logo just disappears into the black.": "Laat sak dit totdat die logo net in die swart verdwyn.",
+  "Raise it until the logo just disappears into the bright square.": "Lig dit op totdat die logo net in die helder vierkant verdwyn.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "Maak die kaart 'n wit wat gemaklik is om lank na te kyk, in die lig waarin jy speel.",
+  "horizon.splitscreen.profiles.forget": "Vergeet",
+  "horizon.splitscreen.profiles.create": "Skep",
+  "horizon.splitscreen.profiles.you": " - jy",
+  "horizon.splitscreen.profiles.forget_named": "Vergeet %s",
+  "horizon.splitscreen.profiles.previous": "Vorige",
+  "horizon.splitscreen.profiles.next": "Volgende",
+  "horizon.splitscreen.profiles.new_button": "Nuwe profiel...",
+  "horizon.splitscreen.profiles.forget_title": "Vergeet profiel?",
+  "horizon.splitscreen.profiles.forget_leaves": "Dit verlaat hierdie instansie se lys.",
+  "horizon.splitscreen.profiles.forget_kept": "Wêreldvordering en instellings word behou.",
+  "horizon.splitscreen.profiles.new_title": "Nuwe profiel",
+  "horizon.splitscreen.profiles.name_hint": "Naam (3 tot 16 letters, syfers, _)",
+  "horizon.splitscreen.profiles.switch_title": "Wissel profiel",
+  "horizon.splitscreen.profiles.offline_note": "Vanlyn profiele behoort aan hierdie geval",
+  "horizon.splitscreen.profiles.move": "Beweeg waar jy speel",
+  "horizon.splitscreen.profiles.move_place": "Beweeg waar jy speel: %s",
+  "horizon.friends.title": "Speel met vriende",
+  "horizon.friends.hint": "Vriende plak die kode na die titelskerm se Vriende-knoppie, in Direkte verbinding, of op die lanseerder se Speel-bladsy.",
+  "horizon.friends.copied": "Gekopieer",
+  "horizon.friends.copy_code": "Kopieer kode",
+  "horizon.friends.stop_sharing": "Hou op deel",
+  "horizon.friends.none_yet": "Nog geen vriende hier nie.",
+  "horizon.friends.here_now": "Hier nou: %s",
+  "horizon.friends.share_intro": "Deel hierdie wêreld agter 'n uitnodigingskode: dit maak oop na LAN, en vriende op die internet sluit aan met die kode. Geen bediener van ons is betrokke nie.",
+  "horizon.friends.start_sharing": "Begin deel",
+  "horizon.friends.troubleshooting": "Foutsporing …",
+  "horizon.friends.stopped": "Het opgehou om die uitnodigingkode te deel.",
+  "horizon.friends.short_code_changed": "Iemand het aanhou om 'n verkeerde kort kode te probeer, so dit het verander.",
+  "horizon.friends.wrong_code": "Iemand het 'n verkeerde kode probeer.",
+  "horizon.friends.code_ready": "Jou uitnodigingskode is gereed: Speletjie-kieslys, Speel met vriende. Kopieer dit en stuur dit aan jou vriende.",
+  "horizon.friends.share_failed": "Kon nie die wêreld deel nie: %s",
+  "horizon.friends.finding_route": "Vind tans hoe vriende jou kan bereik …",
+  "horizon.osk.shift": "Verskuiwing",
+  "horizon.osk.space": "Ruimte",
+  "horizon.osk.delete": "Vee uit",
+  "horizon.osk.type": "Tik",
+  "horizon.osk.symbols": "Simbole",
+  "horizon.osk.close": "Maak toe",
+  "horizon.extras.chat_animation.tooltip": "'n Nuwe kletslyn gly van links af terwyl dit vervaag, in plaas daarvan om heel te lyk.",
+  "horizon.extras.chat_indicator.tooltip": "Die gekleurde balk aan die linkerkant van 'n kletslyn.",
+  "horizon.extras.wheel_cycles_settings.tooltip": "Die rolwiel oor 'n knoppie in die instellings verander die waarde daarvan, soos in vanielje. Af, die wiel blaai net deur die lys.",
+  "horizon.extras.pack_browser.tooltip": "Select Resource Packs kry 'n Voeg by-knoppie wat Modrinth deursoek en 'n pakket in jou pakke-lêergids installeer. Af, die speletjie kontak nooit Modrinth nie.",
+  "horizon.extras.splitscreen.tooltip": "In 'n wêreld kan 'n ander beheerder as 'n nuwe speler aansluit: druk A wanneer dit vra, kies dan 'n profiel en waar om te speel.",
+  "horizon.splitscreen.setup.monitor_unknown": "'n monitor",
+  "horizon.splitscreen.setup.window": "Venster %s",
+  "horizon.splitscreen.setup.new_window": "Nuwe venster",
+  "horizon.splitscreen.setup.fill_monitor": "Vul %s",
+  "horizon.splitscreen.setup.done": "Klaar",
+  "horizon.splitscreen.setup.on": "Aan",
+  "horizon.splitscreen.setup.off": "Af",
+  "horizon.splitscreen.setup.player": "Speler %s",
+  "horizon.splitscreen.setup.revert": "Keer terug",
+  "horizon.splitscreen.setup.apply": "Doen aansoek",
+  "horizon.splitscreen.setup.warning.empty_main": "Niemand speel in Venster 1 nie: dit skuil",
+  "horizon.splitscreen.setup.warning.empty_close": "Niemand speel in Venster %s nie: dit sluit op Toepassing",
+  "horizon.splitscreen.setup.warning.empty_new": "Niemand speel in Venster %s nie: dit sal nie oopmaak nie",
+  "horizon.splitscreen.setup.warning.on_main": "Venster %s vul Venster 1 se monitor: sy spelers speel in Venster 1",
+  "horizon.splitscreen.setup.warning.unplugged": "Venster %s se monitor is nie gekoppel nie: sy spelers speel in Venster 1",
+  "horizon.splitscreen.setup.status.off": "Verdeelskerm is af.",
+  "horizon.splitscreen.setup.status.enable_hint": "Skakel dit aan en druk dan 'n knoppie op 'n ander beheerder in 'n wêreld.",
+  "horizon.splitscreen.setup.status.join_hint": "Druk A om aan te sluit en kies 'n profiel.",
+  "horizon.splitscreen.setup.status.idle": "Gedeelskerm ledig",
+  "horizon.splitscreen.setup.status.alone": "Geen ander plaaslike spelers nie.",
+  "horizon.splitscreen.setup.status.solo_controls": "Solo-kontroles en kontroleerder-terugvoer is onveranderd.",
+  "horizon.splitscreen.setup.window_empty": "Venster %s: leeg",
+  "horizon.splitscreen.setup.note.select": "Klik 'n speler, of sleep dit na 'n venster of 'n monitor.",
+  "horizon.splitscreen.setup.note.apply": "Doen aansoek om op hierdie manier te speel, Keer terug om te ontdoen.",
+  "horizon.splitscreen.setup.note.place": "Waar moet %s speel?",
+  "horizon.splitscreen.setup.this_player": "hierdie speler",
+  "horizon.splitscreen.setup.switch_disabled": "Splitscreen skakel af sodra die ander vertrek het (hul pousekieslys).",
+  "horizon.splitscreen.setup.window_place": "Venster %s (%s van %s)",
+  "horizon.splitscreen.setup.names": "Name",
+  "horizon.splitscreen.setup.identify": "Identifiseer",
+  "horizon.splitscreen.setup.layout.two": "2 deel: %s",
+  "horizon.splitscreen.setup.layout.three": "3 deel: %s",
+  "horizon.splitscreen.setup.layout.two.0": "Outo",
+  "horizon.splitscreen.setup.layout.two.1": "Sy aan sy",
+  "horizon.splitscreen.setup.layout.two.2": "Bo en onder",
+  "horizon.splitscreen.setup.layout.three.0": "Een breed bo-op",
+  "horizon.splitscreen.setup.layout.three.1": "Een lang aan die linkerkant",
+  "horizon.splitscreen.setup.layout.three.2": "Sy aan sy",
+  "horizon.splitscreen.setup.help.player": "Klik of sleep %s om hulle te skuif.",
+  "horizon.splitscreen.setup.help.layout_auto": "%s (naas mekaar wanneer die venster wyd is). Druk om te verander.",
+  "horizon.splitscreen.setup.help.layout": "%s. Druk om te verander.",
+  "horizon.splitscreen.setup.help.switch": "Verdeelskerm vir hierdie rekenaar, aan of af.",
+  "horizon.splitscreen.setup.help.identify": "Elke speler se aansig wys in watter venster dit is.",
+  "horizon.splitscreen.setup.help.names": "Elke speler se naam in die hoek van hul aansig.",
+  "horizon.splitscreen.setup.help.revert": "Ontdoen die veranderinge wat nog nie toegepas is nie.",
+  "horizon.splitscreen.setup.help.apply": "Speel soos die kaart wys.",
+  "horizon.splitscreen.setup.help.unchanged": "Niks het nog verander nie.",
+  "horizon.splitscreen.setup.give_up_pad": "Gee op Pad",
+  "horizon.splitscreen.prompt.controller_connected": "Beheerder gekoppel",
+  "horizon.splitscreen.prompt.controller_disconnected": "Beheerder ontkoppel",
+  "horizon.splitscreen.prompt.controller_disconnected.hint": "Koppel dit weer, of druk 'n knoppie op 'n ander",
+  "horizon.splitscreen.prompt.join.one": "%s wil aansluit",
+  "horizon.splitscreen.prompt.join.many": "%s beheerders wil aansluit",
+  "horizon.splitscreen.prompt.join.yes": "Sluit aan",
+  "horizon.splitscreen.prompt.join.as_p1": "Speel as P1",
+  "horizon.splitscreen.prompt.join.no": "Nee",
+  "horizon.splitscreen.prompt.lost": "%s: beheerder ontkoppel",
+  "horizon.splitscreen.prompt.lost.use_another": "Gebruik 'n ander",
+  "horizon.splitscreen.prompt.lost.leave": "Los",
+  "horizon.splitscreen.setup.help.give_up_pad": "Jou beheerder hou op om jou te bestuur en word aangebied om aan te sluit (A).",
+  "horizon.splitscreen.setup.note.held_at": "%s tot %s: A laat val dit hier, B sit dit terug.",
+  "horizon.splitscreen.setup.note.held": "%s opgetel: links/regs kies waar, A laat val, B sit dit terug.",
+  "Hides models behind opaque blocks. Async checks off-thread; entities tick.": "Versteek modelle agter ondeursigtige blokke. Async kontroleer af-draad; entiteite merk.",
+  "Block Entities": "Blok Entiteite",
+  "Reuses settled boxes; lid movement stays animated.": "Hergebruik afgewikkelde bokse; dekselbeweging bly geanimeerd.",
+  "Signs": "Tekens",
+  "Reuses sign text until text, light, or font changes.": "Hergebruik tekenteks totdat teks, lig of lettertipe verander.",
+  "Decorated Pots": "Versierde potte",
+  "Reuses still pots; break wobble and sherd changes redraw.": "Hergebruik stilpotte; breek wankel en skeur veranderinge herteken.",
+  "Bells": "Klokke",
+  "Reuses still bells; ringing stays animated.": "Hergebruik stilstaande klokke; lui bly geanimeerd.",
+  "Chests": "Kiste",
+  "Reuses closed chests; moving lids stay animated.": "Hergebruik toe kiste; bewegende deksels bly geanimeerd.",
+  "Banners": "Baniere",
+  "Reuses poles; flags and pattern layers still update.": "Hergebruik pale; vlae en patroonlae werk steeds by.",
+  "Copper Golem Statues": "Koper Golem-standbeelde",
+  "Reuses statue geometry until its block state changes.": "Hergebruik standbeeldgeometrie totdat die bloktoestand daarvan verander.",
+  "Leaf Culling": "Blaaruitsny",
+  "Every leaf face. Vanilla's fancy leaves.": "Elke blaar gesig. Vanielje se spoggerige blare.",
+  "Distant Plant Dither": "Verre Plant Dither",
+  "Keeps fine plants in high-res packs from fading far away.": "Hou fyn plante in hoë-resolusie-pakke om ver weg te vervaag.",
+  "Screenshot Quality": "Skermkiekie Kwaliteit",
+  "F2 screenshots at this many times the game's resolution. Higher takes longer.": "F2 skermkiekies teen hierdie baie keer die spel se resolusie. Hoër neem langer.",
+  "Frame Generation": "Raam Generasie",
+  "Shows a made-up frame between each two real ones: smoother, a little more lag.": "Toon 'n opgemaakte raam tussen elke twee regte: gladder, 'n bietjie meer vertraging.",
+  "Shadow Cache": "Skadu-kas",
+  "Reuses the pack shadow map when sun, view and world match. Off by default.": "Hergebruik die pakskadukaart wanneer son, uitsig en wêreld ooreenstem. Af by verstek.",
+  "Find BlueMap": "Vind BlueMap",
+  "On servers, finds their BlueMap web map for far terrain. Next join.": "Op bedieners, vind hul BlueMap-webkaart vir ver terrein. Sluit volgende aan.",
+  "BlueMap Radius": "Blou Kaart Radius",
+  "How far around you BlueMap tiles are downloaded. Next join.": "Hoe ver om jou is BlueMap-teëls afgelaai. Sluit volgende aan.",
+  "Synchronous": "Sinchronies",
+  "Asynchronous": "Asinchronies",
+  "Solid": "Solied",
+  "Solid Aggressive": "Stewige aggressiewe",
+  "Hollow": "Hol",
+  "Leaves fully inside a canopy draw solid: fewer see-through layers.": "Blare volledig binne-in 'n blaredak trek solied: minder deurskynende lae.",
+  "Leaves with one open side draw solid too: faster, chunkier edges.": "Blare met een oop kant trek ook solied: vinniger, bonkiger rande.",
+  "Drops faces between leaves: faster, but gaps look through.": "Laat val gesigte tussen blare: vinniger, maar gapings kyk deur.",
+  "Hotbar: Previous Slot": "Hotbar: Vorige Slot",
+  "Hotbar: Next Slot": "Hotbar: Volgende Slot",
+  "horizon.agent.connected.one": "Gekoppel: 1 agentverbinding",
+  "horizon.agent.connected.many": "Gekoppel: %s agentverbindings",
+  "horizon.agent.connected.one_ago": "Gekoppel: 1 agentverbinding, laaste opdrag %s s gelede",
+  "horizon.agent.connected.many_ago": "Gekoppel: %s agentverbindings, laaste opdrag %s s gelede",
+  "horizon.agent.waiting": "Wag vir 'n agent.",
+  "horizon.agent.off": "Af: agente kan nie hierdie speletjie bereik nie.",
+  "horizon.agent.session_opened": "Geopen vir hierdie sessie deur die program wat die speletjie begin het.",
+  "horizon.agent.socket": "Sok: %s (kopieer die besonderhede vir sy volledige pad)",
+  "horizon.agent.local_only": "Slegs plaaslik: agente op hierdie rekenaar, nooit die netwerk nie.",
+  "%s nits": "%s nete",
+  "Auto (%s nits)": "Outo (%s nete)",
+  "%.2f nits": "%.2f nete",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Versteek modelle agter ondeursigtige blokke. Entiteite-opdatering. Af met pasgemaakte pakke.",
+  "horizon.extras.repro_keys": "Opname kortpaaie",
+  "horizon.extras.repro_keys.tooltip": "F3+R begin of stop 'n repro-opname en F3+E skryf sy bundel. Af by verstek: 'n opname kopieer die wêreld.",
+  "horizon.agent.record_session": "Begin opnamesessie",
+  "horizon.agent.record_stop": "Stop opnamesessie",
+  "horizon.agent.export_repro": "Voer Repro-bundel uit",
+  "horizon.repro.started": "Opname het begin; F3+R stop dit en skryf die bundel.",
+  "horizon.repro.stopped": "Opname gestop: %s",
+  "horizon.repro.bundle": "Repro-bundel: %s",
+  "horizon.repro.no_recording": "Daar is nog geen opname om uit te voer nie.",
+  "horizon.repro.replay_started": "Herhaling het begin: %s",
+  "horizon.pack.addInfo": "Voeg 'n hulpbronpakket van Modrinth by",
+  "horizon.pack.addWorking": "Vra vir Modrinth...",
+  "horizon.pack.addNone": "Geen hulpbronpakke gevind nie",
+  "horizon.pack.addTitle": "Voeg 'n hulpbronpakket by",
+  "horizon.pack.install": "Installeer",
+  "horizon.pack.installing": "Installeer tans",
+  "horizon.pack.installed": "Geïnstalleer",
+  "horizon.pack.search": "Soek",
+  "horizon.pack.searchHint": "Soek Modrinth...",
+  "horizon.pack.filter.realistic": "Realisties",
+  "horizon.pack.filter.simplistic": "Simplistiese",
+  "horizon.pack.filter.vanillaLike": "Vanielje-agtig",
+  "horizon.pack.addFailed": "Die pakkie kon nie bygevoeg word nie: %s",
+  "horizon.extras.header.cosmetics": "Skoonheidsmiddels",
+  "horizon.extras.cosmetics_mine": "My skoonheidsmiddels",
+  "horizon.extras.cosmetics_mine.tooltip": "Versteek: elke Horizon-speler sien jou sonder jou skoonheidsmiddels, jy ingesluit. Dieselfde skakelaar as die lanseerder se klerekas.",
+  "horizon.extras.cosmetics_others": "Ander spelers se skoonheidsmiddels",
+  "horizon.extras.cosmetics_others.tooltip": "Wat ander Horizon-spelers dra: alles, net hul naamplaatjiestyle, of niks. Versteek, die speletjie vra nooit wat hulle dra nie.",
+  "horizon.extras.cosmetics_auras": "Ander se aura's en roetes",
+  "horizon.extras.cosmetics_auras.tooltip": "Auras en roetes wat ander spelers dra. Af by verstek.",
+  "horizon.extras.cosmetics.shown": "Getoon",
+  "horizon.extras.cosmetics.hidden": "Versteek",
+  "horizon.extras.cosmetics.name_tags": "Slegs naamplaatjies"
+}

crates/horizon-client/assets/horizon/lang/ar_sa.json

@@ -0,0 +1,501 @@
+{
+  "horizon.options.controller": "المراقب المالي",
+  "horizon.options.vibration": "الاهتزاز",
+  "horizon.options.adaptive_triggers": "المشغلات التكيفية",
+  "horizon.options.lightbar": "الشريط الضوئي",
+  "horizon.options.look_sensitivity": "حساسية النظر",
+  "horizon.options.invert_x": "عكس محور النظر X",
+  "horizon.options.invert_y": "عكس محور النظر Y",
+  "horizon.options.sneak_button": "زر التسلل",
+  "horizon.options.move_deadzone": "المنطقة الميتة للحركة",
+  "horizon.options.look_deadzone": "المنطقة الميتة للنظر",
+  "horizon.options.button_glyphs": "الحروف الرسومية للأزرار",
+  "horizon.options.menu_navigation": "التنقل في القائمة",
+  "horizon.options.on_screen_keyboard": "لوحة المفاتيح على الشاشة",
+  "horizon.options.chat_delay": "تأخير الدردشة",
+  "horizon.options.lightbar.health": "الصحة",
+  "horizon.options.lightbar.dimension": "البعد",
+  "horizon.options.glyphs.auto": "تلقائي",
+  "horizon.options.glyphs.xbox": "اكس بوكس",
+  "horizon.options.glyphs.playstation": "بلاي ستيشن",
+  "horizon.options.glyphs.nintendo": "نينتندو",
+  "horizon.options.menu_focus": "التركيز",
+  "horizon.options.menu_pointer": "المؤشر",
+  "horizon.options.keyboard.auto": "تلقائي",
+  "horizon.options.keyboard.steam": "البخار",
+  "horizon.options.unavailable": "هذه الميزة غير متوفرة بعد في Horizon.",
+  "horizon.options.search": "إعدادات البحث...",
+  "horizon.pages.mods": "تعديل",
+  "horizon.pages.shader_packs": "حزم شادر",
+  "horizon.pages.shader_options": "خيارات التظليل",
+  "horizon.pages.controller": "إعدادات وحدة التحكم",
+  "horizon.pages.controller_binds": "ربط وحدة التحكم",
+  "horizon.pages.extras": "إضافات Horizon",
+  "horizon.pages.settings": "إعدادات Horizon",
+  "horizon.pages.agent": "وكيل منظمة العفو الدولية",
+  "horizon.split.leave": "غادر",
+  "horizon.pages.split_settings": "إعدادات تقسيم الشاشة",
+  "horizon.pages.split_profiles": "من يلعب؟",
+  "horizon.pages.split_setup": "إعداد تقسيم الشاشة",
+  "horizon.pages.music": "موسيقى",
+  "horizon.pages.music.menu": "القائمة",
+  "horizon.pages.music.overworld": "العالم الخارجي",
+  "horizon.pages.music.creative": "إبداعي",
+  "horizon.pages.music.underwater": "تحت الماء",
+  "horizon.pages.music.end": "النهاية",
+  "horizon.pages.music.boss": "رئيس",
+  "horizon.pages.music.credits": "الاعتمادات",
+  "horizon.pages.music.overworld_biomes": "المناطق الأحيائية في العالم الخارجي",
+  "horizon.pages.music.nether_biomes": "المناطق الأحيائية السفلى",
+  "horizon.pages.music.end_biomes": "نهاية المناطق الأحيائية",
+  "horizon.pages.music.other": "موسيقى أخرى",
+  "horizon.pages.music.empty": "لا توجد مقطوعات موسيقية: لا يتم تحميل أصوات اللعبة.",
+  "horizon.pages.music.tooltip": "المسارات المضمنة، حسب الموقف: العب واحدة الآن، أو قم بإيقاف تشغيل أي منها حتى تتوقف اللعبة عن اختيارها.",
+  "horizon.pages.settings.tooltip": "إعدادات Horizon الخاصة: الرسومات ووحدات التحكم والإضافات والتعديلات.",
+  "horizon.pages.graphics.tooltip": "الرسومات ببساطة: كل إعداد يوضح تكلفته.",
+  "horizon.pages.graphics_advanced.tooltip": "كل إعدادات الرسومات، بما في ذلك Horizon، وتكلفة كل منها.",
+  "horizon.pages.controller.tooltip": "وحدات التحكم: الأزرار والعصي والاهتزاز والتنقل في القائمة.",
+  "horizon.pages.extras.tooltip": "الإضافات الاختيارية، كلها متوقفة بشكل افتراضي: تظل اللعبة عادية حتى تقوم بتشغيلها.",
+  "horizon.pages.agent.tooltip": "اسمح لوكيل الذكاء الاصطناعي الخاص بك باللعب: عملاء Horizon-ctl وMCP على هذا الكمبيوتر.",
+  "horizon.pages.split_profiles.tooltip": "من يلعب: ملف تعريف محفوظ في مجلد اللعبة هذا.",
+  "horizon.pages.split_setup.tooltip": "النوافذ والشاشات ومن يلعب أين.",
+  "horizon.pages.shader_packs.tooltip": "حزم Shader من مجلد Shaderpacks: الخاصة بشركة Horizon وتلك الموجودة في تنسيق التظليل/. واحد يعمل في وقت واحد.",
+  "horizon.pages.mods.tooltip": "التعديلات المعدة لـ Horizon، من مجلد Horizon-mods. يعمل كل منها في وضع الحماية ويظل مغلقًا حتى تقوم بتشغيله.",
+  "horizon.pages.open.graphics": "الرسومات...",
+  "horizon.pages.open.graphics_advanced": "رسومات متقدمة...",
+  "horizon.pages.open.shader_packs": "حزم التظليل...",
+  "horizon.pages.open.controller": "إعدادات وحدة التحكم...",
+  "horizon.pages.open.split_setup": "شاشة مقسمة...",
+  "horizon.pages.open.extras": "إضافات...",
+  "horizon.pages.open.mods": "تعديل...",
+  "horizon.pages.open.agent": "وكيل الذكاء الاصطناعي...",
+  "horizon.pages.open.horizon_graphics": "رسومات Horizon...",
+  "horizon.pages.open.controller_binds": "ربط وحدة التحكم...",
+  "horizon.pages.open.horizon_settings": "إعدادات Horizon...",
+  "horizon.pages.open.music": "موسيقى...",
+  "horizon.mods.empty": "لا توجد تعديلات: ضع ملفات .hmod في مجلد Horizon-mods",
+  "horizon.mods.stopped": " (متوقف)",
+  "horizon.mods.not_built": " (لم يتم بناؤه)",
+  "horizon.mods.dev": " (ديف)",
+  "horizon.mods.settings": "الإعدادات",
+  "horizon.mods.in_world": " (اترك العالم ليتغير)",
+  "horizon.mods.open_folder": "افتح مجلد التعديل",
+  "horizon.shader_packs.empty": "لا توجد حزم تظليل: ضعها في مجلدshaderpacks",
+  "horizon.shader_options.open": "خيارات التظليل...",
+  "horizon.shader_options.profile": "الملف الشخصي",
+  "horizon.shader_options.loading": "قراءة خيارات حزمة التظليل...",
+  "horizon.agent.copy_details": "نسخ تفاصيل الاتصال",
+  "horizon.multiplayer.join": "انضم",
+  "horizon.multiplayer.cancel_reconnecting": "إلغاء إعادة الاتصال",
+  "horizon.multiplayer.join_friend": "انضم إلى صديق",
+  "horizon.multiplayer.invite_code": "رمز الدعوة",
+  "horizon.multiplayer.relay": "التتابع (اختياري)",
+  "Preset": "محددة مسبقا",
+  "LOD Distance": "مسافة اللد",
+  "Far Detail": "تفاصيل بعيدة",
+  "Cave Culling": "إعدام الكهف",
+  "Entity Culling": "إعدام الكيان",
+  "Chunk Updates": "تحديثات القطعة",
+  "Upload Budget": "تحميل الميزانية",
+  "Sky": "السماء",
+  "Fog": "ضباب",
+  "Weather": "الطقس",
+  "Animated Textures": "القوام المتحركة",
+  "Present Mode": "الوضع الحالي",
+  "Frame Pacing": "سرعة الإطار",
+  "Worker Threads": "خيوط العمال",
+  "Resolution Scale": "مقياس القرار",
+  "Anti-aliasing": "مكافحة التعرج",
+  "Upscaling": "الارتقاء",
+  "Paper White": "ورقة بيضاء",
+  "Peak Brightness": "ذروة السطوع",
+  "Black Level": "المستوى الأسود",
+  "UI Brightness": "سطوع واجهة المستخدم",
+  "Battery Mode": "وضع البطارية",
+  "Graphics API": "واجهة برمجة تطبيقات الرسومات",
+  "Translucent Batching": "الخلط الشفاف",
+  "Performance Overlay": "تراكب الأداء",
+  "Full Detail Distance": "مسافة التفاصيل الكاملة",
+  "On": "على",
+  "Off": "إيقاف",
+  "Unlimited": "غير محدود",
+  "Auto": "تلقائي",
+  "Custom": "مخصص",
+  "Performance": "الأداء",
+  "Balanced": "متوازن",
+  "Quality": "الجودة",
+  "Ultra": "الترا",
+  "Ultra Performance": "أداء فائق",
+  "Native": "أصلي",
+  "Full": "كامل",
+  "Reduced": "مخفض",
+  "Efficient": "كفاءة",
+  "Precise": "دقيق",
+  "Auto (VSync)": "تلقائي (VSync)",
+  "FIFO": "يصرف أولاً",
+  "Mailbox": "صندوق البريد",
+  "Immediate": "فوري",
+  "Vulkan": "فولكان",
+  "DirectX 12": "دايركت اكس 12",
+  "OpenGL": "برنامج OpenGL",
+  "FPS and Graph": "FPS والرسم البياني",
+  "FPS": "إطارا في الثانية",
+  "TAA": "تأ",
+  "FXAA": "فكسا",
+  "No cost": "لا تكلفة",
+  "Low cost": "تكلفة منخفضة",
+  "Medium cost": "تكلفة متوسطة",
+  "High cost": "تكلفة عالية",
+  "Saves time": "يوفر الوقت",
+  "HDR": "تقرير التنمية البشرية",
+  "Graphics": "الرسومات",
+  "Done": "تم",
+  "This feature is not yet available in Horizon.": "هذه الميزة غير متوفرة بعد في Horizon.",
+  "Your display or system doesn't offer HDR output.": "لا توفر شاشتك أو نظامك مخرجات HDR.",
+  "Turn HDR on to use it.": "قم بتشغيل HDR لاستخدامه.",
+  "Your GPU or graphics API doesn't support it.": "وحدة معالجة الرسومات (GPU) أو واجهة برمجة تطبيقات الرسومات الخاصة بك لا تدعمها.",
+  "%s chunks": "%s قطع",
+  "%s per frame": "%s لكل إطار",
+  "%s MiB/frame": "%s MiB/الإطار",
+  "%s KiB/frame": "%s كيلو بايت/الإطار",
+  "Auto (%s)": "تلقائي (%s)",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "نطاق التضاريس كامل التفاصيل. يمكن لمسافة LOD أن تمتد إلى عوالم محلية أبعد.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "التضاريس البعيدة الخشنة في العوالم المحلية. تتوقف وحدات معالجة الرسومات المدمجة عند 128 قطعة.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "تم تقليل الرسم على التضاريس البعيدة: بشكل أسرع على وحدة معالجة الرسومات المدمجة هذه.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "يتم تقليل الرسوم على التضاريس البعيدة بشكل أكثر خشونة، أما بالنسبة لوحدات معالجة الرسومات فإنها تبطئ.",
+  "Field of view. Wider shows more terrain at once.": "مجال الرؤية. يُظهر العرض الأوسع المزيد من التضاريس في وقت واحد.",
+  "Caps frames per second; a cap saves power and heat.": "قبعات الإطارات في الثانية الواحدة؛ غطاء يوفر الطاقة والحرارة.",
+  "Waits for the display's refresh: no tearing, a little latency.": "في انتظار تحديث الشاشة: بدون تمزق، وقليل من زمن الوصول.",
+  "Size of menus and the HUD.": "حجم القوائم وHUD.",
+  "Sets the options below together. Changing one makes it Custom.": "يضبط الخيارات أدناه معًا. تغيير واحد يجعله مخصصًا.",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "الحمم البركانية والنار وأشعة الشمس تتألق أكثر من اللون الأبيض. يحتاج إلى شاشة HDR.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "اللون الأسود الداكن لشاشتك. 0 لـ OLED؛ تتوهج شاشات LCD قليلاً.",
+  "How bright highlights get. Auto: the peak your system reports.": "كيف تحصل على النقاط البارزة الساطعة. تلقائي: ذروة تقارير النظام الخاص بك.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "كيف تبدو الورق والقوائم البيضاء الزاهية. تلقائي: سطح المكتب الخاص بك باللون الأبيض.",
+  "How bright the HUD and menus are, against paper white.": "مدى سطوع شاشة HUD والقوائم مقابل الورق الأبيض.",
+  "How far mobs, crops and machines keep working. CPU time.": "إلى أي مدى يستمر الغوغاء والمحاصيل والآلات في العمل. وقت وحدة المعالجة المركزية.",
+  "How far away mobs and items are drawn, as a share of normal.": "إلى أي مدى يتم رسم الغوغاء والعناصر، كنسبة من المعدل الطبيعي.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "يتخطى التضاريس المخفية خلف الأقسام المغلقة. قبالة تكاليف الكثير.",
+  "Hides entities behind opaque blocks.": "يخفي الكيانات خلف الكتل غير الشفافة.",
+  "No entity occlusion culling.": "لا يوجد إعدام انسداد الكيان.",
+  "CPU occlusion test runs this frame.": "يقوم اختبار انسداد وحدة المعالجة المركزية بتشغيل هذا الإطار.",
+  "Occlusion checks run on a worker thread.": "يتم تشغيل عمليات فحص الانسداد على مؤشر ترابط عامل.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "تم تحميل المقاطع المتشابكة لكل إطار. الجزء السفلي أكثر سلاسة أثناء التحميل.",
+  "Soft shadows in corners. Costs chunk building time only.": "ظلال ناعمة في الزوايا. تكاليف بناء قطعة قطعة فقط.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "نسخ أصغر من أنسجة الكتل للتضاريس البعيدة: أقل وميضًا.",
+  "Blends grass and water colours across biomes when building chunks.": "يمزج ألوان العشب والماء عبر المناطق الأحيائية عند بناء القطع.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "طبقة السحابة: معطلة، مسطحة (سريعة) أو ثلاثية الأبعاد (فاخرة).",
+  "How far clouds reach, in chunks.": "إلى أي مدى تصل السحب، في قطع.",
+  "Draws the sky, sun, moon and stars.": "يرسم السماء والشمس والقمر والنجوم.",
+  "Distance fog. Off shows the edge of the loaded world.": "ضباب المسافة. يظهر Off حافة العالم المحمل.",
+  "Draws rain and snow.": "يرسم المطر والثلج.",
+  "How far rain and snow fall around you.": "إلى أي مدى تسقط الأمطار والثلوج من حولك.",
+  "How many particles effects spawn.": "كم عدد الجسيمات التي تفرخ الآثار.",
+  "Round shadows under mobs and items.": "ظلال مستديرة تحت الغوغاء والعناصر.",
+  "Leaves with see-through gaps. Off draws them solid.": "الأوراق بها فجوات شفافة. قبالة يرسمهم الصلبة.",
+  "Sorts water and glass more exactly behind each other.": "يقوم بفرز الماء والزجاج بشكل أكثر دقة خلف بعضهما البعض.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "أي قطعة سيتم إعادة بنائها تنتظر الإطار: لا شيء، قريب أو خاص بك.",
+  "Animates water, lava, fire and other moving textures.": "ينعش الماء والحمم والنار وغيرها من القوام المتحرك.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "بكسل العالم لكل بكسل الشاشة. أقل من 100% أسرع على وحدة معالجة الرسومات.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "ينعم الحواف الخشنة. FXAA: أكثر ليونة. TAA: قد تتبع الأشياء الأكثر سلاسة وتحريكًا.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "يجعل العالم أصغر حجمًا ويعيد بنائه باستخدام TAA. أسرع وأكثر ليونة.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "إخراج HDR على شاشة HDR: تتألق الحمم البركانية والنار وأشعة الشمس بشكل أكثر سطوعًا.",
+  "How frames reach the screen while VSync is off.": "كيفية وصول الإطارات إلى الشاشة أثناء إيقاف تشغيل VSync.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "ينام بكفاءة حتى الإطار التالي؛ يدور بدقة، مثل الفانيليا.",
+  "Fills the screen (borderless).": "يملأ الشاشة (بلا حدود).",
+  "Brightens dark places.": "يضيء الأماكن الداكنة.",
+  "Lowers the frame rate when minimised, or idle too.": "يخفض معدل الإطارات عند تصغيره أو في وضع الخمول أيضًا.",
+  "Sways the view while walking.": "يتأرجح المنظر أثناء المشي.",
+  "Fades newly loaded chunks in.": "يتلاشى القطع المحملة حديثًا.",
+  "Darkens the screen's edges.": "لتغميق حواف الشاشة.",
+  "Shows when the world saves.": "يظهر عندما ينقذ العالم.",
+  "Shows attack cooldown.": "يظهر تباطؤ الهجوم.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "60 إطارًا في الثانية (30 في القوائم أو غير مركزة)، نصف العمال: طاقة أقل.",
+  "Threads that generate, light and mesh chunks. Next start.": "الخيوط التي تولد القطع الخفيفة والشبكية. البداية التالية.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan، ثم DirectX 12 (Windows) أو OpenGL (Linux) حيث يفشل. البداية التالية.",
+  "Water and glass in one buffer: fewer draw calls, a bit more VRAM. Next start.": "الماء والزجاج في مخزن مؤقت واحد: عدد أقل من مكالمات السحب، والمزيد من VRAM. البداية التالية.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "يتم إرسال بيانات الشبكة إلى وحدة معالجة الرسومات لكل إطار. الجزء السفلي أكثر سلاسة أثناء التحميل.",
+  "Frame rate and frame times over the game, with a graph.": "معدل الإطارات وأوقات الإطار خلال اللعبة، مع رسم بياني.",
+  "horizon.multiplayer.finding_friend": "البحث عن عالم صديقك...",
+  "horizon.multiplayer.not_signed_in": "هذا الخادم في وضع الاتصال بالإنترنت. قم بتسجيل الدخول باستخدام حساب Microsoft الخاص بك في Horizon Launcher للانضمام إليه.",
+  "horizon.multiplayer.invalid_address": "عنوان الخادم غير صالح: %s",
+  "horizon.multiplayer.connected_friend_direct": "تواصل مباشرة مع صديقك..",
+  "horizon.multiplayer.connected_friend_relay": "متصل بصديقك من خلال التتابع...",
+  "General": "عام",
+  "Advanced": "متقدم",
+  "Undo": "تراجع",
+  "Search options": "خيارات البحث",
+  "Shortcut": "الاختصار",
+  "Distance": "المسافة",
+  "Display": "عرض",
+  "Interface": "واجهة",
+  "Sky and weather": "السماء والطقس",
+  "Lighting and entities": "الإضاءة والكيانات",
+  "Textures": "القوام",
+  "Image": "صورة",
+  "Chunk loading": "تحميل قطعة",
+  "Culling": "إعدام",
+  "Power": "القوة",
+  "Frames": "إطارات",
+  "Overlay": "تراكب",
+  "Output": "الإخراج",
+  "Brightness": "السطوع",
+  "How far you see, the window and the HUD.": "إلى أي مدى ترى النافذة وشاشة HUD.",
+  "The sky and weather, lighting, textures and the image.": "السماء والطقس والإضاءة والقوام والصورة.",
+  "Chunk loading, culling and power use.": "تحميل القطع وإعدامها واستخدام الطاقة.",
+  "How frames reach the screen, and the performance overlay.": "كيفية وصول الإطارات إلى الشاشة وتراكب الأداء.",
+  "Brighter-than-white output on an HDR display.": "إخراج أكثر سطوعًا من اللون الأبيض على شاشة HDR.",
+  "Results for \"%s\"": "نتائج ل \"%s\"",
+  "No settings match.": "لا توجد إعدادات متطابقة.",
+  "horizon.title.not_affiliated": "لا ينتمي إلى Mojang أو Microsoft",
+  "horizon.extras.header.lighting": "الإضاءة",
+  "horizon.extras.header.third_person": "شخص ثالث",
+  "horizon.extras.header.particles": "الجسيمات",
+  "horizon.extras.header.inventory": "المخزون",
+  "horizon.extras.header.chat": "الدردشة",
+  "horizon.extras.header.multiplayer": "متعددة اللاعبين",
+  "horizon.extras.header.sound": "الصوت",
+  "horizon.extras.header.menus": "القوائم",
+  "horizon.extras.fullbright": "فولبرايت",
+  "horizon.extras.dynamic_lights": "أضواء ديناميكية",
+  "horizon.extras.own_name_tag": "علامة الاسم الخاصة",
+  "horizon.extras.hide_block_particles": "إخفاء جزيئات كسر الكتلة",
+  "horizon.extras.auto_reconnect": "إعادة الاتصال التلقائي",
+  "horizon.extras.ui_sound_reserve": "احتفظ بقنوات لأصوات واجهة المستخدم",
+  "horizon.extras.music_page": "صفحة الموسيقى",
+  "horizon.extras.mouse_tweaks": "الضوابط بتعديل الماوس",
+  "horizon.extras.mouse_tweaks_wheel": "عجلة التمرير تنقل العناصر",
+  "horizon.extras.sort": "أزرار الفرز",
+  "horizon.extras.sort_key": "مفتاح الفرز",
+  "horizon.extras.no_ai": "لا يوجد ذكاء اصطناعي",
+  "horizon.extras.agent_control": "مراقبة الوكيل",
+  "horizon.extras.discord_presence": "وجود الخلاف الغني",
+  "horizon.extras.splitscreen": "تقسيم الشاشة",
+  "horizon.extras.chat_animation": "دردشة سلسة",
+  "horizon.extras.chat_indicator": "مؤشر الرسالة",
+  "horizon.extras.wheel_cycles_settings": "عجلة التمرير تغير الإعدادات",
+  "horizon.extras.pack_browser": "متصفح حزمة الموارد",
+  "horizon.extras.fullbright.tooltip": "إظهار الكتل والكيانات في الضوء الكامل، حتى في المناطق المظلمة.",
+  "horizon.extras.dynamic_lights.tooltip": "تم حمل المشاعل ومصادر الضوء الأخرى أو إسقاطها أو إشعال النار فيها على الكتل المحيطة بها.",
+  "horizon.extras.own_name_tag.tooltip": "يظهر اسمك فوق رأسك بصيغة الغائب، كما يراه اللاعبون الآخرون. يكون مخفيًا عندما يخفي الخادم أسماء فريقك أو عندما تكون غير مرئي.",
+  "horizon.extras.hide_block_particles.tooltip": "يخفي جزيئات الحطام التي تنفجر من كتلة مكسورة وتتفتت من تلك التي قمت بتعدينها. وتبقى الجزيئات الأخرى.",
+  "horizon.extras.auto_reconnect.tooltip": "إعادة الانضمام إلى الخادم بعد انقطاع الاتصال أو إعادة التشغيل، وليس بعد ركلة أو حظر أبدًا.",
+  "horizon.extras.ui_sound_reserve.tooltip": "تترك الأصوات في العالم 16 قناة صوتية من أصل 247 قناة مجانية، لذا فإن طوفانًا منها (انفجار كبير) لا يمكنه إسكات نقرات القائمة.",
+  "horizon.extras.music_page.tooltip": "تحصل الموسيقى والأصوات على صفحة موسيقى...: قم بتشغيل أي مسار مضمن الآن، أو قم بإيقاف تشغيله حتى تتوقف اللعبة عن اختياره. لا شيء يتغير حتى تقوم بإيقاف تشغيل المسار.",
+  "horizon.extras.mouse_tweaks.tooltip": "يؤدي السحب الأيمن إلى وضع عنصر واحد في كل فتحة، بينما يقوم السحب الأيسر بتجميع العنصر المحفوظ، بينما يقوم Shift + السحب الأيسر بنقل كل فتحة.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "يرسل الجزء السفلي عنصرًا واحدًا من الفتحة إلى الجانب الآخر، بينما يقوم الجزء العلوي بإحضار عنصر واحد مرة أخرى.",
+  "horizon.extras.sort.tooltip": "يقوم بفرز المخزون والصناديق والبراميل وصناديق النهاية وصناديق الشولكر بترتيب علامات تبويب إبداعية، ودمج الأكوام.",
+  "horizon.extras.sort_key.tooltip": "فرز الجزء الموجود تحت المؤشر. انقر، ثم اضغط على مفتاح؛ الهروب يفككه.",
+  "horizon.extras.no_ai.tooltip": "يخفي ويوقف تشغيل كل ميزات الذكاء الاصطناعي: التحكم بالوكيل، Horizon-ctl وخوادم MCP. مفتاح المشغل أيضًا.",
+  "horizon.extras.agent_control.tooltip": "يمكن لوكيل الذكاء الاصطناعي الخاص بك لعب هذه اللعبة من خلال Horizon-ctl أو عميل MCP، على هذا الكمبيوتر فقط.",
+  "horizon.extras.discord_presence.tooltip": "يعرض Playing Horizon على ملف تعريف Discord الخاص بك أثناء تشغيل Discord: القوائم، أو اللاعب الفردي أو المتعدد، والبعد ووقت اللعب. لا يوجد أبدًا اسم عالمي أو عنوان خادم.",
+  "Calibrate...": "معايرة...",
+  "Calibrate Anyway...": "معايرة على أية حال...",
+  "Use Automatic Setup": "استخدم الإعداد التلقائي",
+  "Shortcut: %s": "الاختصار: %s",
+  "Next": "التالي",
+  "HDR Calibration %s/%s: %s": "معايرة HDR %s/%s: %s",
+  "Sets the three below full screen, one test picture at a time.": "لتعيين الصور الثلاثة أدناه بملء الشاشة، صورة اختبارية واحدة في كل مرة.",
+  "A key that opens this screen from the game. Not bound at first.": "المفتاح الذي يفتح هذه الشاشة من اللعبة. غير ملزمة في البداية.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "لم توضح شاشتك مدى سطوعها: قم بالمعايرة لإعدادها.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "تم إعداده بالفعل للعرض الخاص بك. قم بالمعايرة فقط إذا كان تقرير HDR يبدو خاطئًا.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "يعيد ذروة السطوع والورق الأبيض إلى إعداد شاشتك.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "قم بإعداد العرض الخاص بك. اتركه على الوضع التلقائي ما لم يبدو خاطئًا.",
+  "Lower it until the logo just disappears into the black.": "قم بخفضه حتى يختفي الشعار باللون الأسود.",
+  "Raise it until the logo just disappears into the bright square.": "ارفعه حتى يختفي الشعار في المربع المشرق.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "اجعل البطاقة بيضاء اللون بحيث تكون مريحة عند النظر إليها لفترة طويلة، في الضوء الذي تلعب فيه.",
+  "horizon.splitscreen.profiles.forget": "ننسى",
+  "horizon.splitscreen.profiles.create": "إنشاء",
+  "horizon.splitscreen.profiles.you": " - أنت",
+  "horizon.splitscreen.profiles.forget_named": "ننسى %s",
+  "horizon.splitscreen.profiles.previous": "السابق",
+  "horizon.splitscreen.profiles.next": "التالي",
+  "horizon.splitscreen.profiles.new_button": "ملف تعريف جديد...",
+  "horizon.splitscreen.profiles.forget_title": "هل نسيت الملف الشخصي؟",
+  "horizon.splitscreen.profiles.forget_leaves": "فإنه يترك قائمة هذا المثيل.",
+  "horizon.splitscreen.profiles.forget_kept": "يتم الاحتفاظ بالتقدم العالمي والإعدادات.",
+  "horizon.splitscreen.profiles.new_title": "ملف تعريف جديد",
+  "horizon.splitscreen.profiles.name_hint": "الاسم (من 3 إلى 16 حرفًا ورقمًا _)",
+  "horizon.splitscreen.profiles.switch_title": "تبديل الملف الشخصي",
+  "horizon.splitscreen.profiles.offline_note": "تنتمي الملفات الشخصية غير المتصلة بالإنترنت إلى هذه الحالة",
+  "horizon.splitscreen.profiles.move": "تحرك حيث تلعب",
+  "horizon.splitscreen.profiles.move_place": "تحرك حيث تلعب: %s",
+  "horizon.friends.title": "العب مع الأصدقاء",
+  "horizon.friends.hint": "يقوم الأصدقاء بلصق الرمز بعد زر الأصدقاء على شاشة العنوان، أو في الاتصال المباشر، أو على صفحة التشغيل الخاصة بالمشغل.",
+  "horizon.friends.copied": "منقول",
+  "horizon.friends.copy_code": "نسخ الرمز",
+  "horizon.friends.stop_sharing": "توقف عن المشاركة",
+  "horizon.friends.none_yet": "لا يوجد أصدقاء هنا بعد.",
+  "horizon.friends.here_now": "هنا الآن: %s",
+  "horizon.friends.share_intro": "شارك هذا العالم خلف رمز الدعوة: فهو يفتح على شبكة LAN، وينضم الأصدقاء على الإنترنت باستخدام الرمز. لا يوجد خادم خاص بنا متورط.",
+  "horizon.friends.start_sharing": "ابدأ المشاركة",
+  "horizon.friends.troubleshooting": "استكشاف الأخطاء وإصلاحها...",
+  "horizon.friends.stopped": "تم إيقاف مشاركة رمز الدعوة.",
+  "horizon.friends.short_code_changed": "استمر شخص ما في تجربة رمز قصير خاطئ، لذلك تغير.",
+  "horizon.friends.wrong_code": "حاول شخص ما رمزا خاطئا.",
+  "horizon.friends.code_ready": "رمز الدعوة الخاص بك جاهز: قائمة الألعاب، العب مع الأصدقاء. انسخها وأرسلها إلى أصدقائك.",
+  "horizon.friends.share_failed": "لا يمكن مشاركة العالم: %s",
+  "horizon.friends.finding_route": "التعرف على كيفية وصول الأصدقاء إليك...",
+  "horizon.osk.shift": "التحول",
+  "horizon.osk.space": "الفضاء",
+  "horizon.osk.delete": "حذف",
+  "horizon.osk.type": "اكتب",
+  "horizon.osk.symbols": "الرموز",
+  "horizon.osk.close": "إغلاق",
+  "horizon.extras.chat_animation.tooltip": "ينزلق خط الدردشة الجديد من اليسار بينما يتلاشى للداخل، بدلاً من أن يظهر كاملاً.",
+  "horizon.extras.chat_indicator.tooltip": "الشريط الملون الموجود على يسار خط الدردشة.",
+  "horizon.extras.wheel_cycles_settings.tooltip": "عجلة التمرير فوق زر في الإعدادات تغير قيمته، كما هو الحال في الفانيليا. مع إيقاف التشغيل، تقوم العجلة بتمرير القائمة فقط.",
+  "horizon.extras.pack_browser.tooltip": "تحديد حزم الموارد يحصل على زر \"إضافة\" الذي يبحث في Modrinth ويقوم بتثبيت حزمة في مجلد الحزم الخاص بك. مع إيقاف التشغيل، لن تتصل اللعبة أبدًا بـ Modrinth.",
+  "horizon.extras.splitscreen.tooltip": "في عالم ما، يمكن لوحدة تحكم أخرى الانضمام كلاعب جديد: اضغط على A عندما يُطلب منك ذلك، ثم اختر ملفًا شخصيًا ومكان اللعب.",
+  "horizon.splitscreen.setup.monitor": "مراقب %s",
+  "horizon.splitscreen.setup.monitor_unknown": "شاشة",
+  "horizon.splitscreen.setup.window": "نافذة %s",
+  "horizon.splitscreen.setup.new_window": "نافذة جديدة",
+  "horizon.splitscreen.setup.fill_monitor": "املأ %s",
+  "horizon.splitscreen.setup.done": "تم",
+  "horizon.splitscreen.setup.on": "على",
+  "horizon.splitscreen.setup.off": "إيقاف",
+  "horizon.splitscreen.setup.player": "اللاعب %s",
+  "horizon.splitscreen.setup.revert": "العودة",
+  "horizon.splitscreen.setup.apply": "تطبيق",
+  "horizon.splitscreen.setup.warning.empty_main": "لا أحد يلعب في النافذة 1: إنه يخفي",
+  "horizon.splitscreen.setup.warning.empty_close": "لا أحد يلعب في النافذة %s: يتم إغلاقها عند تطبيق",
+  "horizon.splitscreen.setup.warning.empty_new": "لا أحد يلعب في النافذة %s: لن يتم فتحها",
+  "horizon.splitscreen.setup.warning.on_main": "النافذة %s تملأ شاشة النافذة 1: يلعب لاعبوها في النافذة 1",
+  "horizon.splitscreen.setup.warning.unplugged": "شاشة النافذة %s غير متصلة: يتم تشغيل مشغلاتها في النافذة 1",
+  "horizon.splitscreen.setup.status.off": "تقسيم الشاشة معطل.",
+  "horizon.splitscreen.setup.status.enable_hint": "قم بتشغيله، ثم اضغط على زر على وحدة تحكم أخرى في العالم.",
+  "horizon.splitscreen.setup.status.join_hint": "اضغط على A للانضمام واختيار ملف التعريف.",
+  "horizon.splitscreen.setup.status.idle": "تقسيم الشاشة خاملاً",
+  "horizon.splitscreen.setup.status.alone": "لا يوجد لاعبين محليين آخرين.",
+  "horizon.splitscreen.setup.status.solo_controls": "لم تتغير عناصر التحكم الفردية وملاحظات وحدة التحكم.",
+  "horizon.splitscreen.setup.window_empty": "النافذة %s: فارغة",
+  "horizon.splitscreen.setup.note.select": "انقر فوق أحد اللاعبين، أو اسحبه إلى نافذة أو شاشة.",
+  "horizon.splitscreen.setup.note.apply": "تقدم للعب بهذه الطريقة، ثم ارجع للتراجع.",
+  "horizon.splitscreen.setup.note.place": "أين يجب أن يلعب %s؟",
+  "horizon.splitscreen.setup.this_player": "هذا اللاعب",
+  "horizon.splitscreen.setup.switch_disabled": "يتم إيقاف تشغيل الشاشة المنقسمة بمجرد مغادرة الآخرين (قائمة الإيقاف المؤقت الخاصة بهم).",
+  "horizon.splitscreen.setup.window_place": "النافذة %s (%s من %s)",
+  "horizon.splitscreen.setup.names": "الأسماء",
+  "horizon.splitscreen.setup.identify": "تحديد",
+  "horizon.splitscreen.setup.layout.two": "2 المشاركة: %s",
+  "horizon.splitscreen.setup.layout.three": "3 المشاركة: %s",
+  "horizon.splitscreen.setup.layout.two.0": "تلقائي",
+  "horizon.splitscreen.setup.layout.two.1": "جنبا إلى جنب",
+  "horizon.splitscreen.setup.layout.two.2": "أعلى وأسفل",
+  "horizon.splitscreen.setup.layout.three.0": "واحدة واسعة في الأعلى",
+  "horizon.splitscreen.setup.layout.three.1": "واحد طويل القامة على اليسار",
+  "horizon.splitscreen.setup.layout.three.2": "جنبا إلى جنب",
+  "horizon.splitscreen.setup.help.player": "انقر أو اسحب %s لتحريكها.",
+  "horizon.splitscreen.setup.help.layout_auto": "%s (جنبًا إلى جنب عندما تكون النافذة واسعة). اضغط للتغيير.",
+  "horizon.splitscreen.setup.help.layout": "%s. اضغط للتغيير.",
+  "horizon.splitscreen.setup.help.switch": "تقسيم الشاشة لهذا الكمبيوتر، أو إيقاف تشغيله.",
+  "horizon.splitscreen.setup.help.identify": "تُظهر طريقة عرض كل لاعب النافذة التي يوجد بها.",
+  "horizon.splitscreen.setup.help.names": "اسم كل لاعب في زاوية رؤيته.",
+  "horizon.splitscreen.setup.help.revert": "التراجع عن التغييرات التي لم يتم تطبيقها بعد.",
+  "horizon.splitscreen.setup.help.apply": "العب بالطريقة التي تظهر بها الخريطة.",
+  "horizon.splitscreen.setup.help.unchanged": "لم يتغير شيء بعد.",
+  "horizon.splitscreen.setup.give_up_pad": "التخلي عن الوسادة",
+  "horizon.splitscreen.prompt.controller_connected": "وحدة التحكم متصلة",
+  "horizon.splitscreen.prompt.controller_disconnected": "وحدة التحكم مفصولة",
+  "horizon.splitscreen.prompt.controller_disconnected.hint": "أعد توصيله، أو اضغط على زر على آخر",
+  "horizon.splitscreen.prompt.join.one": "%s يريد الانضمام",
+  "horizon.splitscreen.prompt.join.many": "%s وحدات التحكم تريد الانضمام",
+  "horizon.splitscreen.prompt.join.yes": "انضم",
+  "horizon.splitscreen.prompt.join.as_p1": "العب بشخصية P1",
+  "horizon.splitscreen.prompt.join.no": "لا",
+  "horizon.splitscreen.prompt.lost": "%s: تم فصل وحدة التحكم",
+  "horizon.splitscreen.prompt.lost.use_another": "استخدم آخر",
+  "horizon.splitscreen.prompt.lost.leave": "غادر",
+  "horizon.splitscreen.setup.help.give_up_pad": "تتوقف وحدة التحكم الخاصة بك عن قيادتك ويُعرض عليك الانضمام (أ).",
+  "horizon.splitscreen.setup.note.held_at": "%s إلى %s: يسقطها A هنا، ويعيدها B.",
+  "horizon.splitscreen.setup.note.held": "%s تم الالتقاط: يسار/يمين يختار المكان، يسقط A، ويعيده B.",
+  "Hides models behind opaque blocks. Async checks off-thread; entities tick.": "يخفي النماذج خلف الكتل المعتمة. غير متزامن يتحقق من خارج الموضوع؛ علامة الكيانات.",
+  "Block Entities": "حظر الكيانات",
+  "Shulker Boxes": "صناديق شوكر",
+  "Reuses settled boxes; lid movement stays animated.": "إعادة استخدام الصناديق المستقرة؛ تبقى حركة الغطاء متحركة.",
+  "Signs": "علامات",
+  "Reuses sign text until text, light, or font changes.": "يعيد استخدام نص التوقيع حتى يتغير النص أو الضوء أو الخط.",
+  "Decorated Pots": "الأواني المزخرفة",
+  "Reuses still pots; break wobble and sherd changes redraw.": "إعادة استخدام الأواني الثابتة؛ كسر تمايل وتغييرات الكسر إعادة رسم.",
+  "Bells": "أجراس",
+  "Reuses still bells; ringing stays animated.": "إعادة استخدام الأجراس الثابتة؛ يبقى الرنين متحركًا.",
+  "Chests": "الصناديق",
+  "Reuses closed chests; moving lids stay animated.": "إعادة استخدام الصناديق المغلقة؛ الأغطية المتحركة تبقى متحركة.",
+  "Banners": "لافتات",
+  "Reuses poles; flags and pattern layers still update.": "إعادة استخدام الأعمدة؛ لا يزال يتم تحديث الأعلام وطبقات الأنماط.",
+  "Copper Golem Statues": "تماثيل النحاس جوليم",
+  "Reuses statue geometry until its block state changes.": "يعيد استخدام هندسة التمثال حتى تتغير حالة الكتلة الخاصة به.",
+  "Leaf Culling": "إعدام الأوراق",
+  "Every leaf face. Vanilla's fancy leaves.": "وجه كل ورقة. أوراق الفانيليا الفاخرة.",
+  "Distant Plant Dither": "ثبات النبات البعيد",
+  "Keeps fine plants in high-res packs from fading far away.": "يحافظ على النباتات الجميلة في عبوات عالية الدقة من البهتان بعيدًا.",
+  "Screenshot Quality": "جودة لقطة الشاشة",
+  "F2 screenshots at this many times the game's resolution. Higher takes longer.": "لقطات شاشة F2 بهذا دقة اللعبة عدة مرات. أعلى يستغرق وقتا أطول.",
+  "Frame Generation": "جيل الإطار",
+  "Shows a made-up frame between each two real ones: smoother, a little more lag.": "يُظهر إطارًا مكوّنًا بين كل إطارين حقيقيين: أكثر سلاسة وتأخرًا قليلًا.",
+  "Shadow Cache": "ذاكرة التخزين المؤقت الظل",
+  "Reuses the pack shadow map when sun, view and world match. Off by default.": "يعيد استخدام خريطة ظل الحزمة عندما تتطابق الشمس والعرض والعالم. إيقاف بشكل افتراضي.",
+  "Find BlueMap": "ابحث عن بلو ماب",
+  "On servers, finds their BlueMap web map for far terrain. Next join.": "على الخوادم، يتم العثور على خريطة الويب BlueMap الخاصة بهم للتضاريس البعيدة. الانضمام التالي.",
+  "BlueMap Radius": "نصف قطر الخريطة الزرقاء",
+  "How far around you BlueMap tiles are downloaded. Next join.": "إلى أي مدى يتم تنزيل بلاط BlueMap من حولك. الانضمام التالي.",
+  "Synchronous": "متزامن",
+  "Asynchronous": "غير متزامن",
+  "Solid": "صلب",
+  "Solid Aggressive": "العدوانية الصلبة",
+  "Hollow": "جوفاء",
+  "Leaves fully inside a canopy draw solid: fewer see-through layers.": "يتم رسم الأوراق بالكامل داخل المظلة بشكل صلب: طبقات شفافة أقل.",
+  "Leaves with one open side draw solid too: faster, chunkier edges.": "الأوراق ذات جانب واحد مفتوح ترسم بشكل صلب أيضًا: حواف أسرع وأكثر كثافة.",
+  "Drops faces between leaves: faster, but gaps look through.": "يسقط الوجوه بين الأوراق: بشكل أسرع، لكن الفجوات تبدو من خلالها.",
+  "Hotbar: Previous Slot": "Hotbar: الفتحة السابقة",
+  "Hotbar: Next Slot": "Hotbar: الفتحة التالية",
+  "horizon.agent.connected.one": "متصل: اتصال وكيل واحد",
+  "horizon.agent.connected.many": "متصل: %s اتصالات الوكيل",
+  "horizon.agent.connected.one_ago": "متصل: اتصال وكيل واحد، آخر أمر %s مضت",
+  "horizon.agent.connected.many_ago": "متصل: %s اتصالات الوكيل، آخر أمر %s مضت",
+  "horizon.agent.waiting": "في انتظار وكيل.",
+  "horizon.agent.off": "إيقاف: لا يمكن للعملاء الوصول إلى هذه اللعبة.",
+  "horizon.agent.session_opened": "تم فتحه لهذه الجلسة بواسطة البرنامج الذي بدأ اللعبة.",
+  "horizon.agent.socket": "المقبس: %s (انسخ التفاصيل لمساره الكامل)",
+  "horizon.agent.local_only": "محلي فقط: الوكلاء على هذا الكمبيوتر، وليس الشبكة أبدًا.",
+  "%s nits": "%s القمل",
+  "Auto (%s nits)": "تلقائي (%s شمعة في المتر المربع)",
+  "%.2f nits": "%.2f القمل",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "يخفي النماذج خلف الكتل المعتمة. تحديث الكيانات مع حزم مخصصة.",
+  "horizon.extras.repro_keys": "تسجيل الاختصارات",
+  "horizon.extras.repro_keys.tooltip": "يقوم F3+R ببدء التسجيل النسخي أو إيقافه ويقوم F3+E بكتابة الحزمة الخاصة به. متوقف بشكل افتراضي: تسجيل ينسخ العالم.",
+  "horizon.agent.record_session": "ابدأ جلسة التسجيل",
+  "horizon.agent.record_stop": "إيقاف جلسة التسجيل",
+  "horizon.agent.export_repro": "تصدير حزمة النسخ المتماثل",
+  "horizon.repro.started": "بدأ التسجيل؛ F3+R يوقفه ويكتب الحزمة.",
+  "horizon.repro.stopped": "توقف التسجيل: %s",
+  "horizon.repro.bundle": "حزمة النسخ: %s",
+  "horizon.repro.error": "استنساخ: %s",
+  "horizon.repro.no_recording": "لا يوجد تسجيل للتصدير حتى الآن.",
+  "horizon.repro.replay_started": "بدأت إعادة التشغيل: %s",
+  "horizon.pack.addInfo": "إضافة حزمة موارد من Modrinth",
+  "horizon.pack.addWorking": "يسأل مودرنث...",
+  "horizon.pack.addNone": "لم يتم العثور على حزم الموارد",
+  "horizon.pack.addTitle": "أضف حزمة الموارد",
+  "horizon.pack.install": "تثبيت",
+  "horizon.pack.installing": "التثبيت",
+  "horizon.pack.installed": "تم التثبيت",
+  "horizon.pack.search": "بحث",
+  "horizon.pack.searchHint": "بحث مودرينث...",
+  "horizon.pack.filters": "المرشحات",
+  "horizon.pack.filter.realistic": "واقعية",
+  "horizon.pack.filter.simplistic": "تبسيط",
+  "horizon.pack.filter.vanillaLike": "تشبه الفانيليا",
+  "horizon.pack.addFailed": "لا يمكن إضافة الحزمة: %s",
+  "horizon.extras.header.cosmetics": "مستحضرات التجميل",
+  "horizon.extras.cosmetics_mine": "مستحضرات التجميل الخاصة بي",
+  "horizon.extras.cosmetics_mine.tooltip": "مخفي: يراك كل لاعب في Horizon بدون مستحضرات التجميل الخاصة بك، بما في ذلك أنت. نفس مفتاح خزانة المشغل.",
+  "horizon.extras.cosmetics_others": "مستحضرات التجميل للاعبين الآخرين",
+  "horizon.extras.cosmetics_others.tooltip": "ما يرتديه لاعبو Horizon الآخرون: كل شيء، فقط أنماط بطاقة الاسم الخاصة بهم، أو لا شيء. مخفيًا، اللعبة لا تسأل أبدًا عما يرتدونه.",
+  "horizon.extras.cosmetics_auras": "هالات ومسارات الآخرين",
+  "horizon.extras.cosmetics_auras.tooltip": "الهالات والمسارات التي يرتديها اللاعبون الآخرون. إيقاف بشكل افتراضي.",
+  "horizon.extras.cosmetics.shown": "معروض",
+  "horizon.extras.cosmetics.hidden": "مخفي",
+  "horizon.extras.cosmetics.name_tags": "علامات الاسم فقط"
+}

crates/horizon-client/assets/horizon/lang/az_az.json

@@ -0,0 +1,473 @@
+{
+  "horizon.options.controller": "Nəzarətçi",
+  "horizon.options.vibration": "Vibrasiya",
+  "horizon.options.adaptive_triggers": "Adaptiv tətiklər",
+  "horizon.options.lightbar": "İşıq çubuğu",
+  "horizon.options.look_sensitivity": "Baxış həssaslığı",
+  "horizon.options.invert_x": "Tərs baxış X",
+  "horizon.options.invert_y": "Tərs baxış Y",
+  "horizon.options.sneak_button": "Gizlənmə düyməsi",
+  "horizon.options.move_deadzone": "Hərəkət ölü zonası",
+  "horizon.options.look_deadzone": "Baxış ölü zonası",
+  "horizon.options.button_glyphs": "Düymə Qlifləri",
+  "horizon.options.menu_navigation": "Menyu Naviqasiyası",
+  "horizon.options.on_screen_keyboard": "Ekran Klaviaturası",
+  "horizon.options.chat_delay": "Söhbət Gecikməsi",
+  "horizon.options.lightbar.health": "Sağlamlıq",
+  "horizon.options.lightbar.dimension": "Ölçü",
+  "horizon.options.glyphs.auto": "Avtomatik",
+  "horizon.options.menu_focus": "Fokus",
+  "horizon.options.menu_pointer": "Göstərici",
+  "horizon.options.keyboard.auto": "Avtomatik",
+  "horizon.options.unavailable": "Bu funksiya hələ Horizon ərazisində mövcud deyil.",
+  "horizon.options.search": "Axtarış parametrləri...",
+  "horizon.pages.mods": "Modlar",
+  "horizon.pages.shader_packs": "Shader Paketləri",
+  "horizon.pages.shader_options": "Shader Seçimləri",
+  "horizon.pages.controller": "Nəzarətçi Parametrləri",
+  "horizon.pages.controller_binds": "Nəzarətçi Bağlayır",
+  "horizon.pages.extras": "Horizon Əlavələr",
+  "horizon.pages.settings": "Horizon Parametrlər",
+  "horizon.pages.agent": "AI agenti",
+  "horizon.split.leave": "tərk et",
+  "horizon.pages.split_settings": "Splitscreen Parametrləri",
+  "horizon.pages.split_profiles": "Kim oynayır?",
+  "horizon.pages.split_setup": "Splitscreen Quraşdırma",
+  "horizon.pages.music": "Musiqi",
+  "horizon.pages.music.menu": "Menyu",
+  "horizon.pages.music.overworld": "Yerüstü dünya",
+  "horizon.pages.music.creative": "Yaradıcı",
+  "horizon.pages.music.underwater": "Sualtı",
+  "horizon.pages.music.end": "Son",
+  "horizon.pages.music.boss": "patron",
+  "horizon.pages.music.credits": "Kreditlər",
+  "horizon.pages.music.overworld_biomes": "Yerüstü biomlar",
+  "horizon.pages.music.nether_biomes": "Nether biomları",
+  "horizon.pages.music.end_biomes": "Biomları bitir",
+  "horizon.pages.music.other": "Digər musiqi",
+  "horizon.pages.music.empty": "Musiqi parçaları yoxdur: oyunun səsləri yüklənmir.",
+  "horizon.pages.music.tooltip": "Vəziyyətə görə quraşdırılmış treklər: birini indi oynayın və ya hər hansı birini söndürün ki, oyun onu seçməyi dayandırsın.",
+  "horizon.pages.settings.tooltip": "Horizon öz parametrləri: qrafika, nəzarətçilər, əlavələr və modlar.",
+  "horizon.pages.graphics.tooltip": "Qrafika, sadəcə olaraq: hər parametr nəyə başa gəldiyini bildirir.",
+  "horizon.pages.graphics_advanced.tooltip": "Hər bir qrafik parametri, Horizon daxil edilir, hər birinin dəyəri ilə.",
+  "horizon.pages.controller.tooltip": "Nəzarətçilər: onların düymələri, çubuqları, vibrasiya və menyu naviqasiyası.",
+  "horizon.pages.extras.tooltip": "Könüllü əlavələr, hamısı defolt olaraq söndürülür: siz birini yandırana qədər oyun vanil olaraq qalır.",
+  "horizon.pages.agent.tooltip": "Öz AI agentinizin oynamasına icazə verin: bu kompüterdə horizon-ctl və MCP müştəriləri.",
+  "horizon.pages.split_profiles.tooltip": "Kim oynayır: bu oyun qovluğunda saxlanılan profil.",
+  "horizon.pages.split_setup.tooltip": "Pəncərələr və monitorlar və kim harada oynayır.",
+  "horizon.pages.shader_packs.tooltip": "shaderpacks qovluğundan şader paketləri: Horizon öz və shaders/formatında olanlar. Bir dəfə qaçır.",
+  "horizon.pages.mods.tooltip": "Horizon-mods qovluğundan Horizon üçün hazırlanmış modlar. Hər biri sandboxda işləyir və siz onu yandırana qədər sönür.",
+  "horizon.pages.open.graphics": "Qrafika...",
+  "horizon.pages.open.graphics_advanced": "Qabaqcıl Qrafika...",
+  "horizon.pages.open.shader_packs": "Shader Paketləri...",
+  "horizon.pages.open.controller": "Nəzarətçi Parametrləri...",
+  "horizon.pages.open.split_setup": "Ayrılmış ekran...",
+  "horizon.pages.open.extras": "Əlavələr...",
+  "horizon.pages.open.mods": "Modlar...",
+  "horizon.pages.open.horizon_graphics": "Horizon Qrafika...",
+  "horizon.pages.open.controller_binds": "Nəzarətçi Bağlayır...",
+  "horizon.pages.open.horizon_settings": "Horizon Parametrlər...",
+  "horizon.pages.open.music": "Musiqi...",
+  "horizon.mods.empty": "Mod yoxdur: .hmod fayllarını horizon-mods qovluğuna qoyun",
+  "horizon.mods.stopped": " (Dayandı)",
+  "horizon.mods.not_built": " (tikilməyib)",
+  "horizon.mods.settings": "Parametrlər",
+  "horizon.mods.in_world": " (Dəyişmək üçün dünyanı tərk et)",
+  "horizon.mods.open_folder": "Mod Qovluğunu açın",
+  "horizon.shader_packs.empty": "Şeyder paketləri yoxdur: onları shaderpacks qovluğuna qoyun",
+  "horizon.shader_options.open": "Shader Seçimləri...",
+  "horizon.shader_options.profile": "Profil",
+  "horizon.shader_options.loading": "Şeyder paketinin seçimləri oxunur...",
+  "horizon.agent.copy_details": "Bağlantı təfərrüatlarını kopyalayın",
+  "horizon.multiplayer.join": "Qoşulun",
+  "horizon.multiplayer.cancel_reconnecting": "Yenidən qoşulmanı ləğv edin",
+  "horizon.multiplayer.join_friend": "Dosta Qoşulun",
+  "horizon.multiplayer.invite_code": "Dəvət Kodu",
+  "horizon.multiplayer.relay": "Rele (isteğe bağlı)",
+  "Preset": "Əvvəlcədən təyin",
+  "LOD Distance": "LOD məsafəsi",
+  "Far Detail": "Uzaq Detal",
+  "Cave Culling": "Mağaraların kəsilməsi",
+  "Entity Culling": "Müəssisə Culling",
+  "Chunk Updates": "Parça Yeniləmələri",
+  "Upload Budget": "Büdcə yükləyin",
+  "Sky": "Göy",
+  "Fog": "Duman",
+  "Weather": "Hava",
+  "Animated Textures": "Animasiyalı Dokular",
+  "Present Mode": "İndiki rejim",
+  "Worker Threads": "İşçi ipləri",
+  "Resolution Scale": "Qətnamə Ölçüsü",
+  "Upscaling": "Təkmilləşdirmə",
+  "Paper White": "Kağız Ağ",
+  "Peak Brightness": "Pik Parlaqlıq",
+  "Black Level": "Qara Səviyyə",
+  "UI Brightness": "UI Parlaqlığı",
+  "Battery Mode": "Batareya rejimi",
+  "Graphics API": "Qrafik API",
+  "Translucent Batching": "Şəffaf Batching",
+  "Performance Overlay": "Performans örtüyü",
+  "Full Detail Distance": "Tam Detal Məsafə",
+  "On": "Aktiv",
+  "Off": "Söndür",
+  "Unlimited": "Limitsiz",
+  "Auto": "Avtomatik",
+  "Custom": "Xüsusi",
+  "Performance": "Performans",
+  "Balanced": "Balanslı",
+  "Quality": "Keyfiyyət",
+  "Ultra Performance": "Ultra Performans",
+  "Native": "Yerli",
+  "Full": "Tam",
+  "Reduced": "Azaldılmış",
+  "Efficient": "Səmərəli",
+  "Precise": "Dəqiq",
+  "Auto (VSync)": "Avtomatik (VSync)",
+  "FIFO": "FİFO",
+  "Mailbox": "Poçt qutusu",
+  "Immediate": "Dərhal",
+  "FPS and Graph": "FPS və Qrafik",
+  "No cost": "Xərc yoxdur",
+  "Low cost": "Aşağı qiymət",
+  "Medium cost": "Orta qiymət",
+  "High cost": "Yüksək qiymət",
+  "Saves time": "Vaxta qənaət edir",
+  "Graphics": "Qrafika",
+  "Done": "Bitdi",
+  "This feature is not yet available in Horizon.": "Bu funksiya hələ Horizon ərazisində mövcud deyil.",
+  "Your display or system doesn't offer HDR output.": "Ekranınız və ya sisteminiz HDR çıxışı təklif etmir.",
+  "Turn HDR on to use it.": "İstifadə etmək üçün HDR-ni yandırın.",
+  "Your GPU or graphics API doesn't support it.": "GPU və ya qrafik API onu dəstəkləmir.",
+  "%s chunks": "%s parçalar",
+  "%s per frame": "%s hər çərçivə üçün",
+  "%s MiB/frame": "%s MiB/çərçivə",
+  "%s KiB/frame": "%s KiB/çərçivə",
+  "Auto (%s)": "Avtomatik (%s)",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Tam detallı ərazi diapazonu. LOD məsafəsi yerli dünyaları daha da uzada bilər.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Yerli dünyalarda kobud uzaq ərazi. İnteqrasiya edilmiş GPU-lar 128 hissədə dayanır.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "Azaldılmış ərazini daha qaba çəkir: bu inteqrasiya olunmuş GPU-da daha sürətli.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "Azaldılmış ərazini daha qaba çəkir, GPU-lar üçün isə yavaşlayır.",
+  "Field of view. Wider shows more terrain at once.": "Baxış sahəsi. Daha geniş bir anda daha çox ərazini göstərir.",
+  "Caps frames per second; a cap saves power and heat.": "Saniyədə kadrların sayı; qapaq enerjiyə və istiliyə qənaət edir.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Ekranın təzələnməsini gözləyir: cırılma, bir az gecikmə.",
+  "Size of menus and the HUD.": "Menyuların ölçüsü və HUD.",
+  "Sets the options below together. Changing one makes it Custom.": "Aşağıdakı seçimləri birlikdə təyin edir. Birinin dəyişdirilməsi onu Xüsusi edir.",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Lava, od və günəş işığı ağdan daha parlaq parlayır. HDR displey lazımdır.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Ekranınız ən tünd qaradır. OLED üçün 0; LCD-lər bir az parlayır.",
+  "How bright highlights get. Auto: the peak your system reports.": "Parlaq məqamlar necə əldə edilir. Avtomatik: sisteminizin ən yüksək hesabatı.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "Ağ kağız və menyular necə parlaq görünür. Avtomatik: masaüstünüz ağ rəngdədir.",
+  "How bright the HUD and menus are, against paper white.": "HUD və menyular ağ kağıza qarşı nə qədər parlaqdır.",
+  "How far mobs, crops and machines keep working. CPU time.": "Kütlələr, məhsullar və maşınlar nə qədər işləməyə davam edir. CPU vaxtı.",
+  "How far away mobs and items are drawn, as a share of normal.": "Nə qədər uzağa mob və əşyalar çəkilir, normal bir pay olaraq.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Qapalı hissələrin arxasında gizlənmiş ərazini ötür. Sıxılma çox baha başa gəlir.",
+  "Hides entities behind opaque blocks.": "Obyektləri qeyri-şəffaf blokların arxasında gizlədir.",
+  "No entity occlusion culling.": "Heç bir obyektin okklyuziyası məhv edilmir.",
+  "CPU occlusion test runs this frame.": "CPU tıxanma testi bu çərçivəni idarə edir.",
+  "Occlusion checks run on a worker thread.": "Tıxanma yoxlanışı işçi ipində aparılır.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Meshed bölmələr hər çərçivəyə yüklənir. Yükləyərkən aşağı daha hamar olur.",
+  "Soft shadows in corners. Costs chunk building time only.": "Künclərdə yumşaq kölgələr. Yalnız tikinti vaxtı xərcləri.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "Uzaq ərazilər üçün blok dokuların daha kiçik nüsxələri: daha az parıltı.",
+  "Blends grass and water colours across biomes when building chunks.": "Parçalar qurarkən biomlar arasında ot və su rənglərini qarışdırır.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Bulud təbəqəsi: sönük, düz (sürətli) və ya 3D (fantastik).",
+  "How far clouds reach, in chunks.": "Buludlar nə qədər uzağa çatır, parça-parça.",
+  "Draws the sky, sun, moon and stars.": "Göyü, günəşi, ayı və ulduzları çəkir.",
+  "Distance fog. Off shows the edge of the loaded world.": "Məsafə dumanı. Off yüklənmiş dünyanın kənarını göstərir.",
+  "Draws rain and snow.": "Yağış və qar çəkir.",
+  "How far rain and snow fall around you.": "Ətrafınıza yağış və qar nə qədər yağır.",
+  "How many particles effects spawn.": "Nə qədər hissəcik effektləri kürü verir.",
+  "Round shadows under mobs and items.": "Kütlələrin və əşyaların altında dairəvi kölgələr.",
+  "Leaves with see-through gaps. Off draws them solid.": "Yarpaqları göz qabağındadır. Off onları möhkəm çəkir.",
+  "Sorts water and glass more exactly behind each other.": "Suyu və şüşəni bir-birinin arxasında daha dəqiq şəkildə sıralayır.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Hansı hissənin yenidən qurulması çərçivəni gözləyir: heç biri, yaxınlıqda və ya sizin.",
+  "Animates water, lava, fire and other moving textures.": "Su, lava, od və digər hərəkətli dokuları canlandırır.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Kəsik kənarları hamarlayır. FXAA: daha yumşaq. TAA: ən hamar, hərəkətli şeylər cığır çəkə bilər.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Dünyanı daha kiçik edir və TAA ilə yenidən qurur. Daha sürətli, daha yumşaq.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "HDR displeydə HDR çıxışı: lava, yanğın və günəş işığı daha parlaq parlayır.",
+  "How frames reach the screen while VSync is off.": "VSync söndürüldükdə çərçivələr ekrana necə çatır.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Növbəti kadra qədər səmərəli yuxular; Vanil kimi dəqiq spinlər.",
+  "Fills the screen (borderless).": "Ekranı doldurur (sərhədsiz).",
+  "Brightens dark places.": "Qaranlıq yerləri işıqlandırır.",
+  "Lowers the frame rate when minimised, or idle too.": "Minimumlaşdırıldıqda və ya boş olduqda kadr sürətini azaldır.",
+  "Sways the view while walking.": "Gəzərkən mənzərəni yelləyir.",
+  "Fades newly loaded chunks in.": "Yeni yüklənmiş parçaları sönür.",
+  "Darkens the screen's edges.": "Ekranın kənarlarını qaraldır.",
+  "Shows when the world saves.": "Dünyanın nə vaxt xilas etdiyini göstərir.",
+  "Shows attack cooldown.": "Hücumun soyumasını göstərir.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "60 FPS qapağı (menyularda 30 və ya diqqətsiz), işçilərin yarısı: daha az güc.",
+  "Threads that generate, light and mesh chunks. Next start.": "Yaradan iplər, yüngül və mesh parçaları. Növbəti başlanğıc.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, sonra uğursuz olduğu DirectX 12 (Windows) və ya OpenGL (Linux). Növbəti başlanğıc.",
+  "Water and glass in one buffer: fewer draw calls, a bit more VRAM. Next start.": "Bir buferdə su və şüşə: daha az çəkiliş zəngi, bir az daha çox VRAM. Növbəti başlanğıc.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Hər kadra GPU-ya göndərilən mesh datası. Yükləyərkən aşağı daha hamar olur.",
+  "Frame rate and frame times over the game, with a graph.": "Qrafik ilə oyun üzrə çərçivə sürəti və kadr vaxtları.",
+  "horizon.multiplayer.finding_friend": "Dostunuzun dünyasını tapmaq...",
+  "horizon.multiplayer.not_signed_in": "Bu server onlayn rejimdədir. Qoşulmaq üçün Horizon başlatma cihazında Microsoft hesabınızla daxil olun.",
+  "horizon.multiplayer.invalid_address": "Yanlış server ünvanı: %s",
+  "horizon.multiplayer.connected_friend_direct": "Dostunuza birbaşa qoşulun...",
+  "horizon.multiplayer.connected_friend_relay": "Rele vasitəsilə dostunuza qoşulun...",
+  "Advanced": "Qabaqcıl",
+  "Undo": "Geri alın",
+  "Search options": "Axtarış seçimləri",
+  "Shortcut": "Qısayol",
+  "Distance": "Məsafə",
+  "Display": "Ekran",
+  "Interface": "İnterfeys",
+  "Sky and weather": "Səma və hava",
+  "Lighting and entities": "İşıqlandırma və obyektlər",
+  "Textures": "Dokular",
+  "Image": "Şəkil",
+  "Chunk loading": "Parça yükləmə",
+  "Power": "Güc",
+  "Frames": "Çərçivələr",
+  "Output": "Çıxış",
+  "Brightness": "Parlaqlıq",
+  "How far you see, the window and the HUD.": "Nə qədər görürsən, pəncərə və HUD.",
+  "The sky and weather, lighting, textures and the image.": "Səma və hava, işıqlandırma, faktura və görüntü.",
+  "Chunk loading, culling and power use.": "Parçaların yüklənməsi, kəsilməsi və enerji istifadəsi.",
+  "How frames reach the screen, and the performance overlay.": "Çərçivələrin ekrana necə çatması və performans örtüyü.",
+  "Brighter-than-white output on an HDR display.": "HDR displeydə ağdan daha parlaq çıxış.",
+  "Results for \"%s\"": "\"%s\" üçün nəticələr",
+  "No settings match.": "Heç bir parametr uyğun gəlmir.",
+  "horizon.title.not_affiliated": "Mojang və ya Microsoft ilə əlaqəli deyil",
+  "horizon.extras.header.lighting": "İşıqlandırma",
+  "horizon.extras.header.third_person": "Üçüncü şəxs",
+  "horizon.extras.header.particles": "hissəciklər",
+  "horizon.extras.header.inventory": "İnventar",
+  "horizon.extras.header.chat": "Söhbət",
+  "horizon.extras.header.sound": "Səs",
+  "horizon.extras.header.menus": "Menyular",
+  "horizon.extras.fullbright": "Tam parlaq",
+  "horizon.extras.dynamic_lights": "Dinamik işıqlar",
+  "horizon.extras.own_name_tag": "Öz ad etiketi",
+  "horizon.extras.hide_block_particles": "Blok qırılan hissəcikləri gizlədin",
+  "horizon.extras.auto_reconnect": "Avtomatik yenidən qoşulun",
+  "horizon.extras.ui_sound_reserve": "UI səsləri üçün kanalları saxlayın",
+  "horizon.extras.music_page": "Musiqi səhifəsi",
+  "horizon.extras.mouse_tweaks": "Mouse Tweaks nəzarətləri",
+  "horizon.extras.mouse_tweaks_wheel": "Sürüşdürmə çarxı elementləri hərəkət etdirir",
+  "horizon.extras.sort": "Çeşidləmə düymələri",
+  "horizon.extras.sort_key": "Sıralama açarı",
+  "horizon.extras.no_ai": "AI yoxdur",
+  "horizon.extras.agent_control": "Agent Nəzarəti",
+  "horizon.extras.chat_animation": "Rahat söhbət",
+  "horizon.extras.chat_indicator": "Mesaj göstəricisi",
+  "horizon.extras.wheel_cycles_settings": "Sürüşdürmə çarxı parametrləri dəyişir",
+  "horizon.extras.pack_browser": "Resurs paketi brauzeri",
+  "horizon.extras.fullbright.tooltip": "Blokları və obyektləri hətta qaranlıq yerlərdə də tam işıqda göstərin.",
+  "horizon.extras.dynamic_lights.tooltip": "Məşəllər və digər işıq mənbələri ətrafdakı blokları tutmuş, yerə atmış və ya odda yandırır.",
+  "horizon.extras.own_name_tag.tooltip": "Başqa oyunçuların gördüyü kimi adınızı başınızın üstündə üçüncü şəxsdə göstərir. Server komandanızın adlarını gizlətdikdə və ya siz görünməz olduğunuzda gizlidir.",
+  "horizon.extras.hide_block_particles.tooltip": "Sınıq blokdan qopan və mənimsədiyiniz blokdan parçalanan zibil hissəciklərini gizlədir. Digər hissəciklər qalır.",
+  "horizon.extras.auto_reconnect.tooltip": "Heç bir zərbə və ya qadağadan sonra itən əlaqə və ya yenidən başladıqdan sonra serverə yenidən qoşulur.",
+  "horizon.extras.ui_sound_reserve.tooltip": "Dünyadakı səslər 247 səs kanalından 16-nı pulsuz buraxır, buna görə də onların selinin (böyük partlayış) menyu kliklərini susdura bilməz.",
+  "horizon.extras.music_page.tooltip": "Musiqi və Səslər Musiqi... səhifəsi əldə edir: hər hansı daxili treki indi çalın və ya birini söndürün ki, oyun onu seçməyi dayandırsın. Siz treki söndürməyincə heç nə dəyişməyəcək.",
+  "horizon.extras.mouse_tweaks.tooltip": "Sağa sürükləmək hər yuvaya bir yerləşdirir, sola sürükləmək saxlanılan elementi toplayır, Shift + sola sürükləmək hər bir yuvaya köçür.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "Aşağı yuvanın bir elementini digər tərəfə göndərir, yuxarı birini geri gətirir.",
+  "horizon.extras.sort.tooltip": "İnventar, sandıqlar, çəlləklər, ender sandıqlar və şulker qutularını yaradıcı nişan sırası ilə çeşidləyir, yığınları birləşdirin.",
+  "horizon.extras.sort_key.tooltip": "Kursorun altındakı hissəni çeşidləyir. Basın, sonra düyməni basın; Escape onu açır.",
+  "horizon.extras.no_ai.tooltip": "Hər bir AI funksiyasını gizlədir və söndürür: agent nəzarəti, horizon-ctl və MCP serverləri. Başlatıcının açarı da.",
+  "horizon.extras.agent_control.tooltip": "Öz AI agentiniz bu oyunu horizon-ctl və ya MCP müştəri vasitəsilə yalnız bu kompüterdə oynaya bilər.",
+  "horizon.extras.discord_presence.tooltip": "Discord işləyərkən Discord profilinizdə Horizon Playing göstərilir: menyular, tək oyunçu və ya multiplayer, ölçü və oynanılan vaxt. Heç vaxt dünyanın adı və ya server ünvanı.",
+  "Calibrate...": "Kalibrləmə...",
+  "Calibrate Anyway...": "İstənilən halda kalibrləyin...",
+  "Use Automatic Setup": "Avtomatik Quraşdırmadan istifadə edin",
+  "Shortcut: %s": "Qısayol: %s",
+  "Next": "Sonrakı",
+  "HDR Calibration %s/%s: %s": "HDR Kalibrləmə %s/%s: %s",
+  "Sets the three below full screen, one test picture at a time.": "Aşağıdakı üç tam ekranı, hər dəfə bir sınaq şəklini təyin edir.",
+  "A key that opens this screen from the game. Not bound at first.": "Oyundan bu ekranı açan açar. Əvvəlcə bağlı deyil.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "Ekranınız nə qədər parlaq olduğunu deməyib: onu qurmaq üçün kalibrləyin.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "Ekranınız üçün artıq qurulub. Yalnız HDR səhv görünürsə kalibrləyin.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "Pik Parlaqlığı və Kağız Ağı ekranınızın quraşdırılmasına qaytarır.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "Ekranınız üçün qurun. Səhv görünməsə, Auto-da buraxın.",
+  "Lower it until the logo just disappears into the black.": "Loqo qara rəngdə yox olana qədər onu endirin.",
+  "Raise it until the logo just disappears into the bright square.": "Loqo parlaq kvadratda yox olana qədər onu qaldırın.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "Kartı oynadığınız işıqda uzun müddət baxmaq üçün rahat olan ağ rəngə çevirin.",
+  "horizon.splitscreen.profiles.forget": "Unut",
+  "horizon.splitscreen.profiles.create": "Yaradın",
+  "horizon.splitscreen.profiles.you": " - sən",
+  "horizon.splitscreen.profiles.forget_named": "Unut %s",
+  "horizon.splitscreen.profiles.previous": "Əvvəlki",
+  "horizon.splitscreen.profiles.next": "Sonrakı",
+  "horizon.splitscreen.profiles.new_button": "Yeni Profil...",
+  "horizon.splitscreen.profiles.forget_title": "Profili unutmusunuz?",
+  "horizon.splitscreen.profiles.forget_leaves": "Bu nümunənin siyahısını tərk edir.",
+  "horizon.splitscreen.profiles.forget_kept": "Dünya tərəqqisi və parametrlər saxlanılır.",
+  "horizon.splitscreen.profiles.new_title": "Yeni Profil",
+  "horizon.splitscreen.profiles.name_hint": "Ad (3-16 hərf, rəqəm, _)",
+  "horizon.splitscreen.profiles.switch_title": "Profilə keçin",
+  "horizon.splitscreen.profiles.offline_note": "Oflayn profillər bu instansiyaya aiddir",
+  "horizon.splitscreen.profiles.move": "Oynadığınız yerdə hərəkət edin",
+  "horizon.splitscreen.profiles.move_place": "Oynadığınız yerə köçürün: %s",
+  "horizon.friends.title": "Dostlarla oynayın",
+  "horizon.friends.hint": "Dostlar kodu başlıq ekranının Dostlar düyməsindən sonra, Birbaşa Bağlantıda və ya başlatma qurğusunun Play səhifəsində yerləşdirin.",
+  "horizon.friends.copied": "Kopyalandı",
+  "horizon.friends.copy_code": "Kodu kopyalayın",
+  "horizon.friends.stop_sharing": "Paylaşmağı dayandırın",
+  "horizon.friends.none_yet": "Burada hələ dost yoxdur.",
+  "horizon.friends.here_now": "İndi burada: %s",
+  "horizon.friends.share_intro": "Bu dünyanı dəvət kodunun arxasında paylaşın: o, LAN-a açılır və internetdəki dostlar kodla qoşulur. Heç bir serverimiz iştirak etmir.",
+  "horizon.friends.start_sharing": "Paylaşmağa başlayın",
+  "horizon.friends.troubleshooting": "Problem həll olunur...",
+  "horizon.friends.stopped": "Dəvət kodunu paylaşmağı dayandırdı.",
+  "horizon.friends.short_code_changed": "Kimsə səhv qısa kodu sınamağa davam etdi, ona görə də dəyişdi.",
+  "horizon.friends.wrong_code": "Kimsə səhv kodu sınadı.",
+  "horizon.friends.code_ready": "Dəvət kodunuz hazırdır: Oyun Menyu, Dostlarla Oyna. Kopyalayın və dostlarınıza göndərin.",
+  "horizon.friends.share_failed": "Dünyanı paylaşmaq mümkün olmadı: %s",
+  "horizon.friends.finding_route": "Dostların sizinlə necə əlaqə saxlaya biləcəyi tapılır...",
+  "horizon.osk.space": "Kosmos",
+  "horizon.osk.delete": "Sil",
+  "horizon.osk.type": "Növ",
+  "horizon.osk.symbols": "Simvollar",
+  "horizon.osk.close": "Bağlayın",
+  "horizon.extras.chat_animation.tooltip": "Yeni söhbət xətti bütöv görünmək əvəzinə soldan içəri sürüşür.",
+  "horizon.extras.chat_indicator.tooltip": "Söhbət xəttinin solunda olan rəngli bar.",
+  "horizon.extras.wheel_cycles_settings.tooltip": "Parametrlərdəki düymənin üzərindəki sürüşdürmə çarxı vanildə olduğu kimi dəyərini dəyişir. Söndürülmüş, təkər yalnız siyahını sürüşdürür.",
+  "horizon.extras.pack_browser.tooltip": "Resurs Paketlərini seçin Modrinth-də axtarış aparan və paketlər qovluğuna paket quraşdıran Əlavə et düyməsini alır. Off, oyun Modrinthlə heç vaxt əlaqə saxlamır.",
+  "horizon.extras.splitscreen.tooltip": "Dünyada başqa bir nəzarətçi yeni oyunçu kimi qoşula bilər: soruşduqda A düyməsini basın, sonra profil və harada oynayacağınızı seçin.",
+  "horizon.splitscreen.setup.monitor_unknown": "monitor",
+  "horizon.splitscreen.setup.window": "Pəncərə %s",
+  "horizon.splitscreen.setup.new_window": "Yeni pəncərə",
+  "horizon.splitscreen.setup.fill_monitor": "%s doldurun",
+  "horizon.splitscreen.setup.done": "Bitdi",
+  "horizon.splitscreen.setup.on": "Aktiv",
+  "horizon.splitscreen.setup.off": "Söndür",
+  "horizon.splitscreen.setup.player": "Oyunçu %s",
+  "horizon.splitscreen.setup.revert": "Geri qaytarın",
+  "horizon.splitscreen.setup.apply": "Müraciət edin",
+  "horizon.splitscreen.setup.warning.empty_main": "Window 1-də heç kim oynamır: gizlənir",
+  "horizon.splitscreen.setup.warning.empty_close": "%s Pəncərəsində heç kim oynamır: Tətbiq edərkən bağlanır",
+  "horizon.splitscreen.setup.warning.empty_new": "%s pəncərəsində heç kim oynamır: açılmayacaq",
+  "horizon.splitscreen.setup.warning.on_main": "Pəncərə %s Pəncərə 1-in monitorunu doldurur: onun oyunçuları Pəncərə 1-də oynayır",
+  "horizon.splitscreen.setup.warning.unplugged": "Pəncərənin %s monitoru bağlı deyil: onun oyunçuları Window 1-də oynayır",
+  "horizon.splitscreen.setup.status.off": "Splitscreen deaktivdir.",
+  "horizon.splitscreen.setup.status.enable_hint": "Onu yandırın, sonra dünyanın başqa bir nəzarətçisində düyməni basın.",
+  "horizon.splitscreen.setup.status.join_hint": "Qoşulmaq və profil seçmək üçün A düyməsini basın.",
+  "horizon.splitscreen.setup.status.idle": "Splitscreen boş",
+  "horizon.splitscreen.setup.status.alone": "Başqa yerli oyunçu yoxdur.",
+  "horizon.splitscreen.setup.status.solo_controls": "Solo nəzarət və nəzarətçi rəyi dəyişməzdir.",
+  "horizon.splitscreen.setup.window_empty": "Pəncərə %s: boş",
+  "horizon.splitscreen.setup.note.select": "Oyunçuya klikləyin və ya onu pəncərəyə və ya monitora sürükləyin.",
+  "horizon.splitscreen.setup.note.apply": "Bu şəkildə oynamaq üçün müraciət edin, ləğv etmək üçün geri qaytarın.",
+  "horizon.splitscreen.setup.note.place": "%s harada oynamalıdır?",
+  "horizon.splitscreen.setup.this_player": "bu oyunçu",
+  "horizon.splitscreen.setup.switch_disabled": "Digərləri ayrıldıqdan sonra Splitscreen sönür (pauza menyusu).",
+  "horizon.splitscreen.setup.window_place": "Pəncərə %s (%s/%s)",
+  "horizon.splitscreen.setup.names": "Adlar",
+  "horizon.splitscreen.setup.identify": "Müəyyən etmək",
+  "horizon.splitscreen.setup.layout.two": "2 paylaşım: %s",
+  "horizon.splitscreen.setup.layout.three": "3 paylaşım: %s",
+  "horizon.splitscreen.setup.layout.two.0": "Avtomatik",
+  "horizon.splitscreen.setup.layout.two.1": "Yan-yana",
+  "horizon.splitscreen.setup.layout.two.2": "Üst və alt",
+  "horizon.splitscreen.setup.layout.three.0": "Üstündə biri geniş",
+  "horizon.splitscreen.setup.layout.three.1": "Solda biri hündür",
+  "horizon.splitscreen.setup.layout.three.2": "Yan-yana",
+  "horizon.splitscreen.setup.help.player": "Onları köçürmək üçün %s üzərinə klikləyin və ya dartın.",
+  "horizon.splitscreen.setup.help.layout_auto": "%s (pəncərə geniş olduqda yan-yana). Dəyişmək üçün basın.",
+  "horizon.splitscreen.setup.help.layout": "%s. Dəyişmək üçün basın.",
+  "horizon.splitscreen.setup.help.switch": "Bu kompüter üçün bölünmüş ekran, aktiv və ya söndürülür.",
+  "horizon.splitscreen.setup.help.identify": "Hər bir oyunçunun görünüşü onun hansı pəncərədə olduğunu göstərir.",
+  "horizon.splitscreen.setup.help.names": "Görünüşünün küncündə hər bir oyunçunun adı.",
+  "horizon.splitscreen.setup.help.revert": "Hələ tətbiq olunmamış dəyişiklikləri geri alın.",
+  "horizon.splitscreen.setup.help.apply": "Xəritənin göstərdiyi şəkildə oynayın.",
+  "horizon.splitscreen.setup.help.unchanged": "Hələ heç nə dəyişməyib.",
+  "horizon.splitscreen.setup.give_up_pad": "Pasxadan imtina et",
+  "horizon.splitscreen.prompt.controller_connected": "Nəzarətçi qoşulub",
+  "horizon.splitscreen.prompt.controller_disconnected": "Nəzarətçi ayrıldı",
+  "horizon.splitscreen.prompt.controller_disconnected.hint": "Onu yenidən birləşdirin və ya digərində düyməni basın",
+  "horizon.splitscreen.prompt.join.one": "%s qoşulmaq istəyir",
+  "horizon.splitscreen.prompt.join.many": "%s nəzarətçilər qoşulmaq istəyirlər",
+  "horizon.splitscreen.prompt.join.yes": "Qoşulun",
+  "horizon.splitscreen.prompt.join.as_p1": "P1 kimi oynayın",
+  "horizon.splitscreen.prompt.join.no": "yox",
+  "horizon.splitscreen.prompt.lost": "%s: nəzarətçi ayrıldı",
+  "horizon.splitscreen.prompt.lost.use_another": "Başqasını istifadə edin",
+  "horizon.splitscreen.prompt.lost.leave": "tərk et",
+  "horizon.splitscreen.setup.help.give_up_pad": "Nəzarətçiniz sizi idarə etməyi dayandırır və ona qoşulmaq təklif olunur (A).",
+  "horizon.splitscreen.setup.note.held_at": "%s to %s: A onu bura düşür, B onu geri qoyur.",
+  "horizon.splitscreen.setup.note.held": "%s götürdü: sol/sağ yeri seçir, A düşür, B onu geri qoyur.",
+  "Hides models behind opaque blocks. Async checks off-thread; entities tick.": "Modelləri qeyri-şəffaf blokların arxasında gizlədir. Async-dən kənar yoxlayır; qurumlar işarələyir.",
+  "Block Entities": "Blok obyektləri",
+  "Shulker Boxes": "Shulker qutuları",
+  "Reuses settled boxes; lid movement stays animated.": "Yerləşmiş qutuları təkrar istifadə edir; qapaq hərəkəti canlı qalır.",
+  "Signs": "İşarələr",
+  "Reuses sign text until text, light, or font changes.": "Mətn, işıq və ya şrift dəyişənə qədər işarə mətnindən təkrar istifadə edir.",
+  "Decorated Pots": "Bəzəkli qablar",
+  "Reuses still pots; break wobble and sherd changes redraw.": "Qazan qabları təkrar istifadə edir; yırğalanmaq və parçalanma dəyişiklikləri yenidən çəkmək.",
+  "Bells": "Zənglər",
+  "Reuses still bells; ringing stays animated.": "Hərəkətsiz zəngləri təkrar istifadə edir; Zəng animasiyalı qalır.",
+  "Chests": "Sinələr",
+  "Reuses closed chests; moving lids stay animated.": "Qapalı sandıqları təkrar istifadə edir; hərəkət edən qapaqlar canlı qalır.",
+  "Banners": "Bannerlər",
+  "Reuses poles; flags and pattern layers still update.": "Dirəkləri təkrar istifadə edir; bayraqlar və naxış qatları hələ də yenilənir.",
+  "Copper Golem Statues": "Mis Qolem heykəlləri",
+  "Reuses statue geometry until its block state changes.": "Blok vəziyyəti dəyişənə qədər heykəlin həndəsəsindən təkrar istifadə edir.",
+  "Leaf Culling": "Yarpaqların kəsilməsi",
+  "Every leaf face. Vanilla's fancy leaves.": "Hər yarpaq üzü. Vanilin gözəl yarpaqları.",
+  "Distant Plant Dither": "Uzaq Bitki Dither",
+  "Keeps fine plants in high-res packs from fading far away.": "Yüksək dəqiqlikli paketlərdəki incə bitkilərin uzaqdan solmasını qarşısını alır.",
+  "Screenshot Quality": "Ekran Şotunun Keyfiyyəti",
+  "F2 screenshots at this many times the game's resolution. Higher takes longer.": "F2 ekran görüntüləri bu dəfələrlə oyunun həlli. Yüksək daha uzun çəkir.",
+  "Frame Generation": "Çərçivə Yaradılması",
+  "Shows a made-up frame between each two real ones: smoother, a little more lag.": "Hər iki real arasında düzəldilmiş çərçivəni göstərir: daha hamar, bir az daha gecikmə.",
+  "Shadow Cache": "Kölgə önbelleği",
+  "Reuses the pack shadow map when sun, view and world match. Off by default.": "Günəş, görünüş və dünya uyğunlaşdıqda paket kölgə xəritəsindən təkrar istifadə edir. Defolt olaraq söndürülür.",
+  "Find BlueMap": "BlueMap tapın",
+  "On servers, finds their BlueMap web map for far terrain. Next join.": "Serverlərdə uzaq ərazilər üçün BlueMap veb xəritəsini tapır. Növbəti qoşulun.",
+  "How far around you BlueMap tiles are downloaded. Next join.": "Ətrafınızda BlueMap plitələri nə qədər yüklənir. Növbəti qoşulun.",
+  "Synchronous": "Sinxron",
+  "Asynchronous": "Asinxron",
+  "Solid": "Möhkəm",
+  "Solid Aggressive": "Möhkəm Aqressiv",
+  "Hollow": "Boş",
+  "Leaves fully inside a canopy draw solid: fewer see-through layers.": "Tam örtünün içindəki yarpaqlar möhkəm çəkilir: daha az keçirici təbəqə.",
+  "Leaves with one open side draw solid too: faster, chunkier edges.": "Bir tərəfi açıq olan yarpaqlar da bərk çəkir: daha sürətli, daha sıx kənarlar.",
+  "Drops faces between leaves: faster, but gaps look through.": "Yarpaqlar arasında üzləri düşür: daha sürətli, lakin boşluqlar içəri baxır.",
+  "Hotbar: Previous Slot": "İsti panel: Əvvəlki yuva",
+  "Hotbar: Next Slot": "İsti panel: Növbəti Slot",
+  "horizon.agent.connected.one": "Qoşuldu: 1 agent bağlantısı",
+  "horizon.agent.connected.many": "Qoşuldu: %s agent əlaqələri",
+  "horizon.agent.connected.one_ago": "Qoşuldu: 1 agent bağlantısı, son əmr %s s əvvəl",
+  "horizon.agent.connected.many_ago": "Qoşuldu: %s agent əlaqələri, son əmr %s s əvvəl",
+  "horizon.agent.waiting": "Agent gözləyir.",
+  "horizon.agent.off": "Off: agentlər bu oyuna daxil ola bilməz.",
+  "horizon.agent.session_opened": "Oyuna başlayan proqram tərəfindən bu sessiya üçün açıldı.",
+  "horizon.agent.socket": "Soket: %s (tam yolu üçün təfərrüatları kopyalayın)",
+  "horizon.agent.local_only": "Yalnız yerli: bu kompüterdəki agentlər, heç vaxt şəbəkə.",
+  "Auto (%s nits)": "Avtomatik (%s nits)",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Modelləri qeyri-şəffaf blokların arxasında gizlədir. Müəssisələrin yenilənməsi. Fərdi paketlərlə endirim.",
+  "horizon.extras.repro_keys": "Qısayolların qeyd edilməsi",
+  "horizon.extras.repro_keys.tooltip": "F3+R repro qeydini başlayır və ya dayandırır və F3+E öz paketini yazır. Defolt olaraq söndürülür: yazı dünyanı kopyalayır.",
+  "horizon.agent.record_session": "Səs yazmağa başlayın",
+  "horizon.agent.record_stop": "Səs yazmağı dayandırın",
+  "horizon.agent.export_repro": "Repro paketini ixrac edin",
+  "horizon.repro.started": "Qeydiyyat başladı; F3+R onu dayandırır və paketi yazır.",
+  "horizon.repro.stopped": "Qeydiyyat dayandırıldı: %s",
+  "horizon.repro.bundle": "Repro paketi: %s",
+  "horizon.repro.error": "Reproduksiya: %s",
+  "horizon.repro.no_recording": "İxrac etmək üçün hələ heç bir qeyd yoxdur.",
+  "horizon.repro.replay_started": "Təkrar başladı: %s",
+  "horizon.pack.addInfo": "Modrinth-dən resurs paketi əlavə edin",
+  "horizon.pack.addWorking": "Modrinthdən soruşur...",
+  "horizon.pack.addNone": "Heç bir resurs paketi tapılmadı",
+  "horizon.pack.addTitle": "Resurs Paketi əlavə edin",
+  "horizon.pack.install": "Quraşdırın",
+  "horizon.pack.installing": "Quraşdırılır",
+  "horizon.pack.installed": "Quraşdırılıb",
+  "horizon.pack.search": "Axtar",
+  "horizon.pack.searchHint": "Modrinth axtar...",
+  "horizon.pack.filters": "Filtrlər",
+  "horizon.pack.filter.realistic": "Realist",
+  "horizon.pack.filter.simplistic": "Sadə",
+  "horizon.pack.filter.vanillaLike": "Vanil kimi",
+  "horizon.pack.addFailed": "Paketi əlavə etmək mümkün olmadı: %s",
+  "horizon.extras.header.cosmetics": "Kosmetika",
+  "horizon.extras.cosmetics_mine": "Kosmetikam",
+  "horizon.extras.cosmetics_mine.tooltip": "Gizli: hər Horizon oyunçu sizi kosmetikanız olmadan görür. Başlatma şkafı ilə eyni açar.",
+  "horizon.extras.cosmetics_others": "Digər oyunçuların kosmetikası",
+  "horizon.extras.cosmetics_others.tooltip": "Digər Horizon oyunçular nə geyinirlər: hər şey, yalnız ad etiketi üslubları və ya heç nə. Gizli, oyun heç vaxt nə geyindiklərini soruşmur.",
+  "horizon.extras.cosmetics_auras": "Başqalarının auraları və izləri",
+  "horizon.extras.cosmetics_auras.tooltip": "Digər oyunçuların geydiyi auralar və izlər. Defolt olaraq söndürülür.",
+  "horizon.extras.cosmetics.shown": "Göstərildi",
+  "horizon.extras.cosmetics.hidden": "Gizli",
+  "horizon.extras.cosmetics.name_tags": "Yalnız ad etiketləri"
+}

crates/horizon-client/assets/horizon/lang/ba_ru.json

@@ -0,0 +1,499 @@
+{
+  "horizon.options.controller": "Контролер",
+  "horizon.options.three_d_skin_layers": "3D скин ҡатламдары",
+  "horizon.options.vibration": "Вибрация",
+  "horizon.options.adaptive_triggers": "Адаптив триггерҙар",
+  "horizon.options.lightbar": "Лайтбар",
+  "horizon.options.look_sensitivity": "Ҡарау һиҙгерлеге",
+  "horizon.options.invert_x": "Ҡараш инверсияһы X",
+  "horizon.options.invert_y": "Ҡараш инверсияһы Y",
+  "horizon.options.sneak_button": "Боҫоу төймәһе",
+  "horizon.options.move_deadzone": "Хәрәкәт үле зонаһы",
+  "horizon.options.look_deadzone": "Ҡараш үле зонаһы",
+  "horizon.options.button_glyphs": "Төймә глифтары",
+  "horizon.options.menu_navigation": "Навигация меню",
+  "horizon.options.on_screen_keyboard": "Экрандағы клавиатура",
+  "horizon.options.chat_delay": "Чат тотҡарланыуы",
+  "horizon.options.lightbar.health": "Һаулыҡ",
+  "horizon.options.lightbar.dimension": "Үлсәм",
+  "horizon.options.glyphs.auto": "Авто",
+  "horizon.options.menu_focus": "Фокус",
+  "horizon.options.menu_pointer": "Күрһәткес",
+  "horizon.options.keyboard.auto": "Авто",
+  "horizon.options.unavailable": "Был функция Horizon-ла әлегә юҡ.",
+  "horizon.options.search": "Эҙләү параметрҙары...",
+  "horizon.pages.mods": "Модтар",
+  "horizon.pages.shader_packs": "Шейдер пакеттары",
+  "horizon.pages.shader_options": "Шейдер параметрҙары",
+  "horizon.pages.controller": "Контроллер параметрҙары",
+  "horizon.pages.controller_binds": "Контроллер бәйләй",
+  "horizon.pages.extras": "Horizon Өҫтәмә",
+  "horizon.pages.settings": "Horizon Көйләүҙәр",
+  "horizon.pages.agent": "ЯИ агенты",
+  "horizon.split.leave": "Ҡалдырырға",
+  "horizon.pages.split_settings": "Сплит-экран параметрҙары",
+  "horizon.pages.split_profiles": "Кем уйнай?",
+  "horizon.pages.split_setup": "Сплит-экранды ҡуйыу",
+  "horizon.pages.music": "Музыка",
+  "horizon.pages.music.menu": "Меню",
+  "horizon.pages.music.overworld": "Өҫтөн донъя",
+  "horizon.pages.music.creative": "Ижади .",
+  "horizon.pages.music.underwater": "Һыу аҫтында .",
+  "horizon.pages.music.end": "Аҙағы",
+  "horizon.pages.music.boss": "Етәксе",
+  "horizon.pages.music.credits": "Кредиттар",
+  "horizon.pages.music.overworld_biomes": "Донъя өҫтөндәге биомдар",
+  "horizon.pages.music.nether_biomes": "Недер биомдары",
+  "horizon.pages.music.end_biomes": "Аҙаҡҡы биомдар",
+  "horizon.pages.music.other": "Башҡа музыка .",
+  "horizon.pages.music.empty": "Музыка тректары юҡ: уйындың тауыштары тейәлмәгән.",
+  "horizon.pages.music.tooltip": "Встроенный тректар, хәл буйынса: хәҙер бер уйнай, йәки теләһә ниндәй һүндерергә, шулай итеп, уйын уны йыйыу туҡтата.",
+  "horizon.pages.settings.tooltip": "Horizon үҙ параметрҙары: графика, контроллерҙар, өҫтәмәләр һәм модтар.",
+  "horizon.pages.graphics.tooltip": "Графика, ябай: һәр параметр нимәгә төшкәнен әйтә.",
+  "horizon.pages.graphics_advanced.tooltip": "Һәр график параметр, Horizon’s инә, һәр береһе нимә менән.",
+  "horizon.pages.controller.tooltip": "Контроллерҙар: уларҙың төймәләре, таяҡсалар, вибрация һәм меню навигацияһы.",
+  "horizon.pages.extras.tooltip": "Факультатив өҫтәүҙәр, бөтәһе лә өҫтөндә ғәҙәттәгесә: уйын ваниль ҡала, тик һеҙ бер өҫтөндә.",
+  "horizon.pages.agent.tooltip": "Һеҙҙең үҙ AI агент уйнай: horizon-ctl һәм MCP клиенттар был компьютерҙа.",
+  "horizon.pages.split_profiles.tooltip": "Кем уйнай: был уйын папкаһында һаҡланған профиль.",
+  "horizon.pages.split_setup.tooltip": "Тәҙрәләр һәм мониторҙар, ә кем ҡайҙа уйнай.",
+  "horizon.pages.shader_packs.tooltip": "Шейдер пакеттары шейдерпакеттар папкаһынан: Horizon үҙ һәм шейдерҙар/ форматындағылар. Берәм-берәм йүгерә.",
+  "horizon.pages.mods.tooltip": "Horizon өсөн эшләнгән модтар, горизонт-модтар папкаһынан. Һәр береһе ҡом йәшниктә йүгерә һәм һеҙ уны тоҡандырғансы һүндерелә.",
+  "horizon.pages.open.graphics": "Графика...",
+  "horizon.pages.open.graphics_advanced": "Алдынғы графика...",
+  "horizon.pages.open.shader_packs": "Шейдер пакеттары...",
+  "horizon.pages.open.controller": "Контроллер параметрҙары...",
+  "horizon.pages.open.split_setup": "Бүленгән экран...",
+  "horizon.pages.open.extras": "Өҫтәмәләр...",
+  "horizon.pages.open.mods": "Модтар...",
+  "horizon.pages.open.agent": "ЯИ агенты...",
+  "horizon.pages.open.horizon_graphics": "Horizon Графика...",
+  "horizon.pages.open.controller_binds": "Контроллер бәйләй...",
+  "horizon.pages.open.horizon_settings": "Horizon Көйләүҙәр...",
+  "horizon.pages.open.music": "Музыка...",
+  "horizon.mods.empty": "Модтар юҡ: .hmod файлдарын горизонт-модтар папкаһына ҡуйығыҙ",
+  "horizon.mods.stopped": " (Туҡтатылған)",
+  "horizon.mods.not_built": " (Төҙөлмәгән)",
+  "horizon.mods.dev": " (Дев)",
+  "horizon.mods.settings": "Көйләүҙәр",
+  "horizon.mods.in_world": " (донъяны үҙгәртергә ҡалдырырға)",
+  "horizon.mods.open_folder": "Мод папкаһын асыу",
+  "horizon.shader_packs.empty": "Шейдер пакеттары юҡ: уларҙы шейдерпакеттар папкаһына һалығыҙ",
+  "horizon.shader_options.open": "Шейдер варианттары...",
+  "horizon.shader_options.profile": "Профиль",
+  "horizon.shader_options.loading": "Шейдер пакетының варианттарын уҡыу...",
+  "horizon.agent.copy_details": "Тоташыу тураһында мәғлүмәтте күсерергә",
+  "horizon.multiplayer.join": "Ҡушылыу",
+  "horizon.multiplayer.cancel_reconnecting": "Яңынан тоташтырыуҙы юҡҡа сығарыу",
+  "horizon.multiplayer.join_friend": "Дуҫҡа ҡушыл",
+  "horizon.multiplayer.invite_code": "Саҡырыу коды",
+  "horizon.multiplayer.relay": "Реле (теләк буйынса)",
+  "Preset": "Алдан ҡуйылған",
+  "LOD Distance": "LOD арауығы",
+  "Far Detail": "Алыҫ деталь",
+  "Cave Culling": "Мәмерйә ҡырҡыу",
+  "Entity Culling": "Субъектты ҡырҡыу",
+  "Chunk Updates": "Яңыртыу өлөштәре",
+  "Upload Budget": "Бюджет тейәү",
+  "Sky": "Күк",
+  "Fog": "Томан",
+  "Weather": "Һауа торошо",
+  "Animated Textures": "Йәнле текстуралар",
+  "Present Mode": "Хәҙерге режим",
+  "Frame Pacing": "Кадр темпы",
+  "Worker Threads": "Эшсе ептәр",
+  "Resolution Scale": "Асыҡлыҡ шкалаһы",
+  "Anti-aliasing": "Анти-псевдоним",
+  "Upscaling": "Масштаблаштырыу",
+  "Paper White": "Аҡ ҡағыҙ",
+  "Peak Brightness": "Иң юғары яҡтылыҡ",
+  "Black Level": "Ҡара кимәл",
+  "UI Brightness": "Яҡтылыҡ",
+  "Battery Mode": "Аккумулятор режимы",
+  "Graphics API": "Графика API",
+  "Translucent Batching": "Ярым үтә күренмәле партиялау",
+  "Performance Overlay": "Һөҙөмтәлелек өҫтөнлөктәре",
+  "Full Detail Distance": "Тулы ентекле арауыҡ",
+  "On": "Өҫтөндә",
+  "Off": "Һүндерелгән",
+  "Unlimited": "Сикләнмәгән",
+  "Auto": "Авто",
+  "Custom": "Ҡулланыусы",
+  "Performance": "Башҡарыу",
+  "Balanced": "Баланслы",
+  "Quality": "Сифат",
+  "Ultra": "Ультра",
+  "Ultra Performance": "Ультра етештереүсәнлеге",
+  "Native": "Натив",
+  "Full": "Тулы",
+  "Reduced": "Кәметелгән",
+  "Efficient": "Һөҙөмтәле",
+  "Precise": "Теүәл",
+  "Auto (VSync)": "Авто (ВСинхронизация)",
+  "FIFO": "ФИФО",
+  "Mailbox": "Почта йәшниге",
+  "Immediate": "Шунда уҡ",
+  "FPS and Graph": "FPS һәм график",
+  "TAA": "ТАА",
+  "FXAA": "ФХАА",
+  "No cost": "Хаҡы юҡ",
+  "Low cost": "Түбән хаҡ",
+  "Medium cost": "Уртаса хаҡ",
+  "High cost": "Юғары хаҡ",
+  "Saves time": "Ваҡытты экономиялай",
+  "Graphics": "Графика",
+  "Done": "Бөттө",
+  "This feature is not yet available in Horizon.": "Был функция Horizon-ла әлегә юҡ.",
+  "Your display or system doesn't offer HDR output.": "Һеҙҙең дисплей йәки система тәҡдим итмәй HDR сығыш.",
+  "Turn HDR on to use it.": "Уны ҡулланыу өсөн HDR ҡабыҙығыҙ.",
+  "Your GPU or graphics API doesn't support it.": "Һеҙҙең GPU йәки график API уны ҡабул итмәй.",
+  "%s chunks": "%s өлөштәр",
+  "%s per frame": "%s бер кадрға",
+  "%s MiB/frame": "%s МиБ/кадр",
+  "%s KiB/frame": "%s КиБ/кадр",
+  "Auto (%s)": "Авто (%s)",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Тулы деталь ер диапазоны. LOD Дистанция урындағы донъяларҙы алыҫҡараҡ һуҙырға мөмкин.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Урындағы донъяларҙа ҡырыҫ алыҫ ерҙәр. Интеграцияланған график процессорҙар 128 өлөштә туҡтай.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "Ҡыҫҡартылған тарта алыҫ ер ҡырыҫ: тиҙерәк был интеграцияланған GPU.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "Кәметелгән тарта алыҫ ер ҡырыҫыраҡ, GPUs өсөн ул яйлатып.",
+  "Field of view. Wider shows more terrain at once.": "Күренеш өлкәһе. Киңерәк бер юлы күберәк ерҙе күрһәтә.",
+  "Caps frames per second; a cap saves power and heat.": "Ҡапҡастар кадрҙар секундына; ҡапҡас энергияны һәм йылылыҡты һаҡлай.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Дисплейҙы яңыртыуҙы көтә: йыртыу юҡ, бер аҙ тотҡарлыҡ.",
+  "Size of menus and the HUD.": "Размер меню һәм HUD.",
+  "Sets the options below together. Changing one makes it Custom.": "Түбәндәге варианттарҙы бергә ҡуя. Бер үҙгәртеү уны Ҡулланыусы итә.",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Лава, ут һәм ҡояш нурҙары аҡтан да сағыуыраҡ балҡый. HDR дисплей кәрәк.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Һеҙҙең дисплей’ы иң ҡара ҡара. 0 өсөн OLED; ЖК-дисплейҙар бер аҙ балҡый.",
+  "How bright highlights get. Auto: the peak your system reports.": "Нисек сағыу өҫтөнлөктәр ала. Авто: пик һеҙҙең система отчеттар.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "Нисек сағыу аҡ ҡағыҙ, менюлар күренә. Авто: һеҙҙең өҫтәл’ы аҡ.",
+  "How bright the HUD and menus are, against paper white.": "Нисек сағыу HUD һәм менюлар, ҡағыҙ аҡ ҡаршы.",
+  "How far mobs, crops and machines keep working. CPU time.": "Күпме алыҫҡа мобтар, культуралар һәм машиналар эшләп тора. Процессор ваҡыты.",
+  "How far away mobs and items are drawn, as a share of normal.": "Нисек алыҫҡа мобтар һәм әйберҙәр тартыла, өлөшө булараҡ нормаль.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Ябыҡ участкалар артында йәшеренгән ерҙәрҙе һикерә. Офф күп сығымдар талап итә.",
+  "Hides entities behind opaque blocks.": "Һүҙ асыҡ булмаған блоктар артында субъекттарҙы йәшерә.",
+  "No entity occlusion culling.": "Юҡ субъект окклюзия ҡырҡыу.",
+  "CPU occlusion test runs this frame.": "Процессор окклюзия һынау был кадрҙа эшләй.",
+  "Occlusion checks run on a worker thread.": "Окклюзия тикшерелеүҙәре эшсе ептә эшләй.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Бер кадрға тейәлгән селтәрле бүлектәр. Түбәнге тейәгәндә шымараҡ.",
+  "Soft shadows in corners. Costs chunk building time only.": "Мөйөштәрҙә йомшаҡ күләгәләр. Сығымдар өлөшө төҙөү ваҡыты ғына.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "Алыҫ ерҙәр өсөн блок текстураларының бәләкәйерәк күсермәләре: ялтырап тороу аҙыраҡ.",
+  "Blends grass and water colours across biomes when building chunks.": "Үлән һәм һыу төҫтәрен биомдар буйынса ҡатнаштырып, өлөштәр төҙөгәндә.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Болот ҡатламы: өҙөлгән, яҫы (тиҙ) йәки 3D (фантазия).",
+  "How far clouds reach, in chunks.": "Болоттар ни тиклем алыҫҡа етә, өлөшләп.",
+  "Draws the sky, sun, moon and stars.": "Күкте, ҡояшты, айҙы, йондоҙҙарҙы һүрәтләй.",
+  "Distance fog. Off shows the edge of the loaded world.": "Дистанция томан. Off йөкләнгән донъяның ситен күрһәтә.",
+  "Draws rain and snow.": "Ямғыр һәм ҡар тарта.",
+  "How far rain and snow fall around you.": "Тирә-яғыңда ни тиклем алыҫҡа ямғыр, ҡар яуа.",
+  "How many particles effects spawn.": "Күпме киҫәксә эффекттары үрсетә.",
+  "Round shadows under mobs and items.": "Мобтар һәм әйберҙәр аҫтында түңәрәк күләгәләр.",
+  "Leaves with see-through gaps. Off draws them solid.": "Япраҡтары үтә күренмәле тишектәр менән. Офф уларҙы ныҡлы тарта.",
+  "Sorts water and glass more exactly behind each other.": "Һыу менән быяланы бер-береһе артында анығыраҡ сорттарға айыра.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Ниндәй өлөшө яңынан төҙөй көтә рамка: бер ниндәй ҙә, яҡында йәки һеҙҙең.",
+  "Animates water, lava, fire and other moving textures.": "Һыу, лава, ут һәм башҡа хәрәкәт итеүсе текстураларҙы йәнләндерә.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Донъя пикселдәре экран пикселе. 100% түбән тиҙерәк GPU.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Тешле ситтәрен тигеҙләй. ФХАА: йомшағыраҡ. ТАА: иң шыма, хәрәкәт итеүсе әйберҙәр эҙҙәре булыуы мөмкин.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Донъяны бәләкәйерәк итә һәм уны ТАА менән яңынан төҙөй. Тиҙерәк, йомшағыраҡ.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "HDR дисплейында HDR сығышы: лава, ут һәм ҡояш нурҙары сағыуыраҡ балҡый.",
+  "How frames reach the screen while VSync is off.": "Нисек кадрҙар экранға етә, ә VSync өҙөлгән.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Һөҙөмтәле йоҡлай сираттағы кадрға тиклем; Теүәл әйләнештәр, ваниль кеүек.",
+  "Fills the screen (borderless).": "Экранды тултыра (сикһеҙ).",
+  "Brightens dark places.": "Ҡараңғы урындарҙы яҡтырта.",
+  "Lowers the frame rate when minimised, or idle too.": "Кадрҙар йышлығын түбәнәйтә, ҡасан минималь, йәки буш ла.",
+  "Sways the view while walking.": "Йөрөгәндә ҡарашты һелкетә.",
+  "Fades newly loaded chunks in.": "Яңы тейәлгән өлөштәрҙе һүнә.",
+  "Darkens the screen's edges.": "Экрандың ситтәрен ҡарайта.",
+  "Shows when the world saves.": "Донъя ҡотҡарғанда күрһәтә.",
+  "Shows attack cooldown.": "Һөжүм итеү ваҡытын күрһәтә.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "60 FPS ҡапҡас (30 менюларҙа йәки нефокусированный), яртыһы эшселәр: ҡөҙрәте аҙыраҡ.",
+  "Threads that generate, light and mesh chunks. Next start.": "Ептәр, генерациялау, яҡтылыҡ һәм селтәр өлөштәре. Киләһе старт.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, унан һуң DirectX 12 (Windows) йәки OpenGL (Linux) ҡайҙа уңышһыҙлыҡҡа осрай. Киләһе старт.",
+  "Water and glass in one buffer: fewer draw calls, a bit more VRAM. Next start.": "Һыу һәм быяла бер буферҙа: низағ шылтыратыуҙар аҙыраҡ, бер аҙ күберәк VRAM. Киләһе старт.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Селтәр мәғлүмәттәре ебәрелгән GPU бер кадр. Түбәнге тейәгәндә шымараҡ.",
+  "Frame rate and frame times over the game, with a graph.": "Кадрҙар тиҙлеге һәм кадрҙар ваҡыты өҫтөндә уйын, график менән.",
+  "horizon.multiplayer.finding_friend": "Дуҫыңдың донъяһын табыу...",
+  "horizon.multiplayer.not_signed_in": "Был сервер онлайн режимда. Уға ҡушылыу өсөн Microsoft иҫәп яҙмағыҙ менән Horizon стартерында инегеҙ.",
+  "horizon.multiplayer.invalid_address": "Дөрөҫ булмаған сервер адресы: %s",
+  "horizon.multiplayer.connected_friend_direct": "Һеҙҙең дуҫығыҙға туранан-тура тоташтырылған...",
+  "horizon.multiplayer.connected_friend_relay": "Һеҙҙең дуҫығыҙға реле аша тоташтырылған...",
+  "General": "Дөйөм",
+  "Advanced": "Алдынғы",
+  "Undo": "Кире ҡайтарыу",
+  "Search options": "Эҙләү варианттары",
+  "Shortcut": "Ярлыҡ",
+  "Distance": "Арауыҡ",
+  "Display": "Дисплей",
+  "Interface": "Интерфейс",
+  "Sky and weather": "Күк йөҙө һәм һауа торошо",
+  "Lighting and entities": "Яҡтыртыу һәм субъекттар",
+  "Textures": "Текстуралар",
+  "Image": "Һүрәт",
+  "Chunk loading": "Ҡыҫҡа тейәү",
+  "Culling": "Куллинг",
+  "Power": "Власть",
+  "Frames": "Рамкалар",
+  "Overlay": "Ҡаплау",
+  "Output": "Сығыш",
+  "Brightness": "Яҡтылыҡ",
+  "How far you see, the window and the HUD.": "Күпме алыҫ күрәһең, тәҙрә һәм HUD.",
+  "The sky and weather, lighting, textures and the image.": "Күк һәм һауа торошо, яҡтыртыу, текстуралар һәм образ.",
+  "Chunk loading, culling and power use.": "Ҡырҡылған тейәү, ҡырҡыу һәм ҡөҙрәт ҡулланыу.",
+  "How frames reach the screen, and the performance overlay.": "Нисек кадрҙар экранға етә, һәм башҡарыу өҫтәү.",
+  "Brighter-than-white output on an HDR display.": "HDR дисплейында аҡтан сағыуыраҡ сығыш.",
+  "Results for \"%s\"": "\"%s\" өсөн һөҙөмтәләр.",
+  "No settings match.": "Бер ниндәй ҙә параметрҙар тап килмәй.",
+  "horizon.title.not_affiliated": "Mojang йәки Microsoft менән бәйле түгел",
+  "horizon.extras.header.lighting": "Яҡтыртыу",
+  "horizon.extras.header.third_person": "Өсөнсө зат .",
+  "horizon.extras.header.particles": "Киҫәксәләр",
+  "horizon.extras.header.inventory": "Инвентаризация",
+  "horizon.extras.header.chat": "Чат",
+  "horizon.extras.header.multiplayer": "Күп уйынсылар",
+  "horizon.extras.header.sound": "Тауыш .",
+  "horizon.extras.header.menus": "Менюлар",
+  "horizon.extras.fullbright": "Фуллбрайт",
+  "horizon.extras.dynamic_lights": "Динамик яҡтылыҡ",
+  "horizon.extras.own_name_tag": "Үҙ исем билдәһе",
+  "horizon.extras.hide_block_particles": "Блок-өҙөү киҫәксәләрен йәшерергә",
+  "horizon.extras.auto_reconnect": "Авто-яңынан тоташтырыу",
+  "horizon.extras.ui_sound_reserve": "Ҡулланыусылар интерфейсы тауыштары өсөн каналдар һаҡлау",
+  "horizon.extras.music_page": "Музыка бите .",
+  "horizon.extras.mouse_tweaks": "Сысҡандың идара итеү элементтарын үҙгәртә",
+  "horizon.extras.mouse_tweaks_wheel": "Прокрутка тәгәрмәсе әйберҙәрҙе күсерә",
+  "horizon.extras.sort": "Сортлау төймәләре",
+  "horizon.extras.sort_key": "Сортлау асҡысы",
+  "horizon.extras.no_ai": "ЯИ юҡ",
+  "horizon.extras.agent_control": "Агент контроле",
+  "horizon.extras.discord_presence": "Discord Бай булыу",
+  "horizon.extras.splitscreen": "Бүлгән экран",
+  "horizon.extras.chat_animation": "Тигеҙ һөйләшеү",
+  "horizon.extras.chat_indicator": "Хәбәр күрһәткесе",
+  "horizon.extras.wheel_cycles_settings": "Прокрутка тәгәрмәсе параметрҙарҙы үҙгәртә",
+  "horizon.extras.pack_browser": "Ресурс пакеты браузеры",
+  "horizon.extras.fullbright.tooltip": "Блоктарҙы һәм субъекттарҙы тулы яҡтылыҡта, хатта ҡараңғы урындарҙа ла күрһәтегеҙ.",
+  "horizon.extras.dynamic_lights.tooltip": "Факелдар һәм башҡа яҡтылыҡ сығанаҡтары тотолған, төшөрөлгән йәки ут өҫтөндә улар тирәһендәге блоктарҙы яҡтырта.",
+  "horizon.extras.own_name_tag.tooltip": "Һеҙҙең исемде баш өҫтөндә өсөнсө заттан күрһәтә, башҡа уйынсылар күргәнсә. Йәшерен ҡасан сервер һеҙҙең команданың исемдәрен йәшерә йәки һеҙ’күренмәй.",
+  "horizon.extras.hide_block_particles.tooltip": "Йәшерә сүп-сар киҫәксәләре, улар өҙөлгән блоктан ярыла һәм һеҙ шахта өҫтөндә емерек. Башҡа киҫәксәләр ҡала.",
+  "horizon.extras.auto_reconnect.tooltip": "Серверға тоташыу юғалғандан йәки ҡабаттан башлағандан һуң ҡабаттан ҡушыла, бер ҡасан да тибеүҙән йәки тыйыуҙан һуң.",
+  "horizon.extras.ui_sound_reserve.tooltip": "Донъялағы тауыштар 247 тауыш каналының 16-һын бушлай ҡалдыра, шуға күрә уларҙы ташҡын (ҙур шартлау) меню баҫыуҙарын тындыра алмай.",
+  "horizon.extras.music_page.tooltip": "Музыка & Тауыштар ала Музыка... бит: уйнау теләһә ниндәй встроенный трек хәҙер, йәки бер һүндереү, шулай итеп, уйын уны йыйыу туҡтата. Тректы һүндермәйенсә бер нәмә лә үҙгәрмәй.",
+  "horizon.extras.mouse_tweaks.tooltip": "Уң-һөйрәп урындар бер слот, һул-һөйрәп йыя үткәрелгән әйбер, Shift + һул-һөйрәп һәр слот күсә.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "Аҫҡа слоттың бер әйберен икенсе яҡҡа ебәрә, өҫкә бер кире килтерә.",
+  "horizon.extras.sort.tooltip": "Сортировать инвентарь, һандыҡтар, бочкалар, эндер һандыҡтар һәм шулкер йәшниктәр ижади вкладка тәртибендә, стека берләштереү.",
+  "horizon.extras.sort_key.tooltip": "Курсор аҫтындағы өлөштө сорттарға бүлә. Баҫығыҙ, һуңынан бер төймәгә баҫығыҙ; Ҡасыу уны сисеп ебәрә.",
+  "horizon.extras.no_ai.tooltip": "Йәшерә һәм һүндерә һәр AI функцияһы: агент менән идара итеү, горизонт-ctl һәм MCP серверҙары. Пускатель’ы переключатель да.",
+  "horizon.extras.agent_control.tooltip": "Һеҙҙең үҙ AI агент был уйынды уйнай ала аша horizon-ctl йәки MCP клиент, был компьютерҙа ғына.",
+  "horizon.extras.discord_presence.tooltip": "Һеҙҙең Discord профилендә Horizon уйнауҙы күрһәтә, ә Discord йүгерә: менюлар, бер уйынсы йәки күп уйынсы, үлсәм һәм уйнаған ваҡыт. Бер ҡасан да донъяның исеме йәки сервер адресы.",
+  "Calibrate...": "Калибрлау...",
+  "Calibrate Anyway...": "Калибрлау барыбер...",
+  "Use Automatic Setup": "Автоматик ҡуйыуҙы ҡулланыу",
+  "Shortcut: %s": "Ҡыҫҡа юл: %s",
+  "Next": "Артабан",
+  "HDR Calibration %s/%s: %s": "HDR калибровкаһы %s/%s: %s",
+  "Sets the three below full screen, one test picture at a time.": "Өс аҫтында тулы экран ҡуя, бер һынау һүрәте бер юлы.",
+  "A key that opens this screen from the game. Not bound at first.": "Уйындан был экранды асҡан асҡыс. Тәүҙә бәйләнмәгән.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "Һеҙҙең дисплей нисек яҡты ала, тип әйтмәне: калибровка, уны ҡуйырға.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "Һеҙҙең дисплей өсөн инде ҡуйылған. Тик калибровка, әгәр HDR дөрөҫ түгел күренә.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "Ҡуя Пик Яркость һәм Ҡағыҙ Аҡ кире һеҙҙең дисплей’ы ҡороу.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "Һеҙҙең дисплей өсөн ҡуйырға. Авто өҫтөндә ҡалдырырға, әгәр ҙә ул дөрөҫ күренмәһә.",
+  "Lower it until the logo just disappears into the black.": "Түбән уны тиклем логотип ҡара ғына юғала.",
+  "Raise it until the logo just disappears into the bright square.": "Логотип яҡты квадратҡа ғына юғалғансы уны күтәрегеҙ.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "Картаны аҡ төҫтә эшләгеҙ, оҙаҡ ҡарарға уңайлы, һеҙ уйнаған яҡтылыҡта.",
+  "horizon.splitscreen.profiles.forget": "Онот .",
+  "horizon.splitscreen.profiles.create": "Ижад итеү",
+  "horizon.splitscreen.profiles.you": " - һин",
+  "horizon.splitscreen.profiles.forget_named": "Онот %s .",
+  "horizon.splitscreen.profiles.previous": "Алдағы",
+  "horizon.splitscreen.profiles.next": "Артабан",
+  "horizon.splitscreen.profiles.new_button": "Яңы профиль...",
+  "horizon.splitscreen.profiles.forget_title": "Профильде оноттоғоҙмо?",
+  "horizon.splitscreen.profiles.forget_leaves": "Ул был инстанцияның исемлегенән сыға.",
+  "horizon.splitscreen.profiles.forget_kept": "Донъя прогресс һәм параметрҙар һаҡлана.",
+  "horizon.splitscreen.profiles.new_title": "Яңы профиль",
+  "horizon.splitscreen.profiles.name_hint": "Исем (3-тән 16-ға тиклем хәреф, һан, _)",
+  "horizon.splitscreen.profiles.switch_title": "Профиль алмаштырыу",
+  "horizon.splitscreen.profiles.offline_note": "Офлайн профилдәр был данаға ҡарай",
+  "horizon.splitscreen.profiles.move": "Уйнаған ергә күсерегеҙ .",
+  "horizon.splitscreen.profiles.move_place": "Уйнаған урынға күсегеҙ: %s .",
+  "horizon.friends.title": "Дуҫтар менән уйнау .",
+  "horizon.friends.hint": "Дуҫтар кодты титул экранының «Дуҫтар» төймәһенән һуң, туранан-тура бәйләнештә йәки стартердың «Уйнау» битендә йәбештерә.",
+  "horizon.friends.copied": "Күсерелгән",
+  "horizon.friends.copy_code": "Код күсермәһе",
+  "horizon.friends.stop_sharing": "Бүлешеүҙе туҡтатығыҙ",
+  "horizon.friends.none_yet": "Бында әлегә дуҫтар юҡ.",
+  "horizon.friends.here_now": "Бында хәҙер: %s",
+  "horizon.friends.share_intro": "Был донъя менән бүлешергә артында саҡырыу коды: ул LAN асыла, һәм дуҫтар интернетта код менән ҡушыла. Беҙҙең бер сервер ҙа ҡатнашмай.",
+  "horizon.friends.start_sharing": "Бүлешергә башлағыҙ",
+  "horizon.friends.troubleshooting": "Неисправность...",
+  "horizon.friends.stopped": "Саҡырыу коды менән бүлешеүҙе туҡтатты.",
+  "horizon.friends.short_code_changed": "Кемдер дөрөҫ булмаған ҡыҫҡа кодты һынап ҡараны, шуға күрә ул үҙгәрҙе.",
+  "horizon.friends.wrong_code": "Кемдер дөрөҫ булмаған кодты ҡулланып ҡараған.",
+  "horizon.friends.code_ready": "Һеҙҙең саҡырыу коды әҙер: Уйын Менюһы, Дуҫтар менән уйнау. Күсереп яҙып, дуҫтарығыҙға ебәрегеҙ.",
+  "horizon.friends.share_failed": "Донъяны бүлешә алманым: %s",
+  "horizon.friends.finding_route": "Һеҙгә дуҫтар нисек барып етә алыуын табыу...",
+  "horizon.osk.shift": "Смена",
+  "horizon.osk.space": "Йыһан",
+  "horizon.osk.delete": "Юйырға",
+  "horizon.osk.type": "Тип .",
+  "horizon.osk.symbols": "Символдар",
+  "horizon.osk.close": "Ябыҡ",
+  "horizon.extras.chat_animation.tooltip": "Яңы чат һыҙығы һулдан шыуып инә, ә ул һүнә, урынына бөтөн күренә.",
+  "horizon.extras.chat_indicator.tooltip": "Чат һыҙығының һул яғында төҫлө һыҙыҡ.",
+  "horizon.extras.wheel_cycles_settings.tooltip": "Көйләүҙәрҙәге төймә өҫтөндәге прокрутка тәгәрмәсе үҙенең ҡиммәтен үҙгәртә, ванильдәге кеүек. Һүндерелгән, тәгәрмәс исемлекте генә йөрөтә.",
+  "horizon.extras.pack_browser.tooltip": "Һайлау ресурс пакеттары ала өҫтәү төймәһе, эҙләү Modrinth һәм һеҙҙең пакеттар папкаһына пакет ҡуя. Һүндерелгән, уйын бер ҡасан да бәйләнешкә инә Modrinth.",
+  "horizon.extras.splitscreen.tooltip": "Донъяла, икенсе контроллер яңы уйынсы булараҡ ҡушыла ала: баҫығыҙ А, ҡасан ул һорай, һуңынан профиль һайлап һәм ҡайҙа уйнау.",
+  "horizon.splitscreen.setup.monitor": "Монитор %s",
+  "horizon.splitscreen.setup.monitor_unknown": "монитор",
+  "horizon.splitscreen.setup.window": "Тәҙрә %s",
+  "horizon.splitscreen.setup.new_window": "Яңы тәҙрә",
+  "horizon.splitscreen.setup.fill_monitor": "Тултырырға %s",
+  "horizon.splitscreen.setup.done": "Бөттө",
+  "horizon.splitscreen.setup.on": "Өҫтөндә",
+  "horizon.splitscreen.setup.off": "Һүндерелгән",
+  "horizon.splitscreen.setup.player": "Уйынсы %s",
+  "horizon.splitscreen.setup.revert": "Кире ҡайтарыу",
+  "horizon.splitscreen.setup.apply": "Ҡулланыу",
+  "horizon.splitscreen.setup.warning.empty_main": "1-се тәҙрәлә бер кем дә уйнамай: ул йәшенә",
+  "horizon.splitscreen.setup.warning.empty_close": "Тәҙрәлә бер кем дә уйнамай %s: ул Ҡулланыуҙа ябыла",
+  "horizon.splitscreen.setup.warning.empty_new": "Тәҙрәлә бер кем дә уйнамай %s: ул асылмай",
+  "horizon.splitscreen.setup.warning.on_main": "%s тәҙрә 1-се тәҙрә мониторын тултыра: уның уйынсылары 1-се тәҙрәлә уйнай",
+  "horizon.splitscreen.setup.warning.unplugged": "Тәҙрә %s мониторы тоташтырылмаған: уның уйынсылары 1-се тәҙрәлә уйнай",
+  "horizon.splitscreen.setup.status.off": "Сплитскрин һүндерелгән.",
+  "horizon.splitscreen.setup.status.enable_hint": "Уны тоҡандырып, һуңынан бер донъяла икенсе контроллерҙағы төймәгә баҫығыҙ.",
+  "horizon.splitscreen.setup.status.join_hint": "А баҫып, ҡушылырға һәм профиль һайларға.",
+  "horizon.splitscreen.setup.status.idle": "Сплит-экран буш тора",
+  "horizon.splitscreen.setup.status.alone": "Башҡа урындағы уйынсылар юҡ.",
+  "horizon.splitscreen.setup.status.solo_controls": "Яңғыҙ идара итеү һәм контроллер кире бәйләнеш үҙгәрешһеҙ.",
+  "horizon.splitscreen.setup.window_empty": "Тәҙрә %s: буш",
+  "horizon.splitscreen.setup.note.select": "Плеерға баҫығыҙ, йәки уны тәҙрәгә йәки мониторға һөйрәгеҙ.",
+  "horizon.splitscreen.setup.note.apply": "Ҡулланыу өсөн уйнау өсөн был ысул, Ҡайтарыу өсөн кире ҡайтарыу.",
+  "horizon.splitscreen.setup.note.place": "%s ҡайҙа уйнарға тейеш?",
+  "horizon.splitscreen.setup.this_player": "был уйынсы",
+  "horizon.splitscreen.setup.switch_disabled": "Splitscreen һүнә бер тапҡыр башҡа ҡалдырҙы (уларҙы пауза менюһы).",
+  "horizon.splitscreen.setup.window_place": "Тәҙрә %s (%s %s-нан)",
+  "horizon.splitscreen.setup.names": "Исемдәр .",
+  "horizon.splitscreen.setup.identify": "Билдәләү",
+  "horizon.splitscreen.setup.layout.two": "2 бүлешеү: %s",
+  "horizon.splitscreen.setup.layout.three": "3 бүлешеү: %s",
+  "horizon.splitscreen.setup.layout.two.0": "Авто",
+  "horizon.splitscreen.setup.layout.two.1": "Ян-яҡтан .",
+  "horizon.splitscreen.setup.layout.two.2": "Өҫкө һәм аҫҡы .",
+  "horizon.splitscreen.setup.layout.three.0": "Өҫтөндә бер киң",
+  "horizon.splitscreen.setup.layout.three.1": "Һул яҡта бер бейек",
+  "horizon.splitscreen.setup.layout.three.2": "Ян-яҡтан .",
+  "horizon.splitscreen.setup.help.player": "Уларҙы күсерер өсөн %s баҫығыҙ йәки һөйрәгеҙ.",
+  "horizon.splitscreen.setup.help.layout_auto": "%s (тәҙрә киң булғанда йәнәш). Үҙгәртергә баҫығыҙ.",
+  "horizon.splitscreen.setup.help.layout": "%s. Үҙгәртергә баҫығыҙ.",
+  "horizon.splitscreen.setup.help.switch": "Был компьютер өсөн экран бүленгән, өҫтөндә йәки өҫтөндә.",
+  "horizon.splitscreen.setup.help.identify": "Һәр уйынсының ҡарашы ниндәй тәҙрәлә икәнен күрһәтә.",
+  "horizon.splitscreen.setup.help.names": "Һәр уйынсының исеме мөйөшөндә уларҙы ҡарау.",
+  "horizon.splitscreen.setup.help.revert": "Әле ҡулланылмаған үҙгәрештәрҙе кире ҡайтарығыҙ.",
+  "horizon.splitscreen.setup.help.apply": "Картала күрһәтелгәнсә уйнағыҙ.",
+  "horizon.splitscreen.setup.help.unchanged": "Әлегә бер нәмә лә үҙгәрмәне.",
+  "horizon.splitscreen.setup.give_up_pad": "Падтан баш тартығыҙ",
+  "horizon.splitscreen.prompt.controller_connected": "Контроллер тоташтырылған",
+  "horizon.splitscreen.prompt.controller_disconnected": "Контроллер өҙөлгән",
+  "horizon.splitscreen.prompt.controller_disconnected.hint": "Яңынан уны тоташтырырға, йәки икенсе төймәгә баҫығыҙ",
+  "horizon.splitscreen.prompt.join.one": "%s ҡушылырға теләй",
+  "horizon.splitscreen.prompt.join.many": "%s контроллерҙар ҡушылырға теләй",
+  "horizon.splitscreen.prompt.join.yes": "Ҡушылыу",
+  "horizon.splitscreen.prompt.join.as_p1": "Р1 булып уйнай.",
+  "horizon.splitscreen.prompt.join.no": "Юҡ",
+  "horizon.splitscreen.prompt.lost": "%s: контроллер өҙөлгән",
+  "horizon.splitscreen.prompt.lost.use_another": "Икенсе ҡулланыу .",
+  "horizon.splitscreen.prompt.lost.leave": "Ҡалдырырға",
+  "horizon.splitscreen.setup.help.give_up_pad": "Һеҙҙең контролер һеҙҙе водитель туҡтата һәм ҡушылырға тәҡдим ителә (А).",
+  "horizon.splitscreen.setup.note.held_at": "%s %s тиклем: А уны бында төшөрә, В кире һала.",
+  "horizon.splitscreen.setup.note.held": "%s йыйып алынған: һул/уң ҡайҙа йыйып ала, А төшә, В кире һала.",
+  "horizon.splitscreen.online_only": "Был сервер онлайн режимда: офлайн профилдәр уға ҡушыла алмай, һәр уйынсыға үҙ Minecraft иҫәбе кәрәк.",
+  "horizon.splitscreen.own_account": "Был серверға һәр уйынсының үҙ Minecraft иҫәбе кәрәк",
+  "horizon.splitscreen.local_only": "Башҡа уйынсылар был серверға үҙҙәренең Minecraft иҫәбенә генә ҡушыла ала: офлайн профилдәр һеҙҙең донъяла, LAN йәки һеҙҙең урындағы селтәрҙәге серверҙа уйнай.",
+  "Hides models behind opaque blocks. Async checks off-thread; entities tick.": "Моделдәрҙе асыҡ булмаған блоктар артында йәшерә. Ассинхрон тикшерә тышҡы еп; субъекттар галочкой.",
+  "Block Entities": "Блок субъекттары",
+  "Shulker Boxes": "Шулкер йәшниктәре",
+  "Reuses settled boxes; lid movement stays animated.": "Ҡабаттан ҡуллана урынлаштырылған йәшниктәр; ҡапҡас хәрәкәте йәнле ҡала.",
+  "Signs": "Билдәләре",
+  "Reuses sign text until text, light, or font changes.": "Текст, яҡтылыҡ йәки шрифт үҙгәргәнсе билдә тексын ҡабаттан ҡуллана.",
+  "Decorated Pots": "Биҙәкле һауыттар .",
+  "Reuses still pots; break wobble and sherd changes redraw.": "Һаман да ҡаҙандарҙы ҡабаттан ҡуллана; өҙөү качаться һәм шерд үҙгәрештәр перерисовать.",
+  "Bells": "Ҡыңғырауҙар",
+  "Reuses still bells; ringing stays animated.": "Ҡабаттан ҡуллана әле ҡыңғырауҙар; шылтыратыу йәнле ҡала.",
+  "Chests": "Һандыҡтар",
+  "Reuses closed chests; moving lids stay animated.": "Ябыҡ һандыҡтарҙы ҡабаттан ҡуллана; хәрәкәт итеүсе ҡапҡастар йәнле булып ҡала.",
+  "Banners": "Баннерҙар",
+  "Reuses poles; flags and pattern layers still update.": "Бағаналарҙы ҡабаттан ҡуллана; флагтар һәм өлгө ҡатламдары һаман да яңыртыла.",
+  "Copper Golem Statues": "Баҡыр Голем статуялары",
+  "Reuses statue geometry until its block state changes.": "Блок хәле үҙгәргәнсе статуя геометрияһын ҡабаттан ҡуллана.",
+  "Leaf Culling": "Япраҡ ҡырҡыу",
+  "Every leaf face. Vanilla's fancy leaves.": "Һәр япраҡ йөҙө. Ванильдың фантазия япраҡтары.",
+  "Distant Plant Dither": "Алыҫ үҫемлек ҡалтыраныуы",
+  "Keeps fine plants in high-res packs from fading far away.": "Юғары асыҡлыҡтағы пакеттарҙағы ваҡ үҫемлектәрҙе алыҫҡа һүнеүҙән һаҡлай.",
+  "Screenshot Quality": "Скриншот сифаты",
+  "F2 screenshots at this many times the game's resolution. Higher takes longer.": "F2 скриншоттар был күп тапҡыр уйын’ы ҡарар. Юғары оҙағыраҡ ваҡыт ала.",
+  "Frame Generation": "Кадр быуын",
+  "Shows a made-up frame between each two real ones: smoother, a little more lag.": "Һәр ике ысын араһында ҡоролған кадр күрһәтә: шымараҡ, бер аҙ күберәк лаг.",
+  "Shadow Cache": "Күләгә кэш",
+  "Reuses the pack shadow map when sun, view and world match. Off by default.": "Ҡояш, ҡараш һәм донъя тап килгәндә пакет күләгә картаһын ҡабаттан ҡуллана. Һүндерелгән по умолчанию.",
+  "Find BlueMap": "Зәңгәр картаны табығыҙ",
+  "On servers, finds their BlueMap web map for far terrain. Next join.": "Серверҙарҙа, алыҫ ерҙәр өсөн уларҙы BlueMap веб-картаһын таба. Киләһе ҡушылыу.",
+  "BlueMap Radius": "Зәңгәр карта радиусы",
+  "How far around you BlueMap tiles are downloaded. Next join.": "Һеҙҙең тирәләй ни тиклем алыҫ BlueMap плиталар скачать. Киләһе ҡушылыу.",
+  "Synchronous": "Синхрон",
+  "Asynchronous": "Ассинхрон",
+  "Solid": "Ҡаты",
+  "Solid Aggressive": "Ҡаты агрессив",
+  "Hollow": "Ҡыуыш",
+  "Leaves fully inside a canopy draw solid: fewer see-through layers.": "Япраҡтар тулыһынса навес эсендә ҡаты тарта: үтә күренмәле ҡатламдар аҙыраҡ.",
+  "Leaves with one open side draw solid too: faster, chunkier edges.": "Япраҡтар менән бер асыҡ яғы ҡаты тарта ла: тиҙерәк, chunkier ситтәре.",
+  "Drops faces between leaves: faster, but gaps look through.": "Япраҡтар араһында йөҙҙәрен тамсылай: тиҙерәк, әммә тишектәр аша ҡарай.",
+  "Hotbar: Previous Slot": "Ҡыҙыу панелдә: Алдағы слот",
+  "Hotbar: Next Slot": "Ҡыҙыу панелдә: Киләһе слот",
+  "horizon.agent.connected.one": "Тоташтырылған: 1 агент тоташыуы",
+  "horizon.agent.connected.many": "Тоташтырылған: %s агент тоташыуҙары",
+  "horizon.agent.connected.one_ago": "Тоташтырылған: 1 агент тоташыу, һуңғы команда %s с элек",
+  "horizon.agent.connected.many_ago": "Тоташтырылған: %s агент тоташыуҙары, һуңғы команда %s с элек",
+  "horizon.agent.waiting": "Агент көтөп.",
+  "horizon.agent.off": "Һүндерелгән: агенттар был уйынға етә алмай.",
+  "horizon.agent.session_opened": "Был сессия өсөн уйынды башлаған программа асты.",
+  "horizon.agent.socket": "Розетка: %s (уның тулы юлы өсөн реквизиттарҙы күсерергә)",
+  "horizon.agent.local_only": "Урындағы ғына: был компьютерҙа агенттар, бер ҡасан да селтәр.",
+  "%s nits": "%s нит",
+  "Auto (%s nits)": "Авто (%s нит)",
+  "%.2f nits": "%.2f нит",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Моделдәрҙе асыҡ булмаған блоктар артында йәшерә. Яңыртыу субъекттары. Ҡулланыусылар пакеттары менән өҙөлгән.",
+  "horizon.extras.repro_keys": "Яҙма ярлыҡтар",
+  "horizon.extras.repro_keys.tooltip": "F3+R репро яҙманы башлай йәки туҡтата һәм F3+E уның өйөмөн яҙа. Ғәҙәттәгесә һүндерелгән: яҙма донъяны күсерә.",
+  "horizon.agent.record_session": "Яҙҙырыу сеансын башлау",
+  "horizon.agent.record_stop": "Яҙҙырыуҙы туҡтатыу",
+  "horizon.agent.export_repro": "Экспортлау Repro йыйылмаһы",
+  "horizon.repro.started": "Яҙҙырыу башланды; F3+R уны туҡтата һәм өйөмдө яҙа.",
+  "horizon.repro.stopped": "Яҙма туҡтатылды: %s",
+  "horizon.repro.bundle": "Репро пакеты: %s",
+  "horizon.repro.error": "Ҡабатлау: %s",
+  "horizon.repro.no_recording": "Әлегә экспортҡа сығарырлыҡ яҙма юҡ.",
+  "horizon.repro.replay_started": "Ҡабатлау башланды: %s",
+  "horizon.pack.addInfo": "Modrinth ресурстар пакетын өҫтәү",
+  "horizon.pack.addWorking": "Һорау Modrinth...",
+  "horizon.pack.addNone": "Ресурс пакеттары табылмаған",
+  "horizon.pack.addTitle": "Ресурстар пакетын өҫтәү",
+  "horizon.pack.install": "Ҡуйыу",
+  "horizon.pack.installing": "Ҡуйыу",
+  "horizon.pack.installed": "Ҡуйылған",
+  "horizon.pack.search": "Эҙләү",
+  "horizon.pack.searchHint": "Эҙләү Modrinth...",
+  "horizon.pack.filters": "Фильтрҙар",
+  "horizon.pack.filter.realistic": "Ысынбарлыҡҡа ярашлы",
+  "horizon.pack.filter.simplistic": "Ябайлаштырылған",
+  "horizon.pack.filter.vanillaLike": "Ваниль һымаҡ",
+  "horizon.pack.filter.x16": "16х",
+  "horizon.pack.filter.x32": "32х",
+  "horizon.pack.filter.x64": "64х",
+  "horizon.pack.addFailed": "Пакетты өҫтәп булманы: %s",
+  "horizon.extras.header.cosmetics": "Косметика",
+  "horizon.extras.cosmetics_mine": "Минең косметика",
+  "horizon.extras.cosmetics_mine.tooltip": "Йәшерен: һәр Horizon уйынсы һеҙҙең косметикаһыҙ күрә, һеҙ ҙә индерелгән. Шул уҡ переключатель стартер’s Гардероб.",
+  "horizon.extras.cosmetics_others": "Башҡа уйынсыларҙың косметикаһы",
+  "horizon.extras.cosmetics_others.tooltip": "Башҡа ниндәй Horizon уйынсылар кейә: барыһы ла, тик уларҙы исем биркаһы стилдәре, йәки бер нәмә лә. Йәшерен, уйын бер ҡасан да һорамай, улар нимә кейә.",
+  "horizon.extras.cosmetics_auras": "Башҡаларҙың ауралары һәм эҙҙәре",
+  "horizon.extras.cosmetics_auras.tooltip": "Аура һәм эҙҙәр башҡа уйынсылар кейә. Һүндерелгән по умолчанию.",
+  "horizon.extras.cosmetics.shown": "Күрһәтелгән",
+  "horizon.extras.cosmetics.hidden": "Йәшерен",
+  "horizon.extras.cosmetics.name_tags": "Исем билдәләре генә"
+}

crates/horizon-client/assets/horizon/lang/be_by.json

@@ -0,0 +1,485 @@
+{
+  "horizon.options.controller": "Кантралёр",
+  "horizon.options.vibration": "Вібрацыя",
+  "horizon.options.adaptive_triggers": "Адаптыўныя трыгеры",
+  "horizon.options.lightbar": "Светлавая панэль",
+  "horizon.options.look_sensitivity": "Адчувальнасць агляду",
+  "horizon.options.invert_x": "Інверсія агляду па X",
+  "horizon.options.invert_y": "Інверсія агляду па Y",
+  "horizon.options.sneak_button": "Кнопка красціся",
+  "horizon.options.move_deadzone": "Мёртвая зона руху",
+  "horizon.options.look_deadzone": "Мёртвая зона агляду",
+  "horizon.options.button_glyphs": "Гліфы кнопак",
+  "horizon.options.menu_navigation": "Навігацыя па меню",
+  "horizon.options.on_screen_keyboard": "Экранная клавіятура",
+  "horizon.options.chat_delay": "Затрымка чата",
+  "horizon.options.lightbar.health": "здароўе",
+  "horizon.options.lightbar.dimension": "Вымярэнне",
+  "horizon.options.glyphs.auto": "Аўто",
+  "horizon.options.menu_focus": "Фокус",
+  "horizon.options.menu_pointer": "Паказальнік",
+  "horizon.options.keyboard.auto": "Аўто",
+  "horizon.options.unavailable": "Гэтая функцыя яшчэ недаступная ў Horizon.",
+  "horizon.options.search": "Налады пошуку...",
+  "horizon.pages.mods": "Моды",
+  "horizon.pages.shader_packs": "Пакеты шэйдараў",
+  "horizon.pages.shader_options": "Параметры шэйдара",
+  "horizon.pages.controller": "Налады кантролера",
+  "horizon.pages.controller_binds": "Прывязкі кантролера",
+  "horizon.pages.extras": "Horizon Дадаткова",
+  "horizon.pages.settings": "Horizon Налады",
+  "horizon.pages.agent": "Агент штучнага інтэлекту",
+  "horizon.split.leave": "Сыходзь",
+  "horizon.pages.split_settings": "Налады падзеленага экрана",
+  "horizon.pages.split_profiles": "Хто гуляе?",
+  "horizon.pages.split_setup": "Налада падзеленага экрана",
+  "horizon.pages.music": "Музыка",
+  "horizon.pages.music.menu": "Меню",
+  "horizon.pages.music.overworld": "Надсвет",
+  "horizon.pages.music.creative": "Творчы",
+  "horizon.pages.music.underwater": "Пад вадой",
+  "horizon.pages.music.end": "Канец",
+  "horizon.pages.music.boss": "Бос",
+  "horizon.pages.music.credits": "Крэдыты",
+  "horizon.pages.music.overworld_biomes": "Сусветныя біёмы",
+  "horizon.pages.music.nether_biomes": "Ніжнія біёмы",
+  "horizon.pages.music.end_biomes": "Канчатковыя біёмы",
+  "horizon.pages.music.other": "Іншая музыка",
+  "horizon.pages.music.empty": "Няма музычных трэкаў: не загружаюцца гукі гульні.",
+  "horizon.pages.music.tooltip": "Убудаваныя трэкі ў залежнасці ад сітуацыі: прайграйце адзін зараз або адключыце любы, каб гульня перастала яго выбіраць.",
+  "horizon.pages.settings.tooltip": "Уласныя налады Horizon: графіка, кантролеры, дадатковыя функцыі і моды.",
+  "horizon.pages.graphics.tooltip": "Простая графіка: кожная налада паказвае, колькі яна каштуе.",
+  "horizon.pages.graphics_advanced.tooltip": "Кожная налада графікі, у тым ліку Horizon, з коштам кожнай.",
+  "horizon.pages.controller.tooltip": "Кантролеры: іх кнопкі, стыкі, вібрацыя і навігацыя па меню.",
+  "horizon.pages.extras.tooltip": "Неабавязковыя дадаткі, усе выключаны па змаўчанні: гульня застаецца яркай, пакуль вы не ўключыце адну.",
+  "horizon.pages.agent.tooltip": "Дазвольце вашаму ўласнаму агенту штучнага інтэлекту гуляць: кліенты horizon-ctl і MCP на гэтым кампутары.",
+  "horizon.pages.split_profiles.tooltip": "Хто гуляе: профіль захоўваецца ў гэтай тэчцы гульні.",
+  "horizon.pages.split_setup.tooltip": "Вокны і маніторы, і хто дзе гуляе.",
+  "horizon.pages.shader_packs.tooltip": "Пакеты шэйдараў з папкі shaderpacks: уласныя Horizon і тыя, якія знаходзяцца ў фармаце shaders/. Бяжыць адзін за адным.",
+  "horizon.pages.mods.tooltip": "Моды, зробленыя для Horizon, з папкі horizon-mods. Кожны працуе ў пясочніцы і застаецца выключаным, пакуль вы яго не ўключыце.",
+  "horizon.pages.open.graphics": "Графіка...",
+  "horizon.pages.open.graphics_advanced": "Пашыраная графіка...",
+  "horizon.pages.open.shader_packs": "Пакеты шэйдэраў...",
+  "horizon.pages.open.controller": "Налады кантролера...",
+  "horizon.pages.open.split_setup": "Раздзелены экран...",
+  "horizon.pages.open.extras": "Дадаткова...",
+  "horizon.pages.open.mods": "Моды...",
+  "horizon.pages.open.agent": "Агент штучнага інтэлекту...",
+  "horizon.pages.open.horizon_graphics": "Horizon Графіка...",
+  "horizon.pages.open.controller_binds": "Кантролер прывязвае...",
+  "horizon.pages.open.horizon_settings": "Horizon Налады...",
+  "horizon.pages.open.music": "музыка...",
+  "horizon.mods.empty": "Няма модаў: змясціце файлы .hmod у тэчку horizon-mods",
+  "horizon.mods.stopped": " (Спынена)",
+  "horizon.mods.not_built": " (Не пабудаваны)",
+  "horizon.mods.settings": "Налады",
+  "horizon.mods.in_world": " (пакінуць свет змяніцца)",
+  "horizon.mods.open_folder": "Адкрыць тэчку Mod",
+  "horizon.shader_packs.empty": "Пакетаў шэйдэраў няма: змесціце іх у тэчку шэйдэраў",
+  "horizon.shader_options.open": "Параметры шэйдара...",
+  "horizon.shader_options.profile": "Профіль",
+  "horizon.shader_options.loading": "Чытанне параметраў пакета шэйдараў...",
+  "horizon.agent.copy_details": "Скапіруйце звесткі аб падключэнні",
+  "horizon.multiplayer.join": "Далучайцеся",
+  "horizon.multiplayer.cancel_reconnecting": "Адмяніць паўторнае падключэнне",
+  "horizon.multiplayer.join_friend": "Далучайцеся да сяброў",
+  "horizon.multiplayer.invite_code": "Код запрашэння",
+  "horizon.multiplayer.relay": "Рэле (неабавязкова)",
+  "Preset": "Прадусталяваная",
+  "LOD Distance": "LOD Адлегласць",
+  "Far Detail": "Далёкая дэталь",
+  "Cave Culling": "Выбракоўка пячор",
+  "Entity Culling": "Выбракоўванне сутнасці",
+  "Chunk Updates": "Абнаўленні чанка",
+  "Upload Budget": "Бюджэт загрузкі",
+  "Sky": "неба",
+  "Fog": "Туман",
+  "Weather": "Надвор'е",
+  "Animated Textures": "Аніміраваныя тэкстуры",
+  "Present Mode": "Рэжым сучаснасці",
+  "Frame Pacing": "Тэмп кадраў",
+  "Worker Threads": "Працоўныя тэмы",
+  "Resolution Scale": "Шкала дазволу",
+  "Anti-aliasing": "Згладжванне",
+  "Upscaling": "Апскейлінг",
+  "Paper White": "Папера белая",
+  "Peak Brightness": "Пікавая яркасць",
+  "Black Level": "Узровень чорнага",
+  "UI Brightness": "Яркасць інтэрфейсу",
+  "Battery Mode": "Рэжым батарэі",
+  "Graphics API": "Графічны API",
+  "Translucent Batching": "Напаўпразрысты дазаванне",
+  "Performance Overlay": "Прадукцыйнасць Overlay",
+  "Full Detail Distance": "Поўная адлегласць",
+  "On": "Укл",
+  "Off": "Выкл",
+  "Unlimited": "Неабмежаваны",
+  "Auto": "Аўто",
+  "Custom": "Прыстасаваныя",
+  "Performance": "Прадукцыйнасць",
+  "Balanced": "Ураўнаважаны",
+  "Quality": "Якасць",
+  "Ultra": "Ультра",
+  "Ultra Performance": "Ультрапрадукцыйнасць",
+  "Native": "Натыўны",
+  "Full": "Поўны",
+  "Reduced": "Паменшаны",
+  "Efficient": "Эфектыўная",
+  "Precise": "Дакладны",
+  "Auto (VSync)": "Аўта (VSync)",
+  "Mailbox": "Паштовая скрыня",
+  "Immediate": "Неадкладны",
+  "FPS and Graph": "FPS і графік",
+  "No cost": "Без выдаткаў",
+  "Low cost": "Нізкі кошт",
+  "Medium cost": "Сярэдні кошт",
+  "High cost": "Высокі кошт",
+  "Saves time": "Эканоміць час",
+  "Graphics": "Графіка",
+  "Done": "Гатова",
+  "This feature is not yet available in Horizon.": "Гэтая функцыя яшчэ недаступная ў Horizon.",
+  "Your display or system doesn't offer HDR output.": "Ваш дысплэй або сістэма не забяспечвае выхад HDR.",
+  "Turn HDR on to use it.": "Уключыце HDR, каб выкарыстоўваць яго.",
+  "Your GPU or graphics API doesn't support it.": "Ваш GPU або графічны API не падтрымлівае гэта.",
+  "%s chunks": "%s кавалкаў",
+  "%s per frame": "%s за кадр",
+  "%s MiB/frame": "%s МіБ/кадр",
+  "%s KiB/frame": "%s КіБ/кадр",
+  "Auto (%s)": "Аўто (%s)",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Поўны дэталёвы дыяпазон мясцовасці. LOD Адлегласць можа пашырыць мясцовыя светы далей.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Грубая аддаленая мясцовасць у лакальных мірах. Убудаваныя графічныя працэсары спыняюцца на 128 кавалках.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "Паменшанае малюнак больш грубай мясцовасці: хутчэй на гэтым убудаваным графічным працэсары.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "Зніжэнне малюе больш грубую мясцовасць, для графічных працэсараў гэта запавольваецца.",
+  "Field of view. Wider shows more terrain at once.": "Поле зроку. Шырэй паказвае адразу больш мясцовасці.",
+  "Caps frames per second; a cap saves power and heat.": "Колькасць кадраў у секунду; шапка эканоміць энергію і цяпло.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Чакае абнаўлення дысплея: без разрыву, з невялікай затрымкай.",
+  "Size of menus and the HUD.": "Памер меню і HUD.",
+  "Sets the options below together. Changing one makes it Custom.": "Разам усталёўвае параметры ніжэй. Змена аднаго робіць яго карыстальніцкім.",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Лава, агонь і сонечнае святло ззяюць ярчэй белага. Патрэбен дысплей HDR.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Самы цёмны чорны на вашым дысплеі. 0 для OLED; ВК-дысплеі трохі свецяцца.",
+  "How bright highlights get. Auto: the peak your system reports.": "Якія яркія моманты становяцца. Аўта: пік, пра які паведамляе ваша сістэма.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "Як ярка выглядаюць белая папера і меню. Аўтаматычна: ваш працоўны стол белы.",
+  "How bright the HUD and menus are, against paper white.": "Наколькі яркія HUD і меню на фоне белай паперы.",
+  "How far mobs, crops and machines keep working. CPU time.": "Як далёка працягваюць працаваць мобы, ураджай і машыны. працэсарны час.",
+  "How far away mobs and items are drawn, as a share of normal.": "Наколькі далёка намаляваны мобы і прадметы ў долі звычайнага.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Прапускае мясцовасць, схаваную за закрытымі ўчасткамі. Off каштуе шмат.",
+  "Hides entities behind opaque blocks.": "Хавае аб'екты за непразрыстымі блокамі.",
+  "No entity occlusion culling.": "Няма выбракоўвання аклюзіі сутнасці.",
+  "CPU occlusion test runs this frame.": "Тэст аклюзіі ЦП запускае гэты кадр.",
+  "Occlusion checks run on a worker thread.": "Праверкі аклюзіі выконваюцца ў працоўным патоку.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Сеткавыя раздзелы, загружаныя на кадр. Ніжняя больш плыўная падчас загрузкі.",
+  "Soft shadows in corners. Costs chunk building time only.": "Мяккія цені ў кутах. Каштуе толькі час зборкі кавалкаў.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "Меншыя копіі блочных тэкстур для далёкай мясцовасці: менш мігацення.",
+  "Blends grass and water colours across biomes when building chunks.": "Змешвае колеру травы і вады ў біёмах пры стварэнні кавалкаў.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Воблачны пласт: выключаны, плоскі (хуткі) або 3D (фантастычны).",
+  "How far clouds reach, in chunks.": "Наколькі дасягаюць воблакі, кавалкамі.",
+  "Draws the sky, sun, moon and stars.": "Малюе неба, сонца, месяц і зоркі.",
+  "Distance fog. Off shows the edge of the loaded world.": "Далёкі туман. Off паказвае край загружанага свету.",
+  "Draws rain and snow.": "Малюе дождж і снег.",
+  "How far rain and snow fall around you.": "Як далёка вакол цябе дождж і снег.",
+  "How many particles effects spawn.": "Колькі эфектаў часціц спараджае.",
+  "Round shadows under mobs and items.": "Круглыя цені пад мобамі і прадметамі.",
+  "Leaves with see-through gaps. Off draws them solid.": "Лісце з празрыстымі прасветамі. Off малюе іх цвёрда.",
+  "Sorts water and glass more exactly behind each other.": "Сартуе ваду і шкло больш дакладна адзін за адным.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Які кавалак перабудоўваецца ў чаканні кадра: ніякі, побач ці ваш.",
+  "Animates water, lava, fire and other moving textures.": "Ажыўляе ваду, лаву, агонь і іншыя рухомыя тэкстуры.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Сусветныя пікселі на піксель экрана. Ніжэй за 100% хутчэй на графічным працэсары.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Згладжвае няроўныя краю. FXAA: мякчэй. TAA: самыя гладкія рэчы, якія рухаюцца, могуць цягнуцца.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Памяншае свет і перабудоўвае яго з TAA. Хутчэй, мякчэй.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "Вывад HDR на дысплеі HDR: лава, агонь і сонечнае святло ззяюць ярчэй.",
+  "How frames reach the screen while VSync is off.": "Як кадры трапляюць на экран, калі VSync выключаны.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Эфектыўнае спіць да наступнага кадра; Дакладныя спіны, як ваніль.",
+  "Fills the screen (borderless).": "Запаўняе экран (без палёў).",
+  "Brightens dark places.": "Асвятляе цёмныя месцы.",
+  "Lowers the frame rate when minimised, or idle too.": "Зніжае частату кадраў пры згортванні або ў рэжыме чакання.",
+  "Sways the view while walking.": "Качае погляд падчас хады.",
+  "Fades newly loaded chunks in.": "Змяншае толькі што загружаныя кавалкі.",
+  "Darkens the screen's edges.": "Зацямняе краю экрана.",
+  "Shows when the world saves.": "Паказвае, калі свет ратуе.",
+  "Shows attack cooldown.": "Паказвае час аднаўлення атакі.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "Абмежаванне 60 кадраў у секунду (30 у меню або без увагі), палова рабочых: меншая магутнасць.",
+  "Threads that generate, light and mesh chunks. Next start.": "Ніткі, якія ствараюць, лёгкія і сеткаватыя кавалкі. Наступны старт.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, затым DirectX 12 (Windows) або OpenGL (Linux), дзе не атрымліваецца. Наступны старт.",
+  "Water and glass in one buffer: fewer draw calls, a bit more VRAM. Next start.": "Вада і шкло ў адным буферы: менш выклікаў на розыгрыш, крыху больш VRAM. Наступны старт.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Даныя сеткі, якія адпраўляюцца ў графічны працэсар за кадр. Ніжняя больш плыўная падчас загрузкі.",
+  "Frame rate and frame times over the game, with a graph.": "Частата кадраў і час кадраў у гульні з графікам.",
+  "horizon.multiplayer.finding_friend": "Пошук свету вашага сябра...",
+  "horizon.multiplayer.not_signed_in": "Гэты сервер знаходзіцца ў онлайн-рэжыме. Увайдзіце ў свой уліковы запіс Microsoft у праграме запуску Horizon, каб далучыцца да яе.",
+  "horizon.multiplayer.invalid_address": "Няправільны адрас сервера: %s",
+  "horizon.multiplayer.connected_friend_direct": "Падключаны непасрэдна да вашага сябра...",
+  "horizon.multiplayer.connected_friend_relay": "Падключаны да вашага сябра праз рэле...",
+  "General": "Генерал",
+  "Advanced": "Пашыраны",
+  "Undo": "Адмяніць",
+  "Search options": "Параметры пошуку",
+  "Shortcut": "Ярлык",
+  "Distance": "Дыстанцыя",
+  "Display": "Дысплей",
+  "Interface": "Інтэрфейс",
+  "Sky and weather": "Неба і надвор'е",
+  "Lighting and entities": "Асвятленне і сутнасці",
+  "Textures": "Тэкстуры",
+  "Image": "Малюнак",
+  "Chunk loading": "Загрузка чанка",
+  "Culling": "Выбракоўка",
+  "Power": "Магутнасць",
+  "Frames": "Рамкі",
+  "Overlay": "Накладка",
+  "Output": "Выхад",
+  "Brightness": "Яркасць",
+  "How far you see, the window and the HUD.": "Як далёка вы бачыце, акно і HUD.",
+  "The sky and weather, lighting, textures and the image.": "Неба і надвор'е, асвятленне, тэкстуры і малюнак.",
+  "Chunk loading, culling and power use.": "Загрузка кавалкаў, выбракоўванне і выкарыстанне энергіі.",
+  "How frames reach the screen, and the performance overlay.": "Як кадры трапляюць на экран і накладанне прадукцыйнасці.",
+  "Brighter-than-white output on an HDR display.": "Ярчэйшы за белы выхад на HDR-дысплеі.",
+  "Results for \"%s\"": "Вынікі для \"%s\"",
+  "No settings match.": "Налады не супадаюць.",
+  "horizon.title.not_affiliated": "Не звязаны з Mojang або Microsoft",
+  "horizon.extras.header.lighting": "Асвятленне",
+  "horizon.extras.header.third_person": "Трэцяя асоба",
+  "horizon.extras.header.particles": "Часціцы",
+  "horizon.extras.header.inventory": "Інвентар",
+  "horizon.extras.header.chat": "Чат",
+  "horizon.extras.header.multiplayer": "Мультыплэер",
+  "horizon.extras.header.sound": "Гук",
+  "horizon.extras.header.menus": "Меню",
+  "horizon.extras.fullbright": "Фулбрайт",
+  "horizon.extras.dynamic_lights": "Дынамічныя фары",
+  "horizon.extras.own_name_tag": "Уласная бірка з імем",
+  "horizon.extras.hide_block_particles": "Схаваць часціцы, якія разбіваюць блок",
+  "horizon.extras.auto_reconnect": "Аўтаматычнае падключэнне",
+  "horizon.extras.ui_sound_reserve": "Захоўвайце каналы для гукаў інтэрфейсу",
+  "horizon.extras.music_page": "Музычная старонка",
+  "horizon.extras.mouse_tweaks": "Элементы кіравання Mouse Tweaks",
+  "horizon.extras.mouse_tweaks_wheel": "Кола пракруткі перамяшчае элементы",
+  "horizon.extras.sort": "Кнопкі сартавання",
+  "horizon.extras.sort_key": "Ключ сартавання",
+  "horizon.extras.agent_control": "Агентскі кантроль",
+  "horizon.extras.splitscreen": "Раздзелены экран",
+  "horizon.extras.chat_animation": "Плаўны чат",
+  "horizon.extras.chat_indicator": "Індыкатар паведамлення",
+  "horizon.extras.wheel_cycles_settings": "Кола пракруткі змяняе налады",
+  "horizon.extras.pack_browser": "Браўзэр Resource Pack",
+  "horizon.extras.fullbright.tooltip": "Паказвайце блокі і аб'екты пры поўным асвятленні, нават у цёмных месцах.",
+  "horizon.extras.dynamic_lights.tooltip": "Факелы і іншыя крыніцы святла, якія трымаюць, упускаюць або гараць, асвятляюць блокі вакол іх.",
+  "horizon.extras.own_name_tag.tooltip": "Паказвае ваша імя над галавой ад трэцяй асобы, як яго бачаць іншыя гульцы. Схаваны, калі сервер хавае назвы вашай каманды або вы нябачныя.",
+  "horizon.extras.hide_block_particles.tooltip": "Хавае часціцы смецця, якія вырываюцца з разбітага блока і рассыпаюцца на той, які вы здабываеце. Іншыя часціцы застаюцца.",
+  "horizon.extras.auto_reconnect.tooltip": "Паўторна далучаецца да сервера пасля страты злучэння або перазагрузкі, ніколі пасля кіку або забароны.",
+  "horizon.extras.ui_sound_reserve.tooltip": "Гукі ў свеце пакідаюць 16 з 247 гукавых каналаў свабоднымі, таму іх паток (вялікі выбух) не можа заглушыць націсканне меню.",
+  "horizon.extras.music_page.tooltip": "«Музыка і гукі» атрымлівае старонку «Музыка...»: прайграйце любы ўбудаваны трэк зараз або адключыце адзін, каб гульня перастала яго выбіраць. Нічога не зменіцца, пакуль вы не адключыце трэк.",
+  "horizon.extras.mouse_tweaks.tooltip": "Перацягванне правай кнопкай мышы змяшчае па адным у слот, перацягванне левай кнопкай збірае ўтрымоўваны прадмет, Shift + перацягванне левай кнопкай мышы перамяшчае кожны слот.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "Уніз адпраўляе адзін элемент слота на другі бок, уверх вяртае адзін назад.",
+  "horizon.extras.sort.tooltip": "Сартуе інвентар, куфры, бочкі, эндэрскія куфры і шулкерныя скрыні ў творчым парадку ўкладак, аб'ядноўваючы стосы.",
+  "horizon.extras.sort_key.tooltip": "Сартуе частку пад курсорам. Націсніце, затым націсніце клавішу; Уцёкі развязвае яго.",
+  "horizon.extras.no_ai.tooltip": "Хавае і адключае ўсе функцыі штучнага інтэлекту: кіраванне агентамі, horizon-ctl і серверы MCP. Пераключальнік пускавы ўстаноўкі таксама.",
+  "horizon.extras.agent_control.tooltip": "Ваш уласны агент штучнага інтэлекту можа гуляць у гэтую гульню праз horizon-ctl або кліент MCP толькі на гэтым камп'ютары.",
+  "horizon.extras.discord_presence.tooltip": "Паказвае Playing Horizon у вашым профілі Discord падчас запуску Discord: меню, адзіночны або шматкарыстальніцкі рэжым, памер і час гульні. Ніколі не назва свету або адрас сервера.",
+  "Calibrate...": "Адкалібраваць...",
+  "Calibrate Anyway...": "Усё роўна адкалібраваць...",
+  "Use Automatic Setup": "Выкарыстоўвайце аўтаматычную наладу",
+  "Shortcut: %s": "Ярлык: %s",
+  "Next": "Далей",
+  "HDR Calibration %s/%s: %s": "Каліброўка HDR %s/%s: %s",
+  "Sets the three below full screen, one test picture at a time.": "Устанаўлівае тры ніжэй на ўвесь экран, па адным тэставым малюнку.",
+  "A key that opens this screen from the game. Not bound at first.": "Ключ, які адкрывае гэты экран з гульні. Спачатку не звязаны.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "На вашым дысплеі не пазначана, наколькі ён яркім: адкалібруйце, каб наладзіць яго.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "Ужо наладжана для вашага дысплея. Калібруйце, толькі калі HDR выглядае няправільна.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "Вяртае пікавую яркасць і папяровы белы ў налады вашага дысплея.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "Наладзьце для вашага дысплея. Пакіньце на Auto, калі гэта не выглядае няправільна.",
+  "Lower it until the logo just disappears into the black.": "Апускайце яго, пакуль лагатып проста не знікне ў чорным колеры.",
+  "Raise it until the logo just disappears into the bright square.": "Падымайце яго, пакуль лагатып не знікне ў яркім квадраце.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "Зрабіце карту белай, каб на яе было зручна глядзець на працягу доўгага часу пры святле, пры якім вы гуляеце.",
+  "horizon.splitscreen.profiles.forget": "Забыць",
+  "horizon.splitscreen.profiles.create": "Ствараць",
+  "horizon.splitscreen.profiles.you": " - вы",
+  "horizon.splitscreen.profiles.forget_named": "Забыць %s",
+  "horizon.splitscreen.profiles.previous": "Папярэдні",
+  "horizon.splitscreen.profiles.next": "Далей",
+  "horizon.splitscreen.profiles.new_button": "Новы профіль...",
+  "horizon.splitscreen.profiles.forget_title": "Забыць профіль?",
+  "horizon.splitscreen.profiles.forget_leaves": "Ён пакідае спіс гэтага экземпляра.",
+  "horizon.splitscreen.profiles.forget_kept": "Сусветны прагрэс і налады захоўваюцца.",
+  "horizon.splitscreen.profiles.new_title": "Новы профіль",
+  "horizon.splitscreen.profiles.name_hint": "Імя (ад 3 да 16 літар, лічбаў, _)",
+  "horizon.splitscreen.profiles.switch_title": "Пераключыць профіль",
+  "horizon.splitscreen.profiles.offline_note": "Афлайн-профілі належаць да гэтага асобніка",
+  "horizon.splitscreen.profiles.move": "Рухайцеся туды, дзе гуляеце",
+  "horizon.splitscreen.profiles.move_place": "Рухайцеся туды, дзе вы гуляеце: %s",
+  "horizon.friends.title": "Гуляць з сябрамі",
+  "horizon.friends.hint": "Сябры ўстаўце код пасля кнопкі \"Сябры\" на тытульным экране ў раздзеле \"Прамое злучэнне\" або на старонцы \"Прайграванне\" праграмы запуску.",
+  "horizon.friends.copied": "Скапіравана",
+  "horizon.friends.copy_code": "Скапіруйце код",
+  "horizon.friends.stop_sharing": "Спыніць абагульванне",
+  "horizon.friends.none_yet": "Тут пакуль няма сяброў.",
+  "horizon.friends.here_now": "Вось зараз: %s",
+  "horizon.friends.share_intro": "Падзяліцеся гэтым светам за кодам запрашэння: ён адкрываецца ў лакальнай сеткі, і сябры ў Інтэрнэце далучаюцца з кодам. Наш сервер не задзейнічаны.",
+  "horizon.friends.start_sharing": "Пачніце абагульваць",
+  "horizon.friends.troubleshooting": "Ліквідацыя непаладак...",
+  "horizon.friends.stopped": "Абагульванне кода запрашэння спынена.",
+  "horizon.friends.short_code_changed": "Хтосьці спрабаваў увесці няправільны кароткі код, таму ён змяніўся.",
+  "horizon.friends.wrong_code": "Хтосьці паспрабаваў увесці няправільны код.",
+  "horizon.friends.code_ready": "Ваш код запрашэння гатовы: меню гульні, гульня з сябрамі. Скапіруйце яго і адпраўце сваім сябрам.",
+  "horizon.friends.share_failed": "Не атрымалася падзяліцца светам: %s",
+  "horizon.friends.finding_route": "Пошук, як сябры могуць звязацца з вамі...",
+  "horizon.osk.shift": "зрух",
+  "horizon.osk.space": "космас",
+  "horizon.osk.delete": "Выдаліць",
+  "horizon.osk.type": "Тып",
+  "horizon.osk.symbols": "Сімвалы",
+  "horizon.osk.close": "Блізка",
+  "horizon.extras.chat_animation.tooltip": "Новы радок чата слізгае злева, пакуль ён знікае, замест таго, каб выглядаць цалкам.",
+  "horizon.extras.chat_indicator.tooltip": "Каляровая паласа злева ад радка чата.",
+  "horizon.extras.wheel_cycles_settings.tooltip": "Кола пракруткі над кнопкай у наладах змяняе яе значэнне, як у vanilla. Выключана, кола толькі пракручвае спіс.",
+  "horizon.extras.pack_browser.tooltip": "Select Resource Packs атрымлівае кнопку «Дадаць», якая выконвае пошук у Modrinth і ўсталёўвае пакет у вашу тэчку пакетаў. Выключана, гульня ніколі не звязваецца з Modrinth.",
+  "horizon.extras.splitscreen.tooltip": "У свеце іншы кантролер можа далучыцца як новы гулец: націсніце A, калі ён запытае, затым выберыце профіль і дзе гуляць.",
+  "horizon.splitscreen.setup.monitor": "Манітор %s",
+  "horizon.splitscreen.setup.monitor_unknown": "манітор",
+  "horizon.splitscreen.setup.window": "Акно %s",
+  "horizon.splitscreen.setup.new_window": "Новае акно",
+  "horizon.splitscreen.setup.fill_monitor": "Запоўніце %s",
+  "horizon.splitscreen.setup.done": "Гатова",
+  "horizon.splitscreen.setup.on": "Укл",
+  "horizon.splitscreen.setup.off": "Выкл",
+  "horizon.splitscreen.setup.player": "Гулец %s",
+  "horizon.splitscreen.setup.revert": "Вярнуць",
+  "horizon.splitscreen.setup.apply": "Ужыць",
+  "horizon.splitscreen.setup.warning.empty_main": "Ніхто не гуляе ў Window 1: яна хаваецца",
+  "horizon.splitscreen.setup.warning.empty_close": "Ніхто не гуляе ў Window %s: яно зачыняецца пры ўжыванні",
+  "horizon.splitscreen.setup.warning.empty_new": "Ніхто не гуляе ў Window %s: яно не адчыняецца",
+  "horizon.splitscreen.setup.warning.on_main": "Window %s запаўняе манітор Window 1: яго гульцы гуляюць у Window 1",
+  "horizon.splitscreen.setup.warning.unplugged": "Манітор Window %s не падключаны: яго гульцы гуляюць у Window 1",
+  "horizon.splitscreen.setup.status.off": "Splitscreen выключаны.",
+  "horizon.splitscreen.setup.status.enable_hint": "Уключыце яго, затым націсніце кнопку на іншым кантролеры ў свеце.",
+  "horizon.splitscreen.setup.status.join_hint": "Націсніце A, каб далучыцца і выбраць профіль.",
+  "horizon.splitscreen.setup.status.idle": "Раздзелены экран у рэжыме чакання",
+  "horizon.splitscreen.setup.status.alone": "Няма іншых мясцовых гульцоў.",
+  "horizon.splitscreen.setup.status.solo_controls": "Індывідуальныя элементы кіравання і зваротная сувязь кантролера не змяніліся.",
+  "horizon.splitscreen.setup.window_empty": "Акно %s: пустое",
+  "horizon.splitscreen.setup.note.select": "Пстрыкніце прайгравальнік або перацягніце яго ў акно або на манітор.",
+  "horizon.splitscreen.setup.note.apply": "Падайце заяўку, каб гуляць такім чынам, вярніце, каб адмяніць.",
+  "horizon.splitscreen.setup.note.place": "Дзе гуляць %s?",
+  "horizon.splitscreen.setup.this_player": "гэты гулец",
+  "horizon.splitscreen.setup.switch_disabled": "Раздзелены экран выключаецца, як толькі іншыя сыдуць (іх меню паўзы).",
+  "horizon.splitscreen.setup.window_place": "Акно %s (%s з %s)",
+  "horizon.splitscreen.setup.names": "Імёны",
+  "horizon.splitscreen.setup.identify": "Ідэнтыфікаваць",
+  "horizon.splitscreen.setup.layout.two": "2 абмен: %s",
+  "horizon.splitscreen.setup.layout.three": "3 абмен: %s",
+  "horizon.splitscreen.setup.layout.two.0": "Аўто",
+  "horizon.splitscreen.setup.layout.two.1": "Бок аб бок",
+  "horizon.splitscreen.setup.layout.two.2": "Зверху і знізу",
+  "horizon.splitscreen.setup.layout.three.0": "Адзін шырокі зверху",
+  "horizon.splitscreen.setup.layout.three.1": "Адзін высокі злева",
+  "horizon.splitscreen.setup.layout.three.2": "Бок аб бок",
+  "horizon.splitscreen.setup.help.player": "Націсніце або перацягніце %s, каб перамясціць іх.",
+  "horizon.splitscreen.setup.help.layout_auto": "%s (побач, калі акно шырокае). Націсніце, каб змяніць.",
+  "horizon.splitscreen.setup.help.layout": "%s. Націсніце, каб змяніць.",
+  "horizon.splitscreen.setup.help.switch": "Splitscreen для гэтага кампутара, уключаны або выключаны.",
+  "horizon.splitscreen.setup.help.identify": "Погляд кожнага гульца паказвае, у якім акне ён знаходзіцца.",
+  "horizon.splitscreen.setup.help.names": "Імя кожнага гульца ў куце іх агляду.",
+  "horizon.splitscreen.setup.help.revert": "Адмяніць яшчэ не прымененыя змены.",
+  "horizon.splitscreen.setup.help.apply": "Гуляйце так, як паказвае карта.",
+  "horizon.splitscreen.setup.help.unchanged": "Пакуль нічога не змянілася.",
+  "horizon.splitscreen.setup.give_up_pad": "Адмоўцеся ад Pad",
+  "horizon.splitscreen.prompt.controller_connected": "Кантролер падключаны",
+  "horizon.splitscreen.prompt.controller_disconnected": "Кантролер адключаны",
+  "horizon.splitscreen.prompt.controller_disconnected.hint": "Зноў падключыце яго або націсніце кнопку на іншым",
+  "horizon.splitscreen.prompt.join.one": "%s хоча далучыцца",
+  "horizon.splitscreen.prompt.join.many": "%s кантралёраў хочуць далучыцца",
+  "horizon.splitscreen.prompt.join.yes": "Далучайцеся",
+  "horizon.splitscreen.prompt.join.as_p1": "Гуляць як P1",
+  "horizon.splitscreen.prompt.join.no": "няма",
+  "horizon.splitscreen.prompt.lost": "%s: кантролер адключаны",
+  "horizon.splitscreen.prompt.lost.use_another": "Выкарыстоўвайце іншы",
+  "horizon.splitscreen.prompt.lost.leave": "Сыходзь",
+  "horizon.splitscreen.setup.help.give_up_pad": "Ваш кантролер перастае кіраваць вамі і прапануе далучыцца (A).",
+  "horizon.splitscreen.setup.note.held_at": "%s да %s: А кідае яго сюды, Б ставіць назад.",
+  "horizon.splitscreen.setup.note.held": "%s падняў: левы/правы выбіраюць, дзе, А кідае, Б ставіць назад.",
+  "Hides models behind opaque blocks. Async checks off-thread; entities tick.": "Хавае мадэлі за непразрыстымі блокамі. Async правярае па-за патокам; суб'ектаў цік.",
+  "Block Entities": "Блокавыя аб'екты",
+  "Shulker Boxes": "Скрынкі Шулкера",
+  "Reuses settled boxes; lid movement stays animated.": "Паўторна выкарыстоўвае адстойнікі; рух вечка застаецца ажыўленым.",
+  "Signs": "Знакі",
+  "Reuses sign text until text, light, or font changes.": "Паўторна выкарыстоўвае тэкст знака, пакуль не зменіцца тэкст, падсвятленне або шрыфт.",
+  "Decorated Pots": "Упрыгожаныя гаршкі",
+  "Reuses still pots; break wobble and sherd changes redraw.": "Паўторна выкарыстоўвае гаршкі; перапыніць хістанне і асколак змены перамаляваць.",
+  "Bells": "Званы",
+  "Reuses still bells; ringing stays animated.": "Паўторна выкарыстоўвае яшчэ званы; званок застаецца аніміраваным.",
+  "Chests": "Сундукі",
+  "Reuses closed chests; moving lids stay animated.": "Паўторна выкарыстоўвае закрытыя куфры; рухомыя павекі застаюцца ажыўленымі.",
+  "Banners": "Банеры",
+  "Reuses poles; flags and pattern layers still update.": "Паўторна выкарыстоўвае слупы; сцягі і ўзоры слаёў па-ранейшаму абнаўляюцца.",
+  "Copper Golem Statues": "Медныя статуі голема",
+  "Reuses statue geometry until its block state changes.": "Паўторна выкарыстоўвае геаметрыю статуі, пакуль не зменіцца яе стан блока.",
+  "Leaf Culling": "Выбракоўванне лісця",
+  "Every leaf face. Vanilla's fancy leaves.": "Кожны ліст твар. Вострыя лісце ванілі.",
+  "Distant Plant Dither": "Дыстантны завод",
+  "Keeps fine plants in high-res packs from fading far away.": "Захоўвае выдатныя расліны ў пакетах з высокім дазволам ад выцвітання.",
+  "Screenshot Quality": "Якасць скрыншота",
+  "F2 screenshots at this many times the game's resolution. Higher takes longer.": "Скрыншоты F2 з дазволам, які шмат разоў перавышае дазвол гульні. Вышэйшы займае больш часу.",
+  "Frame Generation": "Генерацыя фрэймаў",
+  "Shows a made-up frame between each two real ones: smoother, a little more lag.": "Паказвае прыдуманую рамку паміж двума сапраўднымі: больш гладкая, з крыху большым адставаннем.",
+  "Shadow Cache": "Ценявы кэш",
+  "Reuses the pack shadow map when sun, view and world match. Off by default.": "Паўторна выкарыстоўвае карту ценяў зграі, калі сонца, выгляд і свет супадаюць. Выключана па змаўчанні.",
+  "Find BlueMap": "Знайдзіце BlueMap",
+  "On servers, finds their BlueMap web map for far terrain. Next join.": "На серверах знаходзіць вэб-карту BlueMap для далёкай мясцовасці. Далей далучыцца.",
+  "BlueMap Radius": "Радыус BlueMap",
+  "How far around you BlueMap tiles are downloaded. Next join.": "Як далёка вакол вас загружаюцца пліткі BlueMap. Далей далучыцца.",
+  "Synchronous": "Сінхронныя",
+  "Asynchronous": "Асінхронны",
+  "Solid": "Цвёрды",
+  "Solid Aggressive": "Суцэльны агрэсіўны",
+  "Hollow": "Полая",
+  "Leaves fully inside a canopy draw solid: fewer see-through layers.": "Лісце цалкам унутры полага малююць суцэльна: менш празрыстых слаёў.",
+  "Leaves with one open side draw solid too: faster, chunkier edges.": "Лісце з адным адкрытым бокам таксама атрымліваюцца цвёрдымі: больш хуткія, каржакаватыя краю.",
+  "Drops faces between leaves: faster, but gaps look through.": "Апускае грані паміж лісцікамі: хутчэй, але шчыліны праглядваюць.",
+  "Hotbar: Previous Slot": "Гарачая панэль: папярэдні слот",
+  "Hotbar: Next Slot": "Гарачая панэль: наступны слот",
+  "horizon.agent.connected.one": "Падключана: 1 падключэнне агента",
+  "horizon.agent.connected.many": "Падключана: %s агентскіх злучэнняў",
+  "horizon.agent.connected.one_ago": "Падключана: 1 падключэнне агента, апошняя каманда %s с таму",
+  "horizon.agent.connected.many_ago": "Падключана: %s злучэнняў агента, апошняя каманда %s с таму",
+  "horizon.agent.waiting": "Чакаю агента.",
+  "horizon.agent.off": "Выключана: агенты не могуць атрымаць доступ да гэтай гульні.",
+  "horizon.agent.session_opened": "Адкрыты для гэтай сесіі праграмай, якая запусціла гульню.",
+  "horizon.agent.socket": "Сокет: %s (скапіруйце дэталі для поўнага шляху)",
+  "horizon.agent.local_only": "Толькі лакальна: агенты на гэтым кампутары, ніколі ў сетцы.",
+  "%s nits": "%s ніт",
+  "Auto (%s nits)": "Аўта (%s ніт)",
+  "%.2f nits": "%.2f ніт",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Хавае мадэлі за непразрыстымі блокамі. Абнаўленне суб'ектаў. Выключыце спецыяльныя пакеты.",
+  "horizon.extras.repro_keys": "Ярлыкі для запісу",
+  "horizon.extras.repro_keys.tooltip": "F3+R запускае або спыняе прайгравальны запіс, а F3+E запісвае пакет. Выключана па змаўчанні: запіс капіруе свет.",
+  "horizon.agent.record_session": "Пачаць сеанс запісу",
+  "horizon.agent.record_stop": "Спыніць сеанс запісу",
+  "horizon.agent.export_repro": "Экспарт Repro Bundle",
+  "horizon.repro.started": "Запіс пачаўся; F3+R спыняе яго і запісвае пакет.",
+  "horizon.repro.stopped": "Запіс спынены: %s",
+  "horizon.repro.bundle": "Пакет рэпрадукцый: %s",
+  "horizon.repro.error": "Паўтор: %s",
+  "horizon.repro.no_recording": "Пакуль няма запісу для экспарту.",
+  "horizon.repro.replay_started": "Паўтор пачаўся: %s",
+  "horizon.pack.addInfo": "Дадайце пакет рэсурсаў з Modrinth",
+  "horizon.pack.addWorking": "Запыт да Modrinth...",
+  "horizon.pack.addNone": "Пакеты рэсурсаў не знойдзены",
+  "horizon.pack.addTitle": "Дадайце пакет рэсурсаў",
+  "horizon.pack.install": "Усталяваць",
+  "horizon.pack.installing": "Ўстаноўка",
+  "horizon.pack.installed": "Усталяваны",
+  "horizon.pack.search": "Пошук",
+  "horizon.pack.searchHint": "Пошук у Modrinth...",
+  "horizon.pack.filters": "Фільтры",
+  "horizon.pack.filter.realistic": "Рэалістычны",
+  "horizon.pack.filter.simplistic": "Спрошчаны",
+  "horizon.pack.filter.vanillaLike": "Ванільны",
+  "horizon.extras.header.cosmetics": "Касметыка",
+  "horizon.extras.cosmetics_mine": "Мая касметыка",
+  "horizon.extras.cosmetics_mine.tooltip": "Схаваны: кожны гулец Horizon бачыць вас без вашай касметыкі, у тым ліку і вас. The same switch as the launcher's Wardrobe.",
+  "horizon.extras.cosmetics_others": "Касметыка іншых гульцоў",
+  "horizon.extras.cosmetics_others.tooltip": "Што носяць іншыя гульцы Horizon: усё, толькі стылі тэгаў з імёнамі або нічога. Hidden, the game never asks what they wear.",
+  "horizon.extras.cosmetics_auras": "Чужыя аўры і шлейфы",
+  "horizon.extras.cosmetics_auras.tooltip": "Auras and trails other players wear. Выключана па змаўчанні.",
+  "horizon.extras.cosmetics.shown": "Паказана",
+  "horizon.extras.cosmetics.hidden": "Схаваны",
+  "horizon.extras.cosmetics.name_tags": "Толькі біркі з імёнамі"
+}

crates/horizon-client/assets/horizon/lang/bg_bg.json

@@ -0,0 +1,481 @@
+{
+  "horizon.options.controller": "Контролер",
+  "horizon.options.vibration": "Вибрация",
+  "horizon.options.adaptive_triggers": "Адаптивни тригери",
+  "horizon.options.lightbar": "Светлинна лента",
+  "horizon.options.look_sensitivity": "Чувствителност на погледа",
+  "horizon.options.invert_x": "Обръщане на оста X на погледа",
+  "horizon.options.invert_y": "Обръщане на оста Y на погледа",
+  "horizon.options.sneak_button": "Бутон за промъкване",
+  "horizon.options.move_deadzone": "Мъртва зона на движението",
+  "horizon.options.look_deadzone": "Мъртва зона на погледа",
+  "horizon.options.button_glyphs": "Глифове на бутони",
+  "horizon.options.menu_navigation": "Навигация в менюто",
+  "horizon.options.on_screen_keyboard": "Екранна клавиатура",
+  "horizon.options.chat_delay": "Забавяне на чата",
+  "horizon.options.lightbar.health": "здраве",
+  "horizon.options.lightbar.dimension": "Измерение",
+  "horizon.options.glyphs.auto": "Авто",
+  "horizon.options.menu_focus": "Фокус",
+  "horizon.options.menu_pointer": "показалец",
+  "horizon.options.keyboard.auto": "Авто",
+  "horizon.options.keyboard.steam": "Пара",
+  "horizon.options.unavailable": "Тази функция все още не е налична в Horizon.",
+  "horizon.options.search": "Настройки за търсене...",
+  "horizon.pages.mods": "Модификации",
+  "horizon.pages.shader_packs": "Шейдърни пакети",
+  "horizon.pages.shader_options": "Опции на шейдъра",
+  "horizon.pages.controller": "Настройки на контролера",
+  "horizon.pages.controller_binds": "Контролерът се свързва",
+  "horizon.pages.agent": "AI агент",
+  "horizon.split.leave": "тръгвай",
+  "horizon.pages.split_settings": "Настройки за разделен екран",
+  "horizon.pages.split_profiles": "Кой играе?",
+  "horizon.pages.split_setup": "Настройка на разделен екран",
+  "horizon.pages.music": "Музика",
+  "horizon.pages.music.menu": "Меню",
+  "horizon.pages.music.overworld": "Надземният свят",
+  "horizon.pages.music.creative": "Творчески",
+  "horizon.pages.music.underwater": "Под вода",
+  "horizon.pages.music.end": "Краят",
+  "horizon.pages.music.boss": "Шефе",
+  "horizon.pages.music.credits": "Кредити",
+  "horizon.pages.music.overworld_biomes": "Биоми от надземния свят",
+  "horizon.pages.music.nether_biomes": "Долни биоми",
+  "horizon.pages.music.end_biomes": "Крайни биоми",
+  "horizon.pages.music.other": "Друга музика",
+  "horizon.pages.music.empty": "Няма музикални записи: звуците на играта не се зареждат.",
+  "horizon.pages.music.tooltip": "Вградените песни според ситуацията: пуснете една сега или изключете някоя, така че играта да спре да я избира.",
+  "horizon.pages.settings.tooltip": "Собствени настройки на Horizon: графики, контролери, екстри и модове.",
+  "horizon.pages.graphics.tooltip": "Графика просто: всяка настройка казва колко струва.",
+  "horizon.pages.graphics_advanced.tooltip": "Всяка графична настройка, включително Horizon, с цената на всяка.",
+  "horizon.pages.controller.tooltip": "Контролери: техните бутони, стикове, вибрация и навигация в менюто.",
+  "horizon.pages.extras.tooltip": "Незадължителни добавки, всички изключени по подразбиране: играта остава ванилия, докато не включите някоя.",
+  "horizon.pages.agent.tooltip": "Нека вашият собствен AI агент играе: horizon-ctl и MCP клиенти на този компютър.",
+  "horizon.pages.split_profiles.tooltip": "Кой играе: профил, съхраняван в тази папка на играта.",
+  "horizon.pages.split_setup.tooltip": "Прозорците и мониторите и кой къде играе.",
+  "horizon.pages.shader_packs.tooltip": "Шейдърни пакети от папката shaderpacks: собствените на Horizon и тези във формата shaders/. Един тича наведнъж.",
+  "horizon.pages.mods.tooltip": "Модификации, направени за Horizon, от папката horizon-mods. Всеки работи в пясъчна кутия и остава изключен, докато не го включите.",
+  "horizon.pages.open.graphics": "Графика...",
+  "horizon.pages.open.graphics_advanced": "Разширена графика...",
+  "horizon.pages.open.shader_packs": "Шейдър пакети...",
+  "horizon.pages.open.controller": "Настройки на контролера...",
+  "horizon.pages.open.split_setup": "Разделен екран...",
+  "horizon.pages.open.extras": "Екстри...",
+  "horizon.pages.open.mods": "Модове...",
+  "horizon.pages.open.agent": "AI агент...",
+  "horizon.pages.open.controller_binds": "Контролерът се свързва...",
+  "horizon.pages.open.horizon_settings": "Настройки на Horizon...",
+  "horizon.pages.open.music": "музика...",
+  "horizon.mods.empty": "Без модификации: поставете .hmod файлове в папката horizon-mods",
+  "horizon.mods.stopped": " (спряно)",
+  "horizon.mods.not_built": " (Не е построен)",
+  "horizon.mods.settings": "Настройки",
+  "horizon.mods.in_world": " (оставете света да се промени)",
+  "horizon.mods.open_folder": "Отворете папката на Mod",
+  "horizon.shader_packs.empty": "Без шейдър пакети: поставете ги в папката shaderpacks",
+  "horizon.shader_options.open": "Опции за шейдър...",
+  "horizon.shader_options.profile": "Профил",
+  "horizon.shader_options.loading": "Четене на опциите на шейдър пакета...",
+  "horizon.agent.copy_details": "Копиране на подробности за връзката",
+  "horizon.multiplayer.join": "Присъединете се",
+  "horizon.multiplayer.cancel_reconnecting": "Отказ Повторно свързване",
+  "horizon.multiplayer.join_friend": "Присъединете се към приятел",
+  "horizon.multiplayer.invite_code": "Код за покана",
+  "horizon.multiplayer.relay": "Реле (по избор)",
+  "Preset": "Предварителна настройка",
+  "LOD Distance": "LOD разстояние",
+  "Far Detail": "Далечен детайл",
+  "Cave Culling": "Пещерно избиване",
+  "Entity Culling": "Отстраняване на субекти",
+  "Chunk Updates": "Актуализации на парчета",
+  "Upload Budget": "Бюджет за качване",
+  "Sky": "небе",
+  "Fog": "мъгла",
+  "Weather": "Времето",
+  "Animated Textures": "Анимирани текстури",
+  "Present Mode": "Настоящ режим",
+  "Frame Pacing": "Темпо на рамката",
+  "Worker Threads": "Работни нишки",
+  "Resolution Scale": "Скала на резолюцията",
+  "Upscaling": "Премащабиране",
+  "Paper White": "Бяла хартия",
+  "Peak Brightness": "Пикова яркост",
+  "Black Level": "Черно ниво",
+  "UI Brightness": "Яркост на потребителския интерфейс",
+  "Battery Mode": "Режим на батерия",
+  "Graphics API": "Графичен API",
+  "Translucent Batching": "Полупрозрачно пакетиране",
+  "Performance Overlay": "Наслагване на ефективността",
+  "Full Detail Distance": "Пълно подробно разстояние",
+  "On": "включено",
+  "Off": "Изкл",
+  "Unlimited": "Неограничен",
+  "Auto": "Авто",
+  "Custom": "По поръчка",
+  "Performance": "Изпълнение",
+  "Balanced": "Балансиран",
+  "Quality": "качество",
+  "Ultra": "Ултра",
+  "Ultra Performance": "Ултра производителност",
+  "Native": "Роден",
+  "Full": "Пълна",
+  "Reduced": "Намалена",
+  "Efficient": "Ефективно",
+  "Precise": "Прецизен",
+  "Auto (VSync)": "Автоматично (VSync)",
+  "Mailbox": "Пощенска кутия",
+  "Immediate": "Незабавно",
+  "FPS and Graph": "FPS и графика",
+  "No cost": "Без разходи",
+  "Low cost": "Ниска цена",
+  "Medium cost": "Средна цена",
+  "High cost": "Висока цена",
+  "Saves time": "Спестява време",
+  "Graphics": "Графика",
+  "Done": "Готово",
+  "This feature is not yet available in Horizon.": "Тази функция все още не е налична в Horizon.",
+  "Your display or system doesn't offer HDR output.": "Вашият дисплей или система не предлага HDR изход.",
+  "Turn HDR on to use it.": "Включете HDR, за да го използвате.",
+  "Your GPU or graphics API doesn't support it.": "Вашият GPU или графичен API не го поддържат.",
+  "%s chunks": "%s парчета",
+  "%s per frame": "%s на кадър",
+  "%s MiB/frame": "%s MiB/кадър",
+  "%s KiB/frame": "%s KiB/кадър",
+  "Auto (%s)": "Авто (%s)",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Пълен детайлен обхват на терена. LOD Разстоянието може да разшири локалните светове по-далеч.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Груб далечен терен в местните светове. Интегрираните графични процесори спират на 128 парчета.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "Намалено чертане на по-груб терен: по-бързо с този интегриран GPU.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "Намалено рисува далеч по-груб терен, за GPU се забавя.",
+  "Field of view. Wider shows more terrain at once.": "Зрително поле. По-широко показва повече терен наведнъж.",
+  "Caps frames per second; a cap saves power and heat.": "Максимални кадри в секунда; капачката спестява енергия и топлина.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Изчаква опресняване на дисплея: без разкъсване, малко забавяне.",
+  "Size of menus and the HUD.": "Размер на менютата и HUD.",
+  "Sets the options below together. Changing one makes it Custom.": "Задава заедно опциите по-долу. Промяната на един го прави персонализиран.",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Лавата, огънят и слънчевата светлина блестят по-ярко от бялото. Има нужда от HDR дисплей.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Вашият дисплей е най-тъмно черен. 0 за OLED; LCD дисплеите светят малко.",
+  "How bright highlights get. Auto: the peak your system reports.": "Колко ярки стават акцентите. Автоматично: пикът, който вашата система отчита.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "Колко ярки изглеждат бялата хартия и менютата. Автоматично: вашият работен плот е бял.",
+  "How bright the HUD and menus are, against paper white.": "Колко ярки са HUD и менютата на бяла хартия.",
+  "How far mobs, crops and machines keep working. CPU time.": "Докъде продължават да работят тълпите, културите и машините. процесорно време.",
+  "How far away mobs and items are drawn, as a share of normal.": "Колко далеч са изтеглени тълпите и предметите, като дял от нормалното.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Пропуска терен, скрит зад затворени участъци. Off струва много.",
+  "Hides entities behind opaque blocks.": "Скрива обекти зад непрозрачни блокове.",
+  "No entity occlusion culling.": "Без отстраняване на оклузия на обект.",
+  "CPU occlusion test runs this frame.": "Тестът за запушване на процесора изпълнява този кадър.",
+  "Occlusion checks run on a worker thread.": "Проверките за затваряне се изпълняват на работна нишка.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Мрежести секции, качени на кадър. Долната е по-плавна при зареждане.",
+  "Soft shadows in corners. Costs chunk building time only.": "Меки сенки в ъглите. Разходи само време за изграждане на парче.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "По-малки копия на блокови текстури за отдалечени терени: по-малко блясък.",
+  "Blends grass and water colours across biomes when building chunks.": "Смесва тревни и водни цветове в биоми при изграждане на парчета.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Облачен слой: изключен, плосък (бърз) или 3D (фантастичен).",
+  "How far clouds reach, in chunks.": "Докъде достигат облаците, на парчета.",
+  "Draws the sky, sun, moon and stars.": "Рисува небето, слънцето, луната и звездите.",
+  "Distance fog. Off shows the edge of the loaded world.": "Дистанционна мъгла. Изключено показва ръба на заредения свят.",
+  "Draws rain and snow.": "Рисува дъжд и сняг.",
+  "How far rain and snow fall around you.": "Докъде валят дъжд и сняг около вас.",
+  "How many particles effects spawn.": "Колко ефекти на частици хвърлят хайвера си.",
+  "Round shadows under mobs and items.": "Кръгли сенки под тълпи и предмети.",
+  "Leaves with see-through gaps. Off draws them solid.": "Листа с прозрачни празнини. Off ги рисува солидно.",
+  "Sorts water and glass more exactly behind each other.": "Сортира водата и стъклото по-точно едно зад друго.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Коя част се възстановява, чакайки рамката: нито една, наблизо или вашата.",
+  "Animates water, lava, fire and other moving textures.": "Анимира вода, лава, огън и други движещи се текстури.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Световни пиксели на пиксел на екрана. Под 100% е по-бързо на GPU.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Изглажда назъбените ръбове. FXAA: по-мек. TAA: най-плавните, движещи се неща могат да се проточат.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Прави света по-малък и го възстановява с TAA. По-бързо, по-меко.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "HDR изход на HDR дисплей: лава, огън и слънчева светлина блестят по-ярко.",
+  "How frames reach the screen while VSync is off.": "Как кадрите достигат до екрана, докато VSync е изключен.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Ефективно заспиване до следващия кадър; Прецизни завъртания, като ванилия.",
+  "Fills the screen (borderless).": "Запълва екрана (без граници).",
+  "Brightens dark places.": "Осветява тъмните места.",
+  "Lowers the frame rate when minimised, or idle too.": "Намалява честотата на кадрите, когато е минимизирана или неактивна.",
+  "Sways the view while walking.": "Люлее гледката по време на ходене.",
+  "Fades newly loaded chunks in.": "Избледнява новозаредените парчета.",
+  "Darkens the screen's edges.": "Затъмнява ръбовете на екрана.",
+  "Shows when the world saves.": "Показва кога светът спасява.",
+  "Shows attack cooldown.": "Показва изчакване на атаката.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "60 FPS капачка (30 в менюта или нефокусирани), половината работници: по-малко мощност.",
+  "Threads that generate, light and mesh chunks. Next start.": "Нишки, които генерират, леки и мрежести парчета. Следващ старт.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, след това DirectX 12 (Windows) или OpenGL (Linux), където не успее. Следващ старт.",
+  "Water and glass in one buffer: fewer draw calls, a bit more VRAM. Next start.": "Вода и стъкло в един буфер: по-малко извиквания за теглене, малко повече VRAM. Следващ старт.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Мрежови данни, изпратени до GPU на кадър. Долната е по-плавна при зареждане.",
+  "Frame rate and frame times over the game, with a graph.": "Скорост на кадрите и времена на кадрите в играта, с графика.",
+  "horizon.multiplayer.finding_friend": "Намиране на света на вашия приятел...",
+  "horizon.multiplayer.not_signed_in": "Този сървър е в онлайн режим. Влезте с вашия акаунт в Microsoft в стартовия панел на Horizon, за да се присъедините към него.",
+  "horizon.multiplayer.invalid_address": "Невалиден адрес на сървъра: %s",
+  "horizon.multiplayer.connected_friend_direct": "Свързан директно с вашия приятел...",
+  "horizon.multiplayer.connected_friend_relay": "Свързан с вашия приятел чрез релето...",
+  "General": "генерал",
+  "Advanced": "Разширено",
+  "Undo": "Отмяна",
+  "Search options": "Опции за търсене",
+  "Shortcut": "Пряк път",
+  "Distance": "Разстояние",
+  "Display": "Дисплей",
+  "Interface": "Интерфейс",
+  "Sky and weather": "Небе и време",
+  "Lighting and entities": "Осветление и обекти",
+  "Textures": "Текстури",
+  "Image": "Изображение",
+  "Chunk loading": "Зареждане на парчета",
+  "Culling": "Бране",
+  "Power": "Мощност",
+  "Frames": "Рамки",
+  "Overlay": "Наслагване",
+  "Output": "Изход",
+  "Brightness": "Яркост",
+  "How far you see, the window and the HUD.": "Колко далеч виждате, прозореца и HUD.",
+  "The sky and weather, lighting, textures and the image.": "Небето и времето, осветлението, текстурите и изображението.",
+  "Chunk loading, culling and power use.": "Зареждане на парчета, отстраняване и използване на енергия.",
+  "How frames reach the screen, and the performance overlay.": "Как рамките достигат до екрана и наслагването на ефективността.",
+  "Brighter-than-white output on an HDR display.": "По-ярък от бялото изход на HDR дисплей.",
+  "Results for \"%s\"": "Резултати за \"%s\"",
+  "No settings match.": "Няма съответстващи настройки.",
+  "horizon.title.not_affiliated": "Не е свързан с Mojang или Microsoft",
+  "horizon.extras.header.lighting": "Осветление",
+  "horizon.extras.header.third_person": "Трето лице",
+  "horizon.extras.header.particles": "частици",
+  "horizon.extras.header.inventory": "Инвентаризация",
+  "horizon.extras.header.chat": "Чат",
+  "horizon.extras.header.multiplayer": "Мултиплейър",
+  "horizon.extras.header.sound": "Звук",
+  "horizon.extras.header.menus": "Менюта",
+  "horizon.extras.fullbright": "Фулбрайт",
+  "horizon.extras.dynamic_lights": "Динамични светлини",
+  "horizon.extras.own_name_tag": "Собствен етикет с име",
+  "horizon.extras.hide_block_particles": "Скриване на частиците за разбиване на блокове",
+  "horizon.extras.auto_reconnect": "Автоматично повторно свързване",
+  "horizon.extras.ui_sound_reserve": "Запазете канали за звуци от потребителския интерфейс",
+  "horizon.extras.music_page": "Музикална страница",
+  "horizon.extras.mouse_tweaks": "Mouse Tweaks контроли",
+  "horizon.extras.mouse_tweaks_wheel": "Колелото за превъртане премества елементи",
+  "horizon.extras.sort": "Бутони за сортиране",
+  "horizon.extras.sort_key": "Ключ за сортиране",
+  "horizon.extras.no_ai": "Без AI",
+  "horizon.extras.agent_control": "Агентски контрол",
+  "horizon.extras.discord_presence": "Богато присъствие на Discord",
+  "horizon.extras.splitscreen": "Разделен екран",
+  "horizon.extras.chat_animation": "Плавен чат",
+  "horizon.extras.chat_indicator": "Индикатор за съобщение",
+  "horizon.extras.wheel_cycles_settings": "Колелото за превъртане променя настройките",
+  "horizon.extras.pack_browser": "Браузър за пакети с ресурси",
+  "horizon.extras.fullbright.tooltip": "Показвайте блокове и обекти при пълна светлина, дори в тъмни зони.",
+  "horizon.extras.dynamic_lights.tooltip": "Факли и други източници на светлина, държани, изпуснати или запалени, осветяват блоковете около тях.",
+  "horizon.extras.own_name_tag.tooltip": "Показва името ви над главата ви в трето лице, както го виждат другите играчи. Скрит, когато сървърът скрива имената на вашия отбор или сте невидими.",
+  "horizon.extras.hide_block_particles.tooltip": "Скрива частиците отломки, които избухват от счупен блок и се разпадат от този, който копаете. Други частици остават.",
+  "horizon.extras.auto_reconnect.tooltip": "Присъединява се отново към сървър след загубена връзка или рестартиране, никога след ритване или бан.",
+  "horizon.extras.ui_sound_reserve.tooltip": "Звуците в света оставят 16 от 247 звукови канала свободни, така че потоп от тях (голяма експлозия) не може да заглуши щракванията в менюто.",
+  "horizon.extras.music_page.tooltip": "Music & Sounds получава страница Music...: пуснете която и да е вградена песен сега или изключете някоя, така че играта да спре да я избира. Нищо не се променя, докато не изключите запис.",
+  "horizon.extras.mouse_tweaks.tooltip": "Плъзгане с десен бутон поставя по един на слот, плъзгане с ляво събира задържания елемент, Shift + плъзгане наляво премества всеки слот.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "Надолу изпраща един елемент от слота от другата страна, нагоре връща един обратно.",
+  "horizon.extras.sort.tooltip": "Сортира инвентара, сандъците, бъчвите, сандъците за ендер и кутиите за шулкери в творчески ред на раздели, сливайки стекове.",
+  "horizon.extras.sort_key.tooltip": "Сортира частта под курсора. Щракнете, след това натиснете клавиш; Escape го развързва.",
+  "horizon.extras.no_ai.tooltip": "Скрива и изключва всяка функция на AI: контрол на агента, horizon-ctl и MCP сървърите. Превключвателят на стартера също.",
+  "horizon.extras.agent_control.tooltip": "Вашият собствен AI агент може да играе тази игра чрез horizon-ctl или MCP клиент само на този компютър.",
+  "horizon.extras.discord_presence.tooltip": "Показва Playing Horizon във вашия Discord профил, докато Discord работи: менюта, един играч или мултиплейър, измерението и времето на игра. Никога име на света или адрес на сървър.",
+  "Calibrate...": "Калибриране...",
+  "Calibrate Anyway...": "Калибриране все пак...",
+  "Use Automatic Setup": "Използвайте автоматична настройка",
+  "Shortcut: %s": "Пряк път: %s",
+  "Next": "Следваща",
+  "HDR Calibration %s/%s: %s": "HDR калибриране %s/%s: %s",
+  "Sets the three below full screen, one test picture at a time.": "Задава трите под цял екран, една тестова картина наведнъж.",
+  "A key that opens this screen from the game. Not bound at first.": "Ключ, който отваря този екран от играта. В началото не е обвързан.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "Вашият дисплей не каза колко ярък става: калибрирайте, за да го настроите.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "Вече е настроен за вашия дисплей. Калибрирайте само ако HDR изглежда грешно.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "Връща Peak Brightness и Paper White обратно към настройката на вашия дисплей.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "Настройте за вашия дисплей. Оставете на Auto, освен ако не изглежда грешно.",
+  "Lower it until the logo just disappears into the black.": "Спуснете го, докато логото изчезне в черното.",
+  "Raise it until the logo just disappears into the bright square.": "Повдигнете го, докато логото изчезне в яркия квадрат.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "Направете картата бяла, удобна за гледане дълго време, на светлината, на която играете.",
+  "horizon.splitscreen.profiles.forget": "Забравете",
+  "horizon.splitscreen.profiles.create": "Създавайте",
+  "horizon.splitscreen.profiles.you": " - ти",
+  "horizon.splitscreen.profiles.forget_named": "Забравете %s",
+  "horizon.splitscreen.profiles.previous": "Предишен",
+  "horizon.splitscreen.profiles.next": "Следваща",
+  "horizon.splitscreen.profiles.new_button": "Нов профил...",
+  "horizon.splitscreen.profiles.forget_title": "Забравете профила?",
+  "horizon.splitscreen.profiles.forget_leaves": "Напуска списъка на този екземпляр.",
+  "horizon.splitscreen.profiles.forget_kept": "Световният напредък и настройки се запазват.",
+  "horizon.splitscreen.profiles.new_title": "Нов профил",
+  "horizon.splitscreen.profiles.name_hint": "Име (3 до 16 букви, цифри, _)",
+  "horizon.splitscreen.profiles.switch_title": "Превключване на профил",
+  "horizon.splitscreen.profiles.offline_note": "Офлайн профилите принадлежат към този екземпляр",
+  "horizon.splitscreen.profiles.move": "Движете се там, където играете",
+  "horizon.splitscreen.profiles.move_place": "Преместете се там, където играете: %s",
+  "horizon.friends.title": "Играйте с приятели",
+  "horizon.friends.hint": "Приятели поставете кода след бутона Приятели на заглавния екран, в Direct Connection или на страницата за възпроизвеждане на стартовия панел.",
+  "horizon.friends.copied": "Копирано",
+  "horizon.friends.copy_code": "Копиране на код",
+  "horizon.friends.stop_sharing": "Спиране на споделянето",
+  "horizon.friends.none_yet": "Тук все още няма приятели.",
+  "horizon.friends.here_now": "Тук сега: %s",
+  "horizon.friends.share_intro": "Споделете този свят зад код за покана: той се отваря към LAN и приятели в интернет се присъединяват с кода. Не е включен наш сървър.",
+  "horizon.friends.start_sharing": "Започнете споделяне",
+  "horizon.friends.troubleshooting": "Отстраняване на неизправности...",
+  "horizon.friends.stopped": "Спря споделянето на кода за покана.",
+  "horizon.friends.short_code_changed": "Някой продължаваше да опитва грешен кратък код, така че той се промени.",
+  "horizon.friends.wrong_code": "Някой е опитал грешен код.",
+  "horizon.friends.code_ready": "Вашият код за покана е готов: Меню за игри, Играйте с приятели. Копирайте го и го изпратете на приятелите си.",
+  "horizon.friends.share_failed": "Не можах да споделя света: %s",
+  "horizon.friends.finding_route": "Търся как приятелите могат да се свържат с вас...",
+  "horizon.osk.space": "пространство",
+  "horizon.osk.delete": "Изтриване",
+  "horizon.osk.type": "Тип",
+  "horizon.osk.symbols": "Символи",
+  "horizon.osk.close": "затвори",
+  "horizon.extras.chat_animation.tooltip": "Нова линия за чат се плъзга отляво, докато избледнява, вместо да се показва цяла.",
+  "horizon.extras.chat_indicator.tooltip": "Цветната лента отляво на линия за чат.",
+  "horizon.extras.wheel_cycles_settings.tooltip": "Колелцето за превъртане над бутон в настройките променя стойността му, както при vanilla. Изключено, колелото само превърта списъка.",
+  "horizon.extras.pack_browser.tooltip": "Select Resource Packs получава бутон за добавяне, който търси в Modrinth и инсталира пакет във вашата папка с пакети. Off, играта никога не се свързва с Modrinth.",
+  "horizon.extras.splitscreen.tooltip": "В един свят друг контролер може да се присъедини като нов играч: натиснете A, когато поиска, след това изберете профил и къде да играете.",
+  "horizon.splitscreen.setup.monitor": "Монитор %s",
+  "horizon.splitscreen.setup.monitor_unknown": "монитор",
+  "horizon.splitscreen.setup.window": "Прозорец %s",
+  "horizon.splitscreen.setup.new_window": "Нов прозорец",
+  "horizon.splitscreen.setup.fill_monitor": "Попълнете %s",
+  "horizon.splitscreen.setup.done": "Готово",
+  "horizon.splitscreen.setup.on": "включено",
+  "horizon.splitscreen.setup.off": "Изкл",
+  "horizon.splitscreen.setup.player": "Играч %s",
+  "horizon.splitscreen.setup.revert": "Връщане",
+  "horizon.splitscreen.setup.apply": "Кандидатствайте",
+  "horizon.splitscreen.setup.warning.empty_main": "Никой не играе в Window 1: той се скрива",
+  "horizon.splitscreen.setup.warning.empty_close": "Никой не играе в Window %s: затваря се при Apply",
+  "horizon.splitscreen.setup.warning.empty_new": "Никой не играе в Window %s: няма да се отвори",
+  "horizon.splitscreen.setup.warning.on_main": "Window %s изпълва монитора на Window 1: неговите играчи играят в Window 1",
+  "horizon.splitscreen.setup.warning.unplugged": "Мониторът на Window %s не е свързан: неговите играчи играят в Window 1",
+  "horizon.splitscreen.setup.status.off": "Разделеният екран е изключен.",
+  "horizon.splitscreen.setup.status.enable_hint": "Включете го, след това натиснете бутон на друг контролер в свят.",
+  "horizon.splitscreen.setup.status.join_hint": "Натиснете A, за да се присъедините и изберете профил.",
+  "horizon.splitscreen.setup.status.idle": "Разделен екран неактивен",
+  "horizon.splitscreen.setup.status.alone": "Няма други местни играчи.",
+  "horizon.splitscreen.setup.status.solo_controls": "Самостоятелните контроли и обратната връзка на контролера са непроменени.",
+  "horizon.splitscreen.setup.window_empty": "Прозорец %s: празен",
+  "horizon.splitscreen.setup.note.select": "Щракнете върху плейър или го плъзнете към прозорец или монитор.",
+  "horizon.splitscreen.setup.note.apply": "Приложете, за да играете по този начин, Върнете, за да отмените.",
+  "horizon.splitscreen.setup.note.place": "Къде трябва да играе %s?",
+  "horizon.splitscreen.setup.this_player": "този играч",
+  "horizon.splitscreen.setup.switch_disabled": "Splitscreen се изключва, след като другите напуснат (тяхното меню за пауза).",
+  "horizon.splitscreen.setup.window_place": "Прозорец %s (%s от %s)",
+  "horizon.splitscreen.setup.names": "имена",
+  "horizon.splitscreen.setup.identify": "Идентифицирайте",
+  "horizon.splitscreen.setup.layout.two": "2 споделяне: %s",
+  "horizon.splitscreen.setup.layout.three": "3 споделяне: %s",
+  "horizon.splitscreen.setup.layout.two.0": "Авто",
+  "horizon.splitscreen.setup.layout.two.1": "Един до друг",
+  "horizon.splitscreen.setup.layout.two.2": "Отгоре и отдолу",
+  "horizon.splitscreen.setup.layout.three.0": "Един широк отгоре",
+  "horizon.splitscreen.setup.layout.three.1": "Един висок отляво",
+  "horizon.splitscreen.setup.layout.three.2": "Един до друг",
+  "horizon.splitscreen.setup.help.player": "Кликнете или плъзнете %s, за да ги преместите.",
+  "horizon.splitscreen.setup.help.layout_auto": "%s (един до друг, когато прозорецът е широк). Натиснете за промяна.",
+  "horizon.splitscreen.setup.help.layout": "%s. Натиснете за промяна.",
+  "horizon.splitscreen.setup.help.switch": "Разделен екран за този компютър, включен или изключен.",
+  "horizon.splitscreen.setup.help.identify": "Изгледът на всеки играч показва в кой прозорец се намира.",
+  "horizon.splitscreen.setup.help.names": "Името на всеки играч в ъгъла на неговия изглед.",
+  "horizon.splitscreen.setup.help.revert": "Отменете промените, които все още не са приложени.",
+  "horizon.splitscreen.setup.help.apply": "Играйте по начина, по който картата показва.",
+  "horizon.splitscreen.setup.help.unchanged": "Все още нищо не се е променило.",
+  "horizon.splitscreen.setup.give_up_pad": "Подложка за отказване",
+  "horizon.splitscreen.prompt.controller_connected": "Контролерът е свързан",
+  "horizon.splitscreen.prompt.controller_disconnected": "Контролерът е изключен",
+  "horizon.splitscreen.prompt.controller_disconnected.hint": "Свържете го отново или натиснете бутон на друг",
+  "horizon.splitscreen.prompt.join.one": "%s иска да се присъедини",
+  "horizon.splitscreen.prompt.join.many": "%s контролери искат да се присъединят",
+  "horizon.splitscreen.prompt.join.yes": "Присъединете се",
+  "horizon.splitscreen.prompt.join.as_p1": "Играйте като P1",
+  "horizon.splitscreen.prompt.join.no": "не",
+  "horizon.splitscreen.prompt.lost": "%s: контролерът е изключен",
+  "horizon.splitscreen.prompt.lost.use_another": "Използвайте друг",
+  "horizon.splitscreen.prompt.lost.leave": "тръгвай",
+  "horizon.splitscreen.setup.help.give_up_pad": "Вашият контролер спира да ви кара и получава предложение да се присъедини (A).",
+  "horizon.splitscreen.setup.note.held_at": "%s до %s: A го пуска тук, B го връща обратно.",
+  "horizon.splitscreen.setup.note.held": "%s взето: ляв/десен избира къде, A пуска, B го връща обратно.",
+  "Hides models behind opaque blocks. Async checks off-thread; entities tick.": "Скрива модели зад непрозрачни блокове. Async проверява извън нишката; субекти отметка.",
+  "Block Entities": "Блокиране на обекти",
+  "Shulker Boxes": "Кутии Шулкер",
+  "Reuses settled boxes; lid movement stays animated.": "Повторно използване на утаени кутии; движението на капака остава анимирано.",
+  "Signs": "Знаци",
+  "Reuses sign text until text, light, or font changes.": "Използва повторно текста на знака, докато текстът, светлината или шрифтът се променят.",
+  "Decorated Pots": "Декорирани саксии",
+  "Reuses still pots; break wobble and sherd changes redraw.": "Повторно използване на саксии; прекъсване на колебанията и отделяне на промени, преначертаване.",
+  "Bells": "Камбани",
+  "Reuses still bells; ringing stays animated.": "Повторно използване на неподвижни камбани; звъненето остава анимирано.",
+  "Chests": "Сандъци",
+  "Reuses closed chests; moving lids stay animated.": "Повторно използване на затворени сандъци; подвижните клепачи остават анимирани.",
+  "Banners": "Банери",
+  "Reuses poles; flags and pattern layers still update.": "Повторно използване на стълбове; флаговете и слоевете с шаблони все още се актуализират.",
+  "Copper Golem Statues": "Медни статуи на голем",
+  "Reuses statue geometry until its block state changes.": "Използва повторно геометрията на статуята, докато блоковото й състояние се промени.",
+  "Leaf Culling": "Изрязване на листа",
+  "Every leaf face. Vanilla's fancy leaves.": "Всеки лист лице. Елегантните листа на ванилия.",
+  "Keeps fine plants in high-res packs from fading far away.": "Предпазва фините растения в пакети с висока разделителна способност от избледняване.",
+  "Screenshot Quality": "Качество на екранната снимка",
+  "F2 screenshots at this many times the game's resolution. Higher takes longer.": "Екранни снимки на F2 при толкова многократна разделителна способност на играта. По-високото отнема повече време.",
+  "Frame Generation": "Генериране на рамка",
+  "Shows a made-up frame between each two real ones: smoother, a little more lag.": "Показва измислен кадър между всеки два реални: по-гладък, с малко повече забавяне.",
+  "Reuses the pack shadow map when sun, view and world match. Off by default.": "Използва повторно картата на сенките на глутницата, когато слънцето, гледката и света съвпадат. Изключено по подразбиране.",
+  "Find BlueMap": "Намерете BlueMap",
+  "On servers, finds their BlueMap web map for far terrain. Next join.": "На сървъри намира тяхната уеб карта BlueMap за далечен терен. Следващо присъединяване.",
+  "BlueMap Radius": "Радиус на BlueMap",
+  "How far around you BlueMap tiles are downloaded. Next join.": "На какво разстояние около вас се изтеглят плочките BlueMap. Следващо присъединяване.",
+  "Synchronous": "Синхронен",
+  "Asynchronous": "Асинхронен",
+  "Solid": "Твърди",
+  "Solid Aggressive": "Твърди агресивни",
+  "Hollow": "Кух",
+  "Leaves fully inside a canopy draw solid: fewer see-through layers.": "Листата изцяло вътре в сенник рисуват плътно: по-малко прозрачни слоеве.",
+  "Leaves with one open side draw solid too: faster, chunkier edges.": "Листата с една отворена страна също рисуват плътно: по-бързи, по-едри ръбове.",
+  "Drops faces between leaves: faster, but gaps look through.": "Капки лица между листата: по-бързо, но празнини прозират.",
+  "Hotbar: Previous Slot": "Гореща лента: Предишен слот",
+  "Hotbar: Next Slot": "Гореща лента: Следващ слот",
+  "horizon.agent.connected.one": "Свързан: 1 връзка с агент",
+  "horizon.agent.connected.many": "Свързани: %s агентни връзки",
+  "horizon.agent.connected.one_ago": "Свързан: 1 връзка с агент, последна команда преди %s сек",
+  "horizon.agent.connected.many_ago": "Свързани: %s агентни връзки, последна команда преди %s сек",
+  "horizon.agent.waiting": "В очакване на агент.",
+  "horizon.agent.off": "Изключено: агентите не могат да достигнат до тази игра.",
+  "horizon.agent.session_opened": "Отворено за тази сесия от програмата, която стартира играта.",
+  "horizon.agent.socket": "Сокет: %s (копирайте подробностите за пълния му път)",
+  "horizon.agent.local_only": "Само локално: агенти на този компютър, никога в мрежата.",
+  "%s nits": "%s нита",
+  "Auto (%s nits)": "Автоматично (%s нита)",
+  "%.2f nits": "%.2f нита",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Скрива модели зад непрозрачни блокове. Актуализация на обекти. Изключване с персонализирани пакети.",
+  "horizon.extras.repro_keys": "Преки пътища за запис",
+  "horizon.extras.repro_keys.tooltip": "F3+R стартира или спира възпроизвеждане на запис и F3+E записва неговия пакет. Изключено по подразбиране: записът копира света.",
+  "horizon.agent.record_session": "Започнете запис на сесия",
+  "horizon.agent.record_stop": "Спрете сесията за запис",
+  "horizon.agent.export_repro": "Експортиране на Repro Bundle",
+  "horizon.repro.started": "Записът започна; F3+R го спира и записва пакета.",
+  "horizon.repro.stopped": "Записът е спрян: %s",
+  "horizon.repro.bundle": "Repro пакет: %s",
+  "horizon.repro.error": "Репро: %s",
+  "horizon.repro.no_recording": "Все още няма запис за експортиране.",
+  "horizon.repro.replay_started": "Стартирало повторение: %s",
+  "horizon.pack.addInfo": "Добавете ресурсен пакет от Modrinth",
+  "horizon.pack.addNone": "Няма намерени пакети с ресурси",
+  "horizon.pack.addTitle": "Добавете пакет с ресурси",
+  "horizon.pack.install": "Инсталирайте",
+  "horizon.pack.installing": "Инсталиране",
+  "horizon.pack.installed": "Инсталиран",
+  "horizon.pack.search": "Търсене",
+  "horizon.pack.searchHint": "Търсете Modrinth...",
+  "horizon.pack.filters": "Филтри",
+  "horizon.pack.filter.realistic": "Реалистичен",
+  "horizon.pack.filter.simplistic": "Опростено",
+  "horizon.pack.filter.vanillaLike": "Подобно на ванилия",
+  "horizon.pack.addFailed": "Пакетът не можа да бъде добавен: %s",
+  "horizon.extras.header.cosmetics": "Козметика",
+  "horizon.extras.cosmetics_mine": "Моята козметика",
+  "horizon.extras.cosmetics_mine.tooltip": "Скрит: всеки играч на Horizon ви вижда без вашата козметика, включително и вие. Същият превключвател като гардероба на стартера.",
+  "horizon.extras.cosmetics_others": "Козметика за други играчи",
+  "horizon.extras.cosmetics_others.tooltip": "Какво носят другите играчи на Horizon: всичко, само техните стилове на имената или нищо. Скрито, играта никога не пита какво носят.",
+  "horizon.extras.cosmetics_auras": "Аури и следи на други",
+  "horizon.extras.cosmetics_auras.tooltip": "Аури и пътеки, които другите играчи носят. Изключено по подразбиране.",
+  "horizon.extras.cosmetics.shown": "Показано",
+  "horizon.extras.cosmetics.hidden": "Скрити",
+  "horizon.extras.cosmetics.name_tags": "Само етикети с имена"
+}

crates/horizon-client/assets/horizon/lang/br_fr.json

@@ -0,0 +1,484 @@
+{
+  "horizon.options.controller": "Reoler",
+  "horizon.options.three_d_skin_layers": "Gwiskadoù kroc'hen 3D",
+  "horizon.options.vibration": "Krenadenn",
+  "horizon.options.adaptive_triggers": "Gwaskerioù azasaus",
+  "horizon.options.lightbar": "Barrenn gouloù",
+  "horizon.options.look_sensitivity": "Sensibilitez ar sell",
+  "horizon.options.invert_x": "Distreiñ ar sell X",
+  "horizon.options.invert_y": "Distreiñ ar sell Y",
+  "horizon.options.sneak_button": "Bouton mont kuzh",
+  "horizon.options.move_deadzone": "Takad marv ar fiñval",
+  "horizon.options.look_deadzone": "Takad marv ar sell",
+  "horizon.options.button_glyphs": "Glifoù bouton",
+  "horizon.options.menu_navigation": "Merdeiñ dre ar meni",
+  "horizon.options.on_screen_keyboard": "Klavier war ar skramm",
+  "horizon.options.chat_delay": "Dale flapañ",
+  "horizon.options.lightbar.health": "Yec'hed",
+  "horizon.options.lightbar.dimension": "Ment",
+  "horizon.options.glyphs.auto": "Emgefreek",
+  "horizon.options.menu_focus": "Lakaat ar gaoz",
+  "horizon.options.menu_pointer": "Poent",
+  "horizon.options.keyboard.auto": "Emgefreek",
+  "horizon.options.unavailable": "N'eo ket hegerz an elfenn-mañ c'hoazh e Horizon.",
+  "horizon.options.search": "Arventennoù klask...",
+  "horizon.pages.mods": "Modoù",
+  "horizon.pages.shader_packs": "Pakadoù skeudennoù",
+  "horizon.pages.shader_options": "Dibarzhioù skeudenniñ",
+  "horizon.pages.controller": "Arventennoù ar merour",
+  "horizon.pages.controller_binds": "Liammañ ar c'hontroller",
+  "horizon.pages.extras": "Horizon Ouzhpennoù",
+  "horizon.pages.settings": "Horizon Arventennoù",
+  "horizon.pages.agent": "Ajañs IA",
+  "horizon.split.leave": "Kuitaat",
+  "horizon.pages.split_settings": "Arventennoù ar skramm rannet",
+  "horizon.pages.split_profiles": "Piv a zo o c'hoari ?",
+  "horizon.pages.split_setup": "Arventennoù ar skramm rannet",
+  "horizon.pages.music": "Sonerezh",
+  "horizon.pages.music.overworld": "Bed dreist",
+  "horizon.pages.music.creative": "Krouiñ",
+  "horizon.pages.music.underwater": "Dindan an dour",
+  "horizon.pages.music.end": "Ar fin",
+  "horizon.pages.music.boss": "Patron",
+  "horizon.pages.music.credits": "Kredoù",
+  "horizon.pages.music.overworld_biomes": "Biomoù ar bed dreist",
+  "horizon.pages.music.nether_biomes": "Biomoù an izelvroioù",
+  "horizon.pages.music.end_biomes": "Biomoù dibenn",
+  "horizon.pages.music.other": "Sonerezh all",
+  "horizon.pages.music.empty": "Roudenn sonerezh ebet : n'eo ket karget sonioù ar c'hoari.",
+  "horizon.pages.music.tooltip": "An hentoù enkorfet, dre stad : c'hoari unan bremañ, pe diweredekaat unan anezho evit ma paouezfe ar c'hoari da zibab anezhañ.",
+  "horizon.pages.settings.tooltip": "arventennoù Horizon e-unan : grafikoù, kontrollerioù, ouzhpennadennoù ha kemmoù.",
+  "horizon.pages.graphics.tooltip": "Grafikoù, simpl : pep arventenn a lavar petra a goust.",
+  "horizon.pages.graphics_advanced.tooltip": "Pep arventenn grafek, Horizon en o zouez, gant ar pezh a goust pep hini.",
+  "horizon.pages.controller.tooltip": "Kontrollerien : o boutonoù, o bizhier, o c'hrennlavar hag o merdeiñ war al lañserioù.",
+  "horizon.pages.extras.tooltip": "Ouzhpennadennoù dibar, holl diweredekaet dre ziouer : chom a ra ar c'hoari vanilha betek ma vo lakaet unan war-sav.",
+  "horizon.pages.agent.tooltip": "Lakait hoc'h ajañs AI da c'hoari : ar c'hliented horizon-ctl ha MCP war an urzhiataer-mañ.",
+  "horizon.pages.split_profiles.tooltip": "Piv a c'hoari : ur profil miret er renkell c'hoari-mañ.",
+  "horizon.pages.split_setup.tooltip": "Ar prenestroù hag ar skrammoù, ha piv a c'hoari pelec'h.",
+  "horizon.pages.shader_packs.tooltip": "Pakadoù skeudennoù eus an teuliad pakadoù skeudennoù : Horizon o-unan hag ar re er stumm skeudennoù/. Unan a red d'an dro.",
+  "horizon.pages.mods.tooltip": "Modoù savet evit Horizon, eus an teuliad horizon-mods. Pep hini a ya en-dro en ur voest-traezh ha chom a ra diweredekaet betek ma vo lakaet war-sav.",
+  "horizon.pages.open.graphics": "Grafikoù...",
+  "horizon.pages.open.graphics_advanced": "Grafikoù araokaet...",
+  "horizon.pages.open.shader_packs": "Pakadoù skeudennoù...",
+  "horizon.pages.open.controller": "Arventennoù ar merour...",
+  "horizon.pages.open.split_setup": "Skramm rannet...",
+  "horizon.pages.open.extras": "Ouzhpenn...",
+  "horizon.pages.open.mods": "Modoù...",
+  "horizon.pages.open.agent": "Ajañs IA...",
+  "horizon.pages.open.horizon_graphics": "Horizon Grafikoù...",
+  "horizon.pages.open.controller_binds": "Stagañ a ra ar reoler...",
+  "horizon.pages.open.horizon_settings": "Horizon Arventennoù...",
+  "horizon.pages.open.music": "Sonerezh...",
+  "horizon.mods.empty": "Mod ebet : lakait restroù .hmod e teuliad horizon-mods",
+  "horizon.mods.stopped": " (Paouezet)",
+  "horizon.mods.not_built": " (N'eo ket bet savet)",
+  "horizon.mods.settings": "Arventennoù",
+  "horizon.mods.in_world": " (lezel ar bed da cheñch)",
+  "horizon.mods.open_folder": "Digeriñ an teuliad mod",
+  "horizon.shader_packs.empty": "Pakad skeudennoù ebet : lakait anezho e teuliad ar pakadoù skeudennoù",
+  "horizon.shader_options.open": "Dibarzhioù skeudenniñ...",
+  "horizon.shader_options.profile": "Profil",
+  "horizon.shader_options.loading": "O lenn dibaboù ar pakad skeudennoù...",
+  "horizon.agent.copy_details": "Eilañ munudoù ar c'hennask",
+  "horizon.multiplayer.join": "Kemer perzh",
+  "horizon.multiplayer.cancel_reconnecting": "Nullañ an adkennaskañ",
+  "horizon.multiplayer.join_friend": "Kemer perzh en ur mignon",
+  "horizon.multiplayer.invite_code": "Kod pediñ",
+  "horizon.multiplayer.relay": "Treuzkas (dibar)",
+  "Preset": "Raktreset",
+  "LOD Distance": "Pellder LOD",
+  "Far Detail": "Munudoù pell",
+  "Cave Culling": "Lazhañ ar c'hevoù",
+  "Entity Culling": "Distruj an entite",
+  "Chunk Updates": "Hizivadennoù tammoù",
+  "Upload Budget": "Budjed pellgargañ",
+  "Sky": "Oabl",
+  "Fog": "Brumenn",
+  "Weather": "Amzer",
+  "Animated Textures": "Teñzorioù bevaat",
+  "Present Mode": "Mod bremañ",
+  "Frame Pacing": "Pazadur ar framm",
+  "Worker Threads": "Neudennoù labourerien",
+  "Resolution Scale": "Skeul an diarunusted",
+  "Anti-aliasing": "Enep-aliañ",
+  "Upscaling": "Kreskiñ",
+  "Paper White": "Gwenn paper",
+  "Peak Brightness": "Sklêrijenn uhelañ",
+  "Black Level": "Live du",
+  "UI Brightness": "Sklêrijenn UI",
+  "Battery Mode": "Mod pilenn",
+  "Graphics API": "API grafikoù",
+  "Translucent Batching": "Lodennadur treuzwelus",
+  "Performance Overlay": "Dreistlakaat ar perzhded",
+  "Full Detail Distance": "Pellder munudoù klok",
+  "On": "War",
+  "Off": "Diweredekaet",
+  "Unlimited": "Didalvoud",
+  "Auto": "Emgefreek",
+  "Custom": "Personelaet",
+  "Performance": "Arvest",
+  "Balanced": "Kempouez",
+  "Quality": "Kalite",
+  "Native": "Natif",
+  "Full": "Leun",
+  "Reduced": "Digresket",
+  "Efficient": "Efedus",
+  "Precise": "Resis",
+  "Auto (VSync)": "Emgefre (VSync)",
+  "Mailbox": "Boest-postel",
+  "Immediate": "Diouzhtu",
+  "FPS and Graph": "FPS ha grafik",
+  "No cost": "Koust ebet",
+  "Low cost": "Koust izel",
+  "Medium cost": "Koust etre",
+  "High cost": "Koust uhel",
+  "Saves time": "Gounit a ra amzer",
+  "Graphics": "Grafikoù",
+  "Done": "Echu",
+  "This feature is not yet available in Horizon.": "N'eo ket hegerz an elfenn-mañ c'hoazh e Horizon.",
+  "Your display or system doesn't offer HDR output.": "Ho skramm pe ho reizhiad ne ginnig ket un disoc'h HDR.",
+  "Turn HDR on to use it.": "Lakait HDR war-sav evit e implijout.",
+  "Your GPU or graphics API doesn't support it.": "N'eo ket skoret gant ho GPU pe ho API grafikoù.",
+  "%s chunks": "%s tammoù",
+  "%s per frame": "%s dre framm",
+  "%s MiB/frame": "%s MiB/framm",
+  "%s KiB/frame": "%s KiB/framm",
+  "Auto (%s)": "Emgefre (%s)",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Rannvro an douaroù leun a vunudoù. LOD Ar pellder a c'hell astenn ar bedoù lec'hel pelloc'h.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Douaroù pell gros e bedoù lec'hel. Paouez a ra ar GPUoù kevredet da 128 tamm.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "Digreskiñ a ra an douaroù kalz grosoc'h : buanoc'h war ar GPU kevredet-mañ.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "Ar reduset a denn an douaroù kalz grosoc'h, evit ar GPUoù e vez gorrekaet.",
+  "Field of view. Wider shows more terrain at once.": "Tachenn gwel. Ledanoc'h a ziskouez muioc'h a zouaroù war un dro.",
+  "Caps frames per second; a cap saves power and heat.": "Bep frammoù dre eilenn; ur c'hasketenn a espern energiezh ha tommder.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Gortoz a ra freskaat ar skramm : tamm torr ebet, un tamm dale.",
+  "Size of menus and the HUD.": "Ment ar mennozhioù hag an HUD.",
+  "Sets the options below together. Changing one makes it Custom.": "Lakaat a ra an dibarzhioù amañ dindan asambles. Cheñch unan a ra anezhañ Personelaet.",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Lava, tan ha gouloù an heol a lugern muioc'h eget ar gwenn. Ezhomm zo eus ur skramm HDR.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Du teñvalañ eo ho skramm. 0 evit OLED; LCDoù a lugern un tamm.",
+  "How bright highlights get. Auto: the peak your system reports.": "Pegen skedus e teu ar sklêrijennoù. Emgefre : ar pik a vez embannet gant ho reizhiad.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "Pegen skedus e seblant ar paper gwenn hag ar mennozhioù. Emgefre : gwenn eo ho burev.",
+  "How bright the HUD and menus are, against paper white.": "Pegen skedus eo an HUD hag ar mennozhioù, a-enep gwenn ar paper.",
+  "How far mobs, crops and machines keep working. CPU time.": "Pegen pell e kendalc'h ar mobs, ar c'hoadoù hag ar mekanikoù da labourat. Amzer ar CPU.",
+  "How far away mobs and items are drawn, as a share of normal.": "Pegen pell e vez tennet ar mobs hag an traoù, evel ul lodenn eus ar pezh a vez graet normal.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Tremen a ra an douaroù kuzhet a-dreñv rannoù serr. Koustañ a ra kalz.",
+  "Hides entities behind opaque blocks.": "Kuzhat a ra an elfennoù a-dreñv bloc'hoù dister.",
+  "No entity occlusion culling.": "N'eus ket a zistruj entite.",
+  "CPU occlusion test runs this frame.": "Test stankañ ar CPU a gas ar framm-mañ da benn.",
+  "Occlusion checks run on a worker thread.": "Ar gwirioù stankañ a vez kaset da benn war un neudenn labourer.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Rannoù rouedek pellgarget dre framm. Eeunoc'h eo an izelañ e-pad ar c'hargañ.",
+  "Soft shadows in corners. Costs chunk building time only.": "Skeudoù dous er c'hornioù. Koustañ a ra amzer sevel a-stroll hepken.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "Skouerennoù bihanoc'h eus teñzorioù bloc'hoù evit an tachennoù pell : nebeutoc'h a sked.",
+  "Blends grass and water colours across biomes when building chunks.": "Meskañ a ra livioù ar geot hag an dour dre ar biomoù pa vez savet tammoù.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Treuzfollenn ar c'hoad : diweredekaet, plaen (buan) pe 3D (fentus).",
+  "How far clouds reach, in chunks.": "Pegen pell e tizh ar c'houmoul, e tammoù.",
+  "Draws the sky, sun, moon and stars.": "Tresañ a ra an oabl, an heol, al loar hag ar stered.",
+  "Distance fog. Off shows the edge of the loaded world.": "Brumenn pellder. Diweredekaat a ziskouez ribl ar bed karget.",
+  "Draws rain and snow.": "Tennañ a ra glav hag erc'h.",
+  "How far rain and snow fall around you.": "Pegen pell e kouezh ar glav hag an erc'h en-dro deoc'h.",
+  "How many particles effects spawn.": "Peseurt efedoù rannigoù a vez ganet.",
+  "Round shadows under mobs and items.": "Skeudennoù ront dindan mobs hag elfennoù.",
+  "Leaves with see-through gaps. Off draws them solid.": "Delioù gant toulloù gwelus. Off a denn anezho start.",
+  "Sorts water and glass more exactly behind each other.": "Renkañ a ra an dour hag ar gwer an eil a-dreñv egile.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Peseurt rann a adsevel a c'hortoz ar framm : hini ebet, e-kichen pe ho hini.",
+  "Animates water, lava, fire and other moving textures.": "Bevaat a ra an dour, al lava, an tan hag an danvezioù fiñvus all.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Pikseloù bed dre piksel skramm. Buanoc'h eo dindan 100% war ar GPU.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Eeunaat a ra ar c'hornioù ruz. FXAA: dousoc'h. TAA: an traoù eeunañ, o fiñval a c'hell heuliañ.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Bihanaat a ra ar bed hag adsevel anezhañ gant TAA. Buanoc'h, dousoc'h.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "Disoc'h HDR war ur skramm HDR : lava, tan ha gouloù an heol a lugern muioc'h.",
+  "How frames reach the screen while VSync is off.": "Penaos e tistro ar frammoù war ar skramm pa vez diweredekaet VSync.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Kousket a ra efedus betek ar framm da heul; Troioù resis, evel ar vanilha.",
+  "Fills the screen (borderless).": "Leuniañ ar skramm (hep bevennoù).",
+  "Brightens dark places.": "Sklaeraat a ra al lec'hioù teñval.",
+  "Lowers the frame rate when minimised, or idle too.": "Digreskiñ a ra ar feur framm pa vez bihanaet, pe pa vez didalvoud ivez.",
+  "Sways the view while walking.": "Heñchañ a ra ar gwel e-pad ma kerzher.",
+  "Fades newly loaded chunks in.": "Diverkañ a ra an tammoù nevez karget.",
+  "Darkens the screen's edges.": "Teñvalaat a ra ribloù ar skramm.",
+  "Shows when the world saves.": "Diskouez a ra pa savete ar bed.",
+  "Shows attack cooldown.": "Diskouez a ra an amzer yenaat evit an taolioù.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "60 FPS (30 er mennozhioù pe diskoulmet), an hanter eus al labourerien : nebeutoc'h a c'halloud.",
+  "Threads that generate, light and mesh chunks. Next start.": "Neudennoù a grou, a luc'h hag a ro troc'hadoù. Kregiñ war-lerc'h.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, neuze DirectX 12 (Windows) pe OpenGL (Linux) ma c'hwit. Kregiñ war-lerc'h.",
+  "Water and glass in one buffer: fewer draw calls, a bit more VRAM. Next start.": "Dour ha gwer en ur buffer : nebeutoc'h a c'halvoù tennañ, un tamm muioc'h a VRAM. Kregiñ war-lerc'h.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Roadennoù rouedad kaset d'ar GPU dre framm. Eeunoc'h eo an izelañ e-pad ar c'hargañ.",
+  "Frame rate and frame times over the game, with a graph.": "Feur ar framm hag an amzer framm e-pad ar c'hoari, gant ur grafik.",
+  "horizon.multiplayer.finding_friend": "O kavout bed ho mignon...",
+  "horizon.multiplayer.not_signed_in": "E mod enlinenn emañ an dafariad-mañ. En em lugañ gant ho kont Microsoft el lañser Horizon evit mont e-barzh.",
+  "horizon.multiplayer.invalid_address": "Chomlec'h servijer direizh : %s",
+  "horizon.multiplayer.connected_friend_direct": "Kevreet war-eeun ouzh ho mignon...",
+  "horizon.multiplayer.connected_friend_relay": "Kevreet ouzh ho mignon dre ar c'heflusker...",
+  "General": "Hollek",
+  "Advanced": "Araokaet",
+  "Undo": "Dizober",
+  "Search options": "Dibarzhioù klask",
+  "Shortcut": "Berradennoù",
+  "Distance": "Pellder",
+  "Display": "Diskouez",
+  "Interface": "Etrefas",
+  "Sky and weather": "Oabl hag amzer",
+  "Lighting and entities": "Gouloù hag ensavadurioù",
+  "Textures": "Teñzorioù",
+  "Image": "Skeudenn",
+  "Chunk loading": "Kargañ tammoù",
+  "Culling": "Lazhañ",
+  "Power": "Galloud",
+  "Frames": "Frammoù",
+  "Overlay": "Dreistlakaat",
+  "Output": "Disoc'h",
+  "Brightness": "Sklêrijenn",
+  "How far you see, the window and the HUD.": "Pegen pell e weler, ar prenestr hag an HUD.",
+  "The sky and weather, lighting, textures and the image.": "An oabl hag an amzer, ar gouloù, an teñzorioù hag ar skeudenn.",
+  "Chunk loading, culling and power use.": "Kargañ troc'hadoù, distrujañ hag implij ar galloud.",
+  "How frames reach the screen, and the performance overlay.": "Penaos e tistro ar frammoù d'ar skramm, hag an dreuzfollenn perzhded.",
+  "Brighter-than-white output on an HDR display.": "Disoc'h sklaeroc'h eget gwenn war ur skramm HDR.",
+  "Results for \"%s\"": "Disoc'hoù evit \"%s\"",
+  "No settings match.": "Arventennoù ebet a glot.",
+  "horizon.title.not_affiliated": "N'eo ket stag ouzh Mojang pe Microsoft",
+  "horizon.extras.header.lighting": "Gouloù",
+  "horizon.extras.header.third_person": "Trede gour",
+  "horizon.extras.header.particles": "Rannigoù",
+  "horizon.extras.header.inventory": "Enrolladenn",
+  "horizon.extras.header.chat": "Flapañ",
+  "horizon.extras.header.multiplayer": "Liesc'hoarier",
+  "horizon.extras.header.sound": "Son",
+  "horizon.extras.header.menus": "Mennozhioù",
+  "horizon.extras.dynamic_lights": "Gouloù dinamek",
+  "horizon.extras.own_name_tag": "Tikedenn anv e-unan",
+  "horizon.extras.hide_block_particles": "Kuzhat rannigoù bloc'h-torr",
+  "horizon.extras.auto_reconnect": "Adkevreañ emgefre",
+  "horizon.extras.ui_sound_reserve": "Mirout ar chadennoù evit sonioù an UI",
+  "horizon.extras.music_page": "Pajenn sonerezh",
+  "horizon.extras.mouse_tweaks": "Reolennoù kemmañ al logodenn",
+  "horizon.extras.mouse_tweaks_wheel": "Ar rod riklañ a zilec'h elfennoù",
+  "horizon.extras.sort": "Boutonoù renkañ",
+  "horizon.extras.sort_key": "Alc'hwez renkañ",
+  "horizon.extras.no_ai": "AI ebet",
+  "horizon.extras.agent_control": "Kontroll an ajañs",
+  "horizon.extras.discord_presence": "Discord Bezañs pinvidik",
+  "horizon.extras.splitscreen": "Skramm rannet",
+  "horizon.extras.chat_animation": "Flapañ eeun",
+  "horizon.extras.chat_indicator": "Merk kemennadenn",
+  "horizon.extras.wheel_cycles_settings": "Kemmañ a ra arventennoù ar rouedad riklañ",
+  "horizon.extras.pack_browser": "Merdeer pakadoù arc'hwelioù",
+  "horizon.extras.fullbright.tooltip": "Diskouez bloc'hoù hag elfennoù e-pad ar gouloù leun, zoken e lec'hioù teñval.",
+  "horizon.extras.dynamic_lights.tooltip": "Torchoù ha fontoù gouloù all dalc'het, taolet pe en tan a sklêrijenn ar bloc'hoù tro-dro dezho.",
+  "horizon.extras.own_name_tag.tooltip": "Diskouez a ra hoc'h anv a-us d'ho penn en trede gour, evel ma vez gwelet gant ar c'hoarierien all. Kuzhet pa vez kuzhet anvioù ho skipailh gant an dafariad pe pa vezit diwelus.",
+  "horizon.extras.hide_block_particles.tooltip": "Kuzhat a ra ar rannigoù lastez a darzh diwar ur bloc'h torret hag a zismantr diwar an hini a vez tennet ganeoc'h. Chom a ra rannigoù all.",
+  "horizon.extras.auto_reconnect.tooltip": "Adkemer perzh en ur servijer goude ur c'hennask kollet pe un adloc'hañ, biskoazh goude ur c'hrogad pe ur bann.",
+  "horizon.extras.ui_sound_reserve.tooltip": "Ar sonioù er bed a lez 16 eus ar 247 chadenn son digoust, setu ne c'hell ket ur bern anezho (ur splujadenn vras) sioulaat ar c'hlikoù war al lañser.",
+  "horizon.extras.music_page.tooltip": "Music & Sounds a gav ur bajenn Sonerezh... : seniñ un ton enkorfet bremañ, pe diweredekaat unan evit ma paouezfe ar c'hoari da zibab anezhañ. Ne cheñch netra betek ma vo lazhet un hent.",
+  "horizon.extras.mouse_tweaks.tooltip": "An riklañ a-zehou a laka unan dre lec'h, an riklañ a-gleiz a zastum an elfenn dalc'het, an riklañ Shift + an riklañ a-gleiz a zilec'h pep rann.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "Down a gas un elfenn eus ar rann d'an tu all, up a zegas unan en-dro.",
+  "horizon.extras.sort.tooltip": "Urzhiañ a ra an enrolladennoù, ar c'hofoù, ar barilhoù, ar c'hofoù ender hag ar boestoù shulker en urzh ivinelloù krouiñ, o kendeuziñ ar bernoù.",
+  "horizon.extras.sort_key.tooltip": "Urzhiañ a ra al lodenn dindan ar merdeer. Klikañ, ha pouezañ war un alc'hwez ; Tec'hout a zistag anezhañ.",
+  "horizon.extras.no_ai.tooltip": "Kuzhat ha diweredekaat pep elfenn AI : kontroll an ajañs, horizon-ctl hag ar servijerioù MCP. Alc'hwez al lañser ivez.",
+  "horizon.extras.agent_control.tooltip": "Hoc'h ajañs IA a c'hall c'hoari ar c'hoari-mañ dre horizon-ctl pe dre ur c'hlient MCP, war an urzhiataer-mañ hepken.",
+  "horizon.extras.discord_presence.tooltip": "Diskouez a ra C'hoari Horizon war ho profil Discord e-keit ma vez Discord o vont en-dro : mennozhioù, c'hoarier unvan pe liesc'hoarier, ar vent hag an amzer c'hoariet. Biskoazh anv ur bed pe chomlec'h ur servijer.",
+  "Calibrate...": "Kalibrañ...",
+  "Calibrate Anyway...": "Kalibrañ koulskoude...",
+  "Use Automatic Setup": "Implijout arventennoù emgefre",
+  "Shortcut: %s": "Berradennoù : %s",
+  "Next": "Da heul",
+  "HDR Calibration %s/%s: %s": "Kalibradur HDR %s/%s : %s",
+  "Sets the three below full screen, one test picture at a time.": "Lakaat a ra an tri skramm leun a-is, ur skeudenn amprouiñ bep tro.",
+  "A key that opens this screen from the game. Not bound at first.": "Un alc'hwez a zigor ar skramm-mañ eus ar c'hoari. N'eo ket stag da gentañ.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "N'eo ket bet embannet gant ho skramm pegen sklaer e teu da vezañ : kalibret evit e lakaat war-sav.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "Kefluniet dija evit ho skramm. Kalibret nemet ma seblant HDR bezañ fazius.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "Lakaat a ra ar sked uhelañ hag ar gwenn paper en-dro e kefluniadur ho skramm.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "Kefluniañ evit ho skramm. Lezel war Auto nemet pa seblant fall.",
+  "Lower it until the logo just disappears into the black.": "Izelaat anezhañ betek ma vo kollet al logo en du.",
+  "Raise it until the logo just disappears into the bright square.": "Sevel anezhañ betek ma vo kollet al logo er c'harrez skedus.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "Lakaat ar gartenn da vezañ gwenn a vo aes da sellet outi e-pad pell, er gouloù ma c'hoarier.",
+  "horizon.splitscreen.profiles.forget": "Ankounac'haat",
+  "horizon.splitscreen.profiles.create": "Krouiñ",
+  "horizon.splitscreen.profiles.you": " - c'hwi",
+  "horizon.splitscreen.profiles.forget_named": "Ankouaat %s",
+  "horizon.splitscreen.profiles.previous": "Kent",
+  "horizon.splitscreen.profiles.next": "Da heul",
+  "horizon.splitscreen.profiles.new_button": "Profil nevez...",
+  "horizon.splitscreen.profiles.forget_title": "Ankounac'haat ho profil ?",
+  "horizon.splitscreen.profiles.forget_leaves": "Kuitaat a ra roll an ensavadur-mañ.",
+  "horizon.splitscreen.profiles.forget_kept": "Miret e vez an araokadennoù hag an arventennoù er bed.",
+  "horizon.splitscreen.profiles.new_title": "Profil nevez",
+  "horizon.splitscreen.profiles.name_hint": "Anv (3 da 16 lizherenn, sifroù, _)",
+  "horizon.splitscreen.profiles.switch_title": "Cheñch profil",
+  "horizon.splitscreen.profiles.offline_note": "Ar profiloù ezlinenn a ya d'ober an ensavadur-mañ",
+  "horizon.splitscreen.profiles.move": "Dilec'hiañ el lec'h ma c'hoarier",
+  "horizon.splitscreen.profiles.move_place": "Dilec'hiañ el lec'h ma c'hoarier : %s",
+  "horizon.friends.title": "C'hoari gant mignoned",
+  "horizon.friends.hint": "Pegañ a ra ar vignoned ar c'hod goude bouton Mignoned ar skramm titl, e Kevreadur war-eeun, pe war bajenn C'hoari al lañser.",
+  "horizon.friends.copied": "Eilet",
+  "horizon.friends.copy_code": "Eilañ ar c'hod",
+  "horizon.friends.stop_sharing": "Paouez da rannañ",
+  "horizon.friends.none_yet": "Mignon ebet amañ c'hoazh.",
+  "horizon.friends.here_now": "Setu bremañ : %s",
+  "horizon.friends.share_intro": "Rannañ ar bed-mañ a-dreñv ur c'hod pediñ : digeriñ a ra d'ar LAN, ha mignoned war internet a gemer perzh gant ar c'hod. N'eus servijer ebet ac'hanomp e-barzh.",
+  "horizon.friends.start_sharing": "Kregiñ da rannañ",
+  "horizon.friends.troubleshooting": "Diskoulmañ kudennoù...",
+  "horizon.friends.stopped": "Paouezet da rannañ ar c'hod pediñ.",
+  "horizon.friends.short_code_changed": "Unan bennak a gendalc'has da glask ur c'hod berr fazius, setu m'eo cheñchet.",
+  "horizon.friends.wrong_code": "Unan bennak en deus klasket ur c'hod fall.",
+  "horizon.friends.code_ready": "Prest eo ho kod pediñ : Menü ar c'hoari, C'hoari gant mignoned. Eilañ anezhañ ha kas anezhañ d'ho mignoned.",
+  "horizon.friends.share_failed": "N'hall ket rannañ ar bed : %s",
+  "horizon.friends.finding_route": "Kavout penaos e c'hall mignoned tizhout ac'hanoc'h...",
+  "horizon.osk.shift": "Dilec'hiañ",
+  "horizon.osk.space": "Egor",
+  "horizon.osk.delete": "Dilemel",
+  "horizon.osk.type": "Seurt",
+  "horizon.osk.symbols": "Arouezioù",
+  "horizon.osk.close": "Serriñ",
+  "horizon.extras.chat_animation.tooltip": "Ur linenn flapañ nevez a zeu eus an tu kleiz e-keit ma vez o vont da get, e-lec'h dont war wel a-bezh.",
+  "horizon.extras.chat_indicator.tooltip": "Ar varrenn livet a-gleiz d'ul linenn flapañ.",
+  "horizon.extras.wheel_cycles_settings.tooltip": "Ar rod riklañ war ur bouton en arventennoù a gemm e dalvoudegezh, evel e vanilha. Diweredekaet, ne ra ar rod nemet riklañ ar roll.",
+  "horizon.extras.pack_browser.tooltip": "Dibab pakadoù arc'hwelioù a resev ur bouton Ouzhpennañ a glask Modrinth hag a staliañ ur pakad en ho teuliad pakadoù. Diweredekaet, ne vez ket darempredet ar c'hoari gant Modrinth.",
+  "horizon.extras.splitscreen.tooltip": "En ur bed e c'hall ur c'hontroller all mont e-barzh evel c'hoarier nevez : pouezit war A pa c'houlenn, ha dibabit ur profil ha pelec'h c'hoari.",
+  "horizon.splitscreen.setup.monitor": "Heuliañ %s",
+  "horizon.splitscreen.setup.monitor_unknown": "ur skramm",
+  "horizon.splitscreen.setup.window": "Prenestr %s",
+  "horizon.splitscreen.setup.new_window": "Prenestr nevez",
+  "horizon.splitscreen.setup.fill_monitor": "Leuniañ %s",
+  "horizon.splitscreen.setup.done": "Echu",
+  "horizon.splitscreen.setup.on": "War",
+  "horizon.splitscreen.setup.off": "Diweredekaet",
+  "horizon.splitscreen.setup.player": "C'hoarier %s",
+  "horizon.splitscreen.setup.revert": "Distreiñ",
+  "horizon.splitscreen.setup.apply": "Goulenn",
+  "horizon.splitscreen.setup.warning.empty_main": "Den ne c'hoari e Prenestr 1 : kuzhat a ra",
+  "horizon.splitscreen.setup.warning.empty_close": "Den ne c'hoari e Prenestr %s : serriñ a ra war Apply",
+  "horizon.splitscreen.setup.warning.empty_new": "Den ne c'hoari e Prenestr %s : ne vo ket digoret",
+  "horizon.splitscreen.setup.warning.on_main": "Prenestr %s a leun skramm ar prenestr 1 : e c'hoarierien a c'hoari e prenestr 1",
+  "horizon.splitscreen.setup.warning.unplugged": "N'eo ket kevreet skramm ar Prenestr %s : c'hoari a ra e c'hoarierien e Prenestr 1",
+  "horizon.splitscreen.setup.status.off": "Diweredekaet eo ar skramm rannet.",
+  "horizon.splitscreen.setup.status.enable_hint": "Lakait anezhañ war enaou, ha pouezit war ur bouton war ur c'hontroller all en ur bed.",
+  "horizon.splitscreen.setup.status.join_hint": "Pouezit war A evit mont e-barzh ha dibab ur profil.",
+  "horizon.splitscreen.setup.status.idle": "Skramm rannet didalvoud",
+  "horizon.splitscreen.setup.status.alone": "C'hoarier lec'hel all ebet.",
+  "horizon.splitscreen.setup.status.solo_controls": "Ar c'hontrolloù solo hag an evezhiadennoù kontroller n'int ket cheñchet.",
+  "horizon.splitscreen.setup.window_empty": "Prenestr %s: goullo",
+  "horizon.splitscreen.setup.note.select": "Klikit war ur c'hoarier, pe riklañ anezhañ betek ur prenestr pe ur skramm.",
+  "horizon.splitscreen.setup.note.apply": "Arverañ evit c'hoari evel-se, Distreiñ evit distreiñ.",
+  "horizon.splitscreen.setup.note.place": "Pelec'h e tlefe %s c'hoari ?",
+  "horizon.splitscreen.setup.this_player": "ar c'hoarier-mañ",
+  "horizon.splitscreen.setup.switch_disabled": "Lazhañ a ra ar skramm rannet ur wech ma'z a ar re all kuit (o lañser paouez).",
+  "horizon.splitscreen.setup.window_place": "Prenestr %s (%s eus %s)",
+  "horizon.splitscreen.setup.names": "Anvioù",
+  "horizon.splitscreen.setup.identify": "Anavezout",
+  "horizon.splitscreen.setup.layout.two": "2 rannañ : %s",
+  "horizon.splitscreen.setup.layout.three": "3 rannañ : %s",
+  "horizon.splitscreen.setup.layout.two.0": "Emgefreek",
+  "horizon.splitscreen.setup.layout.two.1": "Kichen-ha-kichen",
+  "horizon.splitscreen.setup.layout.two.2": "Krec'h ha traoñ",
+  "horizon.splitscreen.setup.layout.three.0": "Unan ledan war-c'horre",
+  "horizon.splitscreen.setup.layout.three.1": "Unan uhel a-gleiz",
+  "horizon.splitscreen.setup.layout.three.2": "Kichen-ha-kichen",
+  "horizon.splitscreen.setup.help.player": "Klikañ pe riklañ %s evit o dilec'hiañ.",
+  "horizon.splitscreen.setup.help.layout_auto": "%s (kichen-ha-kichen pa vez ledan ar prenestr). Pouezit evit cheñch.",
+  "horizon.splitscreen.setup.help.layout": "%s. Pouezit evit cheñch.",
+  "horizon.splitscreen.setup.help.switch": "Skramm rannet evit an urzhiataer-mañ, war pe get.",
+  "horizon.splitscreen.setup.help.identify": "Gwel pep c'hoarier a ziskouez e peseurt prenestr emañ.",
+  "horizon.splitscreen.setup.help.names": "Anv pep c'hoarier e korn o gwel.",
+  "horizon.splitscreen.setup.help.revert": "Dilemel ar c'hemmoù n'int ket bet arveret c'hoazh.",
+  "horizon.splitscreen.setup.help.apply": "C'hoari evel ma tiskouez ar gartenn.",
+  "horizon.splitscreen.setup.help.unchanged": "N'eus netra cheñchet c'hoazh.",
+  "horizon.splitscreen.setup.give_up_pad": "Pad dilezel",
+  "horizon.splitscreen.prompt.controller_connected": "Reoler kevreet",
+  "horizon.splitscreen.prompt.controller_disconnected": "Diskennet eo ar c'hontroller",
+  "horizon.splitscreen.prompt.controller_disconnected.hint": "Adkevreit anezhañ, pe pouezit war ur bouton war unan all",
+  "horizon.splitscreen.prompt.join.one": "%s a fell dezhañ mont e-barzh",
+  "horizon.splitscreen.prompt.join.many": "%s kontrollerien a fell dezho kemer perzh",
+  "horizon.splitscreen.prompt.join.yes": "Kemer perzh",
+  "horizon.splitscreen.prompt.join.as_p1": "C'hoari evel P1",
+  "horizon.splitscreen.prompt.join.no": "Nann",
+  "horizon.splitscreen.prompt.lost": "%s: distaget eo ar c'hontroller",
+  "horizon.splitscreen.prompt.lost.use_another": "Implijout unan all",
+  "horizon.splitscreen.prompt.lost.leave": "Kuitaat",
+  "horizon.splitscreen.setup.help.give_up_pad": "Paouez a ra ho kontroller da gas ac'hanoc'h ha kinniget e vez deoc'h mont e-barzh (A).",
+  "horizon.splitscreen.setup.note.held_at": "%s da %s: A a laka anezhañ da gouezhañ amañ, B a laka anezhañ en-dro.",
+  "horizon.splitscreen.setup.note.held": "%s dastumet : dibaboù kleiz/dehou e-lec'h ma kouezh A, B a laka anezhañ en-dro.",
+  "horizon.splitscreen.online_only": "E mod enlinenn emañ ar servijer-mañ : n'hall ket ar profiloù ezlinenn mont e-barzh, pep c'hoarier en deus ezhomm eus e gont Minecraft.",
+  "horizon.splitscreen.own_account": "Ezhomm en deus ar servijer-mañ eus ur gont Minecraft evit pep c'hoarier",
+  "horizon.splitscreen.local_only": "Ar c'hoarierien all ne c'hallont mont e-barzh ar servijer-mañ nemet gant o c'hont Minecraft o-unan : ar profiloù ezlinenn a c'hoari en ho bed, war LAN pe war ur servijer war ho rouedad lec'hel.",
+  "Hides models behind opaque blocks. Async checks off-thread; entities tick.": "Kuzhat a ra ar patromoù a-dreñv bloc'hoù dister. Gwiriañ a ra an async e-maez an neudennad; tik an entiteoù.",
+  "Block Entities": "Entiteoù stankañ",
+  "Shulker Boxes": "Boestoù Shulker",
+  "Reuses settled boxes; lid movement stays animated.": "Adimplij a ra ar voestoù staliet; fiñv ar golo a chom bev.",
+  "Signs": "Sinoù",
+  "Reuses sign text until text, light, or font changes.": "Adlakaat a ra testenn ar sin betek ma cheñcho an destenn, ar gouloù pe ar font.",
+  "Decorated Pots": "Podoù kinklet",
+  "Reuses still pots; break wobble and sherd changes redraw.": "Adimplij a ra podoù c'hoazh; terriñ ar c'hrennlazh hag ar c'hemmoù strinkañ adtresañ.",
+  "Bells": "Klochennoù",
+  "Reuses still bells; ringing stays animated.": "Adimplij a ra kloc'hioù c'hoazh; chom a ra bevaat ar sonerezh.",
+  "Chests": "Kofoù",
+  "Reuses closed chests; moving lids stay animated.": "Adimplij ar c'houfr serr; ar goloioù o fiñval a chom bev.",
+  "Banners": "Bannieloù",
+  "Reuses poles; flags and pattern layers still update.": "Adimplij ar palioù; hizivaet c'hoazh ar bannieloù hag ar gwiskadoù patromoù.",
+  "Copper Golem Statues": "Delwennoù golem kouevr",
+  "Reuses statue geometry until its block state changes.": "Adlakaat a ra geometriezh an delwenn betek ma cheñcho he stad bloc'h.",
+  "Leaf Culling": "Lazhañ delioù",
+  "Every leaf face. Vanilla's fancy leaves.": "Pep delienn dremm. Delioù fentus ar vanilha.",
+  "Distant Plant Dither": "Tremen a ra ar plant pell",
+  "Keeps fine plants in high-res packs from fading far away.": "Mirout a ra ar plant fin e pakadoù uhel o resolution da vont da get pell.",
+  "Screenshot Quality": "Kalite ar skramm",
+  "F2 screenshots at this many times the game's resolution. Higher takes longer.": "Skeudennoù skramm F2 gant kement-se meur a wech diarunusted ar c'hoari. Uheloc'h a bad hiroc'h.",
+  "Frame Generation": "Krouiñ frammoù",
+  "Shows a made-up frame between each two real ones: smoother, a little more lag.": "Diskouez a ra ur framm savet etre pep daou hini gwirion : eeunoc'h, un tamm muioc'h a zilez.",
+  "Shadow Cache": "Grubuilh skeud",
+  "Reuses the pack shadow map when sun, view and world match. Off by default.": "Adimplij ar gartenn skeud pakad pa glot an heol, ar gwel hag ar bed. Diweredekaet dre ziouer.",
+  "Find BlueMap": "Kavout BlueMap",
+  "On servers, finds their BlueMap web map for far terrain. Next join.": "War ar servijerioù e kaver o gartenn web BlueMap evit an tachennoù pell. Kemer perzh da heul.",
+  "BlueMap Radius": "Radius ar gartenn glas",
+  "How far around you BlueMap tiles are downloaded. Next join.": "Pegen pell tro-dro deoc'h e vez pellgarget teulioù BlueMap. Kemer perzh da heul.",
+  "Synchronous": "Sinkron",
+  "Asynchronous": "Azinkron",
+  "Solid Aggressive": "Tagus kreñv",
+  "Hollow": "Toull",
+  "Leaves fully inside a canopy draw solid: fewer see-through layers.": "Delioù penn-da-benn e-barzh ur c'hoad a denn solut : nebeutoc'h a gwiskadoù treuzwelus.",
+  "Leaves with one open side draw solid too: faster, chunkier edges.": "Ar delioù gant un tu digor a denn ivez : bordoù buanoc'h ha stankoc'h.",
+  "Drops faces between leaves: faster, but gaps look through.": "Lakaat a ra fazioù etre ar delioù : buanoc'h, met toulloù a sell drezo.",
+  "Hotbar: Previous Slot": "Barrenn-dre-lien : Lec'h a-raok",
+  "Hotbar: Next Slot": "Barrenn-dre-lien : Lec'h war-lerc'h",
+  "horizon.agent.connected.one": "Kevreet : 1 kevreadenn ajañs",
+  "horizon.agent.connected.many": "Kevreet : %s kevreadennoù an ajañs",
+  "horizon.agent.connected.one_ago": "Kevreet : 1 kevreadenn ajañs, ur gemennadenn ziwezhañ %s s zo",
+  "horizon.agent.connected.many_ago": "Kevreet : %s kevreadennoù an ajañs, ar gemennadenn ziwezhañ %s s zo",
+  "horizon.agent.waiting": "O c'hortoz un ajañs.",
+  "horizon.agent.off": "Diweredekaet : n'hall ket an ajañsoù tizhout ar c'hoari-mañ.",
+  "horizon.agent.session_opened": "Digoret evit ar prantad-mañ gant ar programm en deus kroget ar c'hoari.",
+  "horizon.agent.socket": "Socket: %s (eilañ ar munudoù evit e hent klok)",
+  "horizon.agent.local_only": "Lec'hel hepken : an ajañsoù war an urzhiataer-mañ, biskoazh ar rouedad.",
+  "Auto (%s nits)": "Emgefre (%s nits)",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Kuzhat a ra ar patromoù a-dreñv bloc'hoù dister. Hizivaat an ensavadurioù. Dilezet gant pakadoù personelaet.",
+  "horizon.extras.repro_keys": "Berradennoù enrollañ",
+  "horizon.extras.repro_keys.tooltip": "F3+R a grog pe a paouez gant un enrolladenn advouezhiañ ha F3+E a skriv e strollad. Diweredekaet dre ziouer : un enrolladenn a eil ar bed.",
+  "horizon.agent.record_session": "Kregiñ gant an enrollañ",
+  "horizon.agent.record_stop": "Paouez gant an enrollañ",
+  "horizon.agent.export_repro": "Ezporzhiañ ar pakad advouezhiañ",
+  "horizon.repro.started": "Kroget eo an enrollañ ; F3+R a harz anezhañ hag a skriv ar pakad.",
+  "horizon.repro.stopped": "Paouezet gant an enrollañ : %s",
+  "horizon.repro.bundle": "Pakad advouezhiañ : %s",
+  "horizon.repro.no_recording": "N'eus enrolladenn ebet da ezporzhiañ c'hoazh.",
+  "horizon.repro.replay_started": "Adc'hoari kroget : %s",
+  "horizon.pack.addInfo": "Ouzhpennañ ur pakad arc'hwelioù adalek Modrinth",
+  "horizon.pack.addWorking": "Goulenn Modrinth...",
+  "horizon.pack.addNone": "N'eus bet kavet pakad arc'hwel ebet",
+  "horizon.pack.addTitle": "Ouzhpennañ ur pakad arc'hwelioù",
+  "horizon.pack.install": "Staliañ",
+  "horizon.pack.installing": "O staliañ",
+  "horizon.pack.installed": "Staliet",
+  "horizon.pack.search": "Klask",
+  "horizon.pack.searchHint": "Klask Modrinth...",
+  "horizon.pack.filters": "Siloù",
+  "horizon.pack.filter.realistic": "Gwirvoudel",
+  "horizon.pack.filter.simplistic": "Eeun",
+  "horizon.pack.filter.vanillaLike": "Heñvel ouzh ar vanilha",
+  "horizon.pack.addFailed": "N'haller ket ouzhpennañ ar pakad : %s",
+  "horizon.extras.header.cosmetics": "Kosmetikoù",
+  "horizon.extras.cosmetics_mine": "Ma kosmetikoù",
+  "horizon.extras.cosmetics_mine.tooltip": "Kuzhet : pep c'hoarier Horizon a wel ac'hanoc'h hep ho kosmetikoù, c'hwi en o zouez. Ar memes treuzfurmadur hag armel al lañser.",
+  "horizon.extras.cosmetics_others": "Kosmetikoù ar c'hoarierien all",
+  "horizon.extras.cosmetics_others.tooltip": "Ar pezh a vez gwisket gant ar c'hoarierien Horizon all : pep tra, o doareoù tikedenn anv hepken, pe netra. Kuzhet, ar c'hoari ne c'houlenn ket biskoazh petra a wiskont.",
+  "horizon.extras.cosmetics_auras": "Auraoù ha roudoù tud all",
+  "horizon.extras.cosmetics_auras.tooltip": "Auraoù ha roudoù a vez gwisket gant c'hoarierien all. Diweredekaet dre ziouer.",
+  "horizon.extras.cosmetics.shown": "Diskouezet",
+  "horizon.extras.cosmetics.hidden": "Kuzhet",
+  "horizon.extras.cosmetics.name_tags": "Tikedennoù anvioù hepken"
+}