Merge pull request #9913 from Mayonesu0/fix/native-build-smart-app-control-5911

🤖 Agent: The launcher code is identical to what I tested in a union on main dd675b574 (launcher fmt, clippy -D warnings, 699 tests green). With no check before the build, a machine whose build programs ran before Smart App Control was turned on still builds (Mayonesu0's case 1), and only an os error 4551 leads the error with the explanation.

.github/trusted-reviewers.txt

@@ -1,10 +1,16 @@
-# Trusted reviewers: one list for two things (docs/release-flow.md "Trusted reviewers").
+# Trusted reviewers: one list for three things (docs/release-flow.md "Trusted reviewers").
 # - `/nightly 2640 2642` picks the pull requests the Nightly holds (tools/ci/nightly_set.py);
-# - `/close`, `/reopen`, `/label`, `/unlabel` triage issues and pull requests (tools/ci/triage_command.py).
-# Ludovic is always allowed and isn't listed. One GitHub login per line, with who added it and when. Removing a
-# line revokes that login at once. A line with only `paused` stops both for every reviewer (Ludovic's still work).
-kacpherek    # added by Ludovic, 2026-10-27
-rdbtCVS      # added by Ludovic, 2026-10-27
-Online5277   # added by Ludovic, 2026-10-27 (his top three by merged pull requests)
-levzzz5154   # added by Ludovic, 2026-10-28 (Horizon Team; author of horizon-mixins)
-Qwerner88880 # added by Ludovic, 2026-10-31 (Discord vladislav_hagen; native-mod hooks)
+# - `/close`, `/reopen`, `/label`, `/unlabel` triage issues and pull requests (tools/ci/triage_command.py);
+# - `/unclaim @login` releases someone else's claim, and listed reviewers have no claim limit (tools/ci/claim_command.py).
+# One reviewer per line: `<numeric GitHub ID> <login>`, with who added it and when. The ID decides; the login is only
+# for people reading this file and for messages. A login is a name anyone can claim once its owner renames or deletes
+# the account; an ID is never reused. Get it with `gh api users/<login> --jq .id`, or run
+# `python3 tools/ci/resolve_reviewer_ids.py` to fill in the IDs and `--check` to catch renames.
+# A line in any other form (a bare login included) grants nothing. Ludovic is always allowed (OWNER_ID in
+# tools/ci/nightly_set.py) and isn't listed. Removing a line revokes that account at once. A line with only `paused`
+# stops all three for every reviewer (Ludovic's still work).
+54669067 kacpherek       # added by Ludovic, 2026-10-27
+87152661 rdbtCVS         # added by Ludovic, 2026-10-27
+84875247 Online5277      # added by Ludovic, 2026-10-27 (his top three by merged pull requests)
+86072227 levzzz5154      # added by Ludovic, 2026-10-28 (Horizon Team; author of horizon-mixins)
+87478350 Qwerner88880    # added by Ludovic, 2026-10-31 (Discord vladislav_hagen; native-mod hooks)

.github/workflows/ci.yml

@@ -242,6 +242,18 @@ jobs:
           $output = & $launcher --version 2>&1
           if ($LASTEXITCODE -ne 0 -or -not $output) { throw 'horizon-launcher --version failed' }
           Write-Output ($output -join "`n")
+      - name: Build a native-mod game with the launcher's managed toolchain
+        working-directory: launcher
+        shell: pwsh
+        env:
+          HORIZON_LAUNCHER_HOME: ${{ runner.temp }}\horizon-native-arm64-toolchain
+          HORIZON_NATIVE_TARGET_DIR: ${{ runner.temp }}\horizon-native-arm64-toolchain\target
+        run: |
+          $ErrorActionPreference = 'Stop'
+          cargo test --release --locked --target aarch64-pc-windows-msvc --lib rust_toolchain::tests::managed_arm64_toolchain_builds_the_game -- --ignored --exact --nocapture
+          $client = Join-Path $env:HORIZON_NATIVE_TARGET_DIR 'fast/horizon-client.exe'
+          python ../tools/check_pe_arch.py arm64 $client
+          python ../tools/check_imports.py $client
   # Most pull requests leave the harnesses to parity-main, which runs them on main a batch of merges at a time
   # (.github/workflows/parity-main.yml; releases wait for it). A pull request still runs them itself when it changes
   # a harness, an oracle, a probe or the runner, or carries the run-parity label (run-parity.yml, when it is added).
@@ -264,7 +276,7 @@ jobs:
         run: |
           changed=$(git diff --name-only "$(git merge-base "$BASE_SHA" HEAD)" HEAD)
           harness=$(grep -E '^(tools/test_[a-z0-9_]+_parity\.py|tools/(parity[a-z_]*|lab)\.py|tools/parity_hosts\.json|mods/horizon/src/test/|crates/[^/]+/examples/|crates/horizon-client/src/game/[a-z_]*(fixture|harness)\.rs|\.github/workflows/parity[a-z-]*\.yml)' <<< "$changed" || true)
-          if [ -n "$harness" ] || [[ " $LABELS " == *" run-parity "* ]]; then
+          if [ -n "$harness" ] || [[ " $LABELS " == *" run-parity "* ]] || [[ " $LABELS " == *" frame-identity "* ]]; then
             echo "run=true" >> "$GITHUB_OUTPUT"
             echo "The pull request runs its harnesses: ${harness:-label run-parity}"
           else
@@ -279,6 +291,7 @@ jobs:
       base: ${{ github.event.pull_request.base.sha }}
       head: ${{ github.event.pull_request.head.sha }}
       full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}
+      frame_identity: ${{ contains(github.event.pull_request.labels.*.name, 'frame-identity') }}
   # Horizon never downloads the game. These jobs need a self-hosted Linux runner
   # (label horizon-game) holding the maintainer's own copy: the official launcher's
   # game directory in HORIZON_MINECRAFT_DIR and the pinned server jar in

.github/workflows/claim-command.yml

@@ -50,6 +50,8 @@ jobs:
           GH_TOKEN: ${{ github.token }}
           BODY: ${{ github.event.comment.body }}
           AUTHOR: ${{ github.event.comment.user.login }}
+          # Who may act is decided by this numeric ID: a login can be claimed by someone else after a rename.
+          AUTHOR_ID: ${{ github.event.comment.user.id }}
           ISSUE: ${{ github.event.issue.number }}
           COMMENT_ID: ${{ github.event.comment.id }}
           REPO: ${{ github.repository }}

.github/workflows/nightly-build.yml

@@ -165,11 +165,15 @@ jobs:
           path: dist
           pattern: horizon-*
           merge-multiple: true
-      - name: Sign the checksums (SHA256SUMS, SHA256SUMS.sig) for the nightly channel
+      - name: Sign the checksums for the nightly channel (SHA256SUMS.sig) and for this build (SHA256SUMS.v2.sig)
+        # SHA256SUMS.sig is for launchers from before v2 (signed for "nightly"); SHA256SUMS.v2.sig is signed for
+        # nightly-<date>-<commit>, the version the release title names, which current launchers and servers
+        # require (docs/security.md, "Nightly signatures"). The publish step titles the release from the same values.
         env:
           RELEASE_SIGNING_KEY: ${{ secrets.RELEASE_SIGNING_KEY }}
           RELEASE_SIGNING_KEY_NEXT: ${{ secrets.RELEASE_SIGNING_KEY_NEXT }}
           EPHEMERAL: ${{ needs.pick.outputs.dry_run == 'true' && 'yes' || '' }}
+          ALSO_FOR: nightly-${{ needs.pick.outputs.date }}-${{ needs.pick.outputs.short }}
         run: |
           # Windows ARM64's build may fail without holding the Nightly (game-build.yml): then it is left out.
           arm64=(); if [[ -f dist/horizon-windows-arm64.zip ]]; then arm64=(dist/horizon-windows-arm64.zip)
@@ -208,12 +212,17 @@ jobs:
         with:
           path: dist
           merge-multiple: true
-      - name: The signature, checked as launchers check it
+      - name: The signatures, checked as launchers check them
         env:
           EPHEMERAL: ${{ needs.pick.outputs.dry_run == 'true' && 'yes' || '' }}
+          DATE: ${{ needs.pick.outputs.date }}
+          SHORT: ${{ needs.pick.outputs.short }}
         run: |
           key=(); [[ -n "$EPHEMERAL" ]] && key=(--key "$(cat dist/ephemeral.pub)")
           cargo run --locked --quiet -p horizon-release-sign -- verify --tag nightly --publishing "${key[@]}" dist
+          # The version's own signature, which current launchers require: the title below names the same version.
+          cargo run --locked --quiet -p horizon-release-sign -- verify --tag "nightly-${DATE}-${SHORT}" \
+            --signature SHA256SUMS.v2.sig --publishing "${key[@]}" dist
       - name: Ready to publish (the smoke test drew a world, no release-blocker is open)
         # Right before publishing, as for a release: an issue labelled while the builds ran still holds it. A dry run
         # only reports what a real run would do (that is how a blocker's fix is tried).
@@ -230,12 +239,16 @@ jobs:
         env:
           GH_TOKEN: ${{ github.token }}
           SHA: ${{ needs.pick.outputs.sha }}
+          SHORT: ${{ needs.pick.outputs.short }}
           DATE: ${{ needs.pick.outputs.date }}
           SOURCE_TAG: ${{ needs.pick.outputs.source_tag }}
         run: |
           set -euo pipefail
           python3 tools/ci/nightly.py rotate
           signature=(); [[ -f dist/SHA256SUMS.sig ]] && signature=(dist/SHA256SUMS.sig)
+          [[ -f dist/SHA256SUMS.v2.sig ]] && signature+=(dist/SHA256SUMS.v2.sig)
+          # The title is what launchers parse (strictly) into the version SHA256SUMS.v2.sig is signed for.
+          [[ "${SHA:0:7}" == "$SHORT" ]] || { echo "::error::the build's commit isn't the one signed"; exit 1; }
           # The ARM64 archive only when its build succeeded (the sign job left it out of SHA256SUMS otherwise).
           arm64=()
           if [[ -f dist/horizon-windows-arm64.zip ]]; then

.github/workflows/nightly-command.yml

@@ -41,6 +41,8 @@ jobs:
           GH_TOKEN: ${{ github.token }}
           BODY: ${{ github.event.comment.body }}
           AUTHOR: ${{ github.event.comment.user.login }}
+          # Who may act is decided by this numeric ID: a login can be claimed by someone else after a rename.
+          AUTHOR_ID: ${{ github.event.comment.user.id }}
           ISSUE: ${{ github.event.issue.number }}
           COMMENT_URL: ${{ github.event.comment.html_url }}
         run: python3 tools/ci/nightly_set.py command

.github/workflows/parity.yml

@@ -20,6 +20,12 @@ on:
           busy the job waits for it.
         type: boolean
         default: false
+      frame_identity:
+        description: >-
+          The pull request carries the frame-identity label: it must leave the picture alone (HDR, shader packs), so
+          the frame_identity harness, which no automatic selection picks, runs too.
+        type: boolean
+        default: false
 permissions:
   contents: read
 env:
@@ -87,6 +93,12 @@ jobs:
           PARITY_HOSTS: ''
           BASE_SHA: ${{ steps.merge.outputs.base }}
         run: python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400  # world_spawn takes ~1480 s on a busy runner
+      - name: The pictures this change must leave alone
+        if: ${{ !cancelled() && inputs.frame_identity }}
+        env:
+          PARITY_HOSTS: ''
+          BASE_SHA: ${{ steps.merge.outputs.base }}
+        run: python3 tools/parity.py frame_identity --timeout 2400
       - name: Logs of the failed harnesses
         if: failure()
         uses: actions/upload-artifact@v7

.github/workflows/run-parity.yml

@@ -27,3 +27,4 @@ jobs:
       base: ${{ github.event.pull_request.base.sha }}
       head: ${{ github.event.pull_request.head.sha }}
       full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}
+      frame_identity: ${{ contains(github.event.pull_request.labels.*.name, 'frame-identity') }}

.github/workflows/triage-command.yml

@@ -43,6 +43,8 @@ jobs:
           GH_TOKEN: ${{ github.token }}
           BODY: ${{ github.event.comment.body }}
           AUTHOR: ${{ github.event.comment.user.login }}
+          # Who may act is decided by this numeric ID: a login can be claimed by someone else after a rename.
+          AUTHOR_ID: ${{ github.event.comment.user.id }}
           ISSUE: ${{ github.event.issue.number }}
           REPO: ${{ github.repository }}
           COMMENT_URL: ${{ github.event.comment.html_url }}

AGENTS.md

@@ -9,8 +9,10 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
 - **Never commit Mojang's files**: game jars, assets, decompiled source, prepared resources (`.local/`).
   `tools/check_public_tree.py` rejects them; `git config core.hooksPath .githooks` runs it on commit.
 - **Keep your runs away from real player data.** Any game or launcher you start gets fresh `mktemp -d`
-  folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
-  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`, and, for the
+  folders in `HORIZON_HOME` (logs, crash reports, telemetry consent, recordings; not saves), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
+  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`. Saves, `options.txt` and
+  caches go in the game folder, by default the working directory: start the game from a scratch folder with
+  `--game-dir` pointing at it, or they land in the repo root, hidden by `.gitignore`. For the
   launcher, `HORIZON_LAUNCHER_TRASH`, `HORIZON_LAUNCHER_CLIPBOARD` and `HORIZON_LAUNCHER_DESKTOP` pointing into the scratch home. Never write to
   `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`.
 - **Mark what an agent posts.** A PR body starts with a line naming the person whose agent opened it and

Cargo.lock

@@ -1318,6 +1318,7 @@ dependencies = [
  "ab_glyph",
  "bytemuck",
  "chrono",
+ "dunce",
  "flate2",
  "fs4",
  "gilrs",
@@ -1400,6 +1401,7 @@ dependencies = [
  "chrono",
  "flate2",
  "fs4",
+ "getrandom 0.3.4",
  "gilrs",
  "glam",
  "horizon-anticheat",
@@ -1715,6 +1717,7 @@ dependencies = [
  "horizon-mcp",
  "horizon-release-sign",
  "horizon-server-files",
+ "horizon-world",
  "libc",
  "p12-keystore",
  "png",

ROADMAP.md

@@ -206,7 +206,7 @@ Manage a server from a console, ban and pardon players, and drive it from other
 
 <details><summary>Technical</summary>
 
-`horizon-server console` (a text interface), `ban`, `pardon`, `ban-ip` and `mcp` over stdio. Admin API additions: the player list, kick, ban, op and whitelist, an SSE stream of logs and events, a text metrics endpoint, config GET and PATCH, backup delete and download. The panel's later features (bans, worlds, server.properties import, logs and crash reports, modpacks) and vanilla's management protocol (the JSON-RPC over WebSocket that the `management-server-*` keys configure), so vanilla's tools can manage a Horizon server. [docs/server.md](docs/server.md), [docs/api/server.md](docs/api/server.md).
+`horizon-server console` (a text interface), `ban`, `pardon`, `ban-ip` and `mcp` over stdio. Admin API additions: the player list, kick, ban, op and whitelist, an SSE stream of logs and events, a text metrics endpoint, config GET and PATCH, backup delete and download. The last pieces merged: bans edited while the server is stopped ([#9767](https://github.com/horizon-rust/horizon/issues/9767)) and the MCP tools' contracts pinned by a test ([#9748](https://github.com/horizon-rust/horizon/issues/9748)). The panel's later features and vanilla's management protocol are their own item (server-panel-management). [docs/server.md](docs/server.md), [docs/api/server.md](docs/api/server.md).
 
 </details>
 
@@ -396,6 +396,16 @@ A Datapacks tab beside Mods and Resource packs: install into a chosen world's da
 
 ### Servers and multiplayer
 
+#### Server panel extras and vanilla's management protocol
+
+More of a server managed from its web panel (bans, worlds, logs and crash reports, modpacks), and vanilla's own server-management tools working with a Horizon server.
+
+<details><summary>Technical</summary>
+
+The panel's later features (bans, worlds, server.properties import, logs and crash reports, modpacks) and vanilla's management protocol (the JSON-RPC over WebSocket that the `management-server-*` keys configure), so vanilla's tools can manage a Horizon server. Split from server-admin. [docs/server.md](docs/server.md), [docs/api/server.md](docs/api/server.md).
+
+</details>
+
 #### Ely.by and other sign-in providers
 
 Sign in with other account providers, such as Ely.by or any Yggdrasil-compatible one, beside Microsoft.
@@ -600,16 +610,6 @@ An output device list in Music & Sounds, falling back to the system default. [#1
 
 </details>
 
-#### Play in your language
-
-Item names, container titles and server messages follow the language you pick, as in vanilla. Today parts of the game stay in English.
-
-<details><summary>Technical</summary>
-
-Translatable components resolved through the selected language for items, containers and server text ([#1806](https://github.com/horizon-rust/horizon/issues/1806)), on top of the bundled languages the prepared resources carry ([#1594](https://github.com/horizon-rust/horizon/issues/1594)). Left: the client's own screens ([#1672](https://github.com/horizon-rust/horizon/issues/1672)) and the main menu with zh_cn.
-
-</details>
-
 ### Rendering
 
 #### A light default shader pack
@@ -860,30 +860,11 @@ More: [https://playhorizon.dev/docs/performance](https://playhorizon.dev/docs/pe
 
 </details>
 
-### Gameplay parity
-
-#### End city banners keep their pattern
-
-Banners in End cities show as plain magenta instead of with their pattern.
-
-<details><summary>Technical</summary>
-
-Compare the banner block entities the End city templates place with vanilla's (`EndCityPieces`, the templates' block entity NBT, `BannerBlockEntity`'s patterns), in `crates/horizon-world/src/worldgen/structure/`. Issue [#1438](https://github.com/horizon-rust/horizon/issues/1438); possibly related: [#526](https://github.com/horizon-rust/horizon/issues/526). The templates' block entities now keep their patterns ([#1928](https://github.com/horizon-rust/horizon/issues/1928)).
-
-</details>
-
-#### Enchanted loot in End cities
-
-Armour and tools in End city chests should come enchanted, as in vanilla.
-
-<details><summary>Technical</summary>
-
-`loot.rs` implements `enchant_with_levels`: find why the End city chest table's rolls come out bare, and compare them with vanilla's for a few seeds. Issues [#1437](https://github.com/horizon-rust/horizon/issues/1437), [#1660](https://github.com/horizon-rust/horizon/issues/1660). The loot's enchantment functions now reach every table that rolls ([#1911](https://github.com/horizon-rust/horizon/issues/1911), [#2037](https://github.com/horizon-rust/horizon/issues/2037)).
-
-</details>
-
 ## Recently shipped
 
+- **Enchanted loot in End cities** (v0.2.73): Armour and tools in End city chests should come enchanted, as in vanilla. [#1437](https://github.com/horizon-rust/horizon/issues/1437) · [#1660](https://github.com/horizon-rust/horizon/issues/1660) · [#1911](https://github.com/horizon-rust/horizon/issues/1911) · [#2037](https://github.com/horizon-rust/horizon/issues/2037)
+- **End city banners keep their pattern** (v0.2.67): Banners in End cities show as plain magenta instead of with their pattern. [#1438](https://github.com/horizon-rust/horizon/issues/1438) · [#526](https://github.com/horizon-rust/horizon/issues/526) · [#1928](https://github.com/horizon-rust/horizon/issues/1928)
+- **Play in your language** (v0.2.65): Item names, container titles and server messages follow the language you pick, as in vanilla. Today parts of the game stay in English. [#1806](https://github.com/horizon-rust/horizon/issues/1806) · [#1594](https://github.com/horizon-rust/horizon/issues/1594) · [#1672](https://github.com/horizon-rust/horizon/issues/1672)
 - **Chickens flap while they fall** (v0.2.67): Chickens should flap their wings while they fall, not stand still in the air. [#1706](https://github.com/horizon-rust/horizon/issues/1706) · [#1892](https://github.com/horizon-rust/horizon/issues/1892)
 - **Ctrl+Backspace and scroll bars in menus** (v0.2.67): Ctrl+Backspace should delete a whole word in the creative search, and every list's scroll bar should be draggable. [#1764](https://github.com/horizon-rust/horizon/issues/1764) · [#1782](https://github.com/horizon-rust/horizon/issues/1782) · [#1884](https://github.com/horizon-rust/horizon/issues/1884) · [#1931](https://github.com/horizon-rust/horizon/issues/1931)
 - **A pointing hand over buttons** (v0.2.67): The mouse pointer should turn into a pointing hand over menu buttons, as in vanilla 26.3. [#1347](https://github.com/horizon-rust/horizon/issues/1347) · [#1897](https://github.com/horizon-rust/horizon/issues/1897)

THIRD_PARTY_NOTICES.md

@@ -170,3 +170,45 @@ BlueMap is licensed under the MIT license:
 > LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 > OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 > THE SOFTWARE.
+
+## JOML
+
+`crates/horizon-client-render/src/camera.rs` (`joml::Mat4::rotation`, `invert_orthonormal`) and
+`crates/horizon-client-render/src/gfx/pack_uniforms.rs` (`invert_generic`, `invert_affine`, the
+formulas of `pack_projection` and `shadow_ortho`) adapt the float arithmetic of
+`Matrix4f.rotation(Quaternionfc)`, `invertOrthonormal`, `invertGenericNonThis`, `invertAffine`,
+`setPerspective` and `setOrtho` from
+[JOML](https://github.com/JOML-CI/JOML/tree/faf9eef2511242122beb6055fe3da92daed214c5) 1.10.9, the
+library vanilla 26.3 uses, so that shader packs get the same matrices to the last bit. Changes:
+ported to Rust; the pack_uniforms.rs functions drop JOML's property flags, and
+`pack_projection` works the formula in doubles. The copyright line and license notice also head
+both files.
+
+`camera.rs` also adapts `Quaternionf.rotationX`, `rotationY` and `rotationZ`,
+`Matrix4f.rotateAffine` and `Vector4f.mulAffine` (`joml::Quat::rotation_x`/`_y`/`_z`,
+`joml::Mat4::rotate_affine`, `transform_affine`), for the sky's positions shader packs read.
+Changes: ported to Rust; `rotate_affine` keeps only the affine case.
+
+```
+The MIT License
+
+Copyright (c) 2015-2026 Richard Greenlees
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+```

benchmarks/entity-occlusion/2026-11-02/README.md

@@ -0,0 +1,42 @@
+# Entity occlusion split measurements — 2026-11-02
+
+These measurements came from the pre-split integration branch for PR #7054. That build contained the entity-occlusion rewrite and particle light lookup cache; Particle Culling was Off. They are useful comparison evidence, but they are not a benchmark of this isolated entity-only commit. The cache-only run in PR #7391 measured effectively the same CPU time on the ordinary scene, but the combined result still cannot isolate interactions.
+
+Host: Intel Core i7-3770S, Intel HD Graphics 4000, Vulkan/Mesa, 675×727, render distance 4, VSync off, 260 FPS cap. Two opposite-order passes measured for 8 seconds after warmup. Values are means. CPU is harness average CPU ms per frame; p99 is frame time. The driver supplied no usable GPU timing.
+
+## Ordinary scene
+
+The scene had 24 mobs, roughly 9,400–10,100 rain particles and campfire smoke.
+
+| Build and mode | FPS | CPU ms/frame | Frame p99 ms |
+| --- | ---: | ---: | ---: |
+| Main, entity culling Off | 88.59 | 1.829 | 24.51 |
+| Pre-split integration branch, all culling Off | 88.33 | 2.063 | 24.51 |
+| Main, entity culling Synchronous | 89.34 | 1.965 | 23.99 |
+| Pre-split integration branch, entity Synchronous | 89.13 | 2.113 | 24.15 |
+
+This normal-scene run does not show a large FPS change; its CPU differences are small relative to frame time and not attributable to the entity-only change by themselves.
+
+## Opaque-wall scene
+
+A 32×32 platform at Y=300, a 7-block wall with a one-block vertical opening, and 192 pigs spawned behind the wall (216 mobs in the captured scene). The player looked toward the opening from the near side. The same world and camera path were used for the main and integration builds.
+
+| Build and mode | FPS | CPU ms/frame | Frame p99 ms |
+| --- | ---: | ---: | ---: |
+| Main, Off | 89.08 | 2.423 | 13.52 |
+| Integration branch, Off | 89.23 | 2.355 | 13.27 |
+| Main, Synchronous | 92.81 | 2.566 | 14.60 |
+| Integration branch, Synchronous | 93.21 | 2.550 | 12.84 |
+| Main, Asynchronous | 92.73 | 2.364 | 13.04 |
+| Integration branch, Asynchronous | 92.62 | 2.314 | 13.18 |
+
+The asynchronous mode reduced measured CPU time slightly in this wall scene but did not improve FPS beyond run-to-run spread. This is a synthetic occlusion-heavy scene, not a broad performance claim.
+
+## Captures
+
+The HUD performance overlay is visible in each capture. The integration-build screenshots were recorded with the same wall and camera position in Off, Synchronous, and Asynchronous modes.
+
+- Main, Off: `main-off.png`
+- Integration branch, Off: `branch-off.png`
+- Integration branch, Synchronous: `branch-sync.png`
+- Integration branch, Asynchronous: `branch-async.png`

benchmarks/entity-occlusion/2026-11-04-release-opengl/README.md

@@ -0,0 +1,42 @@
+# Entity occlusion pipeline — release/OpenGL run (2026-11-04)
+
+This is the final local smoke benchmark for the entity-occlusion pipeline before opening the PR. It was run from the branch after the release build completed, with the OpenGL backend selected explicitly. The same process created each scene, switched the culling mode, flew the camera for two seconds, collected frame/CPU telemetry, and captured the screenshot after the scene settled.
+
+**Host:** Intel Core i7-3770S, Intel HD Graphics 4000, Mesa OpenGL 4.2
+**Window:** 1280×720, offscreen, VSync disabled
+**World:** fresh temporary home, 32×32 platform at Y=300; wall scenes add a solid stone wall and an optional one-block slit
+**Entities:** 24 pigs in the normal scene, 192 pigs in wall scenes, 512 pigs in stress scenes
+**Settings:** render distance 8, `entityCullingPrecheck:64`, FPS overlay on, no resource-pack occlusion assumptions
+**Build:** `cargo build --release -p horizon-client`
+
+## Results
+
+The values below are branch-only measurements. They are useful for comparing the three modes under identical geometry and for checking that the worker is doing useful work. A fresh main binary was not built in this short pass, so these numbers do not claim a controlled main-to-branch delta.
+
+| Scene | Off FPS / CPU p50 | Sync FPS / CPU p50 | Async FPS / CPU p50 | Async entities culled |
+| --- | ---: | ---: | ---: | ---: |
+| `entity_normal` (24 visible) | 240.5 / 0.586 ms | 233.5 / 0.762 ms | 239.3 / 0.686 ms | 0 |
+| `entity_wall` (192, solid) | 228.8 / 1.245 ms | 318.6 / 1.342 ms | **324.5 / 0.478 ms** | 124,608 |
+| `entity_wall_slit` (192, one-block slit) | 231.4 / 1.102 ms | 265.0 / 1.387 ms | **281.2 / 0.716 ms** | 102,826 |
+| `entity_stress` (512, solid) | 190.3 / 2.467 ms | 299.2 / 2.593 ms | **325.5 / 0.691 ms** | 290,234 |
+| `entity_stress_slit` (512, one-block slit) | 190.4 / 2.476 ms | 262.2 / 2.573 ms | **262.1 / 1.297 ms** | 227,301 |
+
+Async telemetry confirmed that the render thread stayed non-blocking (`try_recv`/`try_send`, `worker_blocking_wait_ms: 0`). The latest wall/slit run completed 562 worker jobs, queued 3,982 queries, avoided about 4.0 million entity bytes, and had 379 ns recent p50 worker-job time. The solid 512-pig run culled 15,552 generated vertices; the slit run culled 120,290 generated vertices. The normal scene recorded no pre-model hides and kept the opt-in path close to Off.
+
+## Captures
+
+Every image includes the FPS performance overlay. The names are `<mode>-<scene>.png`:
+
+- [Off — normal](screenshots/off-entity_normal.png), [wall](screenshots/off-entity_wall.png), [wall slit](screenshots/off-entity_wall_slit.png), [stress](screenshots/off-entity_stress.png), [stress slit](screenshots/off-entity_stress_slit.png)
+- [Sync — normal](screenshots/sync-entity_normal.png), [wall](screenshots/sync-entity_wall.png), [wall slit](screenshots/sync-entity_wall_slit.png), [stress](screenshots/sync-entity_stress.png), [stress slit](screenshots/sync-entity_stress_slit.png)
+- [Async — normal](screenshots/async-entity_normal.png), [wall](screenshots/async-entity_wall.png), [wall slit](screenshots/async-entity_wall_slit.png), [stress](screenshots/async-entity_stress.png), [stress slit](screenshots/async-entity_stress_slit.png)
+
+## Reproduction
+
+From the repository root, with prepared 26.3 resources available:
+
+```sh
+python3 tools/entity_occlusion_bench.py
+```
+
+The script uses fresh temporary game data, the release binary in `target/release`, OpenGL, the FPS overlay, and writes JSON plus captures under `/tmp/horizon-entity-occlusion-release-quick/`.

crates/cargo-horizon-mod/src/check.rs

@@ -93,7 +93,7 @@ pub fn kind_of(path: &Path) -> Option<Kind> {
         "hmod" => Some(Kind::Mod),
         "hnmod" => Some(Kind::NativeMod),
         "hpack" => Some(Kind::Modpack),
-        "zip" => Some(Kind::ResourcePack),
+        "zip" => Some(horizon_mods::index::zip_kind(path)),
         "hshader" => Some(Kind::Shader),
         _ => None,
     }

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

@@ -964,6 +964,10 @@ impl Scoreboard {
     pub fn tracked(&self) -> Vec<String> {
         self.holder_order.stream().map(str::to_owned).collect()
     }
+    /// Every holder on a team (`teamsByPlayer.keySet()`).
+    pub fn team_members(&self) -> impl Iterator<Item = &str> {
+        self.team_of.keys().map(String::as_str)
+    }
 
     // teams
     pub fn team(&self, name: &str) -> Option<&Team> {

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

@@ -815,6 +815,98 @@ pub fn stick_direction(stick: [f32; 2], threshold: f32) -> Option<Button> {
     })
 }
 
+/// How far a stick already stepping must fall back to let go: between this and
+/// the step threshold it holds its direction, so a stick resting on the
+/// threshold doesn't step again.
+pub const STICK_RELEASE: f32 = 0.35;
+/// How much more a stick must lean along another axis to change direction, so
+/// a stick resting on a diagonal doesn't flip between the two.
+const STICK_TURN: f32 = 1.5;
+
+/// [`stick_direction`] for a stick that may already be stepping `held`: it stays
+/// that way until the stick falls back past [`STICK_RELEASE`] or clearly turns.
+pub fn stick_direction_held(
+    stick: [f32; 2],
+    threshold: f32,
+    held: Option<Button>,
+) -> Option<Button> {
+    let fresh = stick_direction(stick, threshold);
+    let Some((axis, positive)) = held.and_then(direction) else {
+        return fresh;
+    };
+    if length(stick) < STICK_RELEASE {
+        return None;
+    }
+    // `direction`'s y runs down the screen, a stick's up.
+    let toward = stick[axis] * if positive == (axis == 0) { 1.0 } else { -1.0 };
+    if toward > 0.0 && stick[1 - axis].abs() <= toward * STICK_TURN {
+        held
+    } else {
+        fresh
+    }
+}
+
+/// A list drawn with a scrollbar (`ui::scrollbar`), how far it is scrolled (a list
+/// moving a whole row a notch draws the same rectangles, so they can't tell) and
+/// the ways it can still scroll.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ScrollArea {
+    pub rect: Rect,
+    pub amount: f32,
+    pub up: bool,
+    pub down: bool,
+}
+
+impl ScrollArea {
+    /// A row counts while any of it is in view: the stick can leave the focus on one nearly gone.
+    pub fn holds(&self, r: &Rect) -> bool {
+        let x = r[0] + r[2] / 2.0;
+        let [ax, ay, aw, ah] = self.rect;
+        (ax..ax + aw).contains(&x) && r[1] < ay + ah && r[1] + r[3] > ay
+    }
+    /// All of a row is in view.
+    fn shows(&self, r: &Rect) -> bool {
+        let [_, ay, _, ah] = self.rect;
+        self.holds(r) && r[1] + 0.5 >= ay && r[1] + r[3] <= ay + ah + 0.5
+    }
+}
+
+/// A vertical focus step, with lists: the strict step, unless it would land
+/// outside the view of the list `from` is in, or only partly in it, while that
+/// list can still scroll that way, when there is none (`None`) and the list
+/// scrolls instead: its hidden rows come first and whole, as vanilla's arrow
+/// keys walk a selection list's entries (`ensureVisible`).
+pub fn list_step(
+    from: Rect,
+    button: Button,
+    targets: &[Rect],
+    areas: &[ScrollArea],
+) -> Option<usize> {
+    let step = focus_step_strict(from, button, targets)?;
+    let can_scroll = |a: &ScrollArea| {
+        if button == Button::DPadUp {
+            a.up
+        } else {
+            a.down
+        }
+    };
+    let leaves = areas
+        .iter()
+        .find(|a| a.holds(&from))
+        .is_some_and(|a| can_scroll(a) && !a.shows(&targets[step]));
+    (!leaves).then_some(step)
+}
+
+/// The farthest centres of two neighbouring slots: 18 apart, 22 over the hotbar's gap.
+const SLOT_NEIGHBOUR: f32 = 24.0;
+
+/// A held direction's repeat stops at the edge of the slots it is walking: it
+/// goes on only from a slot to a slot next to it (the hotbar's small gap
+/// included). A fresh press may go anywhere.
+pub fn repeat_crosses_slots(from: (f32, f32), to: (f32, f32), to_slot: bool) -> bool {
+    !to_slot || (to.0 - from.0).abs().max((to.1 - from.1).abs()) > SLOT_NEIGHBOUR
+}
+
 /// Arrow-key focus navigation as vanilla does it
 /// (`ContainerEventHandler.nextFocusPathInDirection`), over every target of
 /// the screen at once: from a strip one pixel past the focused edge, the
@@ -910,12 +1002,25 @@ pub fn focus_step_vague(from: Rect, button: Button, targets: &[Rect]) -> Option<
 
 /// How far a list scrolled between two frames' targets: the vertical shift
 /// most targets of the same position and size agree on (targets that didn't
-/// move, outside the list, don't count). `None` when nothing moved.
-pub fn scroll_shift(before: &[Rect], after: &[Rect]) -> Option<f32> {
+/// move, outside the list, don't count), for a list scrolled towards its end
+/// (`down`: the rows moved up) or its start. `None` when nothing moved that way.
+/// It takes the direction because half a row's scroll votes the same both ways.
+pub fn scroll_shift(before: &[Rect], after: &[Rect], down: bool) -> Option<f32> {
     let same = |a: &Rect, b: &Rect| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 0.5);
     if before.len() == after.len() && before.iter().zip(after).all(|(a, b)| same(a, b)) {
         return None;
     }
+    // Most votes; among equals the smallest move (the next row, not a far one).
+    shift_votes(before, after)
+        .into_iter()
+        .filter(|v| (v.0 < 0.0) == down)
+        .max_by(|a, b| a.1.cmp(&b.1).then(b.0.abs().total_cmp(&a.0.abs())))
+        .map(|v| v.0)
+}
+
+/// Every vertical shift that would carry a `before` target onto an `after`
+/// target of the same position and size, with how many it would.
+fn shift_votes(before: &[Rect], after: &[Rect]) -> Vec<(f32, usize)> {
     let mut votes: Vec<(f32, usize)> = Vec::new();
     for b in before {
         for a in after {
@@ -932,11 +1037,94 @@ pub fn scroll_shift(before: &[Rect], after: &[Rect]) -> Option<f32> {
             }
         }
     }
-    // Most votes; among equals the smallest move (the next row, not a far one).
     votes
+}
+
+/// Where the focus goes when the right stick scrolled a list (`down`: towards
+/// its end, so the rows moved up): the rectangle moved by the list's shift;
+/// the same rectangle, for a widget outside the list; or, its row out of view,
+/// the nearest target of its kind (`after`'s flag), the list's rows before
+/// anything fixed. `None` when nothing moved that way, or none of its kind is
+/// left. It takes the direction because half a row's scroll votes the same
+/// both ways once a new row comes into view.
+pub fn follow_scroll(
+    focus: Rect,
+    down: bool,
+    before: &[Rect],
+    after: &[(Rect, bool)],
+) -> Option<usize> {
+    let rects: Vec<Rect> = after.iter().map(|t| t.0).collect();
+    // A column that stayed put isn't the list, even spaced like its shift.
+    let column = |of: &[Rect], r: &Rect| -> Vec<f32> {
+        let same = |o: &&Rect| o[0] == r[0] && o[2] == r[2] && o[3] == r[3];
+        of.iter().filter(same).map(|o| o[1]).collect()
+    };
+    let moving = |r: &&Rect| column(before, r) != column(&rects, r);
+    let was: Vec<Rect> = before.iter().filter(moving).copied().collect();
+    let now: Vec<Rect> = rects.iter().filter(moving).copied().collect();
+    let dy = shift_votes(&was, &now)
         .into_iter()
-        .max_by(|a, b| a.1.cmp(&b.1).then(b.0.abs().total_cmp(&a.0.abs())))
-        .map(|v| v.0)
+        .filter(|v| (v.0 < 0.0) == down)
+        .max_by(|a, b| a.1.cmp(&b.1).then(b.0.abs().total_cmp(&a.0.abs())))?
+        .0;
+    let same = |a: &Rect, b: &Rect| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 0.5);
+    let moved = [focus[0], focus[1] + dy, focus[2], focus[3]];
+    let found = |at: &Rect| rects.iter().position(|r| same(r, at));
+    if !moving(&&focus) {
+        return found(&focus);
+    }
+    if let Some(i) = found(&moved).or_else(|| found(&focus)) {
+        return Some(i);
+    }
+    let in_list = |r: &Rect| {
+        let was = [r[0], r[1] - dy, r[2], r[3]];
+        before.iter().any(|b| same(b, &was))
+    };
+    let centre = (moved[0] + moved[2] / 2.0, moved[1] + moved[3] / 2.0);
+    let distance = |r: &Rect| (r[0] + r[2] / 2.0 - centre.0).hypot(r[1] + r[3] / 2.0 - centre.1);
+    after
+        .iter()
+        .enumerate()
+        .filter(|(_, t)| t.1)
+        .min_by(|(_, a), (_, b)| {
+            in_list(&b.0)
+                .cmp(&in_list(&a.0))
+                .then(distance(&a.0).total_cmp(&distance(&b.0)))
+        })
+        .map(|(i, _)| i)
+}
+
+/// The target a focus rectangle stands for once the screen's size changed:
+/// the same widget, by its place in the draw order when the screen drew as
+/// many; else the target nearest where its centre falls at the new size.
+pub fn refind_resized(
+    focus: Rect,
+    before: &[Rect],
+    after: &[Rect],
+    old: (f32, f32),
+    new: (f32, f32),
+) -> Option<usize> {
+    let same = |r: &Rect| r.iter().zip(&focus).all(|(a, b)| (a - b).abs() < 0.5);
+    if before.len() == after.len()
+        && let Some(i) = before.iter().position(same)
+    {
+        return Some(i);
+    }
+    let at = rescaled(
+        (focus[0] + focus[2] / 2.0, focus[1] + focus[3] / 2.0),
+        old,
+        new,
+    );
+    let centres: Vec<(f32, f32)> = after
+        .iter()
+        .map(|r| (r[0] + r[2] / 2.0, r[1] + r[3] / 2.0))
+        .collect();
+    nearest(at, &centres, f32::INFINITY)
+}
+
+/// A point at the same place, proportionally, on a screen of another size.
+pub fn rescaled(at: (f32, f32), old: (f32, f32), new: (f32, f32)) -> (f32, f32) {
+    (at.0 * new.0 / old.0.max(1.0), at.1 * new.1 / old.1.max(1.0))
 }
 
 /// The target a remembered focus rectangle stands for in a new frame: the
@@ -1632,6 +1820,63 @@ mod tests {
         assert_eq!(focus_step_rect(grid[0], Button::South, &grid), None);
     }
 
+    #[test]
+    fn follow_scroll_keeps_rows_and_fixed_widgets() {
+        // Rows 36 tall scrolled down 18: a fifth row comes into view, so +18
+        // carries as many rows as the real -18. Back, below, stays.
+        let back = [296.0, 212.0, 71.0, 20.0];
+        let rows = |ys: &[f32]| -> Vec<(Rect, bool)> {
+            let rows = ys.iter().map(|y| ([78.0, *y, 270.0, 36.0], true));
+            rows.chain([(back, false)]).collect()
+        };
+        let rects = |t: &[(Rect, bool)]| -> Vec<Rect> { t.iter().map(|t| t.0).collect() };
+        let before = rects(&rows(&[33.0, 69.0, 105.0, 141.0]));
+        let after = rows(&[15.0, 51.0, 87.0, 123.0, 159.0]);
+        assert_eq!(follow_scroll(before[1], true, &before, &after), Some(1));
+        assert_eq!(follow_scroll(back, true, &before, &after), Some(5));
+        // And back up.
+        let up = rows(&[33.0, 69.0, 105.0, 141.0]);
+        let was = rects(&after);
+        assert_eq!(follow_scroll(was[2], false, &was, &up), Some(2));
+        // Nothing moved, as on a screen with no list.
+        let still = rows(&[33.0, 69.0, 105.0, 141.0]);
+        assert_eq!(follow_scroll(before[1], true, &before, &still), None);
+        // A sidebar's tabs spaced exactly like the list's shift stay put.
+        let tab = |y: f32| [8.0, y, 112.0, 16.0];
+        let with_tabs = |t: &[(Rect, bool)]| -> Vec<(Rect, bool)> {
+            t.iter()
+                .copied()
+                .chain([(tab(100.0), true), (tab(118.0), true)])
+                .collect()
+        };
+        let was = rects(&with_tabs(&rows(&[33.0, 69.0, 105.0, 141.0])));
+        let now = with_tabs(&after);
+        assert_eq!(follow_scroll(tab(118.0), true, &was, &now), Some(7));
+    }
+
+    #[test]
+    fn follow_scroll_lands_on_the_nearest_row_when_its_row_leaves() {
+        // The row at 33 left the top; the next one is at 51. Nothing fixed.
+        let row = |y: f32| [78.0, y, 270.0, 36.0];
+        let before = [row(33.0), row(69.0), row(105.0)];
+        let after = [(row(51.0), true), (row(87.0), true)];
+        assert_eq!(follow_scroll(row(33.0), true, &before, &after), Some(0));
+        // The last row left the bottom: the list's new last row, not a fixed
+        // widget of its kind (at 200) nearer where the row went.
+        let fixed = [78.0, 200.0, 270.0, 36.0];
+        let before = [row(15.0), row(51.0), row(87.0), row(159.0), fixed];
+        let after = [
+            (row(33.0), true),
+            (row(69.0), true),
+            (row(105.0), true),
+            (fixed, true),
+        ];
+        assert_eq!(follow_scroll(row(159.0), false, &before, &after), Some(2));
+        // Nothing of its kind left.
+        let other = after.map(|t| (t.0, false));
+        assert_eq!(follow_scroll(row(159.0), false, &before, &other), None);
+    }
+
     #[test]
     fn refind_tabs_sliders_and_stick_steps() {
         let rects: Vec<Rect> = vec![[0.0, 0.0, 10.0, 10.0], [0.0, 20.0, 10.0, 10.0]];
@@ -1648,8 +1893,10 @@ mod tests {
             .map(|i| [10.0, 16.0 + 24.0 * i as f32, 100.0, 20.0])
             .chain([[10.0, 200.0, 50.0, 20.0]])
             .collect();
-        assert_eq!(scroll_shift(&before, &after), Some(-24.0));
-        assert_eq!(scroll_shift(&before, &before), None);
+        assert_eq!(scroll_shift(&before, &after, true), Some(-24.0));
+        // Rows this far apart line up the other way too; the direction is what tells them apart.
+        assert_eq!(scroll_shift(&before, &after, false), Some(24.0));
+        assert_eq!(scroll_shift(&before, &before, true), None);
         let tabs = [
             ([60.0, 0.0, 26.0, 32.0], false),
             ([0.0, 0.0, 26.0, 32.0], true),
@@ -1675,6 +1922,127 @@ mod tests {
         assert!(steam_keyboard(TextKeyboard::Steam) && !steam_keyboard(TextKeyboard::Horizon));
     }
 
+    #[test]
+    fn a_list_step_scrolls_rather_than_leave_a_list_that_can() {
+        let rows = |n: usize| -> Vec<Rect> {
+            (0..n)
+                .map(|i| [100.0, 40.0 + i as f32 * 36.0, 270.0, 36.0])
+                .collect()
+        };
+        let back: Rect = [150.0, 220.0, 150.0, 20.0];
+        let search: Rect = [150.0, 10.0, 150.0, 20.0];
+        let mut targets = rows(4);
+        targets.extend([back, search]);
+        let area = |up, down| ScrollArea {
+            rect: [0.0, 40.0, 380.0, 144.0],
+            amount: 0.0,
+            up,
+            down,
+        };
+        let (down, up) = (Button::DPadDown, Button::DPadUp);
+        let step = |from, button, area: &[ScrollArea]| list_step(from, button, &targets, area);
+        // A row below in view comes first.
+        assert_eq!(step(targets[1], down, &[area(true, true)]), Some(2));
+        // The last row in view: more below scrolls; none leaves.
+        assert_eq!(step(targets[3], down, &[area(true, true)]), None);
+        assert_eq!(step(targets[3], down, &[area(true, false)]), Some(4));
+        // The first row in view, the same upwards.
+        assert_eq!(step(targets[0], up, &[area(true, false)]), None);
+        assert_eq!(step(targets[0], up, &[area(false, true)]), Some(5));
+        // From outside the list it enters it, and no list means a plain step.
+        assert_eq!(step(back, up, &[area(true, true)]), Some(3));
+        assert_eq!(step(targets[3], down, &[]), Some(4));
+    }
+
+    #[test]
+    fn a_list_step_shows_its_row_whole_and_starts_from_one_nearly_gone() {
+        let area = |up, down| ScrollArea {
+            rect: [0.0, 40.0, 380.0, 100.0],
+            amount: 50.0,
+            up,
+            down,
+        };
+        let (down, up) = (Button::DPadDown, Button::DPadUp);
+        // The next row is cut by the view's bottom: it scrolls first, unless that's the end.
+        let targets: Vec<Rect> = vec![[100.0, 100.0, 270.0, 25.0], [100.0, 125.0, 270.0, 25.0]];
+        assert_eq!(
+            list_step(targets[0], down, &targets, &[area(true, true)]),
+            None
+        );
+        assert_eq!(
+            list_step(targets[0], down, &targets, &[area(true, false)]),
+            Some(1)
+        );
+        // The same at its top.
+        let targets: Vec<Rect> = vec![[100.0, 30.0, 270.0, 25.0], [100.0, 55.0, 270.0, 25.0]];
+        assert_eq!(
+            list_step(targets[1], up, &targets, &[area(true, true)]),
+            None
+        );
+        // A focused row with its last pixels in view is still in the list: going up scrolls,
+        // even with something above the list to go to.
+        let row: Rect = [100.0, 18.0, 270.0, 25.0];
+        let field: Rect = [150.0, 0.0, 150.0, 15.0];
+        assert!(area(true, true).holds(&row));
+        assert_eq!(list_step(row, up, &[row, field], &[area(true, true)]), None);
+        // Above the view altogether, it isn't.
+        assert!(!area(true, true).holds(&[100.0, 10.0, 270.0, 25.0]));
+    }
+
+    #[test]
+    fn a_stick_holds_its_direction_until_it_lets_go_or_turns() {
+        let step = 0.55;
+        let (up, right) = (Some(Button::DPadUp), Some(Button::DPadRight));
+        // Only a push past the threshold starts a step.
+        assert_eq!(stick_direction_held([0.0, 0.5], step, None), None);
+        assert_eq!(stick_direction_held([0.0, 0.6], step, None), up);
+        // Wobbling on the threshold keeps it; falling back past the release lets go.
+        assert_eq!(stick_direction_held([0.0, 0.5], step, up), up);
+        assert_eq!(stick_direction_held([0.0, 0.3], step, up), None);
+        // A diagonal doesn't flip it, but a clear turn does.
+        assert_eq!(stick_direction_held([0.6, 0.55], step, up), up);
+        assert_eq!(stick_direction_held([0.55, 0.6], step, right), right);
+        assert_eq!(stick_direction_held([0.9, 0.3], step, up), right);
+        // Straight across to the other side.
+        assert_eq!(
+            stick_direction_held([0.0, -0.9], step, up),
+            Some(Button::DPadDown)
+        );
+        // Past the release on the far side, but not far enough for a step.
+        assert_eq!(stick_direction_held([0.0, -0.45], step, up), None);
+    }
+
+    #[test]
+    fn a_repeat_stops_where_the_slots_end() {
+        let at = (100.0, 100.0);
+        assert!(!repeat_crosses_slots(at, (118.0, 100.0), true));
+        // The hotbar, over its small gap, is the same run of slots.
+        assert!(!repeat_crosses_slots(at, (100.0, 122.0), true));
+        // Another block of slots, or a button.
+        assert!(repeat_crosses_slots(at, (100.0, 132.0), true));
+        assert!(repeat_crosses_slots(at, (118.0, 100.0), false));
+    }
+
+    #[test]
+    fn a_resize_keeps_the_same_widget() {
+        let before: Vec<Rect> = vec![[10.0, 10.0, 20.0, 20.0], [100.0, 10.0, 20.0, 20.0]];
+        let after: Vec<Rect> = vec![[300.0, 90.0, 20.0, 20.0], [400.0, 90.0, 20.0, 20.0]];
+        let (old, new) = ((200.0, 100.0), (800.0, 400.0));
+        // The same count: the same place in the draw order, however far it moved.
+        assert_eq!(
+            refind_resized(before[0], &before, &after, old, new),
+            Some(0)
+        );
+        // A list showing more rows: the nearest to where it would be.
+        let more: Vec<Rect> = vec![
+            [30.0, 30.0, 20.0, 20.0],
+            [395.0, 35.0, 20.0, 20.0],
+            [700.0, 300.0, 20.0, 20.0],
+        ];
+        assert_eq!(refind_resized(before[1], &before, &more, old, new), Some(1));
+        assert_eq!(refind_resized(before[0], &before, &[], old, new), None);
+    }
+
     #[test]
     fn labels_and_conflicts() {
         assert_eq!(Button::South.label(GlyphStyle::Xbox), "A");

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

@@ -91,6 +91,36 @@ pub fn settle(start: Point, end: Point, targets: &[Point], tuning: &Tuning) -> O
     }
 }
 
+/// Where a cursor left on a target goes once the targets moved: with most of
+/// them if they moved together (a recipe book opened), else to the nearest
+/// one (a creative tab with other slots), so it never rests between targets.
+/// `None` when it wasn't on a target, or one is still there.
+pub fn follow(at: Point, before: &[Point], after: &[Point]) -> Option<usize> {
+    const SAME: f32 = 0.5;
+    let on = before.iter().find(|t| distance(at, **t) <= SAME)?;
+    if after.iter().any(|t| distance(at, *t) <= SAME) {
+        return None;
+    }
+    let carried = |by: Point| {
+        before
+            .iter()
+            .filter(|b| {
+                let moved = (b.0 + by.0, b.1 + by.1);
+                after.iter().any(|a| distance(moved, *a) <= SAME)
+            })
+            .count()
+    };
+    let together = after
+        .iter()
+        .enumerate()
+        .map(|(i, a)| (i, carried((a.0 - on.0, a.1 - on.1))))
+        .max_by_key(|&(_, count)| count)
+        .filter(|&(_, count)| count * 2 > before.len());
+    together
+        .map(|(i, _)| i)
+        .or_else(|| nearest(at, after, f32::INFINITY))
+}
+
 /// The cursor `seconds` into a glide from `from` to `to`: eased out, so it
 /// slows as it lands, and exactly `to` once the glide is over.
 pub fn glide(from: Point, to: Point, seconds: f32, tuning: &Tuning) -> Point {
@@ -109,6 +139,26 @@ mod tests {
     /// A row of inventory slots, 18 pixels apart, and the slot below the first.
     const SLOTS: [Point; 4] = [(8.0, 8.0), (26.0, 8.0), (44.0, 8.0), (8.0, 26.0)];
 
+    #[test]
+    fn follow_goes_with_targets_that_moved_together() {
+        let moved = SLOTS.map(|s| (s.0 + 77.0, s.1));
+        assert_eq!(follow(SLOTS[1], &SLOTS, &moved), Some(1));
+    }
+
+    #[test]
+    fn follow_takes_the_nearest_of_other_targets() {
+        let other = [(30.0, 50.0), (200.0, 200.0)];
+        assert_eq!(follow(SLOTS[1], &SLOTS, &other), Some(0));
+    }
+
+    #[test]
+    fn follow_leaves_a_free_cursor_and_a_target_still_there() {
+        let other = [(30.0, 50.0)];
+        assert_eq!(follow((100.0, 100.0), &SLOTS, &other), None);
+        assert_eq!(follow(SLOTS[0], &SLOTS, &SLOTS), None);
+        assert_eq!(follow(SLOTS[0], &SLOTS, &[]), None);
+    }
+
     #[test]
     fn a_short_flick_moves_to_the_neighbour_it_heads_for() {
         // 4 pixels right of slot 0: still nearest slot 0, but heading for slot 1.

crates/horizon-client-lib/Cargo.toml

@@ -30,6 +30,8 @@ horizon-world = { path = "../horizon-world" }
 horizon-protocol = { path = "../horizon-protocol" }
 # server.properties, eula.txt and the user lists, shared with horizon-server.
 horizon-server-files = { path = "../horizon-server-files" }
+# The control endpoint's token (control.rs), as horizon-server's and the relay's.
+getrandom = "0.3"
 # The dedicated server's anticheat, off unless server.toml's [anticheat] turns it on (docs/anticheat.md).
 horizon-anticheat = { path = "../horizon-anticheat" }
 # The dedicated server's chat filter: [chat_filter], the slur list, mutes (docs/chat-filter.md).

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

@@ -648,6 +648,7 @@ fn remesh(
                         nether_shading: false,
                         shader_pack_lighting: false,
                         separate_ao: false,
+                        shader_pack: false,
                         assets,
                         render,
                         tables: &tables,

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

@@ -407,6 +407,16 @@ impl BlockEntities {
             self.add(pos);
         }
     }
+    /// [`Self::retain`] for unloading chunks: removes the block entities at
+    /// the positions `gone` names and changes none it keeps, so those that
+    /// sleep stay asleep (a moving player unloads chunks most ticks).
+    pub fn unload(&mut self, mut gone: impl FnMut(&Pos) -> bool) {
+        let asleep = std::mem::take(&mut self.asleep);
+        self.retain(|p, _| !gone(p));
+        self.asleep = asleep;
+        let map = &self.map;
+        self.asleep.retain(|p| map.contains_key(p));
+    }
     /// Removes the block entities `keep` refuses, and their slots
     /// (`clearAllBlockEntities` of unloaded chunks).
     pub fn retain(&mut self, mut keep: impl FnMut(&Pos, &mut BlockEntity) -> bool) {
@@ -558,6 +568,24 @@ mod tests {
             .collect()
     }
 
+    /// Unloading a chunk removes its block entities and leaves the others'
+    /// sleep alone; `retain`, which may change what it keeps, wakes them all.
+    #[test]
+    fn unloading_a_chunk_keeps_the_others_asleep() {
+        let mut b = level();
+        let (kept, gone) = ((1, 64, 1), (17, 64, 1));
+        b.insert(kept, hopper());
+        b.insert(gone, hopper());
+        b.sleep(kept);
+        b.sleep(gone);
+        b.unload(|p| p.0 >> 4 == 1);
+        assert!(b.get(&gone).is_none());
+        assert!(!b.is_asleep(&gone));
+        assert!(b.is_asleep(&kept));
+        b.retain(|_, _| true);
+        assert!(!b.is_asleep(&kept));
+    }
+
     fn near(b: &BlockEntities, x: f64, z: f64, radius: f64) -> Vec<Pos> {
         let mut found: Vec<Pos> = b.mods_near(x, z, radius).copied().collect();
         found.sort();

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

@@ -7,7 +7,7 @@
 //! the block plus `minecraft_mix_light` with the level's two diffuse lights.
 use crate::{
     Result,
-    bidi::visual_str,
+    bidi::visual,
     block_entity_anim::{self, EnchantingBook},
     breaking::entity_geometry,
     fast_hash::FxHashMap,
@@ -271,10 +271,10 @@ pub const DYES: [(&str, u32); 16] = [
     ("black", 0x1D1D21),
 ];
 fn dye_prefix(name: &str) -> Option<(usize, &str)> {
-    // Longest names first so "light_gray" wins over "gray".
-    let mut order: Vec<usize> = (0..16).collect();
-    order.sort_by_key(|&i| std::cmp::Reverse(DYES[i].0.len()));
-    order.into_iter().find_map(|i| {
+    // Longest names first; this is the same stable order as sorting DYES by
+    // descending prefix length, without a Vec allocation or comparison sort.
+    const ORDER: [usize; 16] = [3, 8, 2, 1, 4, 10, 0, 12, 13, 15, 5, 6, 7, 9, 11, 14];
+    ORDER.into_iter().find_map(|i| {
         name.strip_prefix(DYES[i].0)
             .and_then(|rest| rest.strip_prefix('_'))
             .map(|rest| (i, rest))
@@ -639,7 +639,9 @@ fn sign_text_near(pos: [i32; 3], camera: DVec3) -> bool {
 }
 
 /// `AbstractSignRenderer.submitSignText`: four centred lines, glowing text
-/// full-bright with an 8x outline in the dark colour.
+/// full-bright with an 8x outline in the dark colour. The font colours each
+/// glyph by its style (`Font.StringRenderOutput`): a line's own colour wins,
+/// else the sign's. A line is one call per run of one colour.
 fn sign_text_calls(
     scene: &Scene,
     data: &SignData,
@@ -662,25 +664,53 @@ fn sign_text_calls(
         (dark, 0, vertex_light(packed))
     };
     let advance = |c: char| (scene.glyph)(c).advance;
-    let width = |s: &str| s.chars().map(advance).sum::<f32>().ceil();
-    text.lines
-        .iter()
-        .enumerate()
-        .map(|(i, line)| {
-            // The line that fits, in the order it is drawn (getVisualOrder).
-            let shown = first_line(line, data.max_line_width(), &advance);
-            let shown = visual_str(&shown).into_owned();
-            TextCall {
+    let mut calls: Vec<TextCall> = Vec::with_capacity(text.lines.len());
+    for i in 0..text.lines.len() {
+        // The line that fits, in the order it is drawn (getVisualOrder).
+        let line = text.line_text(i);
+        let line = line.resolved();
+        let flat: String = line.chars().map(|(c, _)| c).collect();
+        let fits = first_line(&flat, data.max_line_width(), &advance);
+        let shown = line.slice(0, fits.chars().count());
+        let shown = visual(&shown);
+        let width = shown.chars().map(|(c, _)| advance(c)).sum::<f32>().ceil();
+        let x = -((width as i32) / 2) as f32;
+        let y = i as f32 * line_height - midpoint;
+        let first = calls.len();
+        let mut pen = 0.0;
+        for span in shown.spans.iter().filter(|s| !s.text.is_empty()) {
+            let run = span
+                .style
+                .color
+                .map_or(color, |rgb| 0xFF00_0000 | (rgb & 0xFF_FFFF));
+            match calls[first..].last_mut() {
+                Some(last) if last.color == run => last.text.push_str(&span.text),
+                _ => calls.push(TextCall {
+                    matrix: m,
+                    x: x + pen,
+                    y,
+                    text: span.text.clone(),
+                    color: run,
+                    outline,
+                    light,
+                }),
+            }
+            pen += span.text.chars().map(advance).sum::<f32>();
+        }
+        if calls.len() == first {
+            // A line with no text is still a call, of no glyphs.
+            calls.push(TextCall {
                 matrix: m,
-                x: -((width(&shown) as i32) / 2) as f32,
-                y: i as f32 * line_height - midpoint,
-                text: shown,
+                x,
+                y,
+                text: String::new(),
                 color,
                 outline,
                 light,
-            }
-        })
-        .collect()
+            });
+        }
+    }
+    calls
 }
 
 /// How far the text of an outlined call sits in front of its outline, in
@@ -841,6 +871,9 @@ pub struct Scene<'a> {
     /// Changes whenever `glyph` may answer differently (`Font::epoch`): sign
     /// text laid out under another value is laid out again.
     pub glyphs: u64,
+    /// Per-block visibility for dynamic, animated, or uncached models. Bounds
+    /// are world-space and conservatively include model animation extents.
+    pub dynamic_visible: Option<&'a dyn Fn([i32; 3], u32, DVec3, DVec3) -> bool>,
 }
 
 /// Empty by default (a dedicated server): no state has a block entity model.
@@ -1410,6 +1443,167 @@ impl BlockEntityRenderer {
     fn kind(&self, state: u32) -> &Kind {
         self.kinds.get(state as usize).unwrap_or(&Kind::None)
     }
+    fn dynamic_bounds(
+        &self,
+        scene: &Scene,
+        pos: [i32; 3],
+        kind: &Kind,
+        chest_openness: Option<(f32, Option<[i32; 3]>)>,
+    ) -> (DVec3, DVec3) {
+        let [x, y, z] = pos.map(f64::from);
+        let mut lo = DVec3::new(x, y, z);
+        let mut hi = DVec3::new(x + 1.0, y + 1.0, z + 1.0);
+        match kind {
+            Kind::Chest { double_with, .. } => {
+                if let Some(offset) = double_with {
+                    lo.x += f64::from(offset[0].min(0));
+                    lo.z += f64::from(offset[2].min(0));
+                    hi.x += f64::from(offset[0].max(0));
+                    hi.z += f64::from(offset[2].max(0));
+                }
+                let is_open = chest_openness.map_or_else(
+                    || {
+                        (scene.lid)(pos) != 0.0
+                            || double_with.is_some_and(|offset| {
+                                let other = [
+                                    pos[0].saturating_add(offset[0]),
+                                    pos[1].saturating_add(offset[1]),
+                                    pos[2].saturating_add(offset[2]),
+                                ];
+                                (scene.lid)(other) != 0.0
+                            })
+                    },
+                    |(open, _)| open != 0.0,
+                );
+                if is_open {
+                    // The lid pivots up from the rear edge. Its longest corner
+                    // rises by less than one block in the fully open pose.
+                    hi.y += 0.8;
+                }
+            }
+            Kind::Shulker { facing, .. } => {
+                let offset = step(facing);
+                lo.x += f64::from(offset[0].min(0)) * 0.52;
+                lo.y += f64::from(offset[1].min(0)) * 0.52;
+                lo.z += f64::from(offset[2].min(0)) * 0.52;
+                hi.x += f64::from(offset[0].max(0)) * 0.52;
+                hi.y += f64::from(offset[1].max(0)) * 0.52;
+                hi.z += f64::from(offset[2].max(0)) * 0.52;
+            }
+            Kind::Banner { wall: false, .. } => {
+                hi.y += 1.0;
+                lo.x -= 0.05;
+                lo.z -= 0.05;
+                hi.x += 0.05;
+                hi.z += 0.05;
+            }
+            Kind::Banner { wall: true, .. } => {
+                lo.y -= 1.0;
+                lo.x -= 0.05;
+                lo.z -= 0.05;
+                hi.x += 0.05;
+                hi.z += 0.05;
+            }
+            Kind::Sign { hanging: true, .. } => {
+                lo.y -= 1.0;
+                lo.x -= 0.15;
+                lo.z -= 0.15;
+                hi.x += 0.15;
+                hi.z += 0.15;
+            }
+            Kind::Sign { hanging: false, .. } => {
+                hi.y += 0.3;
+                lo.x -= 0.02;
+                lo.z -= 0.02;
+                hi.x += 0.02;
+                hi.z += 0.02;
+            }
+            Kind::EnchantingTable | Kind::Lectern { .. } => {
+                // The book and statue models rise above the block's collision
+                // cube; include their full rendered height and rotated corners.
+                hi.y += 1.0;
+                lo.x -= 0.25;
+                lo.z -= 0.25;
+                hi.x += 0.25;
+                hi.z += 0.25;
+            }
+            Kind::CopperGolem { .. } => {
+                // The statue pose rotates around the root, so some variants
+                // extend below the block as well as above it.
+                lo.y -= 1.0;
+                hi.y += 1.0;
+                lo.x -= 0.25;
+                lo.z -= 0.25;
+                hi.x += 0.25;
+                hi.z += 0.25;
+            }
+            Kind::Conduit => {
+                // Its animated cage is centered above the conduit block and
+                // the wind model spans multiple cells. The caller bypasses
+                // voxel occlusion for envelopes this tall, but retains frustum
+                // culling with this conservative volume.
+                lo.x -= 1.0;
+                lo.y -= 1.0;
+                lo.z -= 1.0;
+                hi.x += 1.0;
+                hi.y += 1.0;
+                hi.z += 1.0;
+            }
+            Kind::Bell => {
+                // The bell's pivoted swing moves its corners slightly outside
+                // the block even though the model starts centered in it.
+                lo.x -= 0.1;
+                lo.y -= 0.1;
+                lo.z -= 0.1;
+                hi.x += 0.1;
+                hi.y += 0.1;
+                hi.z += 0.1;
+            }
+            Kind::Skull { .. } => {
+                // Wall-mounted and dragon heads can protrude from their block.
+                lo.x -= 0.25;
+                lo.y -= 0.25;
+                lo.z -= 0.25;
+                hi.x += 0.25;
+                hi.y += 0.25;
+                hi.z += 0.25;
+            }
+            Kind::EndGateway { .. } => {
+                let anim = (scene.anim)(pos);
+                let beam = gateway_beam(anim.gateway, scene.partial, scene.max_y, scene.game_time);
+                let height = f64::from(beam.height.max(0));
+                lo.y -= height;
+                hi.y += height;
+            }
+            _ => {}
+        }
+        (lo, hi)
+    }
+
+    fn is_dynamic_visible(
+        &self,
+        scene: &Scene,
+        shapes: &Arc<BlockEntityShapes>,
+        pos: [i32; 3],
+        state: u32,
+        kind: &Kind,
+        chest_openness: Option<(f32, Option<[i32; 3]>)>,
+    ) -> bool {
+        let Some(visible) = scene.dynamic_visible else {
+            return true;
+        };
+        if matches!(kind, Kind::EndGateway { .. }) {
+            return true;
+        }
+        // A pack model may extend outside the vanilla envelope. Keep that
+        // geometry on the uncullable path unless its model bounds are known.
+        if !Arc::ptr_eq(shapes, &self.vanilla) {
+            return true;
+        }
+        let (lo, hi) = self.dynamic_bounds(scene, pos, kind, chest_openness);
+        visible(pos, state, lo, hi)
+    }
+
     fn cached_entry_is_current(
         &self,
         scene: &Scene,
@@ -1419,6 +1613,7 @@ impl BlockEntityRenderer {
         options: CacheOptions,
         entry: &StaticEntry,
         section_revision: StaticSectionRevision,
+        chest_openness: Option<(f32, Option<[i32; 3]>)>,
     ) -> bool {
         if entry.key.state != state
             || entry.key.nether != scene.nether
@@ -1430,15 +1625,24 @@ impl BlockEntityRenderer {
         }
         match kind {
             Kind::Chest { .. } => {
-                let (open, other) = self.chest_openness(
-                    pos,
-                    kind,
-                    &|p| scene.world.block(p[0], p[1], p[2]).0,
-                    scene.lid,
-                );
-                // Double chests depend on the neighboring half's light too;
-                // let those uncommon models take the full key path.
-                open == 0.0 && other.is_none()
+                let (open, other) = chest_openness.unwrap_or_else(|| {
+                    self.chest_openness(
+                        pos,
+                        kind,
+                        &|p| scene.world.block(p[0], p[1], p[2]).0,
+                        scene.lid,
+                    )
+                });
+                if open != 0.0 {
+                    return false;
+                }
+                let mut light = scene.world.light(pos[0], pos[1], pos[2]);
+                if let Some(other) = other {
+                    let other_light = scene.world.light(other[0], other[1], other[2]);
+                    light = (light >> 4).max(other_light >> 4) << 4
+                        | (light & 15).max(other_light & 15);
+                }
+                entry.key.light == light
             }
             Kind::Shulker { .. } => {
                 let (progress, old) = (scene.anim)(pos).shulker;
@@ -1701,6 +1905,17 @@ impl BlockEntityRenderer {
                 }
                 let local = static_local_index(pos, section_min_y);
                 let current_section_revision = active_section_revision.unwrap_or_default();
+                let chest_openness = (cache.is_some()
+                    && options.chests
+                    && matches!(kind, Kind::Chest { .. }))
+                .then(|| {
+                    self.chest_openness(
+                        pos,
+                        kind,
+                        &|p| scene.world.block(p[0], p[1], p[2]).0,
+                        scene.lid,
+                    )
+                });
                 if cache_only && section_revision.is_some() && active_section_revision.is_none() {
                     break 'draw;
                 }
@@ -1716,6 +1931,7 @@ impl BlockEntityRenderer {
                         options,
                         &active_entries[index].1,
                         current_section_revision,
+                        chest_openness,
                     )
                 {
                     let entry = &mut active_entries[index].1;
@@ -1735,7 +1951,9 @@ impl BlockEntityRenderer {
                             ..*vertex
                         }));
                     }
-                    if matches!(kind, Kind::Banner { .. }) {
+                    if matches!(kind, Kind::Banner { .. })
+                        && self.is_dynamic_visible(scene, &shapes, pos, state, kind, None)
+                    {
                         let packed = scene.world.light(pos[0], pos[1], pos[2]);
                         let origin =
                             (DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]))
@@ -1756,11 +1974,25 @@ impl BlockEntityRenderer {
                     }
                     break 'draw;
                 }
+                if cache_only && chest_openness.is_some_and(|(open, _)| open != 0.0) {
+                    if let Some(cache) = &mut cache
+                        && let Ok(index) =
+                            active_entries.binary_search_by_key(&local, |(index, _)| *index)
+                    {
+                        active_entries.remove(index);
+                        cache.len -= 1;
+                        cache.mark_section_dirty(section);
+                    }
+                    break 'draw;
+                }
                 let origin = (DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]))
                     - scene.camera)
                     .as_vec3();
                 let mut packed = scene.world.light(pos[0], pos[1], pos[2]);
                 if matches!(kind, Kind::Sign { .. }) && scene.texts.is_none() {
+                    if !self.is_dynamic_visible(scene, &shapes, pos, state, kind, None) {
+                        break 'draw;
+                    }
                     if options.signs {
                         self.sign_text(scene, pos, state, origin, packed, out);
                     } else {
@@ -1779,8 +2011,15 @@ impl BlockEntityRenderer {
                     break 'draw;
                 }
                 if let Some(cache) = &mut cache
-                    && let Some(key) =
-                        self.static_key(scene, pos, state, kind, options, &mut packed)
+                    && let Some(key) = self.static_key(
+                        scene,
+                        pos,
+                        state,
+                        kind,
+                        options,
+                        &mut packed,
+                        chest_openness,
+                    )
                 {
                     let slot = active_entries.binary_search_by_key(&local, |(index, _)| *index);
                     let entry = match slot {
@@ -1865,7 +2104,9 @@ impl BlockEntityRenderer {
                             ..*vertex
                         }));
                     }
-                    if matches!(kind, Kind::Banner { .. }) {
+                    if matches!(kind, Kind::Banner { .. })
+                        && self.is_dynamic_visible(scene, &shapes, pos, state, kind, None)
+                    {
                         self.render_banner(
                             &shapes,
                             scene,
@@ -1892,6 +2133,9 @@ impl BlockEntityRenderer {
                 if cache_only {
                     break 'draw;
                 }
+                if !self.is_dynamic_visible(scene, &shapes, pos, state, kind, chest_openness) {
+                    break 'draw;
+                }
                 let base = Mat4::from_translation(origin);
                 self.render_one(scene, pos, kind, base, packed, lights, false, true, out);
             }
@@ -1958,6 +2202,7 @@ impl BlockEntityRenderer {
         kind: &Kind,
         options: CacheOptions,
         packed: &mut u8,
+        chest_openness: Option<(f32, Option<[i32; 3]>)>,
     ) -> Option<StaticKey> {
         let mut sprite_rects = [None; 5];
         let mut sprite_count = 0;
@@ -1975,12 +2220,14 @@ impl BlockEntityRenderer {
                 part,
                 ..
             } if options.chests => {
-                let (open, other) = self.chest_openness(
-                    pos,
-                    kind,
-                    &|p| scene.world.block(p[0], p[1], p[2]).0,
-                    scene.lid,
-                );
+                let (open, other) = chest_openness.unwrap_or_else(|| {
+                    self.chest_openness(
+                        pos,
+                        kind,
+                        &|p| scene.world.block(p[0], p[1], p[2]).0,
+                        scene.lid,
+                    )
+                });
                 if open != 0.0 {
                     return None;
                 }
@@ -3250,6 +3497,7 @@ fn portal_cube(m: Mat4, faces: &[Direction], layer: u32, out: &mut Vec<Vertex>)
 mod tests {
     use super::*;
     use crate::assets::Assets;
+    use horizon_world::nbt::Tag;
     #[test]
     #[ignore = "requires prepared models/textures in HORIZON_TEST_RESOURCES"]
     fn entity_block_particles_and_breaking_use_exported_models() -> Result<()> {
@@ -3362,6 +3610,7 @@ mod tests {
             skull: &|_| None,
             glyph: &|_| Glyph::default(),
             glyphs: 0,
+            dynamic_visible: None,
         };
         // Compare the cached world path with the original model renderer,
         // including atlas replacement, current light and animated fallback.
@@ -3656,6 +3905,7 @@ mod tests {
             skull: &|_| None,
             glyph: &glyph,
             glyphs: 0,
+            dynamic_visible: None,
         };
         let mut call = TextCall {
             matrix: Mat4::IDENTITY,
@@ -3728,6 +3978,7 @@ mod tests {
             skull: &|_| None,
             glyph: &glyph,
             glyphs: 0,
+            dynamic_visible: None,
         };
         let call = TextCall {
             matrix: Mat4::IDENTITY,
@@ -3756,6 +4007,129 @@ mod tests {
         assert_eq!(boxes, [[10.0, 14.0, 2.0, 10.0], [15.0, 19.0, 2.0, 10.0]]);
     }
 
+    /// The front text calls of a sign whose every glyph advances 6.
+    fn front_calls(data: &SignData, near: bool) -> Vec<(String, f32, f32, u32, u32)> {
+        let world = World::new(BlockStateId(0), 1);
+        let sprites = HashMap::new();
+        let glyph = |_: char| Glyph {
+            advance: 6.0,
+            ..Glyph::default()
+        };
+        let scene = Scene {
+            camera: DVec3::ZERO,
+            orientation: Quat::IDENTITY,
+            anim: &|_| BlockAnim::default(),
+            texts: None,
+            partial: 0.0,
+            game_time: 0,
+            max_y: 320,
+            world: &world,
+            sprites: &sprites,
+            emissive: &Default::default(),
+            translucent_sprites: &HashSet::new(),
+            atlas_revision: 1,
+            nether: false,
+            lid: &|_| 0.0,
+            sign: &|_| None,
+            banner: &|_| Vec::new(),
+            skull: &|_| None,
+            glyph: &glyph,
+            glyphs: 0,
+            dynamic_visible: None,
+        };
+        sign_text_calls(&scene, data, &data.front, Mat4::IDENTITY, 0, near)
+            .into_iter()
+            .map(|c| (c.text, c.x, c.y, c.color, c.outline))
+            .collect()
+    }
+    fn sign_with(lines: [Tag; 4]) -> SignData {
+        let mut data = SignData::default();
+        data.decode(&Tag::compound([(
+            "front_text",
+            Tag::compound([("messages", Tag::List(lines.to_vec()))]),
+        )]));
+        data
+    }
+    fn colored(text: &str, color: &str) -> Tag {
+        Tag::compound([
+            ("text", Tag::String(text.into())),
+            ("color", Tag::String(color.into())),
+        ])
+    }
+
+    /// `Font.StringRenderOutput`: a glyph takes its style's colour and the
+    /// sign's dark text colour only when the style has none (#9783). A line
+    /// of two colours is two calls, the second where the first ends, the
+    /// whole line centred.
+    #[test]
+    fn sign_text_takes_each_lines_own_colors() {
+        let mut two = colored("ab", "red");
+        let Tag::Compound(parts) = &mut two else {
+            unreachable!()
+        };
+        parts.insert("extra".into(), Tag::List(vec![colored("cd", "blue")]));
+        let data = sign_with([
+            Tag::String("plain".into()),
+            colored("Online", "green"),
+            two,
+            Tag::String("".into()),
+        ]);
+        // Black dye: the dark text colour is black. Sign lines are 10 apart
+        // from 20 above the middle.
+        assert_eq!(
+            front_calls(&data, false),
+            [
+                ("plain".to_owned(), -15.0, -20.0, 0xFF00_0000, 0),
+                ("Online".to_owned(), -18.0, -10.0, 0xFF55_FF55, 0),
+                ("ab".to_owned(), -12.0, 0.0, 0xFFFF_5555, 0),
+                ("cd".to_owned(), 0.0, 0.0, 0xFF55_55FF, 0),
+                (String::new(), 0.0, 10.0, 0xFF00_0000, 0),
+            ]
+        );
+    }
+
+    /// A glowing sign's own colour still wins over its dye, and the outline
+    /// stays the dye's dark colour. `§` codes in a line colour it too, and
+    /// `§r` goes back to the sign's colour.
+    #[test]
+    fn glowing_sign_text_keeps_its_outline_under_a_lines_own_colors() {
+        let mut data = sign_with([
+            Tag::String("plain".into()),
+            colored("Online", "green"),
+            Tag::String("§cRed§rX".into()),
+            Tag::String("".into()),
+        ]);
+        data.front.color = 14;
+        data.front.glowing = true;
+        let (red, outline) = (0xFFFF_0000, 0xFF66_0000);
+        assert_eq!(
+            front_calls(&data, true),
+            [
+                ("plain".to_owned(), -15.0, -20.0, red, outline),
+                ("Online".to_owned(), -18.0, -10.0, 0xFF55_FF55, outline),
+                ("Red".to_owned(), -12.0, 0.0, 0xFFFF_5555, outline),
+                ("X".to_owned(), 6.0, 0.0, red, outline),
+                (String::new(), 0.0, 10.0, red, outline),
+            ]
+        );
+    }
+
+    /// The text that fits the sign is drawn, in the colour it had.
+    #[test]
+    fn a_long_colored_line_is_cut_where_it_stops_fitting() {
+        // 90 wide: fifteen glyphs of 6.
+        let data = sign_with([
+            colored("abcdefghijklmnopqrst", "gold"),
+            Tag::String("".into()),
+            Tag::String("".into()),
+            Tag::String("".into()),
+        ]);
+        assert_eq!(
+            front_calls(&data, false)[0],
+            ("abcdefghijklmno".to_owned(), -45.0, -20.0, 0xFFFF_AA00, 0)
+        );
+    }
+
     #[test]
     fn cached_sign_text_matches_and_follows_changes() {
         let renderer = BlockEntityRenderer {
@@ -3843,6 +4217,7 @@ mod tests {
             skull: &|_| None,
             glyph: &glyph,
             glyphs: 0,
+            dynamic_visible: None,
         };
         let check = |scene: &Scene, pos: [i32; 3], state: u32| {
             let mut cached = Vec::new();
@@ -3983,6 +4358,7 @@ mod tests {
             skull: &|_| None,
             glyph: &|_| Glyph::default(),
             glyphs: 0,
+            dynamic_visible: None,
         };
         let mut verts = Vec::new();
         renderer.render_block(&scene, [0; 3], state.0, Mat4::IDENTITY, 0xff, &mut verts);
@@ -4068,6 +4444,7 @@ mod tests {
             skull: &|_| None,
             glyph: &|_| Glyph::default(),
             glyphs: 0,
+            dynamic_visible: None,
         };
         // A closed single chest of `block` drawn by `renderer`: positions and UVs.
         let draw = |renderer: &BlockEntityRenderer, block: &str, texture: &'static str| {

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

@@ -358,6 +358,7 @@ fn batched_callbacks_preserve_entity_ranges_and_allow_immediate_culling() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     // Reverse local-position order to check that cache indexing does not
     // change the order of emitted entities.
@@ -446,6 +447,7 @@ fn static_cache_qualifies_local_positions_by_section_and_drops_old_entries() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let options = CacheOptions {
         shulker_boxes: true,
@@ -500,6 +502,7 @@ fn gpu_static_cache_uses_section_local_chests_and_keeps_visibility_separate() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let blocks = [([100, 70, -32], 0)];
     let other_block = [([116, 70, -32], 0)];
@@ -686,6 +689,7 @@ fn sign_text_cache_can_be_disabled_and_reenabled_without_changing_output() {
         skull: &|_| None,
         glyph: &glyph,
         glyphs: 0,
+        dynamic_visible: None,
     };
     let blocks = [([0, 64, 0], 0)];
     let enabled = CacheOptions {
@@ -739,6 +743,7 @@ fn shulker_cache_tracks_settled_poses_and_does_not_freeze_opening_animation() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let blocks = [([0, 64, 0], 0)];
     let options = CacheOptions {
@@ -840,6 +845,7 @@ fn shulker_cache_covers_all_colors_and_facing_directions() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let options = CacheOptions {
         shulker_boxes: true,
@@ -894,6 +900,7 @@ fn cached_bells_keep_shaking_until_the_animation_ends() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let blocks = [([0, 64, 0], 0)];
     let options = CacheOptions {
@@ -955,6 +962,7 @@ fn cached_closed_chests_match_the_direct_model_and_rebuild_when_opening() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let blocks = [([0, 64, 0], 0)];
     let options = CacheOptions {
@@ -1050,6 +1058,7 @@ fn closed_chest_cache_covers_all_materials_and_atlas_reloads() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let pos = [0, 64, 0];
     let options = CacheOptions {
@@ -1138,6 +1147,7 @@ fn double_chest_cache_bypasses_both_halves_while_either_lid_is_open() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let pair = [([0, 64, 0], 0), ([1, 64, 0], 1)];
     let options = CacheOptions {
@@ -1213,6 +1223,7 @@ fn decorated_pot_cache_tracks_sherds_and_bypasses_wobble_animation() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let blocks = [([0, 64, 0], 0)];
     let options = CacheOptions {
@@ -1291,6 +1302,7 @@ fn banner_cache_keeps_the_pole_static_while_the_flag_and_patterns_update() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let blocks = [([0, 64, 0], 0)];
     let options = CacheOptions {
@@ -1357,6 +1369,7 @@ fn cached_wall_banner_poles_use_the_wall_model() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let pos = [0, 64, 0];
     let options = CacheOptions {
@@ -1404,6 +1417,7 @@ fn copper_statue_cache_rebuilds_when_its_pose_state_changes() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let options = CacheOptions {
         copper_golem_statues: true,
@@ -1509,6 +1523,7 @@ fn copper_statue_cache_covers_weathering_waxing_and_all_poses() {
         skull: &|_| None,
         glyph: &|_| Glyph::default(),
         glyphs: 0,
+        dynamic_visible: None,
     };
     let options = CacheOptions {
         copper_golem_statues: true,

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

@@ -90,9 +90,20 @@ pub fn effect_lines<'a>(
                 );
             }
             let instant = effect(e).is_some_and(|d| d.instant);
-            let scaled = (duration as f32 * scale) as i32;
-            if !instant && scaled > 20 {
-                line = format!("{line} ({})", format_duration(scaled));
+            if !instant {
+                if duration == -1 {
+                    // MobEffectInstance.isInfiniteDuration: formatDuration says
+                    // the infinite sign, not a time.
+                    line = format!(
+                        "{line} ({})",
+                        translate("effect.duration.infinite").unwrap_or_else(|| "∞".to_owned())
+                    );
+                } else {
+                    let scaled = (duration as f32 * scale) as i32;
+                    if scaled > 20 {
+                        line = format!("{line} ({})", format_duration(scaled));
+                    }
+                }
             }
             (line, effect(e).map_or(Category::Neutral, |d| d.category))
         })
@@ -487,6 +498,63 @@ mod tests {
         assert!(!stand.idle());
     }
 
+    /// The stand sleeps while `idle`, so its tick must change nothing then: run the real
+    /// tick on idle stands and compare, and check a stand with fuel to take wakes.
+    #[test]
+    fn an_idle_brewing_stand_tick_changes_nothing() {
+        let items = Items::for_tests(std::collections::HashMap::new());
+        let brewing = Brewing {
+            reagents: ["minecraft:nether_wart".to_owned()].into_iter().collect(),
+            inputs: HashSet::new(),
+            recipes: vec![BrewingRecipe {
+                id: "awkward".into(),
+                input: PotionIngredient {
+                    items: ["minecraft:potion".to_owned()].into_iter().collect(),
+                    potions: Some(["minecraft:water".to_owned()].into_iter().collect()),
+                },
+                reagent: PotionIngredient {
+                    items: ["minecraft:nether_wart".to_owned()].into_iter().collect(),
+                    potions: None,
+                },
+                output: ItemStack::new("minecraft:potion", 1).with_potion("minecraft:awkward"),
+            }],
+        };
+        let providers = Providers::empty();
+        let water = || Some(ItemStack::new("minecraft:potion", 1).with_potion("minecraft:water"));
+        let stand = |bottle: bool, fuel: i32, powder: bool| {
+            let mut s = BrewingStand::new();
+            s.fuel = fuel;
+            if bottle {
+                s.items[1] = water();
+            }
+            if powder {
+                s.items[4] = Some(ItemStack::new("minecraft:blaze_powder", 1));
+            }
+            s.last_bottles = Some([false, bottle, false]);
+            s
+        };
+        for before in [
+            stand(false, 0, false),
+            stand(true, 0, false),
+            stand(true, 5, false),
+            stand(true, 5, true),
+        ] {
+            assert!(before.idle(), "{before:?}");
+            let mut after = before.clone();
+            assert_eq!(
+                after.tick(&brewing, &items, &providers),
+                BrewTick::default()
+            );
+            assert_eq!(format!("{after:?}"), format!("{before:?}"));
+        }
+        // A brewable ingredient starts the brew: not idle, and the tick changes it.
+        let mut brewing_now = stand(true, 5, false);
+        brewing_now.items[3] = Some(ItemStack::new("minecraft:nether_wart", 1));
+        assert!(!brewing_now.idle());
+        brewing_now.tick(&brewing, &items, &providers);
+        assert_eq!(brewing_now.brew_time, 400);
+    }
+
     /// #3312: `PotionContents.getPotionDescription` names the effects with
     /// translatable components, so a Russian game reads them from ru_ru.json
     /// (the prepared one; skipped without it), as the tooltip's other lines.
@@ -505,4 +573,15 @@ mod tests {
         assert!(lines[0].0.starts_with("Замедление IV ("), "{lines:?}");
         assert!(lines[1].0.starts_with("Сопротивление III ("), "{lines:?}");
     }
+
+    #[test]
+    fn infinite_effects_say_the_infinite_sign() {
+        // MobEffectInstance.isInfiniteDuration: a -1 duration says the
+        // infinite sign, not a time; a short one still says nothing.
+        let translate = |key: &str| (key == "effect.duration.infinite").then(|| "∞".to_owned());
+        let lines = effect_lines([("minecraft:resistance", -1, 0)], 1.0, &translate);
+        assert_eq!(lines[0].0, "resistance (∞)");
+        let lines = effect_lines([("minecraft:resistance", 15, 0)], 1.0, &translate);
+        assert_eq!(lines[0].0, "resistance");
+    }
 }

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

@@ -1,3 +1,27 @@
+// `joml::Mat4::rotation`, `rotate_affine`, `transform_affine` and `invert_orthonormal`, and
+// `joml::Quat::rotation_x`/`_y`/`_z`, in this file are adapted from JOML 1.10.9's `Matrix4f`,
+// `Quaternionf` and `Vector4f` (https://github.com/JOML-CI/JOML, MIT; see THIRD_PARTY_NOTICES.md).
+//
+// Copyright (c) 2015-2026 Richard Greenlees
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
 //! The camera (`Camera.tick`, `tickFov`, `calculateFov`, `alignWithEntity`,
 //! `getMaxZoom`, `setRotation`, `move`), view and hurt bobbing
 //! (`GameRenderer.bobView`, `bobHurt`), the walk and bob history they read
@@ -119,6 +143,40 @@ pub mod joml {
                 w: w * cz + z * sz,
             }
         }
+        /// `Quaternionf.rotationX(angle)`.
+        pub fn rotation_x(angle: f32) -> Self {
+            let (x, w) = Self::half_turn(angle);
+            Self {
+                x,
+                y: 0.0,
+                z: 0.0,
+                w,
+            }
+        }
+        /// `Quaternionf.rotationY(angle)`.
+        pub fn rotation_y(angle: f32) -> Self {
+            let (y, w) = Self::half_turn(angle);
+            Self {
+                x: 0.0,
+                y,
+                z: 0.0,
+                w,
+            }
+        }
+        /// `Quaternionf.rotationZ(angle)`.
+        pub fn rotation_z(angle: f32) -> Self {
+            let (z, w) = Self::half_turn(angle);
+            Self {
+                x: 0.0,
+                y: 0.0,
+                z,
+                w,
+            }
+        }
+        fn half_turn(angle: f32) -> (f32, f32) {
+            let sin = sin(angle * 0.5);
+            (sin, cos_from_sin(sin, angle * 0.5))
+        }
         /// `Quaternionf.transform(x, y, z, dest)` (`Vector3f.rotate`).
         pub fn transform(&self, v: [f32; 3]) -> [f32; 3] {
             let [x, y, z] = v;
@@ -142,8 +200,10 @@ pub mod joml {
     }
 
     const PERSPECTIVE: u8 = 1;
+    const AFFINE: u8 = 2;
     const IDENTITY: u8 = 4;
     const TRANSLATION: u8 = 8;
+    const ORTHONORMAL: u8 = 16;
 
     /// A JOML `Matrix4f` with its property flags, which select the code
     /// paths (and so the rounding) of later operations. `m[column * 4 + row]`.
@@ -284,10 +344,149 @@ pub mod joml {
             // already taken that branch.
             self.rotate_axis(2, ang);
         }
+        /// `Matrix4f.rotation(Quaternionfc)`.
+        pub fn rotation(&mut self, q: Quat) {
+            let (w2, x2, y2, z2) = (q.w * q.w, q.x * q.x, q.y * q.y, q.z * q.z);
+            let zw = q.z * q.w;
+            let dzw = zw + zw;
+            let xy = q.x * q.y;
+            let dxy = xy + xy;
+            let xz = q.x * q.z;
+            let dxz = xz + xz;
+            let yw = q.y * q.w;
+            let dyw = yw + yw;
+            let yz = q.y * q.z;
+            let dyz = yz + yz;
+            let xw = q.x * q.w;
+            let dxw = xw + xw;
+            self.reset_unless_identity();
+            self.set(0, 0, w2 + x2 - z2 - y2);
+            self.set(0, 1, dxy + dzw);
+            self.set(0, 2, dxz - dyw);
+            self.set(1, 0, -dzw + dxy);
+            self.set(1, 1, y2 - z2 + w2 - x2);
+            self.set(1, 2, dyz + dxw);
+            self.set(2, 0, dyw + dxz);
+            self.set(2, 1, dyz - dxw);
+            self.set(2, 2, z2 - y2 - x2 + w2);
+            self.properties = AFFINE | ORTHONORMAL;
+        }
+        /// An affine matrix of no more specific kind, as JOML's property flags have it.
+        pub fn affine(m: glam::Mat4) -> Self {
+            Self {
+                m: m.to_cols_array(),
+                properties: AFFINE,
+            }
+        }
+        /// `Matrix4f.rotate(Quaternionfc)` of an affine matrix that is neither the identity nor
+        /// a pure translation (`rotateAffine`).
+        pub fn rotate_affine(&mut self, q: Quat) {
+            debug_assert!(
+                self.properties & AFFINE != 0 && self.properties & (IDENTITY | TRANSLATION) == 0
+            );
+            let (w2, x2, y2, z2) = (q.w * q.w, q.x * q.x, q.y * q.y, q.z * q.z);
+            let zw = q.z * q.w;
+            let dzw = zw + zw;
+            let xy = q.x * q.y;
+            let dxy = xy + xy;
+            let xz = q.x * q.z;
+            let dxz = xz + xz;
+            let yw = q.y * q.w;
+            let dyw = yw + yw;
+            let yz = q.y * q.z;
+            let dyz = yz + yz;
+            let xw = q.x * q.w;
+            let dxw = xw + xw;
+            let r = [
+                [w2 + x2 - z2 - y2, dxy + dzw, dxz - dyw],
+                [-dzw + dxy, y2 - z2 + w2 - x2, dyz + dxw],
+                [dyw + dxz, dyz - dxw, z2 - y2 - x2 + w2],
+            ];
+            let s = *self;
+            for (column, r) in r.iter().enumerate() {
+                for row in 0..3 {
+                    let v = s.get(0, row) * r[0] + s.get(1, row) * r[1] + s.get(2, row) * r[2];
+                    self.set(column, row, v);
+                }
+                self.set(column, 3, 0.0);
+            }
+            self.properties &= !(PERSPECTIVE | IDENTITY | TRANSLATION);
+        }
+        /// `Vector4f.mul(Matrix4fc)` of an affine matrix (`mulAffine`, JOML's `Math.fma`
+        /// unfused): the matrix times `v`, `w` kept.
+        pub fn transform_affine(&self, v: [f32; 4]) -> [f32; 3] {
+            debug_assert!(self.properties & AFFINE != 0);
+            let [x, y, z, w] = v;
+            std::array::from_fn(|row| {
+                self.get(0, row) * x
+                    + (self.get(1, row) * y + (self.get(2, row) * z + self.get(3, row) * w))
+            })
+        }
+        /// `Matrix4f.invert()` of a rotation and translation (`invertOrthonormal`; with the
+        /// identity and pure-translation shortcuts). `None` for any other matrix, which JOML
+        /// inverts by other code paths.
+        pub fn invert_orthonormal(&self) -> Option<Self> {
+            if self.properties & IDENTITY != 0 {
+                return Some(Self::IDENTITY);
+            }
+            let mut out = *self;
+            if self.properties & TRANSLATION != 0 {
+                for row in 0..3 {
+                    out.set(3, row, -self.get(3, row));
+                }
+                out.properties = AFFINE | TRANSLATION | ORTHONORMAL;
+                return Some(out);
+            }
+            if self.properties & ORTHONORMAL == 0 {
+                return None;
+            }
+            let g = |c, r| self.get(c, r);
+            let t = |c| -(g(c, 0) * g(3, 0) + g(c, 1) * g(3, 1) + g(c, 2) * g(3, 2));
+            out.m = [
+                g(0, 0),
+                g(1, 0),
+                g(2, 0),
+                0.0,
+                g(0, 1),
+                g(1, 1),
+                g(2, 1),
+                0.0,
+                g(0, 2),
+                g(1, 2),
+                g(2, 2),
+                0.0,
+                t(0),
+                t(1),
+                t(2),
+                1.0,
+            ];
+            out.properties = AFFINE | ORTHONORMAL;
+            Some(out)
+        }
+        pub fn to_glam(self) -> glam::Mat4 {
+            glam::Mat4::from_cols_array(&self.m)
+        }
     }
 }
 use joml::{Mat4, Quat};
 
+/// `Camera.getViewRotationMatrix` to the last bit: `Matrix4f.rotation` of the conjugate of
+/// `setRotation`'s quaternion, and its JOML `invert()`. `view_matrix` turns the same quaternion
+/// into a matrix by glam's formula, which differs in the last bits (1.0 for 0.99999994, 6e-8 for
+/// 0).
+pub fn view_rotation_matrix(yaw: f32, pitch: f32) -> (glam::Mat4, glam::Mat4) {
+    let q = Quat::rotation_yxz(PI - yaw * DEG_TO_RAD, -pitch * DEG_TO_RAD, 0.0);
+    let mut m = Mat4::IDENTITY;
+    m.rotation(Quat {
+        x: -q.x,
+        y: -q.y,
+        z: -q.z,
+        w: q.w,
+    });
+    let inverse = m.invert_orthonormal().expect("a rotation is orthonormal");
+    (m.to_glam(), inverse.to_glam())
+}
+
 /// Camera-relative world view used by terrain, sky and the first-person hand.
 pub fn view_matrix(yaw: f32, pitch: f32) -> glam::Mat4 {
     // Vanilla uses the conjugate of Camera.rotation, not a world-up look-at.

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

@@ -431,6 +431,16 @@ pub struct SignText {
     pub glowing: bool,
     /// The `click_event` in each line's component style, as saved.
     pub click: [Option<Tag>; 4],
+    /// Each line's saved component when it is more than plain text (a colour,
+    /// siblings, a list), so its style survives loading, saving and the
+    /// network. See `SignText::message` for a line edited since.
+    pub saved: [Option<SavedLine>; 4],
+}
+/// A sign line's saved component and the text it showed when it was read.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SavedLine {
+    pub text: String,
+    pub component: Tag,
 }
 /// `SignBlockEntity` / `HangingSignBlockEntity` data.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]

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

@@ -749,6 +749,43 @@ mod tests {
         assert!(c.idle(false));
     }
 
+    /// The campfire sleeps while `idle`, so the tick its block runs (`cook_tick` lit,
+    /// `cooldown_tick` unlit) must change nothing then, and must change an awake one.
+    #[test]
+    fn an_idle_campfire_tick_changes_nothing() {
+        let tick = |c: &mut Campfire, lit: bool| {
+            if lit {
+                !c.cook_tick().is_empty()
+            } else {
+                c.cooldown_tick()
+            }
+        };
+        let empty = Campfire::default();
+        let mut food = Campfire::default();
+        assert!(food.place_food(&mut ItemStack::new("minecraft:beef", 1), 600));
+        let mut warm = food.clone();
+        warm.cook_tick();
+        let mut cooled = warm.clone();
+        while cooled.cooldown_tick() {}
+        for (before, lit) in [
+            (&empty, true),
+            (&empty, false),
+            (&food, false),
+            (&cooled, false),
+        ] {
+            assert!(before.idle(lit), "{before:?} lit {lit}");
+            let mut after = before.clone();
+            assert!(!tick(&mut after, lit));
+            assert_eq!(&after, before, "lit {lit}");
+        }
+        for (before, lit) in [(&food, true), (&warm, false)] {
+            assert!(!before.idle(lit), "{before:?} lit {lit}");
+            let mut after = before.clone();
+            tick(&mut after, lit);
+            assert_ne!(&after, before, "lit {lit}");
+        }
+    }
+
     #[test]
     fn campfire_slots_take_food_cook_it_and_cool_down() {
         let mut c = Campfire::default();

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

@@ -66,6 +66,8 @@ pub struct Extras {
     /// Modrinth. Off by default: it is Horizon's own and the screen is
     /// otherwise vanilla's (tools/test_pack_screen_parity.py).
     pub pack_browser: bool,
+    /// Make /pregen available in single-player and hosted LAN worlds.
+    pub pregen: bool,
     pub fullbright: bool,
     /// Held, dropped and burning light sources light their surroundings (`dynamic_light`).
     pub dynamic_lights: bool,
@@ -166,9 +168,17 @@ pub struct Extras {
     pub cosmetics_mine: bool,
     pub cosmetics_others: Option<horizon_cosmetics::prefs::Others>,
     pub cosmetics_auras: bool,
+    /// My cosmetics in single player too (`cosmeticsSolo`, off by default): the window's own server
+    /// names the player by their offline profile, which the service doesn't know, so their own
+    /// cosmetics and name tag style show only with this on.
+    pub cosmetics_solo: bool,
     /// Whether the signed-in account owns a cosmetic, as the service said (never saved; the game
     /// sets it): with no choice made, others' cosmetics show only then.
     pub cosmetics_owner: bool,
+    /// Horizon's mark before the names of other Horizon players (name tags, player list), and
+    /// whether the service may say this player plays Horizon: both on by default.
+    pub horizon_marks: bool,
+    pub horizon_listed: 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`).
@@ -180,6 +190,7 @@ impl Default for Extras {
     fn default() -> Self {
         Self {
             pack_browser: false,
+            pregen: false,
             fullbright: false,
             dynamic_lights: false,
             zoom: false,
@@ -225,7 +236,10 @@ impl Default for Extras {
             cosmetics_mine: true,
             cosmetics_others: None,
             cosmetics_auras: false,
+            cosmetics_solo: false,
             cosmetics_owner: false,
+            horizon_marks: true,
+            horizon_listed: true,
             three_d_skin_layers: false,
             pvp: Default::default(),
         }
@@ -259,6 +273,7 @@ impl Extras {
             };
             match key.trim() {
                 "packBrowser" => e.pack_browser = flag(e.pack_browser),
+                "pregen" => e.pregen = flag(e.pregen),
                 "fullbright" => e.fullbright = flag(e.fullbright),
                 "dynamicLights" => e.dynamic_lights = flag(e.dynamic_lights),
                 "zoom" => e.zoom = flag(e.zoom),
@@ -335,6 +350,9 @@ impl Extras {
                         horizon_cosmetics::prefs::Others::parse(value).or(e.cosmetics_others)
                 }
                 "cosmeticsAuras" => e.cosmetics_auras = flag(e.cosmetics_auras),
+                "cosmeticsSolo" => e.cosmetics_solo = flag(e.cosmetics_solo),
+                horizon_cosmetics::prefs::MARKS => e.horizon_marks = flag(e.horizon_marks),
+                horizon_cosmetics::prefs::LISTED => e.horizon_listed = flag(e.horizon_listed),
                 SKIN_LAYERS_KEY => e.three_d_skin_layers = flag(e.three_d_skin_layers),
                 key => {
                     e.pvp.parse_line(key, value);
@@ -345,8 +363,9 @@ impl Extras {
     }
     pub fn serialize(&self) -> String {
         let mut text = format!(
-            "packBrowser:{}\nfullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nlodZoomDetail:{}\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:{}\n{}cosmeticsAuras:{}\n{}:{}\n",
+            "packBrowser:{}\npregen:{}\nfullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nlodZoomDetail:{}\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:{}\n{}cosmeticsAuras:{}\ncosmeticsSolo:{}\n{}:{}\n{}:{}\n{}:{}\n",
             bool_text(self.pack_browser),
+            bool_text(self.pregen),
             bool_text(self.fullbright),
             bool_text(self.dynamic_lights),
             bool_text(self.zoom),
@@ -399,6 +418,11 @@ impl Extras {
             self.cosmetics_others
                 .map_or(String::new(), |o| format!("cosmeticsOthers:{}\n", o.name())),
             bool_text(self.cosmetics_auras),
+            bool_text(self.cosmetics_solo),
+            horizon_cosmetics::prefs::MARKS,
+            bool_text(self.horizon_marks),
+            horizon_cosmetics::prefs::LISTED,
+            bool_text(self.horizon_listed),
             SKIN_LAYERS_KEY,
             bool_text(self.three_d_skin_layers),
         );
@@ -570,24 +594,25 @@ pub enum Item {
     WheelCyclesSettings,
     /// The Select Resource Packs screen's Add button (Modrinth).
     PackBrowser,
+    Pregen,
     /// Shown only while cosmetics are enabled (`horizon_cosmetics::enabled`).
     CosmeticsMine,
     CosmeticsOthers,
     CosmeticsAuras,
+    CosmeticsSolo,
+    HorizonMarks,
+    HorizonMe,
     /// On the PvP & HUD page (`pvp::rows`).
     Pvp(crate::pvp::Opt),
 }
 /// The Extras page: headers (language keys) and items.
 pub fn rows() -> Vec<Result<Item, &'static str>> {
     use Item::*;
+    // Fullbright, Dynamic lights and Hide block-break particles change the picture: they
+    // are on the graphics screen's Quality page (`graphics_ui::rows`), not here.
     let mut rows = vec![
-        Err("horizon.extras.header.lighting"),
-        Ok(Fullbright),
-        Ok(DynamicLights),
         Err("horizon.extras.header.third_person"),
         Ok(OwnNameTag),
-        Err("horizon.extras.header.particles"),
-        Ok(HideBlockParticles),
         Err("horizon.extras.header.inventory"),
         Ok(MouseTweaks),
         Ok(MouseTweaksWheel),
@@ -596,6 +621,8 @@ pub fn rows() -> Vec<Result<Item, &'static str>> {
         Err("horizon.extras.header.chat"),
         Ok(ChatAnimation),
         Ok(ChatIndicator),
+        Err("horizon.extras.header.world"),
+        Ok(Pregen),
         Err("horizon.extras.header.multiplayer"),
         Ok(AutoReconnect),
         Err("horizon.extras.header.sound"),
@@ -609,8 +636,11 @@ pub fn rows() -> Vec<Result<Item, &'static str>> {
         rows.extend([
             Err("horizon.extras.header.cosmetics"),
             Ok(CosmeticsMine),
+            Ok(CosmeticsSolo),
             Ok(CosmeticsOthers),
             Ok(CosmeticsAuras),
+            Ok(HorizonMarks),
+            Ok(HorizonMe),
         ]);
     }
     rows
@@ -639,9 +669,13 @@ impl Item {
             Item::ChatIndicator => "horizon.extras.chat_indicator",
             Item::WheelCyclesSettings => "horizon.extras.wheel_cycles_settings",
             Item::PackBrowser => "horizon.extras.pack_browser",
+            Item::Pregen => "horizon.extras.pregen",
             Item::CosmeticsMine => "horizon.extras.cosmetics_mine",
             Item::CosmeticsOthers => "horizon.extras.cosmetics_others",
             Item::CosmeticsAuras => "horizon.extras.cosmetics_auras",
+            Item::CosmeticsSolo => "horizon.extras.cosmetics_solo",
+            Item::HorizonMarks => "horizon.extras.horizon_marks",
+            Item::HorizonMe => "horizon.extras.horizon_me",
             Item::Pvp(o) => o.caption_key(),
         }
     }
@@ -668,9 +702,13 @@ impl Item {
             Item::ChatIndicator => "horizon.extras.chat_indicator.tooltip",
             Item::WheelCyclesSettings => "horizon.extras.wheel_cycles_settings.tooltip",
             Item::PackBrowser => "horizon.extras.pack_browser.tooltip",
+            Item::Pregen => "horizon.extras.pregen.tooltip",
             Item::CosmeticsMine => "horizon.extras.cosmetics_mine.tooltip",
             Item::CosmeticsOthers => "horizon.extras.cosmetics_others.tooltip",
             Item::CosmeticsAuras => "horizon.extras.cosmetics_auras.tooltip",
+            Item::CosmeticsSolo => "horizon.extras.cosmetics_solo.tooltip",
+            Item::HorizonMarks => "horizon.extras.horizon_marks.tooltip",
+            Item::HorizonMe => "horizon.extras.horizon_me.tooltip",
             Item::Pvp(o) => o.description_key(),
         }
     }
@@ -706,9 +744,13 @@ impl Item {
             Item::Splitscreen => "Splitscreen",
             Item::WheelCyclesSettings => "Scroll wheel changes settings",
             Item::PackBrowser => "Resource pack browser",
+            Item::Pregen => "Chunk pregeneration",
             Item::CosmeticsMine => "My cosmetics",
             Item::CosmeticsOthers => "Other players' cosmetics",
             Item::CosmeticsAuras => "Others' auras and trails",
+            Item::CosmeticsSolo => "In single player",
+            Item::HorizonMarks => "Horizon logos",
+            Item::HorizonMe => "Show me as Horizon",
             Item::Pvp(o) => o.caption(),
         }
     }
@@ -724,7 +766,8 @@ impl Item {
             Fullbright | DynamicLights | OwnNameTag | HideBlockParticles | MouseTweaks | Sort
             | AutoReconnect | NoAi | AgentControl | ReproKeys | DiscordPresence | Splitscreen
             | ChatAnimation | WheelCyclesSettings | MusicPage | PackBrowser | CosmeticsMine
-            | CosmeticsOthers | CosmeticsAuras => {
+            | CosmeticsOthers | CosmeticsAuras | CosmeticsSolo | HorizonMarks | HorizonMe
+            | Pregen => {
                 return None;
             }
         })
@@ -732,6 +775,9 @@ impl Item {
     /// The English description: the fallback of [`Item::description_text`].
     pub fn description(self) -> &'static str {
         match self {
+            Item::Pregen => {
+                "Enables /pregen in your single-player and LAN worlds. With cheats enabled, use /pregen start to generate an area before exploring it. Does not enable the command on servers you join."
+            }
             Item::Fullbright => "Show blocks and entities at full light, even in dark areas.",
             Item::DynamicLights => {
                 "Torches and other light sources held, dropped or on fire light the blocks around them."
@@ -789,6 +835,15 @@ impl Item {
                 "What other Horizon players wear: everything, only their name tag styles, or nothing. Hidden unless you own cosmetics, until you choose. Hidden, the game never asks what they wear."
             }
             Item::CosmeticsAuras => "Auras and trails other players wear. Off by default.",
+            Item::CosmeticsSolo => {
+                "Show your cosmetics and your name tag's badge in your single-player worlds too (your name tag with Own name tag). Off: only on servers."
+            }
+            Item::HorizonMarks => {
+                "Show the Horizon logo next to Horizon players: a small logo before the names of other players who use Horizon, above their heads and in the player list. Only Horizon players see it: servers receive nothing."
+            }
+            Item::HorizonMe => {
+                "Show me as a Horizon player: other Horizon players see the logo by your name. On, the service answers anyone who asks about you that you played Horizon in the last 3 hours; off, it never reports you."
+            }
             Item::Pvp(o) => o.description(),
             Item::WheelCyclesSettings => {
                 "The scroll wheel over a button in the settings changes its value, as in vanilla. Off, the wheel only scrolls the list."
@@ -815,7 +870,12 @@ impl Item {
             | Item::Splitscreen
             | Item::WheelCyclesSettings
             | Item::PackBrowser => Some(Cost::None),
-            Item::CosmeticsMine | Item::CosmeticsOthers | Item::CosmeticsAuras => Some(Cost::Low),
+            Item::CosmeticsMine
+            | Item::CosmeticsOthers
+            | Item::CosmeticsAuras
+            | Item::CosmeticsSolo
+            | Item::HorizonMarks
+            | Item::HorizonMe => Some(Cost::Low),
             _ => None,
         }
     }
@@ -841,7 +901,11 @@ impl Item {
             Item::Splitscreen => e.splitscreen,
             Item::WheelCyclesSettings => e.wheel_cycles_settings,
             Item::PackBrowser => e.pack_browser,
+            Item::Pregen => e.pregen,
             Item::CosmeticsAuras => e.cosmetics_auras,
+            Item::CosmeticsSolo => e.cosmetics_solo,
+            Item::HorizonMarks => e.horizon_marks,
+            Item::HorizonMe => e.horizon_listed,
             Item::Pvp(o) => return o.switch(&e.pvp),
             _ => return None,
         })
@@ -896,6 +960,7 @@ impl Item {
             Item::Splitscreen => e.splitscreen = !e.splitscreen,
             Item::WheelCyclesSettings => e.wheel_cycles_settings = !e.wheel_cycles_settings,
             Item::PackBrowser => e.pack_browser = !e.pack_browser,
+            Item::Pregen => e.pregen = !e.pregen,
             Item::CosmeticsMine => e.cosmetics_mine = !e.cosmetics_mine,
             Item::CosmeticsOthers => {
                 // From what the button shows; the result is the player's choice from now on.
@@ -903,6 +968,9 @@ impl Item {
                 e.cosmetics_others = Some(if back { o.next().next() } else { o.next() });
             }
             Item::CosmeticsAuras => e.cosmetics_auras = !e.cosmetics_auras,
+            Item::CosmeticsSolo => e.cosmetics_solo = !e.cosmetics_solo,
+            Item::HorizonMarks => e.horizon_marks = !e.horizon_marks,
+            Item::HorizonMe => e.horizon_listed = !e.horizon_listed,
             Item::Pvp(o) => o.cycle(&mut e.pvp, back),
             Item::SortKey => {}
         }
@@ -993,7 +1061,7 @@ mod tests {
         assert!(!d.fullbright && !d.dynamic_lights);
         assert!(!d.zoom && !d.fps && !d.keystrokes && !d.minimap && !d.auto_reconnect);
         assert!(!d.mouse_tweaks && !d.sort && !d.own_name_tag && !d.ui_sound_reserve);
-        assert!(!d.hide_block_particles);
+        assert!(!d.hide_block_particles && !d.pregen);
         assert!(!d.music_page && d.music_off.is_empty());
         assert!(d.discord_presence && d.wheel_cycles_settings);
         assert_eq!(Extras::parse(""), d);
@@ -1018,6 +1086,8 @@ mod tests {
         e.minimap_rotate = true;
         e.minimap_corner = Corner::BottomLeft;
         e.auto_reconnect = true;
+        Item::Pregen.cycle(&mut e, false);
+        assert_eq!(Item::Pregen.switch(&e), Some(true));
         Item::OwnNameTag.cycle(&mut e, false);
         assert_eq!(Item::OwnNameTag.switch(&e), Some(true));
         assert_eq!(Item::HideBlockParticles.switch(&e), Some(false));

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

@@ -936,6 +936,10 @@ impl Font {
             offset: 0.5,
         })
     }
+    /// Starts the random `random_glyph` draws on over from `seed`.
+    pub fn reseed(&self, seed: i64) {
+        self.cache.borrow_mut().random = horizon_core::random::LegacyRandom::new(seed);
+    }
     /// `FontSet.getRandomGlyph`: what an obfuscated character draws, a random
     /// glyph of the font as wide as `advance` (rounded up), else the missing
     /// glyph.

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

@@ -55,6 +55,13 @@ const RETEST: u32 = 8;
 /// more than they save. Else one frame in `PROBE` tests every section.
 const MIN_SHARE: f32 = 0.1;
 const PROBE: u32 = 64;
+/// The gate, for frame `stamp`, with `share` the newest result's hidden share:
+/// whether the frame culls, and whether it probes (tests every section). GPU
+/// culling's frames take it too.
+pub(super) fn gate(share: f32, stamp: u32) -> (bool, bool) {
+    let probe = share < MIN_SHARE;
+    (!probe || stamp.is_multiple_of(PROBE), probe)
+}
 /// On Metal, sections in view from which a frame culls. Apple's GPUs store
 /// and reload the whole frame at each of the passes the test adds, a fixed
 /// cost that the sections it hides repay only at high render distances: on
@@ -232,6 +239,11 @@ impl Cull {
             ))
         .then_some(depth_test)
     }
+    /// Its test runs in phase 1's pass, the depth test forced early (Vulkan):
+    /// GPU culling's frames can run it too.
+    pub fn early(&self) -> bool {
+        self.depth_test == DepthTest::Early
+    }
     /// `color` is the world pass's colour format.
     pub fn new(device: &wgpu::Device, color: wgpu::TextureFormat, depth_test: DepthTest) -> Self {
         let entry = |binding, visibility, ty| wgpu::BindGroupLayoutEntry {
@@ -422,8 +434,12 @@ impl Cull {
         self.test_slots.clear();
         self.test_indices.clear();
         self.total = 0;
-        self.probe = !self.always && self.hidden.1 < MIN_SHARE;
-        !self.probe || self.stamp.is_multiple_of(PROBE)
+        let (culls, probe) = match self.always {
+            true => (true, false),
+            false => gate(self.hidden.1, self.stamp),
+        };
+        self.probe = probe;
+        culls
     }
 
     /// Whether phase 1 draws the section in resident `slot` (or the far tile
@@ -718,6 +734,15 @@ fn source(depth_test: DepthTest) -> String {
 mod tests {
     use super::*;
 
+    /// Culling while the newest result hid enough; else one frame in `PROBE`
+    /// tests every section. GPU culling's frames take the same gate.
+    #[test]
+    fn the_gate_culls_while_enough_is_hidden_and_probes_else() {
+        assert_eq!(gate(MIN_SHARE, 3), (true, false));
+        assert_eq!(gate(MIN_SHARE / 2.0, 3), (false, true));
+        assert_eq!(gate(MIN_SHARE / 2.0, PROBE), (true, true));
+    }
+
     #[test]
     fn shaders_validate() {
         for (depth_test, capabilities) in [

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

@@ -14,7 +14,8 @@ use super::Vertex;
 /// material at the end: the render types vanilla gives an `OitPipelineSet`
 /// (translucent, emissive, eyes and breeze wind entity models). Off, the tag is
 /// ignored and they stay in the first one, in their order.
-const MATERIALS: usize = 10;
+/// Two native world-canvas text materials follow it, NORMAL then POLYGON_OFFSET.
+const MATERIALS: usize = 12;
 /// A bit of `Vertex::layer`, above the overlay (low 16 bits) and the HDR tier
 /// (bits 16 to 23): the quad's render type has an `OitPipelineSet`
 /// (`RenderTypes.entityTranslucent`, `entityTranslucentEmissive`, `eyes`,
@@ -51,6 +52,10 @@ pub const TRANSLUCENT_GLINT_ITEM_OVERLAY: u32 = 33;
 /// The overlay of text in `Font.DisplayMode.POLYGON_OFFSET` (text displays):
 /// drawn like an ordinary entity, pulled toward the camera.
 pub const TEXT_POLYGON_OFFSET_OVERLAY: u32 = 35;
+/// A native world canvas, drawn after particles with normal text depth/culling.
+pub const WORLD_TEXT_OVERLAY: u32 = 39;
+/// The front of its eight-offset outlined text, using POLYGON_OFFSET.
+pub const WORLD_TEXT_POLYGON_OFFSET_OVERLAY: u32 = 40;
 
 /// The material of a quad by its overlay (`MATERIALS` order): the overlay is the layer's low 16
 /// bits, as entity.wgsl reads it; HDR output's tier rides in the high ones.
@@ -59,6 +64,8 @@ fn material(layer: u32, oit: bool) -> usize {
         return 9;
     }
     match layer & 0xffff {
+        WORLD_TEXT_OVERLAY => 10,
+        WORLD_TEXT_POLYGON_OFFSET_OVERLAY => 11,
         TEXT_POLYGON_OFFSET_OVERLAY => 1,
         11 => 2,
         12 => 3,
@@ -118,7 +125,7 @@ impl EntityBatch {
         self.combined.clear();
         self.combined
             .reserve(entity_vertices + additive.len() + hand.len() + see_through.len());
-        for runs in &self.runs {
+        for runs in &self.runs[..10] {
             for &(first, count) in runs {
                 self.combined
                     .extend_from_slice(&entities[first * 4..(first + count) * 4]);
@@ -141,6 +148,27 @@ impl EntityBatch {
                 }
             }
         }
+        // RenderType.text sorts alpha-blended quads from far to near. Keep
+        // both world-canvas layers after existing materials (including eyes
+        // moved out of additive); front text uses polygon offset.
+        for runs in &self.runs[10..] {
+            let start = self.combined.len();
+            for &(first, count) in runs {
+                self.combined
+                    .extend_from_slice(&entities[first * 4..(first + count) * 4]);
+            }
+            self.combined[start..]
+                .as_chunks_mut::<4>()
+                .0
+                .sort_by(|a, b| {
+                    let distance = |q: &[Vertex; 4]| {
+                        (0..3)
+                            .map(|i| ((q[0].pos[i] + q[2].pos[i]) * 0.5).powi(2))
+                            .sum::<f32>()
+                    };
+                    distance(b).total_cmp(&distance(a))
+                });
+        }
         if self.moved_additive == 0 {
             self.combined.extend_from_slice(additive);
         } else {
@@ -160,6 +188,41 @@ impl EntityBatch {
 mod tests {
     use super::*;
     use std::{hint::black_box, time::Instant};
+    #[test]
+    fn world_canvas_sorts_after_oit_eyes_before_frame_tails() {
+        let quad = |layer, x| {
+            [Vertex {
+                layer,
+                pos: [x, 0.0, 0.0],
+                ..geometry(1, false)[0]
+            }; 4]
+        };
+        let entities: Vec<_> = [
+            (0, 1.0),
+            (35, 2.0),
+            (OIT_ENTITY, 3.0),
+            (WORLD_TEXT_OVERLAY, 4.0),
+            (WORLD_TEXT_OVERLAY, 5.0),
+            (WORLD_TEXT_POLYGON_OFFSET_OVERLAY, 6.0),
+        ]
+        .into_iter()
+        .flat_map(|(layer, x)| quad(layer, x))
+        .collect();
+        let additive: Vec<_> = [(OIT_ENTITY | 2, 7.0), (2, 8.0)]
+            .into_iter()
+            .flat_map(|(layer, x)| quad(layer, x))
+            .collect();
+        let mut batch = EntityBatch::default();
+        assert_eq!(
+            batch.update(&entities, &additive, &quad(0, 9.0), &quad(0, 10.0), true),
+            [1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 1]
+        );
+        let positions: Vec<_> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
+        assert_eq!(
+            positions,
+            [1.0, 2.0, 3.0, 7.0, 5.0, 4.0, 6.0, 8.0, 9.0, 10.0]
+        );
+    }
 
     // Retain the original implementation as the equivalence/benchmark oracle.
     fn baseline(
@@ -257,12 +320,12 @@ mod tests {
         let mut batch = EntityBatch::default();
         // Off: the tag changes nothing, the quads keep their place.
         let counts = batch.update(&entities, &[], &[], &[], false);
-        assert_eq!(counts, [4, 0, 0, 0, 0, 0, 1, 0, 0, 0]);
+        assert_eq!(counts, [4, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]);
         let xs: Vec<f32> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
         assert_eq!(xs, [0.0, 1.0, 2.0, 4.0, 3.0]);
         // On: the tagged quads come last, in order.
         let counts = batch.update(&entities, &[], &[], &[], true);
-        assert_eq!(counts, [2, 0, 0, 0, 0, 0, 1, 0, 0, 2]);
+        assert_eq!(counts, [2, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0]);
         let xs: Vec<f32> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
         assert_eq!(xs, [0.0, 2.0, 3.0, 1.0, 4.0]);
     }

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

@@ -31,6 +31,12 @@
 //! walk's would and a thin shell more, alike on every backend; a frame whose
 //! sums could leave i32 is drawn by the CPU (`Prepared::Cpu`).
 //!
+//! Its statistics, the sections the pass kept and their draws (`counts[0]`,
+//! `counts[1]`), are copied after the pass into one of `READBACKS` small
+//! buffers with the CPU's part of the same frame (`copy_stats`), mapped once the
+//! frame is submitted (`submitted`, from the frame's after-submit hook) and
+//! taken in a frame or a few later (`collect`); nothing waits for them.
+//!
 //! A record also holds where its section's buckets of solid quads by the side
 //! they face end, and what `mesher::Sides::visible_from` compares the eye with
 //! for each, its margin in (`Sides::thresholds`); the tables hold the eye less
@@ -70,9 +76,17 @@ use super::{
     submit::Queue,
     upload::Uploads,
 };
-use crate::mesher::Sides;
-use glam::{DVec3, DVec4, Vec3};
-use std::{cmp::Reverse, collections::BinaryHeap, time::Instant};
+use crate::{graphics::GpuCullingOffer, mesher::Sides};
+use glam::{DVec3, DVec4, Mat4, Vec3};
+use std::{
+    cmp::Reverse,
+    collections::BinaryHeap,
+    sync::{
+        Arc,
+        atomic::{AtomicU8, Ordering},
+    },
+    time::Instant,
+};
 
 /// One section (`gpu_culling.wgsl`'s `Section`).
 #[repr(C)]
@@ -176,9 +190,9 @@ fn threshold_key(t: f32, positive: bool) -> u32 {
 /// The most draws a section has: the runs its buckets that can face the eye
 /// lie in. Two runs are apart by a bucket left out, so 7 buckets hold at most 4.
 const RUNS: u32 = 4;
-/// Words per id in `runs` (the shader's `RUN_WORDS`): its page and draws, then
-/// each draw's first quad and quads.
-const RUN_WORDS: u64 = 1 + 2 * RUNS as u64;
+/// Words per id in `runs` (the shader's `RUN_WORDS`): its page, flags and draws,
+/// then each draw's first quad and quads, then its two occlusion stamps.
+const RUN_WORDS: u64 = 1 + 2 * RUNS as u64 + 2;
 
 /// `rounded_box` for bounds past what a box's codes hold, or not finite: no
 /// frustum plane rejects it, so it is drawn wherever its column is within the
@@ -256,15 +270,36 @@ struct Params {
     /// Its height in sections, and the level's (the sky band's top section).
     reach_height: i32,
     reach_sections: i32,
-    /// `REACH`, `SKY`, `EYE`.
+    /// `REACH`, `SKY`, `EYE`, `OCCLUDE`, `PROBE`.
     flags: u32,
     /// With `EYE`, where the eye's keys start in `tables`, in words.
     eyes: u32,
+    /// With `OCCLUDE`: the frame's stamp (never 0), where the boxes to test
+    /// start in `counts`, in words, 0, 0.
+    occl: [u32; 4],
+    /// The world pass's view projection, which the test draws its boxes with.
+    view_proj: [[f32; 4]; 4],
 }
 
 /// Counts before the pages' (the shader's `STATS`): the sections `cull` kept,
-/// and the draws, fewer only where a region was short.
-const STATS: u64 = 2;
+/// the draws (fewer only where a region was short), then occlusion's: the
+/// quads of the sections with runs and of the tested boxes not seen (the
+/// gate's share), the box draw (its instances: the boxes tested), and the
+/// boxes not seen.
+const STATS: u64 = 12;
+const QUADS: usize = 2;
+const HIDDEN_QUADS: usize = 3;
+const BOX: u64 = 4;
+const HIDDEN: usize = 9;
+/// Statistics on their way back at once, a frame or a few late so the CPU never
+/// waits (as `cull`'s results).
+const READBACKS: usize = 3;
+const FREE: u8 = 0;
+const PENDING: u8 = 1;
+const MAPPED: u8 = 2;
+/// Its mapping failed or the device lost its buffer: never copied into or
+/// unmapped again, so the statistics stop (as `timing::GpuTimer`'s).
+const FAILED: u8 = 3;
 /// In `Params::flags` (the shader's `REACH`): cave culling's graph is in
 /// `reach`.
 const REACH: u32 = 1;
@@ -274,6 +309,10 @@ const SKY: u32 = 2;
 /// In `Params::flags` (the shader's `EYE`): solid quads facing away from the
 /// eye are left out, its keys in `tables` from `Params::eyes`.
 const EYE: u32 = 4;
+/// In `Params::flags` (the shader's `OCCLUDE` and `PROBE`): the frame occludes,
+/// and it tests every box (cull.rs's probe frame).
+const OCCLUDE: u32 = 8;
+const PROBE: u32 = 16;
 /// Ids per block (the shader's `BLOCK`), and the workgroup of the passes over ids.
 const WORKGROUP: u32 = 64;
 /// Workgroups along x when there are more (the shader's `ROW`).
@@ -314,6 +353,11 @@ pub(super) struct FrameInputs<'a> {
     /// from it are left out (`sides_on`); `None`: every solid quad is drawn. A
     /// GPU frame has no water mirror, whose eye below would see more of them.
     pub eye: Option<Vec3>,
+    /// The world pass's view projection (gfx.rs `globals.view_proj`), and
+    /// whether occlusion culling is on: frames that can run its test then
+    /// do, by its gate (`GpuCulling::occluding`).
+    pub view_proj: Mat4,
+    pub occlude: bool,
 }
 
 /// What `GpuCulling::prepare` made of a frame.
@@ -475,10 +519,31 @@ pub(super) fn supported(
         // The pass binds 8, the last cave culling's graph.
         && limits.max_storage_buffers_per_shader_stage >= 8
         && !super::flat::is_broken_intel_vulkan(info)
-        // DX12's count draws leave each draw's base vertex out of `vertex_index`, by which the
-        // pulled solid pipelines (those of a device with flat page groups) read the page.
-        // shortcut: not offered there, until GPU culling's draws carry their base vertex otherwise.
-        && !(info.backend == wgpu::Backend::Dx12 && flat_min_sections.is_some())
+        && !loses_base_vertex(info, flat_min_sections.is_some())
+}
+
+/// DX12's count draws leave each draw's base vertex out of `vertex_index`, by which the
+/// pulled solid pipelines (those of a device with flat page groups) read the page.
+/// shortcut: not offered there, until GPU culling's draws carry their base vertex otherwise.
+pub(super) fn loses_base_vertex(info: &wgpu::AdapterInfo, flat_page_groups: bool) -> bool {
+    info.backend == wgpu::Backend::Dx12 && flat_page_groups
+}
+
+/// What the settings offer (`graphics::GpuCullingOffer`): where `supported`
+/// holds, but not on a software adapter (WARP, lavapipe), whose pass would run
+/// on the CPU beside the frame, as occlusion culling's default has it; where it
+/// doesn't, DX12 with flat page groups says why (`loses_base_vertex`).
+pub(super) fn offer(
+    info: &wgpu::AdapterInfo,
+    supported: bool,
+    flat_page_groups: bool,
+) -> GpuCullingOffer {
+    match (supported, super::is_software(info.device_type)) {
+        (false, _) if loses_base_vertex(info, flat_page_groups) => GpuCullingOffer::Dx12,
+        (false, _) => GpuCullingOffer::Unsupported,
+        (true, true) => GpuCullingOffer::Software,
+        (true, false) => GpuCullingOffer::Offered,
+    }
 }
 
 /// A buffer that is recreated larger when it must hold more.
@@ -523,6 +588,20 @@ impl Grown {
         self.bytes = size;
         Some(true)
     }
+    /// `reserve`, keeping what the buffer held (`runs`' stamps).
+    fn reserve_keeping(
+        &mut self,
+        device: &wgpu::Device,
+        encoder: &mut wgpu::CommandEncoder,
+        bytes: u64,
+    ) -> Option<bool> {
+        let (old, old_bytes) = (self.buffer.clone(), self.bytes);
+        let made = self.reserve(device, bytes)?;
+        if made {
+            encoder.copy_buffer_to_buffer(&old, 0, &self.buffer, 0, old_bytes);
+        }
+        Some(made)
+    }
 }
 
 /// The section table as the CPU keeps it, by id, and what changed since
@@ -653,6 +732,7 @@ impl Records {
         self.fading = 0;
     }
     /// The sections with a record.
+    #[cfg(any(test, debug_assertions))]
     pub fn live(&self) -> usize {
         let free: u32 = self.free.iter().map(|word| word.count_ones()).sum();
         self.records.len() - free as usize
@@ -730,6 +810,159 @@ impl Fades {
     }
 }
 
+/// One GPU frame's statistics on their way back: `counts[..STATS]`, and what
+/// the CPU drew of the same frame.
+struct Readback {
+    buffer: wgpu::Buffer,
+    state: Arc<AtomicU8>,
+    /// Its frame (gfx.rs `frame_serial`), and the CPU's part of its statistics:
+    /// the sections it drew that the pass didn't count, its section draws, and
+    /// every draw call.
+    frame: u64,
+    cpu: [usize; 3],
+    /// Its frame occluded: its counts carry the test's.
+    occluded: bool,
+}
+
+/// The occlusion test (`gpu_occlusion.wgsl`): its boxes' pipeline and bind
+/// group, and phase 2's passes (count2, scan2, scatter2).
+struct BoxTest {
+    pipeline: wgpu::RenderPipeline,
+    layout: wgpu::BindGroupLayout,
+    group: Option<wgpu::BindGroup>,
+    phase2: [wgpu::ComputePipeline; 3],
+}
+
+impl BoxTest {
+    /// `color`: the world pass's colour format. `None` when the device fails to
+    /// make the pipelines: GPU culling then runs without the test.
+    fn new(
+        device: &wgpu::Device,
+        color: wgpu::TextureFormat,
+        compute: &wgpu::BindGroupLayout,
+    ) -> Option<Self> {
+        let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
+        let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
+        let entry = |binding, visibility, ty| wgpu::BindGroupLayoutEntry {
+            binding,
+            visibility,
+            ty: wgpu::BindingType::Buffer {
+                ty,
+                has_dynamic_offset: false,
+                min_binding_size: None,
+            },
+            count: None,
+        };
+        let storage = |read_only| wgpu::BufferBindingType::Storage { read_only };
+        use wgpu::ShaderStages as S;
+        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("GPU culling occlusion test"),
+            entries: &[
+                entry(0, S::VERTEX_FRAGMENT, wgpu::BufferBindingType::Uniform),
+                entry(9, S::VERTEX, storage(true)),
+                entry(10, S::VERTEX, storage(true)),
+                entry(11, S::FRAGMENT, storage(false)),
+                entry(12, S::VERTEX, storage(true)),
+            ],
+        });
+        let source = [
+            include_str!("gpu_culling.wgsl"),
+            include_str!("gpu_occlusion.wgsl"),
+        ]
+        .concat();
+        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("GPU culling occlusion test"),
+            source: wgpu::ShaderSource::Wgsl(source.into()),
+        });
+        let layouts = [Some(&layout)];
+        let box_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("GPU culling occlusion test"),
+            bind_group_layouts: &layouts,
+            ..Default::default()
+        });
+        // cull.rs's `Early` pipeline: front faces against the world pass's
+        // reversed depth, without writes.
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("GPU culling occlusion test"),
+            layout: Some(&box_layout),
+            vertex: wgpu::VertexState {
+                module: &module,
+                entry_point: Some("vs_box"),
+                compilation_options: Default::default(),
+                buffers: &[],
+            },
+            primitive: wgpu::PrimitiveState {
+                cull_mode: Some(wgpu::Face::Back),
+                ..Default::default()
+            },
+            depth_stencil: Some(wgpu::DepthStencilState {
+                format: wgpu::TextureFormat::Depth32Float,
+                depth_write_enabled: Some(false),
+                depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
+                stencil: Default::default(),
+                bias: Default::default(),
+            }),
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: &module,
+                entry_point: Some("fs_box"),
+                compilation_options: Default::default(),
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: color,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::empty(),
+                })],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        let compute_layouts = [Some(compute)];
+        let compute_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("GPU culling phase 2"),
+            bind_group_layouts: &compute_layouts,
+            ..Default::default()
+        });
+        let phase2 = ["count2", "scan2", "scatter2"].map(|entry| {
+            device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+                label: Some("GPU culling phase 2"),
+                layout: Some(&compute_layout),
+                module: &module,
+                entry_point: Some(entry),
+                compilation_options: Default::default(),
+                cache: None,
+            })
+        });
+        let internal = pollster::block_on(internal.pop());
+        if let Some(e) = internal.or(pollster::block_on(validation.pop())) {
+            log::warn!("Horizon renderer: GPU culling's occlusion test unavailable ({e})");
+            return None;
+        }
+        Some(Self {
+            pipeline,
+            layout,
+            group: None,
+            phase2,
+        })
+    }
+
+    /// Its bind group: the parameters, then the test list (`counts`), the
+    /// origins, the stamps (`runs`) and the records.
+    fn bind(&self, device: &wgpu::Device, buffers: [&wgpu::Buffer; 5]) -> wgpu::BindGroup {
+        let entries = [0, 9, 10, 11, 12]
+            .into_iter()
+            .zip(buffers)
+            .map(|(binding, buffer)| wgpu::BindGroupEntry {
+                binding,
+                resource: buffer.as_entire_binding(),
+            });
+        device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("GPU culling occlusion test"),
+            layout: &self.layout,
+            entries: &entries.collect::<Vec<_>>(),
+        })
+    }
+}
+
 /// The pass, its buffers and the records it draws from: made when GPU culling
 /// is switched on, dropped when it is switched off.
 pub(super) struct GpuCulling {
@@ -769,12 +1002,28 @@ pub(super) struct GpuCulling {
     /// This frame's updates and table words, kept for their room.
     scratch: Vec<Update>,
     words: Vec<u32>,
+    /// The statistics on their way back (`Readback`), the next one to copy
+    /// into, and this frame's copy.
+    readbacks: Vec<Readback>,
+    next: usize,
+    current: Option<usize>,
+    /// The occlusion test, where the device can run it (Vulkan, with cull.rs's
+    /// test forced early: `Cull::early`).
+    test: Option<BoxTest>,
+    /// Advanced by every frame that may occlude (never 0); the newest share of
+    /// quads the test hid, with its frame; whether this frame occludes; and the
+    /// newest result's boxes not seen and tested.
+    stamp: u32,
+    share: (u64, f32),
+    occluding: bool,
+    hidden: Option<[usize; 2]>,
 }
 
 impl GpuCulling {
     /// `None` when the device fails to make the pipelines or the memory for the
-    /// buffers is missing (caught, not raised: raised errors are fatal).
-    pub fn new(device: &wgpu::Device) -> Option<Self> {
+    /// buffers is missing (caught, not raised: raised errors are fatal). `test`:
+    /// the world pass's colour format, where frames can run the occlusion test.
+    pub fn new(device: &wgpu::Device, test: Option<wgpu::TextureFormat>) -> Option<Self> {
         let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
         let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
         let entry = |binding, ty| wgpu::BindGroupLayoutEntry {
@@ -827,7 +1076,24 @@ impl GpuCulling {
             log::warn!("Horizon renderer: GPU culling unavailable ({e})");
             return None;
         }
+        let test = test.and_then(|color| BoxTest::new(device, color, &layout));
         use wgpu::BufferUsages as U;
+        let readbacks = (0..READBACKS)
+            .map(|_| {
+                Some(Readback {
+                    buffer: try_create(
+                        device,
+                        "GPU culling statistics",
+                        STATS * 4,
+                        U::MAP_READ | U::COPY_DST,
+                    )?,
+                    state: Arc::new(AtomicU8::new(FREE)),
+                    frame: 0,
+                    cpu: [0; 3],
+                    occluded: false,
+                })
+            })
+            .collect::<Option<Vec<_>>>()?;
         Some(Self {
             pipelines,
             layout,
@@ -859,7 +1125,8 @@ impl GpuCulling {
                 device,
                 "GPU culling counts",
                 (STATS + 64) * 4,
-                U::STORAGE | U::INDIRECT | U::COPY_DST | TEST_READ,
+                // The counts are copied out for the statistics (`copy_stats`).
+                U::STORAGE | U::INDIRECT | U::COPY_DST | U::COPY_SRC,
             )?,
             draws: Grown::new(
                 device,
@@ -873,7 +1140,13 @@ impl GpuCulling {
                 1024 * 16,
                 U::VERTEX | U::STORAGE | TEST_READ,
             )?,
-            runs: Grown::new(device, "GPU culling runs", 1024 * RUN_WORDS * 4, U::STORAGE)?,
+            // Kept when it grows (`reserve_keeping`): it holds the stamps.
+            runs: Grown::new(
+                device,
+                "GPU culling runs",
+                1024 * RUN_WORDS * 4,
+                U::STORAGE | U::COPY_SRC | U::COPY_DST,
+            )?,
             // Room for render distance 64's graph, 57.5 KB.
             reach: Grown::new(
                 device,
@@ -891,6 +1164,15 @@ impl GpuCulling {
             pass_pages: 1,
             scratch: Vec::new(),
             words: Vec::new(),
+            readbacks,
+            next: 0,
+            current: None,
+            test,
+            stamp: 0,
+            // cull.rs's start: culling until a result says otherwise.
+            share: (0, 1.0),
+            occluding: false,
+            hidden: None,
         })
     }
 
@@ -912,6 +1194,7 @@ impl GpuCulling {
         self.pages.clear();
         self.ids = 0;
         self.n_updates = 0;
+        self.occluding = false;
         self.prepare_buffers(device, queue, uploads, encoder, input)
             .unwrap_or(Prepared::OutOfMemory)
     }
@@ -955,12 +1238,18 @@ impl GpuCulling {
         let pass_pages = self.records.page_sections.len().max(1) as u32;
         // A region has room for every draw of every record on its page.
         let total = RUNS * self.records.page_sections.iter().sum::<u32>();
-        // The statistics, each page's count, then each block's per page.
-        let count_words = STATS + u64::from(pass_pages) * (1 + u64::from(ids.div_ceil(WORKGROUP)));
+        // The statistics, each page's count in both phases, each block's per
+        // page in both phases, then where the test exists the boxes to test.
+        let blocks = u64::from(ids.div_ceil(WORKGROUP));
+        let phase1_end = STATS + u64::from(pass_pages) * (2 + blocks);
+        let tests_at = phase1_end + u64::from(pass_pages) * blocks;
+        let count_words = match self.test {
+            Some(_) => tests_at + u64::from(ids),
+            None => phase1_end,
+        };
         for (buffer, bytes) in [
             (&mut self.updates, self.scratch.len() as u64 * Update::BYTES),
             (&mut self.origins, u64::from(ids) * 16),
-            (&mut self.runs, u64::from(ids) * RUN_WORDS * 4),
             (&mut self.tables, u64::from(regions + 2 * pass_pages) * 4),
             (&mut self.counts, count_words * 4),
             (&mut self.draws, u64::from(total.max(1)) * 20),
@@ -969,6 +1258,12 @@ impl GpuCulling {
                 self.group = None;
             }
         }
+        if self
+            .runs
+            .reserve_keeping(device, encoder, u64::from(ids) * RUN_WORDS * 4)?
+        {
+            self.group = None;
+        }
         // A copy of the graph made anew holds none.
         if let Some(r) = &input.reach
             && self.reach.reserve(device, r.bits.len() as u64 * 4)?
@@ -982,6 +1277,16 @@ impl GpuCulling {
         let Some(params) = planes else {
             return Some(Prepared::Cpu);
         };
+        // Occlusion, by cull.rs's gate over the share the newest test hid.
+        let mut occl = 0;
+        if self.test.is_some() && input.occlude {
+            self.stamp = self.stamp.wrapping_add(1).max(1);
+            let (occludes, probe) = super::cull::gate(self.share.1, self.stamp);
+            if occludes && ids > 0 {
+                self.occluding = true;
+                occl = OCCLUDE | if probe { PROBE } else { 0 };
+            }
+        }
         if self.records.all_dirty {
             // The whole table, after it grew or more records changed than
             // updates take (GPU culling switched on in a loaded world, a
@@ -1025,8 +1330,11 @@ impl GpuCulling {
             updates: self.scratch.len() as u32,
             pages: pass_pages,
             regions,
+            occl: [self.stamp, tests_at as u32, 0, 0],
+            view_proj: input.view_proj.to_cols_array_2d(),
             ..params
         };
+        params.flags |= occl;
         if let Some(r) = &input.reach {
             if self.reach_generation != Some(r.generation) {
                 // Through the belt: a search lands every few frames while the
@@ -1040,9 +1348,24 @@ impl GpuCulling {
             params.flags |= REACH | if r.sky_reached { SKY } else { 0 };
         }
         uploads.buffer(encoder, &self.params, 0, bytemuck::bytes_of(&params));
-        encoder.clear_buffer(&self.counts.buffer, 0, Some(count_words * 4));
+        // A frame that occludes reads phase 2's blocks too; the boxes to test
+        // are written before they are read.
+        let cleared = if self.occluding { tests_at } else { phase1_end };
+        encoder.clear_buffer(&self.counts.buffer, 0, Some(cleared * 4));
         if self.group.is_none() {
             self.group = Some(self.bind(device));
+            if let Some(test) = &mut self.test {
+                test.group = Some(test.bind(
+                    device,
+                    [
+                        &self.params,
+                        &self.counts.buffer,
+                        &self.origins.buffer,
+                        &self.runs.buffer,
+                        &self.sections.buffer,
+                    ],
+                ));
+            }
         }
         self.ids = ids;
         self.n_updates = params.updates;
@@ -1102,11 +1425,13 @@ impl GpuCulling {
     /// The kept sections' solid draws, a count draw per page, with the quad
     /// indices bound. Leaves the origins at vertex slot 1. `group`: the page's group 1 for
     /// pipelines that read the page themselves (`Flat::page_group`), else none.
+    /// `phase`: 0, or 1 after `compact` in a frame that occludes.
     pub fn draw<'a>(
         &self,
         pass: &mut wgpu::RenderPass<'_>,
         arena: &Arena,
         group: impl Fn(u32) -> Option<&'a wgpu::BindGroup>,
+        phase: u64,
     ) {
         if self.pages.is_empty() {
             return;
@@ -1121,7 +1446,7 @@ impl GpuCulling {
                 &self.draws.buffer,
                 u64::from(first) * 20,
                 &self.counts.buffer,
-                (STATS + u64::from(page)) * 4,
+                (STATS + phase * u64::from(self.pass_pages) + u64::from(page)) * 4,
                 size,
             );
         }
@@ -1131,6 +1456,139 @@ impl GpuCulling {
     pub fn draw_calls(&self) -> usize {
         self.pages.len()
     }
+
+    /// Whether the frame occludes (`prepare`): phase 1's `draw`, then `test` in
+    /// its pass, `compact` after it, and phase 2's `draw` in the next pass.
+    pub fn occluding(&self) -> bool {
+        self.occluding
+    }
+
+    /// The boxes the newest test read back did not see and those it tested,
+    /// and the share of quads it hid (cull.rs `Cull::hidden`).
+    pub fn hidden(&self) -> Option<([usize; 2], f32)> {
+        self.hidden.map(|h| (h, self.share.1))
+    }
+
+    /// In the world pass after phase 1's draws: the listed boxes against its
+    /// depth. Leaves the pass's pipeline and group 0 changed.
+    pub fn test(&self, pass: &mut wgpu::RenderPass<'_>) {
+        if let Some(BoxTest {
+            pipeline,
+            group: Some(group),
+            ..
+        }) = &self.test
+            && self.occluding
+        {
+            pass.set_pipeline(pipeline);
+            pass.set_bind_group(0, group, &[]);
+            pass.draw_indirect(&self.counts.buffer, BOX * 4);
+        }
+    }
+
+    /// Between the world passes: phase 2's draws, of the sections the test saw,
+    /// into the regions phase 1 drew from.
+    pub fn compact(&self, encoder: &mut wgpu::CommandEncoder, timing: Option<&mut PassTiming>) {
+        let (Some(test), Some(group)) = (&self.test, &self.group) else {
+            return;
+        };
+        if !self.occluding {
+            return;
+        }
+        let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
+            label: Some("GPU culling phase 2"),
+            timestamp_writes: timing.and_then(|t| t.compute_writes("GPU culling phase 2")),
+        });
+        pass.set_bind_group(0, group, &[]);
+        let [count2, scan2, scatter2] = &test.phase2;
+        let blocks = self.ids.div_ceil(WORKGROUP);
+        pass.set_pipeline(count2);
+        pass.dispatch_workgroups(blocks.min(ROW), blocks.div_ceil(ROW), 1);
+        pass.set_pipeline(scan2);
+        pass.dispatch_workgroups(self.pass_pages, 1, 1);
+        pass.set_pipeline(scatter2);
+        pass.dispatch_workgroups(blocks.min(ROW), blocks.div_ceil(ROW), 1);
+    }
+
+    /// After the frame's world passes (phase 2's counts too), in the same
+    /// encoder: the pass's counts copied out with
+    /// the CPU's part of frame `frame` (`Readback::cpu`), into the next readback
+    /// if it is free. While three frames' are on their way, this one's
+    /// statistics are never shown.
+    pub fn copy_stats(&mut self, encoder: &mut wgpu::CommandEncoder, frame: u64, cpu: [usize; 3]) {
+        let r = &mut self.readbacks[self.next];
+        if r.state.load(Ordering::Acquire) != FREE {
+            return;
+        }
+        encoder.copy_buffer_to_buffer(&self.counts.buffer, 0, &r.buffer, 0, STATS * 4);
+        (r.frame, r.cpu, r.occluded) = (frame, cpu, self.occluding);
+        self.current = Some(self.next);
+    }
+
+    /// The frame's statistics to read back, started by calling it right after
+    /// the frame's submission (gfx's after-submit hook, on the submit thread
+    /// when the frame goes there), as `cull::Cull::submitted`.
+    pub fn submitted(&mut self) -> Option<impl FnOnce() + Send + 'static> {
+        let i = self.current.take()?;
+        let r = &self.readbacks[i];
+        let (buffer, state) = (r.buffer.clone(), r.state.clone());
+        state.store(PENDING, Ordering::Release);
+        self.next = (i + 1) % READBACKS;
+        Some(move || {
+            buffer
+                .slice(..)
+                .map_async(wgpu::MapMode::Read, move |result| {
+                    state.store(
+                        if result.is_ok() { MAPPED } else { FAILED },
+                        Ordering::Release,
+                    );
+                });
+        })
+    }
+
+    /// The statistics that came back, their readbacks freed: the newest
+    /// frame's, as (frame, [sections drawn, section draws, draw calls]), the
+    /// pass's counts added to the CPU's part. Called as a frame starts, so a
+    /// copy no submission took (a frame that failed on the way) is dropped.
+    pub fn collect(&mut self, device: &wgpu::Device) -> Option<(u64, [usize; 3])> {
+        self.current = None;
+        if device.poll(wgpu::PollType::Poll).is_err() {
+            return None;
+        }
+        let mut newest: Option<(u64, [usize; 3])> = None;
+        for r in &self.readbacks {
+            if r.state.load(Ordering::Acquire) != MAPPED {
+                continue;
+            }
+            {
+                let Ok(data) = r.buffer.slice(..).get_mapped_range() else {
+                    // Device loss can destroy a buffer after its mapping
+                    // succeeded; unmapping it would panic (`timing::GpuTimer`).
+                    r.state.store(FAILED, Ordering::Release);
+                    continue;
+                };
+                // The mapping need not be 4-byte aligned: read the words unaligned.
+                let words: [u32; STATS as usize] =
+                    bytemuck::pod_read_unaligned(&data[..STATS as usize * 4]);
+                let [kept, draws] = [words[0], words[1]];
+                // The newest test's share, for the gate (`prepare`).
+                if r.occluded && r.frame > self.share.0 {
+                    let quads = words[QUADS].max(1);
+                    self.share = (r.frame, words[HIDDEN_QUADS] as f32 / quads as f32);
+                    self.hidden = Some([words[HIDDEN] as usize, words[BOX as usize + 1] as usize]);
+                }
+                let [sections, cpu_draws, calls] = r.cpu;
+                if newest.is_none_or(|(frame, _)| r.frame > frame) {
+                    newest = Some((
+                        r.frame,
+                        [sections + kept as usize, cpu_draws + draws as usize, calls],
+                    ));
+                }
+            }
+            r.buffer.unmap();
+            r.state.store(FREE, Ordering::Release);
+        }
+        newest
+    }
 }
 
 #[cfg(test)]
@@ -1231,6 +1689,8 @@ mod tests {
             frustum,
             reach: None,
             eye: None,
+            view_proj: Mat4::IDENTITY,
+            occlude: false,
         }
     }
 
@@ -1393,6 +1853,21 @@ mod tests {
         runs
     }
 
+    /// The pass's module validates without the early depth test, and the
+    /// occlusion test's (the pass's with `gpu_occlusion.wgsl`) with it.
+    #[test]
+    fn the_shaders_validate() {
+        use naga::valid::Capabilities as C;
+        let pass = include_str!("gpu_culling.wgsl");
+        let test = [pass, include_str!("gpu_occlusion.wgsl")].concat();
+        for (source, capabilities) in [(pass, C::all() - C::EARLY_DEPTH_TEST), (&test, C::all())] {
+            let module = naga::front::wgsl::parse_str(source).unwrap();
+            naga::valid::Validator::new(naga::valid::ValidationFlags::all(), capabilities)
+                .validate(&module)
+                .unwrap();
+        }
+    }
+
     /// Ids, page counts, flags and changes against a plain list of what each id
     /// holds: the lowest free id comes back, flagged only if inserted so, free
     /// ids at the end leave, counts follow moves (to pages past the last too), a
@@ -1631,6 +2106,8 @@ mod tests {
             ("reach_sections", offset_of!(Params, reach_sections)),
             ("flags", offset_of!(Params, flags)),
             ("eyes", offset_of!(Params, eyes)),
+            ("occl", offset_of!(Params, occl)),
+            ("view_proj", offset_of!(Params, view_proj)),
         ] {
             assert!(members.contains(&(name.into(), offset)), "Params.{name}");
         }
@@ -1651,7 +2128,7 @@ mod tests {
         ];
         assert_eq!(layout("Update"), (size_of::<Update>(), named(&id)));
         assert_eq!((size_of::<Record>(), size_of::<Update>()), (80, 96));
-        assert_eq!(size_of::<Params>(), 128);
+        assert_eq!(size_of::<Params>(), 208);
         let constant = |name: &str| {
             let (_, c) = module
                 .constants
@@ -2339,7 +2816,7 @@ mod tests {
         // So have the sections' buckets and whether a frame has an eye.
         let mut shapes = Rng(0x3C6E_F372_FE94_F82B);
         let (min_y, height) = (-64, 24);
-        let mut gpu = GpuCulling::new(device).expect("the pass");
+        let mut gpu = GpuCulling::new(device, None).expect("the pass");
         let mut uploads = Uploads::new(device);
         let mut held: BTreeMap<u32, (Placed, Sides)> = BTreeMap::new();
         // Fading sections the frustum and the graph keep, left to the CPU.
@@ -2512,6 +2989,8 @@ mod tests {
                 frustum: &frustum,
                 reach,
                 eye,
+                view_proj: Mat4::IDENTITY,
+                occlude: false,
             };
             if case == 7 {
                 // Planes past the integers: the CPU draws that frame, nothing is
@@ -2581,8 +3060,12 @@ mod tests {
                 }
             }
             gpu.dispatch(&mut encoder, None);
+            // Its statistics come back with a CPU part of the case's own.
+            let cpu = [case * 7, case * 3, case];
+            gpu.copy_stats(&mut encoder, case as u64, cpu);
             uploads.finish(&encoder);
             queue.submit([encoder.finish()]);
+            gpu.submitted().expect("a readback free")();
             let pages = u64::from(gpu.pass_pages);
             let counts = read(device, queue, &gpu.counts.buffer, (STATS + pages) * 4);
             let draws = read(device, queue, &gpu.draws.buffer, gpu.draws.bytes);
@@ -2619,6 +3102,13 @@ mod tests {
                 [kept_sections, draw_count],
                 "case {case}: sections kept, draws"
             );
+            // The reads above waited for the GPU.
+            let (kept, drawn) = (kept_sections as usize, draw_count as usize);
+            assert_eq!(
+                gpu.collect(device),
+                Some((case as u64, [cpu[0] + kept, cpu[1] + drawn, cpu[2]])),
+                "case {case}: statistics"
+            );
             compared += kept_sections as usize;
         }
         // Not a comparison of empty lists, nor of a test that keeps everything.
@@ -2645,6 +3135,73 @@ mod tests {
         );
     }
 
+    /// The statistics come back with their frame, in place and from the submit
+    /// thread, submitted as gfx.rs submits frames (`submit_later`, or in place
+    /// with its `after` handed back): three frames on their way fill the ring, a
+    /// fourth's are skipped, `collect` takes in the newest; and a readback whose
+    /// buffer the device lost after its mapping goes `FAILED`, never copied into
+    /// or unmapped again (as `timing::GpuTimer`'s), so the statistics stop.
+    #[test]
+    fn the_statistics_come_back_with_their_frame() {
+        use super::super::submit::{AfterSubmit, Job};
+        on_each_device(|device, queue| {
+            for threaded in [false, true] {
+                let queue = Queue::new((**queue).clone(), threaded);
+                let mut gpu = GpuCulling::new(device, None).expect("the pass");
+                // As if the pass kept 5 sections and drew 7 times.
+                queue.write_buffer(&gpu.counts.buffer, 0, bytemuck::cast_slice(&[5_u32, 7]));
+                // Whether the frame's statistics went out.
+                let frame = |gpu: &mut GpuCulling, f: u64| {
+                    let mut encoder = device.create_command_encoder(&Default::default());
+                    gpu.copy_stats(&mut encoder, f, [f as usize, 10, 3]);
+                    let after = gpu.submitted().map(|g| Box::new(g) as AfterSubmit);
+                    let sent = after.is_some();
+                    let job = Job {
+                        encoder,
+                        surface: None,
+                        after,
+                    };
+                    if let Err(back) = queue.submit_later(job) {
+                        queue.submit([back.encoder.finish()]);
+                        if let Some(read) = back.after {
+                            read();
+                        }
+                    }
+                    sent
+                };
+                let landed = |gpu: &mut GpuCulling| {
+                    queue.landed();
+                    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+                    gpu.collect(device)
+                };
+                for f in 1..=3 {
+                    assert!(frame(&mut gpu, f), "frame {f}, threaded {threaded}");
+                }
+                assert!(!frame(&mut gpu, 4), "a full ring, threaded {threaded}");
+                assert_eq!(landed(&mut gpu), Some((3, [3 + 5, 10 + 7, 3])));
+                assert_eq!(gpu.collect(device), None);
+                assert!(frame(&mut gpu, 5));
+                assert_eq!(landed(&mut gpu), Some((5, [5 + 5, 10 + 7, 3])));
+                // Frame 6's buffer destroyed after its mapping (#6320).
+                let lost = gpu.next;
+                assert!(frame(&mut gpu, 6));
+                queue.landed();
+                device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+                gpu.readbacks[lost].buffer.destroy();
+                assert_eq!(gpu.collect(device), None);
+                for f in 7..=12 {
+                    let sent = frame(&mut gpu, f);
+                    let back = landed(&mut gpu);
+                    let state = gpu.readbacks[lost].state.load(Ordering::Acquire);
+                    assert_eq!(state, FAILED, "frame {f}, threaded {threaded}");
+                    // The two other readbacks, then none.
+                    assert_eq!(sent, f <= 8, "frame {f}, threaded {threaded}");
+                    assert_eq!(back.is_some(), f <= 8, "frame {f}, threaded {threaded}");
+                }
+            }
+        });
+    }
+
     /// `draw`'s count draws draw what the pass kept, page by page: each kept
     /// section's quads from its own range, all of them without an eye and those
     /// of its runs that can face one with it, with its own origin, which the
@@ -2687,7 +3244,7 @@ struct Quad {
         for _ in 0..4 {
             assert!(arena.open_page(device, u64::from(SECTIONS / 3) * grain));
         }
-        let mut gpu = GpuCulling::new(device).expect("the pass");
+        let mut gpu = GpuCulling::new(device, None).expect("the pass");
         let mut rng = Rng(0x9E37_79B9_7F4A_7C15);
         // The sections' buckets by facing side have their own sequence.
         let mut shapes = Rng(0xA54F_F53A_5F1D_36F1);
@@ -2816,6 +3373,8 @@ struct Quad {
                 frustum,
                 reach: None,
                 eye,
+                view_proj: Mat4::IDENTITY,
+                occlude: false,
             };
             let prepared = gpu.prepare(device, queue, &mut uploads, &mut encoder, &input);
             assert_eq!(prepared, Prepared::Gpu, "frame {frame}");
@@ -2860,7 +3419,7 @@ struct Quad {
             });
             pass.set_pipeline(&pipeline);
             pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32);
-            gpu.draw(&mut pass, &arena, |_| None);
+            gpu.draw(&mut pass, &arena, |_| None, 0);
             drop(pass);
             encoder.copy_texture_to_buffer(
                 target.as_image_copy(),

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

@@ -13,6 +13,13 @@
 // integers the CPU computed, and facing compares keys that order as the floats
 // the CPU compares. `cull` leaves sections fading in or out to the CPU
 // (`FADING`).
+// Frames that occlude (`OCCLUDE`, gpu_occlusion.wgsl) draw in two phases, each
+// in id order: `cull` leaves to phase 2 the sections whose box the last test
+// did not see and lists the boxes to test; after the test, `count2`, `scan2`
+// and `scatter2` write the draws of those it saw into the same regions. Which
+// boxes count as seen untested (`near_or_big`) is float arithmetic of the
+// shader's own: it only sorts sections between the phases, and doubt counts as
+// seen.
 
 struct Params {
     // Ids to test, records `apply` writes, the arena pages the counts and
@@ -34,13 +41,19 @@ struct Params {
     // 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, SKY and EYE;
-    // where the eye's keys start in `tables`.
+    // section y; its height in sections and the level's; REACH, SKY, EYE,
+    // OCCLUDE and PROBE; where the eye's keys start in `tables`.
     reach: vec4<i32>,
     reach_height: i32,
     reach_sections: i32,
     flags: u32,
     eyes: u32,
+    // Occlusion (OCCLUDE): this frame's stamp (never 0), where the boxes to
+    // test start in `counts`, 0, 0.
+    occl: vec4<u32>,
+    // The world pass's view projection, TAA's jitter included (gfx.rs
+    // `globals.view_proj`).
+    view_proj: mat4x4<f32>,
 }
 
 // gpu_culling.rs `Record`.
@@ -75,15 +88,18 @@ struct Update {
 // 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
-// draws (`cull`), turned into where they start (`scan`).
+// The statistics (`STATS`), each page's draws in phase 1 and in phase 2, then
+// per block of ids and page its draws in each phase (`cull`, `count2`), turned
+// into where they start (`scan`, `scan2`), then the boxes to test (`cull`).
 @group(0) @binding(4) var<storage, read_write> counts: array<atomic<u32>>;
 // DrawIndexedIndirectArgs, five words each.
 @group(0) @binding(5) var<storage, read_write> draws: array<u32>;
 // Per id the instance it is drawn with: origin and UV step, as f32 bits.
 @group(0) @binding(6) var<storage, read_write> origins: array<vec4<u32>>;
-// Per id `RUN_WORDS`: its page << PAGE_SHIFT | its draws when it is drawn this
-// frame, else 0; then each draw's first quad and quads.
+// Per id `RUN_WORDS`: its page << PAGE_SHIFT | TESTED | PHASE2 | its draws when
+// it is drawn this frame, else 0; then each draw's first quad and quads; then
+// the stamps of the frames whose test last saw its box and last tested it,
+// kept from frame to frame.
 @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).
@@ -95,8 +111,16 @@ const STEP_BITS: u32 = 0x38000000u;
 const ROW: u32 = 65535u;
 // Ids per block.
 const BLOCK: u32 = 64u;
-// Counts before the pages'.
-const STATS: u32 = 2u;
+// Counts before the pages': sections kept and draws, then occlusion's: the
+// quads of the sections with runs and those of the tested boxes not seen, the
+// box draw (four words and a spare), those boxes, phase 2's draws, a spare.
+const STATS: u32 = 12u;
+const DRAWS: u32 = 1u;
+const QUADS: u32 = 2u;
+const HIDDEN_QUADS: u32 = 3u;
+const BOX: u32 = 4u;
+const HIDDEN: u32 = 9u;
+const DRAWN2: u32 = 10u;
 // gpu_culling.rs `rounded_box` for a box past what its codes hold: no plane
 // rejects it.
 const UNBOUNDED: u32 = 0x80000000u;
@@ -109,14 +133,56 @@ const FADING: u32 = 1u;
 // In `params.flags`: solid quads facing away from the eye are left out, its
 // keys in `tables` from `params.eyes`.
 const EYE: u32 = 4u;
-// Words per id in `runs`, and where its page starts in the first, its draws
-// (at most 4: gpu_culling.rs `RUNS`) below.
-const RUN_WORDS: u32 = 9u;
-const PAGE_SHIFT: u32 = 3u;
+// Words per id in `runs`, and where its page starts in the first, its flags and
+// draws (at most 4: gpu_culling.rs `RUNS`) below.
+const RUN_WORDS: u32 = 11u;
+const PAGE_SHIFT: u32 = 5u;
+// In its first word: its box is tested this frame; it waits for phase 2.
+const TESTED: u32 = 16u;
+const PHASE2: u32 = 8u;
+// Its stamps: the frames whose test last saw its box, and last tested it.
+const SEEN_WORD: u32 = 9u;
+const TESTED_WORD: u32 = 10u;
+// In `params.flags`: the frame occludes, and tests every box (cull.rs's probe).
+const OCCLUDE: u32 = 8u;
+const PROBE: u32 = 16u;
+// cull.rs `RETEST` and `BIG`.
+const RETEST: u32 = 8u;
+const BIG: f32 = 0.25;
+// gpu_culling.rs `CODE_OFFSET`: the rounded box's codes hold -8..=23.
+const CODE_OFFSET: i32 = 8i;
+// Past the box, for rounding: far past what f32 moves a camera-relative corner.
+const EPS: f32 = 0.015625;
+// Clip z / w at about twice the near plane's distance: reversed depth is 1 at
+// the near plane and grows toward the eye; behind it, z > 0 >= w.
+const NEAR_DEPTH: f32 = 0.5;
 
-// The count of `block`'s draws in `page` (`cull`), then where they start (`scan`).
-fn block_count(block: u32, page: u32) -> u32 {
-    return STATS + params.pages + block * params.pages + page;
+// `page`'s count draw in `phase` (0: the first world pass; 1: after the test).
+fn page_count(page: u32, phase: u32) -> u32 {
+    return STATS + phase * params.pages + page;
+}
+
+// The count of `block`'s draws in `page` and `phase` (`cull`, `count2`), then
+// where they start (`scan`): phase 1's slots, then phase 2's.
+fn block_count(block: u32, page: u32, phase: u32) -> u32 {
+    let blocks = (params.ids + BLOCK - 1u) / BLOCK;
+    return STATS + 2u * params.pages + (phase * blocks + block) * params.pages + page;
+}
+
+// The id's first `runs` word, its flags cleared, if it draws in `phase` (in
+// phase 2, only once this frame's test saw its box); else 0.
+fn drawn_in(id: u32, phase: u32) -> u32 {
+    if id >= params.ids {
+        return 0u;
+    }
+    let w = runs[id * RUN_WORDS];
+    if (w & 7u) == 0u || ((w & PHASE2) != 0u) != (phase == 1u) {
+        return 0u;
+    }
+    if (w & PHASE2) != 0u && runs[id * RUN_WORDS + SEEN_WORD] != params.occl.x {
+        return 0u;
+    }
+    return w & ~(PHASE2 | TESTED);
 }
 
 // `page`'s region of `draws`: its first draw and its size.
@@ -218,6 +284,59 @@ fn seen(id: u32, b: u32, eye: vec3<u32>) -> bool {
     }
 }
 
+// Corner `c` (bit 0: x, bit 1: y, bit 2: z) of the box tested for the section
+// at `o` whose rounded box is `b` (never UNBOUNDED here): cull.wgsl's box, the
+// cell grown by a block, grown further to the section's own bounds where they
+// reach past it, then by EPS.
+fn box_corner(o: vec3<f32>, b: u32, c: u32) -> vec3<f32> {
+    let low = vec3<i32>(vec3<u32>(b, b >> 5u, b >> 10u) & vec3(31u)) - vec3(CODE_OFFSET);
+    let high = vec3<i32>(vec3<u32>(b >> 15u, b >> 20u, b >> 25u) & vec3(31u)) - vec3(CODE_OFFSET);
+    let lo = min(vec3<f32>(low), vec3(-1.0)) - vec3(EPS);
+    let hi = max(vec3<f32>(high), vec3(17.0)) + vec3(EPS);
+    return o + select(lo, hi, (vec3(c) & vec3(1u, 2u, 4u)) != vec3(0u));
+}
+
+// Boxes that count as seen untested: one with a corner within about twice the
+// near plane's distance, behind the eye, or NaN, whose front faces near
+// clipping could cut away; or, as in cull.wgsl, one over BIG of the screen.
+fn near_or_big(o: vec3<f32>, b: u32) -> bool {
+    var lo = vec2(1e30);
+    var hi = vec2(-1e30);
+    for (var c = 0u; c < 8u; c++) {
+        let p = params.view_proj * vec4(box_corner(o, b, c), 1.0);
+        if !(p.z < NEAR_DEPTH * p.w) {
+            return true;
+        }
+        let q = p.xy / p.w;
+        lo = min(lo, q);
+        hi = max(hi, q);
+    }
+    let size = max(min(hi, vec2(1.0)) - max(lo, vec2(-1.0)), vec2(0.0));
+    return size.x * size.y > BIG * 4.0;
+}
+
+// In frames that occlude, a kept section with runs: its flags (0: phase 1,
+// untested), its box listed when it is tested. Its last test saw it: phase 1,
+// retested every RETEST frames (every frame with PROBE). A box that counts as
+// seen: phase 1. Else phase 2, drawn if this frame's test sees its box.
+fn occlusion(id: u32, at: u32, o: vec3<f32>, b: u32) -> u32 {
+    let stamp = params.occl.x;
+    let seen = runs[at + SEEN_WORD];
+    let passed = seen != 0u && seen == runs[at + TESTED_WORD];
+    if passed && (params.flags & PROBE) == 0u && (id + stamp) % RETEST != 0u {
+        return 0u;
+    }
+    if (b & UNBOUNDED) != 0u || near_or_big(o, b) {
+        runs[at + SEEN_WORD] = stamp;
+        runs[at + TESTED_WORD] = stamp;
+        return 0u;
+    }
+    runs[at + TESTED_WORD] = stamp;
+    let t = atomicAdd(&counts[BOX + 1u], 1u);
+    atomicStore(&counts[params.occl.y + t], id);
+    return TESTED | select(PHASE2, 0u, passed);
+}
+
 // One invocation per changed record; the CPU lists each id once.
 @compute @workgroup_size(64)
 fn apply(@builtin(global_invocation_id) gid: vec3<u32>) {
@@ -230,6 +349,10 @@ 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;
+    if id == 0u && (params.flags & OCCLUDE) != 0u {
+        // The box draw's vertices: the cube's corners (gpu_occlusion.wgsl).
+        atomicStore(&counts[BOX], 36u);
+    }
     // Past the table's end the records are stale: the CPU never writes them free.
     if id >= params.ids {
         return;
@@ -252,7 +375,8 @@ fn cull(@builtin(global_invocation_id) gid: vec3<u32>) {
     atomicAdd(&counts[0], 1u);
     let nx = params.cells.x;
     let ny = params.cells.y;
-    origins[id] = vec4<u32>(tables[c.x], tables[nx + c.y], tables[nx + ny + c.z], STEP_BITS);
+    let origin = vec4<u32>(tables[c.x], tables[nx + c.y], tables[nx + ny + c.z], STEP_BITS);
+    origins[id] = origin;
     // gfx.rs `facing_runs`: the runs of its buckets that can face the eye, an
     // empty bucket breaking none, a draw each; without an eye, its solid quads.
     var n = 0u;
@@ -292,24 +416,29 @@ fn cull(@builtin(global_invocation_id) gid: vec3<u32>) {
     if n == 0u {
         return;
     }
-    runs[at] = (page << PAGE_SHIFT) | n;
-    atomicAdd(&counts[block_count(id / BLOCK, page)], n);
+    var flags = 0u;
+    if (params.flags & OCCLUDE) != 0u {
+        flags = occlusion(id, at, bitcast<vec3<f32>>(origin.xyz), s.a.z);
+    }
+    runs[at] = (page << PAGE_SHIFT) | flags | n;
+    if (flags & PHASE2) == 0u {
+        atomicAdd(&counts[block_count(id / BLOCK, page, 0u)], n);
+    }
 }
 
 var<workgroup> partial: array<u32, 256>;
 
 // One workgroup per page: each lane sums a stretch of blocks, the lanes'
-// sums are scanned, and each block's sum becomes where its draws start.
-@compute @workgroup_size(256)
-fn scan(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
-    let page = group.x;
+// sums are scanned, and each block's sum becomes where its draws start, in
+// `phase` (`scan`, gpu_occlusion.wgsl `scan2`).
+fn scan_page(page: u32, lane: u32, phase: u32) {
     let blocks = (params.ids + BLOCK - 1u) / BLOCK;
     let stretch = (blocks + 255u) / 256u;
     let first = min(lane * stretch, blocks);
     let last = min(first + stretch, blocks);
     var sum = 0u;
     for (var b = first; b < last; b++) {
-        sum += atomicLoad(&counts[block_count(b, page)]);
+        sum += atomicLoad(&counts[block_count(b, page, phase)]);
     }
     partial[lane] = sum;
     workgroupBarrier();
@@ -327,31 +456,35 @@ fn scan(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index
         start = partial[lane - 1u];
     }
     for (var b = first; b < last; b++) {
-        let count = atomicLoad(&counts[block_count(b, page)]);
-        atomicStore(&counts[block_count(b, page)], start);
+        let count = atomicLoad(&counts[block_count(b, page, phase)]);
+        atomicStore(&counts[block_count(b, page, phase)], start);
         start += count;
     }
     if lane == 255u {
         // A region has room for every draw of its page's records; were one
         // short, its draws past it go.
         let total = min(partial[255], region(page).y);
-        atomicStore(&counts[STATS + page], total);
-        atomicAdd(&counts[1], total);
+        atomicStore(&counts[page_count(page, phase)], total);
+        atomicAdd(&counts[DRAWS], total);
+        if phase == 1u {
+            atomicAdd(&counts[DRAWN2], total);
+        }
     }
 }
 
+@compute @workgroup_size(256)
+fn scan(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
+    scan_page(group.x, lane, 0u);
+}
+
 var<workgroup> held: array<u32, 64>;
 
 // One workgroup per block of ids: each section's draws go after those of the
-// block's earlier sections in its page, in its runs' order.
-@compute @workgroup_size(64)
-fn scatter(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
-    let block = group.y * ROW + group.x;
+// block's earlier sections in its page, in its runs' order, in `phase`
+// (`scatter`, gpu_occlusion.wgsl `scatter2`).
+fn scatter_block(block: u32, lane: u32, phase: u32) {
     let id = block * BLOCK + lane;
-    var mine = 0u;
-    if id < params.ids {
-        mine = runs[id * RUN_WORDS];
-    }
+    let mine = drawn_in(id, phase);
     held[lane] = mine;
     workgroupBarrier();
     // Its draws below PAGE_SHIFT, its page above.
@@ -360,7 +493,7 @@ fn scatter(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_in
         return;
     }
     let page = mine >> PAGE_SHIFT;
-    var slot = atomicLoad(&counts[block_count(block, page)]);
+    var slot = atomicLoad(&counts[block_count(block, page, phase)]);
     for (var other = 0u; other < lane; other++) {
         // A section not drawn holds 0: no draws.
         if (held[other] >> PAGE_SHIFT) == page {
@@ -383,3 +516,8 @@ fn scatter(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_in
         draws[d + 4u] = id;
     }
 }
+
+@compute @workgroup_size(64)
+fn scatter(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
+    scatter_block(group.y * ROW + group.x, lane, 0u);
+}

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

@@ -0,0 +1,95 @@
+// GPU culling's occlusion test (gpu_culling.rs `BoxTest`), after
+// gpu_culling.wgsl in one module, made only where the depth test can be forced
+// before the fragment shader (Vulkan, cull.rs `DepthTest::Early`): one instance
+// per box `cull` listed, its section's box drawn front faces only against phase
+// 1's depth; then `count2`, `scan2` and `scatter2` write phase 2's draws.
+@group(0) @binding(9) var<storage, read> box_list: array<u32>;
+@group(0) @binding(10) var<storage, read> box_origins: array<vec4<u32>>;
+@group(0) @binding(11) var<storage, read_write> box_runs: array<u32>;
+@group(0) @binding(12) var<storage, read> box_sections: array<Section>;
+
+// The corners (bit 0: x, bit 1: y, bit 2: z) of the box's 12 triangles,
+// counter-clockwise seen from outside (cull.wgsl's).
+const CORNERS = array<u32, 36>(
+    0u, 6u, 2u, 0u, 4u, 6u, 1u, 3u, 7u, 1u, 7u, 5u, 0u, 1u, 5u, 0u, 5u, 4u,
+    2u, 7u, 3u, 2u, 6u, 7u, 0u, 3u, 1u, 0u, 2u, 3u, 4u, 5u, 7u, 4u, 7u, 6u,
+);
+
+struct BoxOut {
+    @builtin(position) position: vec4<f32>,
+    @location(0) @interpolate(flat) id: u32,
+}
+
+@vertex
+fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> BoxOut {
+    let id = box_list[params.occl.y + t];
+    let o = bitcast<vec3<f32>>(box_origins[id].xyz);
+    var out: BoxOut;
+    out.id = id;
+    out.position = params.view_proj * vec4(box_corner(o, box_sections[id].a.z, CORNERS[v]), 1.0);
+    return out;
+}
+
+// Seen at this fragment, which runs only where the depth test passes (forced
+// before it: a fragment that failed would still write). Every writer stores
+// the same stamp.
+@fragment
+@early_depth_test(force)
+fn fs_box(in: BoxOut) -> @location(0) vec4<f32> {
+    let at = in.id * RUN_WORDS + SEEN_WORD;
+    if box_runs[at] != params.occl.x {
+        box_runs[at] = params.occl.x;
+    }
+    return vec4(0.0);
+}
+
+var<workgroup> tally: array<atomic<u32>, 3>;
+
+// After the test, one workgroup per block of ids: the quads of the sections
+// with runs, the tested boxes not seen and their quads, and per page each
+// block's draws that phase 2 makes (`drawn_in`'s condition).
+@compute @workgroup_size(64)
+fn count2(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
+    if lane < 3u {
+        atomicStore(&tally[lane], 0u);
+    }
+    workgroupBarrier();
+    let block = group.y * ROW + group.x;
+    let id = block * BLOCK + lane;
+    if id < params.ids {
+        let at = id * RUN_WORDS;
+        let w = runs[at];
+        let n = w & 7u;
+        if n > 0u {
+            var quads = 0u;
+            for (var k = 0u; k < n; k++) {
+                quads += runs[at + 2u + 2u * k];
+            }
+            atomicAdd(&tally[0], quads);
+            let saw = runs[at + SEEN_WORD] == params.occl.x;
+            if (w & TESTED) != 0u && !saw {
+                atomicAdd(&tally[1], 1u);
+                atomicAdd(&tally[2], quads);
+            }
+            if (w & PHASE2) != 0u && saw {
+                atomicAdd(&counts[block_count(block, w >> PAGE_SHIFT, 1u)], n);
+            }
+        }
+    }
+    workgroupBarrier();
+    if lane == 0u {
+        atomicAdd(&counts[QUADS], atomicLoad(&tally[0]));
+        atomicAdd(&counts[HIDDEN], atomicLoad(&tally[1]));
+        atomicAdd(&counts[HIDDEN_QUADS], atomicLoad(&tally[2]));
+    }
+}
+
+@compute @workgroup_size(256)
+fn scan2(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
+    scan_page(group.x, lane, 1u);
+}
+
+@compute @workgroup_size(64)
+fn scatter2(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
+    scatter_block(group.y * ROW + group.x, lane, 1u);
+}

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

@@ -101,6 +101,11 @@ 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()),
+        (
+            "GPU culling occlusion test",
+            vec!["gpu_culling.wgsl", "gpu_occlusion.wgsl"],
+            include_str!("gpu_culling.wgsl").to_owned() + include_str!("gpu_occlusion.wgsl"),
+        ),
         (
             "static entity",
             vec!["entity.wgsl", "static_entity.wgsl"],

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

@@ -367,6 +367,7 @@ impl NativeFrame {
             distance: None,
             unculled: None,
             every_face: false,
+            view_casters: false,
         })
     }
 
@@ -510,15 +511,24 @@ impl NativeFrame {
 
     /// Writes this frame's inputs, for a world of `size`.
     pub fn write(&mut self, queue: &wgpu::Queue, frame: &Frame, size: [u32; 2]) {
-        let seconds = self.start.elapsed().as_secs_f32() % 3600.0;
+        // Under `HORIZON_STILL` the world's ticks are the clock (`PackInputs::still_ticks`), and
+        // eased values sit at their targets.
+        let still = frame.pack.still_ticks;
+        let seconds = still.map_or_else(
+            || self.start.elapsed().as_secs_f32() % 3600.0,
+            |ticks| (ticks as f32 / 20.0) % 3600.0,
+        );
         let now = std::time::Instant::now();
-        let since = self.wetness.1.map_or(0.0, |t| (now - t).as_secs_f32());
+        let since = match still {
+            Some(_) => f32::INFINITY,
+            None => self.wetness.1.map_or(0.0, |t| (now - t).as_secs_f32()),
+        };
         self.wetness = (wetness(self.wetness.0, frame.pack.rain, since), Some(now));
         let mut inputs = frame_inputs(
             frame,
             size,
             seconds,
-            self.frames,
+            still.map_or(self.frames, |ticks| ticks as u32),
             self.shadow_camera.as_ref(),
         );
         inputs.wetness = self.wetness.0;
@@ -551,7 +561,13 @@ impl NativeFrame {
             (f32::from(u8::from(inputs.eye_in == 1)), 0.25),
             (f32::from(u8::from(inputs.eye_in == 2)), 0.25),
         ];
-        let dt = inputs.delta_time;
+        let dt = match still {
+            Some(_) => {
+                inputs.delta_time = 0.05;
+                f32::INFINITY
+            }
+            None => inputs.delta_time,
+        };
         for (value, (target, half_life)) in self.eye.iter_mut().zip(targets) {
             *value = eased(*value, target, half_life, dt);
         }
@@ -1156,6 +1172,14 @@ pub fn frame_inputs(
             let k = super::native_shadow::distortion(s.distance, s.resolution);
             2.0 * s.distance / s.resolution.max(1) as f32 * (1.0 - k)
         }),
+        // Shader API 0.2's display fields, which 0.1 packs don't declare: SDR's values, also
+        // with HDR on, until HDR output is served for 0.2 packs.
+        hdr: 0,
+        headroom: 1.0,
+        paper_white: 80.0,
+        peak: 80.0,
+        black_level: 0.0,
+        padding: [0; 3],
     }
 }
 
@@ -1598,7 +1622,7 @@ file = \"b.wgsl\"
             mapped_at_creation: false,
         });
         // What the material stage stores, as the bits of floats: the normal +x (octahedral
-        // (1, 0), two snorm16), smoothness 0.5, data 0.25 and the fragment's depth 0.5.
+        // (1, 0), two snorm16), smoothness 0.75, data 0.25 and the fragment's depth 0.5.
         let writer = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: None,
             source: wgpu::ShaderSource::Wgsl(
@@ -1607,7 +1631,7 @@ file = \"b.wgsl\"
                 }
                 @fragment fn fs() -> @location(0) vec4<u32> {
                     return bitcast<vec4<u32>>(vec4<f32>(
-                        bitcast<f32>(pack2x16snorm(vec2<f32>(1.0, 0.0))), 0.5, 0.25, 0.5));
+                        bitcast<f32>(pack2x16snorm(vec2<f32>(1.0, 0.0))), 0.75, 0.25, 0.5));
                 }"
                 .into(),
             ),
@@ -1707,8 +1731,9 @@ file = \"b.wgsl\"
             buffer.unmap();
             pixel
         };
-        // Present where the world's depth is the stored one: +x, 0.5, 0.25 as 8-bit.
-        assert_eq!(read(0.5), [255, 128, 64, 255]);
+        // Present where the world's depth is the stored one: +x, 0.75, 0.25 as 8-bit. No value
+        // here sits halfway between two 8-bit levels, where drivers round either way.
+        assert_eq!(read(0.5), [255, 191, 64, 255]);
         // Hidden by something nearer drawn since: the stored values no longer show.
         assert_eq!(read(0.25), [0, 0, 0, 0]);
     }

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

@@ -159,9 +159,9 @@ const SHADOW_COLOR: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
 /// staying put while the camera walks a `SNAP`-block cell. The map is distorted about its
 /// centre, so a centre that moves with the camera, even by a texel, resamples every shadow but
 /// the nearest each frame and they shimmer; a still one maps the world to the same texels until
-/// the next cell. Its depth starts 256 blocks further toward the light than `shaders/` packs'
-/// (the projection's near plane is at `-near`), so the ground over a deep cave still casts its
-/// shadow, and ends past the build height and the slant across the map below the camera.
+/// the next cell. Its depth starts 356 blocks toward the light (256 further than `shaders/`
+/// packs' default), so the ground over a deep cave still casts its shadow, and ends past the
+/// build height and the slant across the map below the camera.
 pub fn camera(settings: &Settings) -> Shadow {
     Shadow {
         resolution: settings.resolution,
@@ -169,8 +169,8 @@ pub fn camera(settings: &Settings) -> Shadow {
         render_mul: 1.0,
         interval: SNAP,
         euclidean_snap: true,
-        near: 256.0,
-        far: super::pack_uniforms::SHADOW_EYE + 2.0 * settings.distance + 384.0,
+        near: Some(-356.0),
+        far: Some(2.0 * settings.distance + 384.0),
         ..Shadow::default()
     }
 }

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

@@ -692,6 +692,25 @@ impl Occlusion {
     pub fn contains(&self, key: SectionKey) -> bool {
         self.graph.as_ref().is_none_or(|g| g.contains(key))
     }
+    /// Whether the current graph knows that `key` is visible from
+    /// `camera_section`. Unknown is returned when the graph is absent, was
+    /// searched from another section, or does not cover the queried section.
+    pub fn visible_for_camera(&self, key: SectionKey, camera_section: SectionKey) -> Option<bool> {
+        let graph = self.graph.as_ref()?;
+        if graph.from != camera_section {
+            return None;
+        }
+        let dx = i64::from(key.0) - i64::from(graph.from.0);
+        let dz = i64::from(key.2) - i64::from(graph.from.2);
+        if dx.abs() > i64::from(graph.radius)
+            || dz.abs() > i64::from(graph.radius)
+            || key.1 < graph.y0
+            || key.1 > graph.sections
+        {
+            return None;
+        }
+        Some(graph.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))]
@@ -904,6 +923,77 @@ mod tests {
         assert!(o.contains((2, 1, 0)));
     }
 
+    /// `visible_for_camera` answers only for the box of the graph it holds, and
+    /// only for the camera that search started from. Everywhere else it says
+    /// unknown, so the caller keeps the geometry.
+    #[test]
+    fn visible_for_camera_is_unknown_outside_its_box_and_its_camera() {
+        // No graph yet: nothing to answer with.
+        assert_eq!(
+            Occlusion::new(0, 4).visible_for_camera((0, 1, 0), (0, 1, 0)),
+            None
+        );
+        let mut o = Occlusion::new(0, 4);
+        o.settle(at((0, 1, 0)), 2);
+        let from = o.columns.section_of(at((0, 1, 0)));
+        assert_eq!(from, (0, 1, 0), "the camera section searched from");
+        // Inside the searched box the answer is `contains`, its edges too.
+        for x in -2..=2 {
+            for z in -2..=2 {
+                for y in -1..=4 {
+                    assert_eq!(
+                        o.visible_for_camera((x, y, z), from),
+                        Some(o.contains((x, y, z))),
+                        "{x} {y} {z}"
+                    );
+                }
+            }
+        }
+        assert_eq!(
+            o.visible_for_camera((2, 1, 0), from),
+            Some(true),
+            "the box's edge"
+        );
+        // Off the box's sides, below it, or above the level: unknown.
+        for key in [
+            (3, 1, 0),
+            (-3, 1, 0),
+            (0, 1, 3),
+            (0, 1, -3),
+            (0, -2, 0),
+            (0, 5, 0),
+        ] {
+            assert_eq!(o.visible_for_camera(key, from), None, "{key:?}");
+        }
+        // Another camera section: this graph is not about it.
+        assert_eq!(o.visible_for_camera((0, 1, 0), (1, 1, 0)), None);
+    }
+
+    /// The answer follows the graph: a closed wall hides the section behind it,
+    /// and opening the wall shows it again.
+    #[test]
+    fn visible_for_camera_reports_what_the_graph_hides() {
+        let mut o = Occlusion::new(0, 4);
+        for (dx, dy, dz) in STEPS {
+            o.set((dx, 1 + dy, dz), 0);
+        }
+        o.settle(at((0, 1, 0)), 3);
+        let from = (0, 1, 0);
+        assert_eq!(
+            o.visible_for_camera((1, 1, 0), from),
+            Some(true),
+            "the wall itself"
+        );
+        assert_eq!(
+            o.visible_for_camera((2, 1, 0), from),
+            Some(false),
+            "hidden behind it"
+        );
+        o.set((1, 1, 0), ALL_VISIBLE);
+        o.settle(at((0, 1, 0)), 3);
+        assert_eq!(o.visible_for_camera((2, 1, 0), from), Some(true));
+    }
+
     /// Faces `a` and `b` of a section see each other, nothing else does.
     fn connects(a: usize, b: usize) -> u64 {
         1 << (a * 6 + b) | 1 << (b * 6 + a)

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

@@ -519,6 +519,36 @@ const FACE: &str = "    uint hz_q = (uint(gl_VertexIndex) & ~3u) * 6u;\n    \
         }\n    \
     }\n";
 
+/// `terrain` (`PackAtlas::terrain_inputs`) drawing only solid terrain, then only cutout terrain:
+/// each leaves the other part's quads outside the clip volume. Solid: the quads over opaque
+/// texels and opaque leaves (`mesher::OPAQUE_LAYER`), as vanilla picks `ChunkSectionLayer.SOLID`
+/// per quad (`FaceBakery.computeMaterialTransparency`, `SectionCompiler.compile`), and lava's
+/// faces (sprite layers `lava`, its still and flowing sprites), which Iris 1.11.7 drew with
+/// `gbuffers_terrain_solid` in our probes, with and without `separateAo`.
+///
+/// The test reads only the vertex's sprite layer, which all four vertices of a quad share: a
+/// quad lands whole in one part. The colour's alpha can't decide it, as with `separateAo` it
+/// holds each vertex's own ambient occlusion.
+pub fn terrain_parts(
+    terrain: &horizon_shaders::GbuffersInputs,
+    lava: &[u16],
+) -> [horizon_shaders::GbuffersInputs; 2] {
+    let opaque = crate::mesher::OPAQUE_LAYER;
+    let lava: String = lava
+        .iter()
+        .map(|l| format!(" || hz_v_layer == {l}u"))
+        .collect();
+    let part = |solid: bool| {
+        let mut inputs = terrain.clone();
+        inputs.after.push_str(&format!(
+            "    bool hz_solid = (hz_v_layer & {opaque}u) != 0u{lava};\n    \
+             if (hz_solid != {solid}) gl_Position = vec4(2.0, 2.0, 2.0, 1.0);\n"
+        ));
+        inputs
+    };
+    [part(true), part(false)]
+}
+
 impl PackAtlas {
     /// The vertex inputs of a gbuffers program drawing terrain (`TerrainVertex`, terrain.wgsl's
     /// `vs_terrain` or, for `flat` draws, `vs_terrain_flat`), in atlas coordinates.
@@ -577,12 +607,16 @@ impl PackAtlas {
         } else {
             "1.0"
         };
+        // A vertex's place in its section goes down to the 32768th of a block below it: read back
+        // with a probe pack of ours, Iris 1.11.7's terrain `gl_Vertex` has that for every position
+        // we read (water tops at 8/9 - 0.001, plants' offsets), on all three axes (#8464). A fit,
+        // not Iris's code. Whole and half blocks, and every 1/16, are on that grid already.
         let body = format!(
             "    vec4 hz_origin = {origin};\n    \
              uint hz_layer = hz_v_layer & 32767u;\n    \
              {cell}\
              hz_scale = vec2({:?}, {:?}) * {side};\n    \
-             hz_Vertex = vec4(hz_v_pos + hz_origin.xyz, 1.0);\n    \
+             hz_Vertex = vec4(floor(hz_v_pos * 32768.0) / 32768.0 + hz_origin.xyz, 1.0);\n    \
              hz_uv_scale = hz_origin.w > 0.0 ? uintBitsToFloat(floatBitsToUint(hz_origin.w) & 0xff800000u) : fract(abs(hz_origin.w));\n    \
              hz_mid = vec2(0.5);\n    \
              hz_MultiTexCoord0 = vec4((hz_cell + clamp(vec2(hz_v_uv) * hz_uv_scale, 0.0, 1.0)) * hz_scale, 0.0, 1.0);\n    \
@@ -644,6 +678,7 @@ impl PackAtlas {
             after: String::new(),
             alpha_test: None,
             item_id_declared: false,
+            far_depth: false,
         }
     }
 }

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

@@ -171,13 +171,98 @@ fn flat_draws_map_uvs_onto_a_stitched_sprite() {
     assert!(failures.is_empty(), "{}", failures.join("\n"));
 }
 
+/// Read back with a probe pack of ours, Iris 1.11.7's terrain `gl_Vertex` (camera on the block
+/// grid) puts a water top, 8/9 - 0.001 of a block up, at 29094/32768, and plants offset by 13/15
+/// and 0.1 of a block at 28398/32768 and 3276/32768 (#8464): each 32768th below the position.
+/// Whole blocks and sixteenths stay where they are.
+#[test]
+fn terrain_vertices_go_down_to_the_32768th_below_them() {
+    let instance = crate::gfx::test_gpu::instance();
+    let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
+        return;
+    };
+    let (device, queue) = pollster::block_on(adapter.request_device(&Default::default())).unwrap();
+    let texture = device.create_texture(&wgpu::TextureDescriptor {
+        label: None,
+        size: wgpu::Extent3d {
+            width: 16,
+            height: 16,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba8Unorm,
+        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_SRC,
+        view_formats: &[],
+    });
+    let mut encoder = device.create_command_encoder(&Default::default());
+    let atlas = PackAtlas::new(&device, &mut encoder, &[texture], 1, 1, 16).unwrap();
+    queue.submit([encoder.finish()]);
+    let water = 8.0f32 / 9.0 - 0.001;
+    let cases = [
+        ([0.1, water, 13.0 / 15.0], [3276.0, 29094.0, 28398.0]),
+        ([13.0 / 15.0, 0.1, water], [28398.0, 3276.0, 29094.0]),
+        ([1.0, 0.5, 15.9375], [32768.0, 16384.0, 522240.0]),
+    ];
+    let vertices: Vec<_> = cases
+        .iter()
+        .map(|&(pos, _)| TerrainVertex::new(pos, [0.0, 0.0], 0x8000, u32::MAX, 0))
+        .collect();
+    let origin = f32::from_bits((1. / UV_STEPS).to_bits());
+    let mut failures = Vec::new();
+    for flat in [true, false] {
+        for shadow in [false, true] {
+            let read = sample_probe(
+                &device,
+                &queue,
+                &atlas,
+                &vertices,
+                origin,
+                [flat, shadow],
+                "gl_Vertex",
+            );
+            for ((pos, expected), got) in cases.iter().zip(&read) {
+                let got = [got[0], got[1], got[2]].map(|v| v * 32768.0);
+                if got != *expected {
+                    failures.push(format!(
+                        "{pos:?}, flat={flat} shadow={shadow}: {got:?} != {expected:?}"
+                    ));
+                }
+            }
+        }
+    }
+    assert!(failures.is_empty(), "{}", failures.join("\n"));
+}
+
 fn sample(
+    device: &wgpu::Device,
+    queue: &wgpu::Queue,
+    atlas: &PackAtlas,
+    vertices: &[TerrainVertex],
+    scale: f32,
+    flags: [bool; 2],
+) -> Vec<[f32; 4]> {
+    sample_probe(
+        device,
+        queue,
+        atlas,
+        vertices,
+        scale,
+        flags,
+        "vec4(mc_midTexCoord, gl_MultiTexCoord0.xy)",
+    )
+}
+
+/// What the pack's vertex stage sets `probe` to (`expression`), for each of `vertices`.
+fn sample_probe(
     device: &wgpu::Device,
     queue: &wgpu::Queue,
     atlas: &PackAtlas,
     vertices: &[TerrainVertex],
     scale: f32,
     [flat, shadow]: [bool; 2],
+    expression: &str,
 ) -> Vec<[f32; 4]> {
     let pp = |code| horizon_shaders::Preprocessed {
         code,
@@ -185,7 +270,7 @@ fn sample(
     };
     let vertex = pp(format!(
         "attribute vec2 mc_midTexCoord;\nvarying vec4 probe;\nvoid main() {{\n\
-         probe = vec4(mc_midTexCoord, gl_MultiTexCoord0.xy);\n\
+         probe = {expression};\n\
          gl_Position = vec4((float(gl_VertexID) + 0.5) * {} - 1.0, 0.0, 0.0, 1.0);\n}}",
         2. / vertices.len() as f32,
     ));

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

@@ -102,6 +102,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
             reference: 0.1,
         }),
         item_id_declared: false,
+        far_depth: false,
     }
 }
 
@@ -164,6 +165,7 @@ pub fn cloud_inputs() -> horizon_shaders::GbuffersInputs {
         after: String::new(),
         alpha_test: None,
         item_id_declared: false,
+        far_depth: false,
     }
 }
 

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

@@ -51,6 +51,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
         after,
         alpha_test: None,
         item_id_declared: false,
+        far_depth: false,
     }
 }
 

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

@@ -37,12 +37,24 @@ mod world_target_tests;
 #[cfg(test)]
 mod higher_shadowcolor_tests;
 
+#[cfg(test)]
+mod single_side_tests;
+
 #[cfg(test)]
 mod shadow_faces_tests;
 
 #[cfg(test)]
 mod forced_flip_tests;
 
+#[cfg(test)]
+mod weather_depth_tests;
+
+#[cfg(test)]
+mod custom_type_tests;
+
+#[cfg(test)]
+mod sky_depth_tests;
+
 /// The texture behind a pack sampler name.
 #[derive(Clone, Copy, PartialEq)]
 enum Source {
@@ -99,6 +111,8 @@ enum SamplerKind {
     Nearest,
     Repeat,
     NearestRepeat,
+    /// The block atlas: nearest texels, blended between the two nearest levels.
+    Atlas,
     Comparison,
 }
 
@@ -108,15 +122,15 @@ impl SamplerKind {
             Source::Color(_) | Source::ShadowColor(_) | Source::Dummy if !filtering => {
                 Self::Nearest
             }
-            // shadowtex0/1 through a plain sampler: linear, as Iris 1.11.7 reads them, when the
-            // device filters their copies (`ShadowTargets::linear`).
-            Source::ShadowDepth(_, false) if filtering => Self::Linear,
             Source::Depth | Source::Depth1 | Source::Depth2 | Source::ShadowDepth(_, false) => {
                 Self::Nearest
             }
             Source::Noise => Self::Repeat,
             Source::Shadow | Source::ShadowDepth(_, true) => Self::Comparison,
-            // Blocks look as the game draws them: nearest texels.
+            // Blocks look as the game draws them: nearest texels. Between levels, Iris 1.11.7
+            // blends `gtexture`'s two nearest (our probe packs, #9307: a read at level 1.25 is
+            // levels 1 and 2 mixed 3:1).
+            Source::Atlas if filtering => Self::Atlas,
             Source::Atlas | Source::Normals | Source::Specular => Self::NearestRepeat,
             Source::Image(_) if filtering => Self::Linear,
             Source::Image(_) => Self::Nearest,
@@ -134,7 +148,7 @@ impl SamplerKind {
 
     fn binding_type(self) -> wgpu::SamplerBindingType {
         match self {
-            Self::Linear | Self::Repeat => wgpu::SamplerBindingType::Filtering,
+            Self::Linear | Self::Repeat | Self::Atlas => wgpu::SamplerBindingType::Filtering,
             Self::Nearest | Self::NearestRepeat => wgpu::SamplerBindingType::NonFiltering,
             Self::Comparison => wgpu::SamplerBindingType::Comparison,
         }
@@ -357,6 +371,8 @@ struct Pass {
     writes: Vec<(u32, usize)>,
     /// Buffers flipped after the pass.
     flip: u16,
+    /// `hz_depth_linear`: which of the depth samplers a plain sampler reads filter.
+    depth_linear: [f32; 4],
     /// Buffers sampled, for the bind group cache key.
     reads: u16,
     /// shadowcolor buffers sampled by a program of the other buffers.
@@ -516,8 +532,14 @@ pub struct PackPost {
     passes: Vec<Pass>,
     /// Shadow cache for temporal reprojection.
     shadow_cache: ShadowCache,
-    /// What draws terrain (`gbuffers_terrain` or its fallback), between `prepare` and `deferred`.
+    /// What draws terrain (`gbuffers_terrain` or its fallback), between `prepare` and `deferred`;
+    /// when the pack draws terrain in two parts, solid terrain only (`gbuffers_terrain_solid` or
+    /// its fallback).
     terrain: Option<Pass>,
+    /// What draws cutout terrain (`gbuffers_terrain_cutout` or its fallback), after `terrain`,
+    /// when the pack draws terrain in two parts. A pack with no program for one part has only
+    /// the other.
+    terrain_cutout: Option<Pass>,
     /// What draws translucent terrain (`gbuffers_water` or its fallback), after `deferred`.
     water: Option<Pass>,
     /// What draws the sky (`gbuffers_skybasic` or its fallback), before terrain, and its vertices.
@@ -593,6 +615,8 @@ pub struct PackPost {
     rgb: u16,
     rgb_unset: bool,
     used: u16,
+    /// Buffers some pass draws into the "alt" side of or flips; the others' B is their A.
+    doubled: u16,
     /// `size.buffer.*`.
     sizes: [Option<horizon_shaders::BufferSize>; BUFFERS],
     /// Buffers bound as images, and those also copied for a pass that samples them.
@@ -627,6 +651,7 @@ pub struct PackPost {
     nearest: wgpu::Sampler,
     repeat: wgpu::Sampler,
     nearest_repeat: wgpu::Sampler,
+    atlas_sampler: wgpu::Sampler,
     /// None when it would write nothing: colortex0 holds integers and there is no depth to copy
     /// nor buffer to clear.
     blit: Option<(wgpu::RenderPipeline, wgpu::BindGroupLayout)>,
@@ -757,6 +782,14 @@ fn fits(ty: &str, sample_type: wgpu::TextureSampleType) -> bool {
         }
 }
 
+/// `hz_depth_linear` for a program: 1 for each of shadowtex0, shadowtex1, `shadow` and
+/// `watershadow` whose depth filters (`linear`, bit n: shadowtex n). `shadow` is shadowtex1 in a
+/// program that also declares `watershadow` (6.3).
+fn depth_linear(interface: &horizon_shaders::Interface, linear: u8) -> [f32; 4] {
+    let watershadow = interface.samplers.iter().any(|s| s.name == "watershadow");
+    [0, 1, usize::from(watershadow), 0].map(|n| f32::from(linear >> n & 1))
+}
+
 fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool) -> Source {
     let shadow_color = horizon_shaders::shadow_color(name);
     let shadow_depth = match name {
@@ -1079,6 +1112,11 @@ pub(super) struct ShadowView {
     /// shadow map holds the faces turned away from the light too (#9033): under a hill at low sun
     /// a cave's ceiling, which faces away, is often all that shadows the cave.
     pub every_face: bool,
+    /// Only the sections whose shadow can fall into the camera's view: those the camera's
+    /// frustum, stretched toward the light, takes in (`shadow_casters`). Our probes' Iris 1.11.7
+    /// maps fit keeping only those with `shadow.culling` unset (#8464): under a noon sun, only
+    /// the terrain above the ground the camera sees; with a low sun ahead, none behind the camera.
+    pub view_casters: bool,
 }
 
 /// Set 3 of flat terrain, read by the vertex stage: the sprite layers' table (`mc_Entity`'s id
@@ -1165,7 +1203,7 @@ struct Resources<'a> {
     /// The formats and dimensions of the images no `image.*` gives, for their stand-ins.
     stand_ins: &'a std::cell::RefCell<Vec<(wgpu::TextureFormat, wgpu::TextureViewDimension)>>,
     /// Bit n: shadowtex n read through a plain sampler filters linearly (`shadowtexNNearest`
-    /// unset, and the device filters `R32Float`).
+    /// unset): the translator's helpers blend a gather of it (`hz_depth_linear`).
     shadow_linear: u8,
 }
 
@@ -1283,6 +1321,36 @@ fn bindings(
             }
             None => {
                 let mut src = source(&s.name, group.shadow(), shadow.is_some(), watershadow);
+                // A sampler the game gives no texture reads texture unit 0, as do the atlas's
+                // names: the atlas in gbuffers programs, `colortex0` in deferred, composite and
+                // final (OptiFine's shaders.txt). Iris 1.11.7 read the atlas through a name of
+                // ours in gbuffers_terrain, and the scene in `colortex0` through such a name and
+                // through `gtexture`, `tex` and `texture` in those three, with or without
+                // `colortex0` declared (probe packs of ours, #9307). Translucent programs and
+                // the other groups weren't measured and keep the stand-in.
+                let unit_0 = match group {
+                    Group::Gbuffers => Some(Source::Atlas),
+                    Group::Deferred | Group::Composite | Group::Final => Some(Source::Color(0)),
+                    _ => None,
+                };
+                // A name of the game's that has no texture here (a shadow sampler with no
+                // shadow pass) stays blank; so does a sampler that isn't 2D, and one under a
+                // `texture.<stage>.<name>` left unbound (#9064's probe read a 16-texel-wide
+                // texture there in final, undiagnosed).
+                let unknown = src == Source::Dummy
+                    && source(&s.name, false, true, false) == Source::Dummy
+                    && s.ty == "sampler2D"
+                    && !textures.iter().any(|t| t.name == s.name);
+                // colortex0 to colortex3 (gcolor, gdepth, gnormal, composite) are no gbuffers
+                // samplers in shaders.txt's table: Iris 1.11.7 read the atlas through each of
+                // colortex0-3 and gnormal in gbuffers_terrain (our probe, #9307).
+                let not_gbuffers =
+                    group == Group::Gbuffers && matches!(src, Source::Color(n) if n < 4);
+                if let Some(unit_0) = unit_0
+                    && (src == Source::Atlas || unknown || not_gbuffers)
+                {
+                    src = unit_0;
+                }
                 let blank = match src {
                     // The shadow pass writes the shadow map.
                     Source::ShadowDepth(..) => group == Group::Shadow,
@@ -1300,7 +1368,6 @@ fn bindings(
                     Source::ShadowColor(n) => shadow
                         .and_then(|f| f[n].sample_type(None, Some(features)))
                         .unwrap_or(float),
-                    Source::ShadowDepth(n, false) if pack.shadow_linear & 1 << n != 0 => float,
                     Source::Depth | Source::Depth1 | Source::Depth2 | Source::ShadowDepth(..) => {
                         wgpu::TextureSampleType::Float { filterable: false }
                     }
@@ -1503,6 +1570,22 @@ fn image_format(qualifier: &str) -> Option<wgpu::TextureFormat> {
     })
 }
 
+/// The value slot of the pack's custom uniform `name` for a program declaring it as GLSL type
+/// `ty`: after the frame's uniforms, in the order of `custom` (each with the type
+/// `shaders.properties` gives it). A `float`, `int`, `vec2`, `vec3` or `vec4` custom uniform
+/// declared as another of these types gets none, and reads 0: Iris 1.11.7 logs "Wrong uniform
+/// type ... Disabling that uniform" and our probes read 0 there (float as int, int as float,
+/// vec3 as vec2, vec2 as vec3; the vec4 cases were not probed). Other pairs (a `bool` on either
+/// side) keep the conversion `Value::write` makes: our probe read a float of 2.5 declared
+/// `bool` as true in both games.
+fn custom_index(custom: &[(String, String)], name: &str, ty: &str) -> Option<usize> {
+    const STRICT: [&str; 5] = ["float", "int", "vec2", "vec3", "vec4"];
+    let k = custom.iter().position(|(c, _)| c == name)?;
+    let declared = custom[k].1.as_str();
+    let disabled = declared != ty && STRICT.contains(&declared) && STRICT.contains(&ty);
+    (!disabled).then_some(pack_uniforms::NAMES.len() + k)
+}
+
 /// The pass of program `p`: a quad, or `geometry` drawn by the game. `None` (with a note) when
 /// wgpu refuses it or it writes nothing. `formats` are its buffers' (for a program of the shadow
 /// buffers, buffer n is shadowcolor n); `shadow` the shadowcolor formats when the shadow pass
@@ -1516,17 +1599,14 @@ fn build_pass(
     screen: wgpu::TextureFormat,
     notes: &mut Vec<String>,
     geometry: Option<&Geometry<'_>>,
-    custom: &[String],
+    custom: &[(String, String)],
     draws: &wgpu::BindGroupLayout,
     pack: &Resources<'_>,
 ) -> Option<Pass> {
     let features = device.features();
     // The frame's uniforms, then the pack's custom ones.
-    let index = |name: &str| {
-        pack_uniforms::index_in(name, geometry.is_some()).or_else(|| {
-            let k = custom.iter().position(|c| c == name)?;
-            Some(pack_uniforms::NAMES.len() + k)
-        })
+    let index = |name: &str, ty: &str| {
+        pack_uniforms::index_in(name, geometry.is_some()).or_else(|| custom_index(custom, name, ty))
     };
     let mask = |flips: &[(u32, bool)]| flips.iter().filter(|f| f.1).fold(0u16, |m, f| m | 1 << f.0);
     let mut p = p;
@@ -1718,7 +1798,7 @@ fn build_pass(
     let missing: Vec<&str> = interface
         .uniforms
         .iter()
-        .filter(|u| !u.name.starts_with("hz_") && index(&u.name).is_none())
+        .filter(|u| !u.name.starts_with("hz_") && index(&u.name, &u.ty).is_none())
         .map(|u| u.name.as_str())
         .collect();
     if !missing.is_empty() {
@@ -1740,7 +1820,7 @@ fn build_pass(
         uniforms: interface
             .uniforms
             .iter()
-            .map(|u| (index(&u.name), u.ty.clone(), u.offset))
+            .map(|u| (index(&u.name, &u.ty), u.ty.clone(), u.offset))
             .collect(),
         name: p.name,
         group: p.group,
@@ -1749,6 +1829,7 @@ fn build_pass(
         samplers,
         writes,
         flip,
+        depth_linear: depth_linear(interface, pack.shadow_linear),
         shadow_reads,
         written,
         mipmaps: p.mipmaps,
@@ -1793,14 +1874,11 @@ fn build_compute(
     formats: &[wgpu::TextureFormat; BUFFERS],
     shadow: Option<&[wgpu::TextureFormat; SHADOW_COLORS]>,
     notes: &mut Vec<String>,
-    custom: &[String],
+    custom: &[(String, String)],
     pack: &Resources<'_>,
 ) -> Option<Pass> {
-    let index = |name: &str| {
-        pack_uniforms::index(name).or_else(|| {
-            let k = custom.iter().position(|c| c == name)?;
-            Some(pack_uniforms::NAMES.len() + k)
-        })
+    let index = |name: &str, ty: &str| {
+        pack_uniforms::index(name).or_else(|| custom_index(custom, name, ty))
     };
     let interface = &c.interface;
     let (entries, samplers, slots, reads, shadow_reads, images) = bindings(
@@ -1869,7 +1947,7 @@ fn build_compute(
         uniforms: interface
             .uniforms
             .iter()
-            .map(|u| (index(&u.name), u.ty.clone(), u.offset))
+            .map(|u| (index(&u.name, &u.ty), u.ty.clone(), u.offset))
             .collect(),
         name,
         group,
@@ -1883,6 +1961,7 @@ fn build_compute(
         samplers,
         writes: Vec::new(),
         flip: 0,
+        depth_linear: depth_linear(interface, pack.shadow_linear),
         copies: written & reads | before_colors,
         reads: reads | written,
         shadow_reads,
@@ -1965,7 +2044,9 @@ impl PackPost {
         // 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();
+        let custom_names: Vec<(String, String)> = (custom.uniforms())
+            .map(|(name, ty)| (name.to_owned(), ty.to_owned()))
+            .collect();
         // A first run finds the names neither the frame nor the pack defines.
         custom.eval(0.0, &pack_uniforms::zero);
         // Its zeros are no start for `smooth`: the first frame's values are, as in Iris.
@@ -1977,6 +2058,9 @@ impl PackPost {
         let mask =
             |flips: &[(u32, bool)]| flips.iter().filter(|f| f.1).fold(0u16, |m, f| m | 1 << f.0);
         let mut used = 1u16;
+        // Buffers some pass draws into the "alt" side of, or flips: only these get a B texture.
+        let mut doubled = mask(&post.deferred_pre) | mask(&post.composite_pre);
+        let mut shadow_doubled = 0u16;
         let draws = DrawUniforms::new(device);
         // The shadow buffers' formats when the shadow pass runs; their programs see them as
         // buffers 0 to 7.
@@ -2060,13 +2144,9 @@ impl PackPost {
             packed,
             released: std::cell::Cell::new(("", 0)),
             stand_ins: &stand_ins,
-            shadow_linear: if features.contains(wgpu::Features::FLOAT32_FILTERABLE) {
-                (0..2)
-                    .filter(|&n| !shadow_config.nearest[n])
-                    .fold(0, |m, n| m | 1 << n)
-            } else {
-                0
-            },
+            shadow_linear: (0..2)
+                .filter(|&n| !shadow_config.nearest[n])
+                .fold(0, |m, n| m | 1 << n),
         };
         let mut build = |mut p: horizon_shaders::PostProgram, geometry: Option<&Geometry<'_>>| {
             let in_shadow = p.group.shadow();
@@ -2135,11 +2215,29 @@ impl PackPost {
                 ));
                 return None;
             }
+            // Composite-style programs draw into the "alt" side of what they write; gbuffers,
+            // shadow and `final` programs write in place, compute programs through images.
+            let alt = if geometry.is_none()
+                && group != Group::Final
+                && matches!(pass.pipeline, Pipeline::Render(_))
+            {
+                pass.written
+            } else {
+                0
+            };
+            if in_shadow {
+                shadow_doubled |= alt;
+            } else {
+                doubled |= alt;
+            }
             for p in std::iter::once(&pass).chain(&pass.compute) {
                 let (stage, flipped) = pack.released.get();
                 pack.released.set((stage, flipped | p.flip));
-                if !in_shadow {
+                if in_shadow {
+                    shadow_doubled |= p.flip;
+                } else {
                     used |= p.reads | p.written | p.flip;
+                    doubled |= p.flip;
                 }
                 storage |= image_buffers(&p.images);
                 image_copied |= p.image_copies;
@@ -2163,10 +2261,15 @@ impl PackPost {
             ids: block_ids.as_ref().map(|i| &i.0),
             cull: g.cull,
         });
-        let terrain = post
+        let split = post.terrain.is_some() && post.terrain_cutout.is_some();
+        let mut terrain = post
             .terrain
             .zip(terrain_geometry.as_ref())
             .and_then(|(p, g)| build(p, Some(g)));
+        let mut terrain_cutout = post
+            .terrain_cutout
+            .zip(terrain_geometry.as_ref())
+            .and_then(|(p, g)| build(p, Some(g)));
         let water = post
             .water
             .zip(terrain_geometry.as_ref())
@@ -2295,7 +2398,7 @@ impl PackPost {
         let weather_geometry = world.weather.then(|| Geometry {
             buffers: &entity_buffers,
             table: None,
-            depth_write: true,
+            depth_write: post.rain_depth,
             atlas: None,
             material_maps: false,
             ids: None,
@@ -2371,8 +2474,31 @@ impl PackPost {
             .filter_map(|p| build(p, None))
             .collect();
         let stand_ins = pack_images::stand_ins(device, stand_ins.take());
-        if let Some(t) = &terrain {
-            notes.push(format!("terrain draws with {}", t.name));
+        // Terrain in two parts draws both or neither: one alone would leave the other part's
+        // terrain undrawn. Without either, the game draws all terrain, as when the terrain
+        // program of a pack that doesn't split can't draw.
+        if split
+            && terrain.is_some() != terrain_cutout.is_some()
+            && let Some(p) = terrain.take().or(terrain_cutout.take())
+        {
+            notes.push(format!(
+                "{}: the other part of terrain can't draw; the game draws all terrain",
+                p.name
+            ));
+        }
+        match (&terrain, &mut terrain_cutout) {
+            (Some(t), None) => notes.push(format!("terrain draws with {}", t.name)),
+            (t, Some(c)) => {
+                if let Some(t) = t {
+                    notes.push(format!("solid terrain draws with {}", t.name));
+                }
+                notes.push(format!("cutout terrain draws with {}", c.name));
+                // Timed (and labelled) apart from the solid part when it runs the same program.
+                if t.as_ref().is_some_and(|t| t.name == c.name) {
+                    c.name.push_str(" (cutout)");
+                }
+            }
+            (None, None) => {}
         }
         for (part, pass) in [
             ("terrain", &shadow_terrain),
@@ -2456,6 +2582,7 @@ impl PackPost {
                 .iter()
                 .chain(&shadow_comp)
                 .chain(&terrain)
+                .chain(&terrain_cutout)
                 .chain(&water))
             .chain(shadow_terrain.iter().chain(&shadow_water))
             .chain(sky.iter().flat_map(|s| s.basic.iter().chain(&s.textured)))
@@ -2478,30 +2605,28 @@ impl PackPost {
             let depth1 = every_pass()
                 .flat_map(|p| &p.samplers)
                 .any(|s| matches!(s.source, Source::ShadowDepth(1, _)));
-            let linear = every_pass()
-                .flat_map(|p| &p.samplers)
-                .filter(|s| s.filtering)
-                .fold(0u8, |m, s| match s.source {
-                    Source::ShadowDepth(n, false) => m | 1 << n,
-                    _ => m,
-                });
             let t = super::pack_shadow::ShadowTargets::new(
                 device,
                 &shadow_config,
                 f,
                 colors,
+                shadow_doubled & colors,
                 depth1,
-                linear,
             );
             notes.push(format!(
-                "shadow map {0}x{0} over {2} blocks, sunPathRotation {3}, shadowcolor buffers {colors:#b}{1}",
+                "shadow map {0}x{0} over {2} blocks, sunPathRotation {3}, shadowcolor buffers {colors:#b} (two textures: {4:#b}){1}",
                 t.size,
                 if depth1 { ", shadowtex1" } else { "" },
                 shadow_config.distance,
                 shadow_config.sun_path_rotation,
+                shadow_doubled & colors,
             ));
             t
         });
+        log::info!(
+            "shader pack: colortex buffers {used:#b}, with two textures {:#b}",
+            doubled & used
+        );
         // Any program can leave pixels untouched. Composite-style passes also write the
         // alternate image, so their first write does not replace the main image's clear.
         let mut cleared = Vec::new();
@@ -2513,6 +2638,7 @@ impl PackPost {
                 .iter()
                 .flat_map(|s| s.basic.iter().chain(&s.textured))
                 .chain(&terrain)
+                .chain(&terrain_cutout)
                 .chain(entities.iter().flat_map(|e| e.passes.iter().flatten()))
                 .chain(&clouds)
                 .chain(&lines)
@@ -2528,6 +2654,7 @@ impl PackPost {
         }
         // Terrain tests against the world's depth (entities...), so the blit copies it then.
         let blit_depth = terrain.is_some()
+            || terrain_cutout.is_some()
             || water.is_some()
             || sky.is_some()
             || entities.as_ref().is_some_and(Entities::drawn)
@@ -2665,6 +2792,7 @@ impl PackPost {
             setup_pending: true,
             passes,
             terrain,
+            terrain_cutout,
             water,
             sky,
             entities,
@@ -2708,6 +2836,7 @@ impl PackPost {
             rgb,
             rgb_unset: true,
             used,
+            doubled: doubled & used,
             storage,
             copied,
             sizes,
@@ -2814,6 +2943,13 @@ impl PackPost {
             ),
             repeat: sampler(device, wgpu::FilterMode::Linear, wgpu::AddressMode::Repeat),
             nearest_repeat: sampler(device, wgpu::FilterMode::Nearest, wgpu::AddressMode::Repeat),
+            atlas_sampler: device.create_sampler(&wgpu::SamplerDescriptor {
+                label: Some("Shader pack atlas"),
+                address_mode_u: wgpu::AddressMode::Repeat,
+                address_mode_v: wgpu::AddressMode::Repeat,
+                mipmap_filter: wgpu::MipmapFilterMode::Linear,
+                ..Default::default()
+            }),
             blit,
             copy,
             uniforms: {
@@ -2858,7 +2994,8 @@ impl PackPost {
             }
         }
         let fog = self.uniforms.fog();
-        // Our block members first (`hz_target`, `hz_fog_color`, `hz_fog`), then the pack's.
+        // Our block members first (`hz_target`, `hz_fog_color`, `hz_fog`, `hz_depth_linear`),
+        // then the pack's.
         let ours = [
             [
                 out[0] as f32,
@@ -2868,12 +3005,21 @@ impl PackPost {
             ],
             fog[0].to_array(),
             fog[1].to_array(),
+            pass.depth_linear,
         ];
         let head: &[u8] = bytemuck::cast_slice(&ours);
         let n = head.len().min(pass.block.len());
         pass.block[..n].copy_from_slice(&head[..n]);
         for (index, ty, offset) in &pass.uniforms {
-            if let Some(v) = index.and_then(|i| self.uniforms.values.get(i)) {
+            let Some((i, v)) = index.and_then(|i| Some((i, self.uniforms.values.get(i)?))) else {
+                continue;
+            };
+            // A built-in of another type keeps its initial value (0); custom uniforms were
+            // checked when the pass was built.
+            if pack_uniforms::NAMES
+                .get(i)
+                .is_none_or(|name| v.read_as(name, ty))
+            {
                 v.write(ty, &mut pass.block, *offset as usize);
             }
         }
@@ -2911,12 +3057,6 @@ impl PackPost {
                         shadow_color(i, usize::from(key & 1 << (32 + i) != 0))
                             .unwrap_or(&self.dummy)
                     }
-                    Source::ShadowDepth(i, false) if s.filtering => {
-                        match shadow.and_then(|t| t.linear[i].as_ref()) {
-                            Some(v) => v,
-                            None => &self.dummy,
-                        }
-                    }
                     Source::ShadowDepth(i, _) => match shadow {
                         Some(t) => match (i, &t.depth1) {
                             (1, Some(d)) => &d.1,
@@ -3017,6 +3157,7 @@ impl PackPost {
                     SamplerKind::Nearest => &self.nearest,
                     SamplerKind::Repeat => &self.repeat,
                     SamplerKind::NearestRepeat => &self.nearest_repeat,
+                    SamplerKind::Atlas => &self.atlas_sampler,
                     SamplerKind::Comparison => shadow.map_or(&self.shadow.1, |t| &t.comparison),
                 };
                 entries.push(wgpu::BindGroupEntry {
@@ -3153,7 +3294,8 @@ impl PackPost {
     }
 
     /// Terrain (or, `translucent`, translucent terrain) with the pack's program; `draw` issues
-    /// the game's draws.
+    /// the game's draws. Solid terrain in two parts has its cutout part drawn second, from the
+    /// same draws.
     fn draw_terrain(
         &mut self,
         device: &wgpu::Device,
@@ -3163,13 +3305,35 @@ impl PackPost {
         list: TerrainList,
         draw: &mut TerrainDraw<'_>,
     ) {
-        let slot = match list {
+        self.draw_terrain_part(device, queue, encoder, size, list, false, draw);
+        if list == TerrainList::Solid {
+            self.draw_terrain_part(device, queue, encoder, size, list, true, draw);
+        }
+    }
+
+    /// The pass that draws `list`, or the cutout part of the solid list.
+    fn terrain_slot(&mut self, list: TerrainList, cutout: bool) -> &mut Option<Pass> {
+        match list {
+            TerrainList::Solid if cutout => &mut self.terrain_cutout,
             TerrainList::Solid => &mut self.terrain,
             TerrainList::Translucent => &mut self.water,
             TerrainList::ShadowSolid => &mut self.shadow_terrain,
             TerrainList::ShadowTranslucent => &mut self.shadow_water,
-        };
-        let Some(mut pass) = slot.take() else {
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn draw_terrain_part(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        encoder: &mut wgpu::CommandEncoder,
+        size: [u32; 2],
+        list: TerrainList,
+        cutout: bool,
+        draw: &mut TerrainDraw<'_>,
+    ) {
+        let Some(mut pass) = self.terrain_slot(list, cutout).take() else {
             return;
         };
         let translucent = list.translucent();
@@ -3207,12 +3371,7 @@ impl PackPost {
         if !pass.group.shadow() {
             self.mips_valid &= !pass.written;
         }
-        *match list {
-            TerrainList::Solid => &mut self.terrain,
-            TerrainList::Translucent => &mut self.water,
-            TerrainList::ShadowSolid => &mut self.shadow_terrain,
-            TerrainList::ShadowTranslucent => &mut self.shadow_water,
-        } = Some(pass);
+        *self.terrain_slot(list, cutout) = Some(pass);
     }
 
     /// The sky's parts in vanilla's order, each with the program that draws it; one render pass
@@ -3846,12 +4005,13 @@ impl PackPost {
                 horizon_shaders::ShadowCulling::Reversed => Some(shadow.voxel_distance),
             },
             every_face: true,
+            view_casters: true,
         })
     }
 
     /// Whether the pack draws terrain itself.
     pub fn has_terrain(&self) -> bool {
-        self.terrain.is_some()
+        self.terrain.is_some() || self.terrain_cutout.is_some()
     }
 
     /// Whether the pack's shadow pass draws terrain (`shadow_view`).
@@ -3902,6 +4062,7 @@ impl PackPost {
             .passes
             .iter_mut()
             .chain(&mut self.terrain)
+            .chain(&mut self.terrain_cutout)
             .chain(&mut self.water)
             .chain(sky)
             .chain(entities)
@@ -3983,8 +4144,16 @@ impl PackPost {
                 if i != 0 && self.clears[i].is_none() {
                     attachment |= wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::COPY_DST;
                 }
-                let sides = [0, 1]
-                    .map(|_| texture_sized(&label, self.formats[i], attachment, levels, sizes[i]));
+                let side = || texture_sized(&label, self.formats[i], attachment, levels, sizes[i]);
+                let a = side();
+                let sides = [
+                    a.clone(),
+                    if self.doubled & 1 << i != 0 {
+                        side()
+                    } else {
+                        a
+                    },
+                ];
                 if mipped && let Some((_, layout)) = self.down.get(&self.formats[i]) {
                     mips[i] = Some(sides.each_ref().map(|t| {
                         Mips {
@@ -4147,9 +4316,6 @@ impl PackPost {
             TerrainList::ShadowTranslucent,
             terrain,
         );
-        if let Some(t) = &self.shadow_targets {
-            t.copy_linear(encoder);
-        }
         let mut comp = std::mem::take(&mut self.shadow_comp);
         for pass in &mut comp {
             let mut compute = std::mem::take(&mut pass.compute);
@@ -4229,8 +4395,8 @@ impl PackPost {
         shadow.interval.to_bits().hash(&mut hasher);
         shadow.sun_path_rotation.to_bits().hash(&mut hasher);
         shadow.fov.map(|f| f.to_bits()).hash(&mut hasher);
-        shadow.near.to_bits().hash(&mut hasher);
-        shadow.far.to_bits().hash(&mut hasher);
+        shadow.near.map(f32::to_bits).hash(&mut hasher);
+        shadow.far.map(f32::to_bits).hash(&mut hasher);
         for hf in &shadow.hardware_filtering {
             hf.hash(&mut hasher);
         }
@@ -4420,7 +4586,10 @@ impl PackPost {
                 store: wgpu::StoreOp::Store,
             };
             for b in (0..BUFFERS).filter(|&b| self.rgb & 1 << b != 0) {
-                for alt in [false, true] {
+                for alt in [false, true]
+                    .into_iter()
+                    .take(1 + usize::from(self.doubled & 1 << b != 0))
+                {
                     if let Some(v) = view(self.main, b, alt) {
                         encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                             label: Some("Shader pack three-channel start"),
@@ -4453,7 +4622,8 @@ impl PackPost {
         let max_attachments = (limits.max_color_attachments as usize).min(8);
         // 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())
+            .filter(|&b| self.clears[b].is_some() && self.doubled & 1 << b != 0)
+            .filter(|&b| 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
@@ -4561,6 +4731,7 @@ impl PackPost {
         let mut shown = false;
         // A water-only pack still needs the opaque phase to populate requested snapshots.
         let mut terrain_drawn = self.terrain.is_none()
+            && self.terrain_cutout.is_none()
             && self.sky.is_none()
             && !self.entities.as_ref().is_some_and(Entities::drawn)
             && self.clouds.is_none()
@@ -4735,6 +4906,10 @@ mod snorm_tests;
 #[path = "pack_post/depth_test.rs"]
 mod depth_test;
 
+#[cfg(test)]
+#[path = "pack_post/terrain_parts_tests.rs"]
+mod terrain_parts_tests;
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -5404,3 +5579,18 @@ mod const_offset_tests;
 
 #[cfg(test)]
 mod integer_colortex0_tests;
+
+#[cfg(test)]
+mod atlas_mip_tests;
+
+#[cfg(test)]
+mod wrong_type_uniform_tests;
+
+#[cfg(test)]
+mod atlas_name_post_tests;
+
+#[cfg(test)]
+mod unknown_sampler_terrain_tests;
+
+#[cfg(test)]
+mod mipmap_box_tests;

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

@@ -54,10 +54,39 @@ fn fs_copy(v: Full) -> @location(0) vec4<f32> {
     return textureSample(source, linear, v.uv);
 }
 
-// One level of a buffer's mip chain from the level above (6.1.7): the average of the 2×2
-// texels under each destination texel, by one bilinear sample at their shared corner.
+// One level of a buffer's mip chain from the level above (6.1.7): a box filter, the average
+// of the texels under each destination texel (OpenGL 4.6, 8.14.4, recommends one). Along an
+// even side a texel covers two of the level above; along an odd side of 2d + 1 texels, texel i
+// covers 2 + 1 / d of them: 2i, 2i + 1 and 2i + 2, weighted d - i, d and i + 1 over 2d + 1.
+// Every texel of the level above then counts as much, so a small bright spot keeps its share
+// down to the last level, which is the buffer's mean.
+fn down_weights(i: u32, side: u32) -> vec3<f32> {
+    if side == 1u {
+        return vec3<f32>(1.0, 0.0, 0.0);
+    }
+    if side % 2u == 0u {
+        return vec3<f32>(0.5, 0.5, 0.0);
+    }
+    let d = f32(side / 2u);
+    return vec3<f32>(d - f32(i), d, f32(i) + 1.0) / f32(side);
+}
+
 @fragment
 fn fs_down(@builtin(position) p: vec4<f32>) -> @location(0) vec4<f32> {
-    let size = max(textureDimensions(source) / 2u, vec2<u32>(1u));
-    return textureSampleLevel(source, linear, p.xy / vec2<f32>(size), 0.0);
+    let above = textureDimensions(source);
+    let at = vec2<u32>(p.xy);
+    let wx = down_weights(at.x, above.x);
+    let wy = down_weights(at.y, above.y);
+    let first = vec2<i32>(at * 2u);
+    let last = vec2<i32>(above) - 1;
+    var sum = vec4<f32>(0.0);
+    for (var y = 0; y < 3; y++) {
+        for (var x = 0; x < 3; x++) {
+            let w = wx[x] * wy[y];
+            if w > 0.0 {
+                sum += w * textureLoad(source, min(first + vec2<i32>(x, y), last), 0);
+            }
+        }
+    }
+    return sum;
 }

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

@@ -0,0 +1,108 @@
+//! The block atlas is read with nearest texels, blended between the two nearest levels: our
+//! probe packs (#9307) read `gtexture` in gbuffers_terrain, and the atlas as a custom texture in
+//! composite, at levels 0.5 and 1.25 in Iris 1.11.7, and got the two nearest levels mixed.
+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";
+
+/// The atlas as composite's `noisetex`, read at levels 0.5 (red) and 0.25 (green).
+fn pack() -> Post {
+    let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    let mut add = |name: &str, source: &str| {
+        zip.start_file(name, zip::write::SimpleFileOptions::default())
+            .unwrap();
+        zip.write_all(source.as_bytes()).unwrap();
+    };
+    add(
+        "shaders/shaders.properties",
+        "texture.composite.noisetex=minecraft:textures/atlas/blocks.png\n",
+    );
+    add("shaders/composite.vsh", VERTEX);
+    add(
+        "shaders/composite.fsh",
+        "#version 130\nuniform sampler2D noisetex;\nvoid main() {\n/* DRAWBUFFERS:0 */\n\
+         \x20   gl_FragData[0] = vec4(textureLod(noisetex, vec2(0.5), 0.5).r, textureLod(noisetex, vec2(0.5), 0.25).r, 0.0, 1.0);\n}\n",
+    );
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-atlas-levels",
+        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())
+}
+
+/// A 4x4 atlas whose first level is black and second white.
+fn atlas(gpu: &Fixture) -> wgpu::TextureView {
+    let texture = gpu.device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("Original two-level atlas"),
+        size: wgpu::Extent3d {
+            width: 4,
+            height: 4,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 2,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba8Unorm,
+        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+        view_formats: &[],
+    });
+    for (level, side, value) in [(0u32, 4u32, 0u8), (1, 2, 255)] {
+        gpu.queue.write_texture(
+            wgpu::TexelCopyTextureInfo {
+                texture: &texture,
+                mip_level: level,
+                origin: wgpu::Origin3d::ZERO,
+                aspect: wgpu::TextureAspect::All,
+            },
+            &[value, value, value, 255].repeat((side * side) as usize),
+            wgpu::TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(side * 4),
+                rows_per_image: None,
+            },
+            wgpu::Extent3d {
+                width: side,
+                height: side,
+                depth_or_array_layers: 1,
+            },
+        );
+    }
+    texture.create_view(&Default::default())
+}
+
+#[test]
+fn the_atlas_blends_its_two_nearest_levels() {
+    let Some(gpu) = Fixture::new() else { return };
+    // The pack reads no lightmap: any texture serves.
+    let lightmap = atlas(&gpu);
+    let mut post = PackPost::new(
+        &gpu.device,
+        &gpu.queue,
+        &gpu.adapter,
+        pack(),
+        wgpu::TextureFormat::Rgba8Unorm,
+        World {
+            atlas: Some((atlas(&gpu), [4, 4])),
+            material_maps: None,
+            lightmap,
+            terrain: None,
+            block_ids: &[],
+            sprite_rects: &[],
+            celestial: None,
+            gui_size: [16, 16],
+            clouds: None,
+            weather: false,
+            hand: false,
+        },
+    )
+    .expect("the pack runs");
+    for p in gpu.render(&mut post, [4, 4]) {
+        // Half of white, and a quarter (within the blend's 8-bit weight).
+        assert!(p[0].abs_diff(128) <= 2 && p[1].abs_diff(64) <= 2, "{p:?}");
+    }
+}

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

@@ -0,0 +1,74 @@
+//! In deferred, composite and final programs the atlas's sampler names (`gtexture`, `tex`,
+//! `texture`) and names the game gives no texture read texture unit 0, which OptiFine's
+//! shaders.txt gives to `colortex0` there. Our probe packs (#9307) read the scene in `colortex0`
+//! through each in Iris 1.11.7, also in programs that don't declare `colortex0`.
+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";
+
+/// deferred writes a colour into colortex0; composite reads it through `gtexture` into
+/// colortex1, composite1 through `tex` into colortex2, composite2 through a name of its own into
+/// colortex3; final shows them in that order, left to right, then what its own `texture` reads.
+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();
+    };
+    for program in ["deferred", "composite", "composite1", "composite2", "final"] {
+        add(&format!("{program}.vsh"), VERTEX);
+    }
+    add(
+        "deferred.fsh",
+        "#version 120\nvoid main() {\n/* DRAWBUFFERS:0 */\n    gl_FragData[0] = vec4(0.0, 200.0 / 255.0, 40.0 / 255.0, 1.0);\n}\n",
+    );
+    add(
+        "composite.fsh",
+        "#version 130\nuniform sampler2D gtexture;\nvarying vec2 uv;\nvoid main() {\n/* DRAWBUFFERS:1 */\n    gl_FragData[0] = texture(gtexture, uv);\n}\n",
+    );
+    add(
+        "composite1.fsh",
+        "#version 130\nuniform sampler2D tex;\nvarying vec2 uv;\nvoid main() {\n/* DRAWBUFFERS:2 */\n    gl_FragData[0] = texture(tex, uv);\n}\n",
+    );
+    add(
+        "composite2.fsh",
+        "#version 130\nuniform sampler2D probeOwnName;\nvarying vec2 uv;\nvoid main() {\n/* DRAWBUFFERS:3 */\n    gl_FragData[0] = texture(probeOwnName, uv);\n}\n",
+    );
+    add(
+        "final.fsh",
+        "#version 120\nuniform sampler2D texture;\nuniform sampler2D colortex1;\nuniform sampler2D colortex2;\n\
+         uniform sampler2D colortex3;\nvarying vec2 uv;\nvoid main() {\n\
+         \x20   gl_FragColor = uv.x < 0.25 ? texture2D(colortex1, uv) : uv.x < 0.5 ? texture2D(colortex2, uv)\n\
+         \x20       : uv.x < 0.75 ? texture2D(colortex3, uv) : texture2D(texture, uv);\n}\n",
+    );
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-atlas-names-in-post",
+        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 atlas_names_read_colortex0_in_deferred_composite_and_final() {
+    let Some(gpu) = Fixture::new() else { return };
+    let mut post = gpu.build(pack());
+    let pixels = gpu.render(&mut post, [8, 8]);
+    for (i, p) in pixels.iter().enumerate() {
+        let name = match i % 8 {
+            0..2 => "gtexture in composite",
+            2..4 => "tex in composite1",
+            4..6 => "a name of the pack's in composite2",
+            _ => "texture in final",
+        };
+        assert_eq!(*p, [0, 200, 40, 255], "{name}, pixel {i}");
+    }
+}

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

@@ -0,0 +1,76 @@
+//! A custom uniform of `shaders.properties` that the GLSL declares with another type: an original
+//! probe (#9307). In Iris 1.11.7 our probe packs read 0 for a float custom uniform declared `int`,
+//! an int declared `float`, a vec3 declared `vec2` and a vec2 declared `vec3`, and the uniform's
+//! own value where the types agree. A float of 2.5 declared `bool` read true (Iris logged it as
+//! disabled, but it read true in both games).
+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(
+        "shaders.properties",
+        "uniform.float.floatAsInt = 7.0\n\
+         uniform.int.intAsFloat = 7\n\
+         uniform.vec3.vec3AsVec2 = vec3(1.0, 2.0, 3.0)\n\
+         uniform.vec2.vec2AsVec3 = vec2(4.0, 5.0)\n\
+         uniform.float.floatAsFloat = 0.5\n\
+         uniform.int.intAsInt = 3\n\
+         uniform.float.floatAsBool = 2.5\n",
+    );
+    add("final.vsh", VERTEX);
+    // Pixel column x shows case x % 7 in red.
+    add(
+        "final.fsh",
+        "#version 330 compatibility\n\
+         uniform int floatAsInt;\nuniform float intAsFloat;\nuniform vec2 vec3AsVec2;\n\
+         uniform vec3 vec2AsVec3;\nuniform float floatAsFloat;\nuniform int intAsInt;\n\
+         uniform bool floatAsBool;\n\
+         void main() {\n    int x = int(gl_FragCoord.x) % 7;\n    float o = 0.0;\n\
+             if (x == 0) o = float(floatAsInt) / 10.0;\n\
+             else if (x == 1) o = intAsFloat / 10.0;\n\
+             else if (x == 2) o = (vec3AsVec2.x + vec3AsVec2.y) / 10.0;\n\
+             else if (x == 3) o = (vec2AsVec3.x + vec2AsVec3.y) / 10.0;\n\
+             else if (x == 4) o = floatAsFloat;\n\
+             else if (x == 5) o = float(intAsInt) / 10.0;\n\
+             else o = floatAsBool ? 1.0 : 0.0;\n\
+             gl_FragColor = vec4(o, 0.0, 0.0, 1.0);\n}\n",
+    );
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-custom-types",
+        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(), 1, "{:?}", post.notes);
+    post
+}
+
+#[test]
+fn a_custom_uniform_declared_with_another_type_reads_zero() {
+    let Some(gpu) = Fixture::new() else { return };
+    let Ok(mut post) = gpu.try_build(pack()) else {
+        panic!("the pack runs")
+    };
+    let pixels = gpu.render(&mut post, [7, 1]);
+    let red: Vec<u8> = pixels[..7].iter().map(|p| p[0]).collect();
+    // 0 for the four mismatches, 0.5 and 0.3 where the types agree, then true.
+    let want = [0.0, 0.0, 0.0, 0.0, 0.5, 0.3, 1.0].map(|v: f32| (v * 255.0).round() as u8);
+    assert!(
+        red.iter().zip(want).all(|(g, w)| g.abs_diff(w) <= 1),
+        "{red:?}, expected {want:?}"
+    );
+}

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

@@ -3,15 +3,15 @@ use super::*;
 use crate::{gfx::Frame, hud::HudBatch};
 use wgpu::{TextureFormat as T, util::DeviceExt};
 
-const SIZE: [u32; 2] = [16, 16];
+pub(super) const SIZE: [u32; 2] = [16, 16];
 
-struct Gpu {
+pub(super) struct Gpu {
     adapter: wgpu::Adapter,
-    device: wgpu::Device,
-    queue: wgpu::Queue,
+    pub(super) device: wgpu::Device,
+    pub(super) queue: wgpu::Queue,
 }
 impl Gpu {
-    fn new() -> Option<Self> {
+    pub(super) fn new() -> Option<Self> {
         let instance = crate::gfx::test_gpu::instance();
         let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
         let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
@@ -27,7 +27,7 @@ impl Gpu {
             queue,
         })
     }
-    fn texture(&self, format: T) -> wgpu::TextureView {
+    pub(super) fn texture(&self, format: T) -> wgpu::TextureView {
         self.device
             .create_texture(&wgpu::TextureDescriptor {
                 label: Some("Original depth fixture input"),
@@ -47,7 +47,7 @@ impl Gpu {
             })
             .create_view(&Default::default())
     }
-    fn load(
+    pub(super) fn load(
         &self,
         files: Vec<(String, String)>,
         world: World<'_>,
@@ -92,7 +92,12 @@ impl Gpu {
         );
         built
     }
-    fn clear(&self, color: &wgpu::TextureView, depth: &wgpu::TextureView, reverse_depth: f32) {
+    pub(super) fn clear(
+        &self,
+        color: &wgpu::TextureView,
+        depth: &wgpu::TextureView,
+        reverse_depth: f32,
+    ) {
         let mut encoder = self.device.create_command_encoder(&Default::default());
         encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("Independent original fixture clear"),
@@ -122,7 +127,7 @@ impl Gpu {
         });
         self.queue.submit([encoder.finish()]);
     }
-    fn render(
+    pub(super) fn render(
         &self,
         post: &mut PackPost,
         color: &wgpu::TextureView,
@@ -213,7 +218,7 @@ enum Scene {
     WaterOnly,
 }
 
-const VERTEX: &str =
+pub(super) const VERTEX: &str =
     "#version 120\nvarying vec2 uv;void main(){uv=gl_MultiTexCoord0.xy;gl_Position=ftransform();}";
 
 fn shaders(sampler: &str, stage: Stage, scene: Scene) -> Vec<(String, String)> {
@@ -316,7 +321,7 @@ fn check(sampler: &str, stage: Stage, scene: Scene, expected: [u8; 4]) {
     let hand = matches!(scene, Scene::Terrain { hand: true, .. });
     let water = matches!(scene, Scene::Terrain { water: true, .. } | Scene::WaterOnly);
     let inputs=horizon_shaders::GameInputs {
-        terrain:terrain.then(|| horizon_shaders::GbuffersInputs { declarations:"layout(location=0)in vec3 fixture_position;\n".into(),body:"hz_Vertex=vec4(fixture_position,1.0);hz_Color=vec4(1.0);hz_MultiTexCoord0=vec4(0.0);hz_MultiTexCoord1=vec4(240.0);hz_MultiTexCoord2=vec4(240.0);hz_Normal=vec3(0.0,0.0,1.0);\n".into(),attributes:vec![],after:String::new(),alpha_test:None,item_id_declared:false }),
+        terrain:terrain.then(|| horizon_shaders::GbuffersInputs { declarations:"layout(location=0)in vec3 fixture_position;\n".into(),body:"hz_Vertex=vec4(fixture_position,1.0);hz_Color=vec4(1.0);hz_MultiTexCoord0=vec4(0.0);hz_MultiTexCoord1=vec4(240.0);hz_MultiTexCoord2=vec4(240.0);hz_Normal=vec3(0.0,0.0,1.0);\n".into(),attributes:vec![],after:String::new(),alpha_test:None,item_id_declared:false,far_depth:false }),
         hand:hand.then(crate::gfx::pack_hand::inputs),..Default::default()
     };
     let mut post = gpu.load(
@@ -561,7 +566,7 @@ fn attached_compute_preserves_distinct_hand_snapshots() {
 }
 
 // Frame literal adapted from MIT Horizon f700231 pack_uniforms.rs test API setup.
-fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
+pub(super) fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
     Frame {
         eye: glam::DVec3::ZERO,
         eye_rotation: [0.0; 2],
@@ -648,15 +653,23 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
 /// moved toward the next texel, times four (0 nearest, 255 linear). `nearest` is a line for
 /// both stage files.
 fn shadow_depth_filtering(nearest: &str) -> Option<Vec<[u8; 4]>> {
+    shadow_depth_reads(
+        nearest,
+        "float moved(sampler2D s, ivec2 t) {\n\
+             float a = texelFetch(s, t, 0).r;\n\
+             return (texture(s, (vec2(t) + vec2(0.75, 0.5)) / 16.0).r - a) * 16.0;\n\
+         }\n\
+         void main() {\n\
+             ivec2 t = ivec2(int(gl_FragCoord.x) % 15, 8);\n\
+             gl_FragColor = vec4(moved(shadowtex0, t) * 4.0, moved(shadowtex1, t) * 4.0, 0.0, 1.0);\n\
+         }\n",
+    )
+}
+
+/// `shadow_depth_filtering`'s shadow map read by `reads`: `final`'s code after its declarations
+/// of shadowtex0 and shadowtex1.
+fn shadow_depth_reads(nearest: &str, reads: &str) -> Option<Vec<[u8; 4]>> {
     let gpu = Gpu::new()?;
-    if !gpu
-        .device
-        .features()
-        .contains(wgpu::Features::FLOAT32_FILTERABLE)
-    {
-        eprintln!("DEPTH_FIXTURE_NO_FLOAT32_FILTERABLE");
-        return None;
-    }
     let color = gpu.texture(T::Rgba8Unorm);
     let depth = gpu.texture(T::Depth32Float);
     gpu.clear(&color, &depth, 0.0);
@@ -677,6 +690,7 @@ fn shadow_depth_filtering(nearest: &str) -> Option<Vec<[u8; 4]>> {
             after: String::new(),
             alpha_test: None,
             item_id_declared: false,
+            far_depth: false,
         }),
         ..Default::default()
     };
@@ -687,15 +701,7 @@ fn shadow_depth_filtering(nearest: &str) -> Option<Vec<[u8; 4]>> {
             "final.fsh".into(),
             format!(
                 "#version 330 compatibility\n{settings}\
-                 uniform sampler2D shadowtex0;\nuniform sampler2D shadowtex1;\n\
-                 float moved(sampler2D s, ivec2 t) {{\n\
-                     float a = texelFetch(s, t, 0).r;\n\
-                     return (texture(s, (vec2(t) + vec2(0.75, 0.5)) / 16.0).r - a) * 16.0;\n\
-                 }}\n\
-                 void main() {{\n\
-                     ivec2 t = ivec2(int(gl_FragCoord.x) % 15, 8);\n\
-                     gl_FragColor = vec4(moved(shadowtex0, t) * 4.0, moved(shadowtex1, t) * 4.0, 0.0, 1.0);\n\
-                 }}\n"
+                 uniform sampler2D shadowtex0;\nuniform sampler2D shadowtex1;\n{reads}"
             ),
         ),
         // The shadow map's depth runs from 0 at its left edge to 1 at its right.
@@ -769,6 +775,24 @@ fn shadow_depth_is_read_linearly_through_a_plain_sampler() {
     }
 }
 
+#[test]
+fn shadow_depth_reads_filter_directly_and_with_a_texel_offset() {
+    // texture2D on the sampler itself, and textureOffset one texel to the right: both a quarter
+    // texel past a centre, so each moves a quarter of the way to the next texel.
+    let reads = "void main() {\n\
+             ivec2 t = ivec2(int(gl_FragCoord.x) % 14, 8);\n\
+             vec2 p = (vec2(t) + vec2(0.75, 0.5)) / 16.0;\n\
+             float a = texelFetch(shadowtex0, t, 0).r;\n\
+             float b = texelFetch(shadowtex1, t + ivec2(1, 0), 0).r;\n\
+             float r = (texture2D(shadowtex0, p).r - a) * 64.0;\n\
+             float g = (textureOffset(shadowtex1, p, ivec2(1, 0)).r - b) * 64.0;\n\
+             gl_FragColor = vec4(r, g, 0.0, 1.0);\n\
+         }\n";
+    if let Some(pixels) = shadow_depth_reads("", reads) {
+        all_pixels(&pixels, [255, 255, 0, 255], "shadowtex direct and offset");
+    }
+}
+
 #[test]
 fn shadowtex_nearest_settings_read_the_nearest_texel() {
     for (line, expected) in [
@@ -783,3 +807,68 @@ fn shadowtex_nearest_settings_read_the_nearest_texel() {
         }
     }
 }
+
+/// The sky program covers the horizon and downward viewing directions too.
+/// This original probe reports sky colour in RGB and window depth in alpha.
+#[test]
+#[ignore = "requires a host GPU"]
+fn sky_covers_the_horizon_without_writing_depth_or_overpainting_terrain() {
+    let gpu = Gpu::new().expect("GPU required for the sky coverage regression");
+    assert_ne!(gpu.adapter.get_info().device_type, wgpu::DeviceType::Cpu);
+    let color = gpu.texture(T::Rgba8Unorm);
+    let depth = gpu.texture(T::Depth32Float);
+    let files = vec![
+        ("gbuffers_skybasic.vsh".into(), "#version 120\nvoid main(){gl_Position=ftransform();}".into()),
+        ("gbuffers_skybasic.fsh".into(), "#version 120\n/* DRAWBUFFERS:0 */\nvoid main(){gl_FragData[0]=vec4(1.0,0.0,0.0,1.0);}".into()),
+        ("final.vsh".into(), VERTEX.into()),
+        ("final.fsh".into(), "#version 120\nuniform sampler2D colortex0;uniform sampler2D depthtex0;varying vec2 uv;\nconst vec4 colortex0ClearColor=vec4(0.0,1.0,0.0,1.0);\nvoid main(){gl_FragColor=vec4(texture2D(colortex0,uv).rgb,texture2D(depthtex0,uv).r);}".into()),
+    ];
+    let mut post = gpu.load(
+        files,
+        World {
+            atlas: None,
+            material_maps: None,
+            lightmap: color.clone(),
+            terrain: None,
+            block_ids: &[],
+            sprite_rects: &[],
+            celestial: None,
+            gui_size: SIZE,
+            clouds: None,
+            weather: false,
+            hand: false,
+        },
+        horizon_shaders::GameInputs {
+            sky: Some(crate::gfx::pack_sky::inputs()),
+            ..Default::default()
+        },
+    );
+    let hud = HudBatch::new(SIZE);
+    let mut frame = fixture_frame(&hud);
+    frame.title = false;
+    frame.skybox = true;
+    frame.distance = 512.0;
+    frame.detail_distance = 512.0;
+    frame.depth_far = 2048.0;
+    for yaw in [0.0, 45.0, 90.0, 180.0, 270.0] {
+        for pitch in [-60.0, 0.0, 21.1, 60.0] {
+            frame.yaw = yaw;
+            frame.pitch = pitch;
+            gpu.clear(&color, &depth, 0.0);
+            let pixels = gpu.render(&mut post, &color, &depth, &frame, &mut |_, _, _, _| {});
+            all_pixels(
+                &pixels,
+                [255, 0, 0, 255],
+                &format!("sky yaw={yaw} pitch={pitch}"),
+            );
+        }
+    }
+    // A pre-existing foreground depth must survive the sky, as must its colour.
+    gpu.clear(&color, &depth, 0.5);
+    let pixels = gpu.render(&mut post, &color, &depth, &frame, &mut |_, _, _, _| {});
+    all_pixels(
+        &pixels,
+        [16, 16, 16, 128],
+        "foreground colour and depth survive sky",
+    );
+}

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

@@ -0,0 +1,65 @@
+//! A buffer's mip chain is a box filter of the level above, odd sides included, so a small
+//! bright spot keeps its share of every level down to the last, the buffer's mean: OpenGL 4.6
+//! (8.14.4) recommends a box filter for generated mipmaps, and Iris 1.11.7's colortex mipmaps
+//! kept a 26x22-pixel spot of a 1280x720 buffer in its last level (probe packs of ours).
+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";
+
+/// composite writes 1.0 into one texel of colortex1, its top right corner, and 0 elsewhere;
+/// final shows level 2 (the 1x1 level of a 5x3 buffer) in red and texel (1, 0) of level 1 (2x1)
+/// in green, both scaled so that the box filter's values read 0.5.
+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 330 compatibility\n/*\nconst int colortex1Format = RGBA16F;\n*/\n\
+         /* RENDERTARGETS: 1 */\nlayout(location = 0) out vec4 o;\n\
+         void main() {\n    ivec2 p = ivec2(gl_FragCoord.xy);\n\
+             o = vec4(p == ivec2(4, 2) ? 1.0 : 0.0, 0.0, 0.0, 1.0);\n}\n",
+    );
+    add("final.vsh", VERTEX);
+    add(
+        "final.fsh",
+        "#version 330 compatibility\n/*\nconst bool colortex1MipmapEnabled = true;\n*/\n\
+         uniform sampler2D colortex1;\n\
+         void main() {\n    float mean = textureLod(colortex1, vec2(0.5), 2.0).r;\n\
+             float right = texelFetch(colortex1, ivec2(1, 0), 1).r;\n\
+             gl_FragColor = vec4(mean * 7.5, right * 3.75, 0.0, 1.0);\n}\n",
+    );
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-mipmap-box",
+        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 a_bright_texel_keeps_its_share_of_odd_sized_levels() {
+    let Some(gpu) = Fixture::new() else { return };
+    let mut post = gpu.build(pack());
+    let pixels = gpu.render(&mut post, [5, 3]);
+    // The 1x1 level is the mean of the 15 texels, 1/15; texel (1, 0) of the 2x1 level covers
+    // columns 2, 3 and 4 (weights 1, 2, 2 of 5) of all three rows (1 of 3 each): 2/15.
+    let [r, g, ..] = pixels[0];
+    assert!(
+        r.abs_diff(128) <= 2 && g.abs_diff(128) <= 2,
+        "mean and level-1 texel scaled to 0.5: got red {r}, green {g}, expected 128 and 128"
+    );
+}

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

@@ -45,6 +45,7 @@ fn pack() -> Post {
     let inputs = horizon_shaders::GameInputs {
         terrain: Some(horizon_shaders::GbuffersInputs {
             item_id_declared: false,
+            far_depth: false,
             declarations: "layout(location=0)in vec3 fixture_position;\n".into(),
             body: "hz_Vertex=vec4(fixture_position,1.0);hz_Color=vec4(1.0);\
                    hz_MultiTexCoord0=vec4(0.0);hz_MultiTexCoord1=vec4(240.0);\

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

@@ -0,0 +1,93 @@
+//! A buffer gets its B texture only when a composite-style program draws into it or flips it:
+//! the others' B is a second view of A, and they read the same as before. 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";
+
+/// `composite` writes colortex1 from colortex2, which no program writes; colortex4 is only
+/// flipped by a directive. `shadowcomp` writes shadowcolor1; shadowcolor0 is only read.
+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: 1 */\nvoid main() { gl_FragData[0]=vec4(0,0.5,0,1); }\n",
+    );
+    add("composite.vsh", VERTEX);
+    add(
+        "composite.fsh",
+        "#version 120\nuniform sampler2D colortex2;\nvarying vec2 uv;\n/* RENDERTARGETS: 1 */\n\
+         void main() { gl_FragData[0]=vec4(texture2D(colortex2,uv).rgb*0.5,1); }\n",
+    );
+    add("final.vsh", VERTEX);
+    // Pixel column x shows colortex1, colortex4, shadowcolor0 and shadowcolor1 in turn.
+    add(
+        "final.fsh",
+        "#version 330 compatibility\nconst int shadowMapResolution=16;\n\
+         const vec4 colortex2ClearColor=vec4(1,1,1,1);\n\
+         const vec4 colortex4ClearColor=vec4(0,0,0.75,1);\n\
+         const vec4 shadowcolor0ClearColor=vec4(0.25,0,0,1);\n\
+         uniform sampler2D colortex1;\nuniform sampler2D colortex4;\n\
+         uniform sampler2D shadowcolor0;\nuniform sampler2D shadowcolor1;\nin vec2 uv;\n\
+         void main() {\n    vec4 c[4] = vec4[4](texture(colortex1,uv), texture(colortex4,uv),\n\
+         texture(shadowcolor0,uv), texture(shadowcolor1,uv));\n\
+             gl_FragColor = c[int(gl_FragCoord.x) % 4];\n}\n",
+    );
+    add(
+        "shaders.properties",
+        "shadow.enabled=true\nflip.composite.colortex4=true\n",
+    );
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-single-side",
+        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 only_buffers_drawn_into_or_flipped_get_a_second_texture() {
+    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]);
+        let expected = [
+            [128, 128, 128, 255],
+            [0, 0, 191, 255],
+            [64, 0, 0, 255],
+            [0, 128, 0, 255],
+        ];
+        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:?}"
+            );
+        }
+    }
+    let shared = |sides: &[wgpu::TextureView; 2]| sides[0].texture() == sides[1].texture();
+    let targets = post.targets.as_ref().expect("rendered");
+    for (b, single) in [(1, false), (2, true), (4, false)] {
+        let sides = targets.color[b].as_ref().expect("used buffer");
+        assert_eq!(shared(sides), single, "colortex{b}");
+    }
+    let shadow = post.shadow_targets.as_ref().expect("shadow pass");
+    for (n, single) in [(0, true), (1, false)] {
+        let sides = shadow.color[n].as_ref().expect("used buffer");
+        assert_eq!(shared(sides), single, "shadowcolor{n}");
+    }
+}

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

@@ -0,0 +1,166 @@
+//! The sky's programs read their fragments' own depth in `gl_FragCoord.z`, as our probe packs
+//! read it in Iris 1.11.7: the sky disc at its distance; and
+//! the sky still shows only where the world left the far plane. Original fixture, no pack files.
+use super::depth_test::{Gpu, SIZE, VERTEX, fixture_frame};
+use super::*;
+use crate::hud::HudBatch;
+use wgpu::TextureFormat as T;
+
+/// `program` writes its fragment's `gl_FragCoord.z` into colortex1 (32-bit floats) and red into
+/// colortex0; final shows colortex1's value as a 24-bit integer on the top half, and the top
+/// half of colortex0 on the bottom half.
+fn files(program: &str) -> Vec<(String, String)> {
+    vec![
+        (
+            "shaders.properties".into(),
+            format!("blend.{program}=off\n"),
+        ),
+        (
+            format!("{program}.vsh"),
+            "#version 120\nvoid main() { gl_Position = ftransform(); }\n".into(),
+        ),
+        (
+            format!("{program}.fsh"),
+            "#version 120\n/* DRAWBUFFERS:01 */\nvoid main() {\n\
+             \x20   gl_FragData[0] = vec4(1.0, 0.0, 0.0, 1.0);\n\
+             \x20   gl_FragData[1] = vec4(gl_FragCoord.z);\n}\n"
+                .into(),
+        ),
+        ("final.vsh".into(), VERTEX.into()),
+        (
+            "final.fsh".into(),
+            "#version 130\n/*\nconst int colortex1Format = RGBA32F;\n*/\n\
+             uniform sampler2D colortex0;\nuniform sampler2D colortex1;\nvarying vec2 uv;\n\
+             void main() {\n\
+             \x20   uint n = min(uint(texture(colortex1, uv).r * 16777215.0 + 0.5), 16777215u);\n\
+             \x20   vec4 depth = vec4(uvec4(n >> 16u, (n >> 8u) & 255u, n & 255u, 255u)) / 255.0;\n\
+             \x20   gl_FragColor = uv.y > 0.5 ? depth : texture(colortex0, uv + vec2(0.0, 0.5));\n}\n"
+                .into(),
+        ),
+    ]
+}
+
+/// GL window depth of a point `distance` in front of the camera along its view axis, for the
+/// fixture's perspective: near 0.05, far `depth_far`.
+fn window_depth(distance: f64, far: f64) -> f64 {
+    let near = 0.05;
+    let ndc = (far + near) / (far - near) - 2.0 * far * near / ((far - near) * distance);
+    ndc * 0.5 + 0.5
+}
+
+/// The pack's picture of a frame of the fixture, whose world drew nothing but left
+/// `world_depth` (GL window depth) everywhere.
+fn picture(
+    gpu: &Gpu,
+    program: &str,
+    world_depth: f32,
+    celestial: &[crate::mesher::Vertex],
+) -> Vec<[u8; 4]> {
+    let color = gpu.texture(T::Rgba8Unorm);
+    let depth = gpu.texture(T::Depth32Float);
+    // The world's depth is reverse-Z.
+    gpu.clear(&color, &depth, 1.0 - world_depth);
+    let sun = gpu.texture(T::Rgba8Unorm);
+    let mut post = gpu.load(
+        files(program),
+        World {
+            atlas: None,
+            material_maps: None,
+            lightmap: color.clone(),
+            terrain: None,
+            block_ids: &[],
+            sprite_rects: &[],
+            celestial: Some(sun),
+            gui_size: SIZE,
+            clouds: None,
+            weather: false,
+            hand: false,
+        },
+        horizon_shaders::GameInputs {
+            sky: Some(super::super::pack_sky::inputs()),
+            celestial: Some(super::super::pack_sky::celestial_inputs()),
+            ..Default::default()
+        },
+    );
+    assert!(post.sky.is_some(), "{:?}", post.notes);
+    let hud = HudBatch::new(SIZE);
+    let mut frame = fixture_frame(&hud);
+    frame.title = false;
+    frame.skybox = true;
+    frame.celestial = celestial;
+    gpu.render(&mut post, &color, &depth, &frame, &mut |_, _, _, _| {})
+}
+
+fn decode(p: [u8; 4]) -> f64 {
+    f64::from(u32::from(p[0]) << 16 | u32::from(p[1]) << 8 | u32::from(p[2])) / 16_777_215.0
+}
+
+/// The sky disc lies 16 blocks above the eye: the fixture looks level with a 90° field of view,
+/// so a pixel `row` rows below the top of the 16-pixel picture sees it along the view axis at
+/// 16 / tan(elevation) = 16 / (1 - (row + 0.5) / 8) blocks.
+#[test]
+fn the_sky_disc_reads_its_own_depth() {
+    let Some(gpu) = Gpu::new() else { return };
+    let pixels = picture(&gpu, "gbuffers_skybasic", 1.0, &[]);
+    for row in 0..4 {
+        let along = 16.0 / (1.0 - (row as f64 + 0.5) / 8.0);
+        let expected = window_depth(along, 1000.0);
+        for x in 0..SIZE[0] as usize {
+            let got = decode(pixels[row * SIZE[0] as usize + x]);
+            assert!(
+                (got - expected).abs() < 2e-5,
+                "row {row}, column {x}: gl_FragCoord.z {got}, expected {expected}"
+            );
+        }
+    }
+}
+
+/// The sun's quad (and the moon's behind the camera), 100 blocks away across the view axis:
+/// one depth everywhere.
+#[test]
+fn the_sun_reads_its_own_depth() {
+    let Some(gpu) = Gpu::new() else { return };
+    let quad = |z: f32| {
+        [
+            [-400.0, -400.0],
+            [400.0, -400.0],
+            [400.0, 400.0],
+            [-400.0, 400.0],
+        ]
+        .map(|[x, y]| crate::mesher::Vertex {
+            pos: [x, y, z],
+            uv: [0.0; 2],
+            layer: 0,
+            color: u32::MAX,
+            light: 0,
+            normal: [0; 4],
+            glint_uv: [0.0; 2],
+        })
+    };
+    let quads: Vec<_> = quad(100.0).into_iter().chain(quad(-100.0)).collect();
+    let pixels = picture(&gpu, "gbuffers_skytextured", 1.0, &quads);
+    let expected = window_depth(100.0, 1000.0);
+    for (i, &p) in pixels[..pixels.len() / 2].iter().enumerate() {
+        let got = decode(p);
+        assert!(
+            (got - expected).abs() < 2e-5,
+            "pixel {i}: gl_FragCoord.z {got}, expected {expected}"
+        );
+    }
+}
+
+/// Where the world left a depth nearer than the far plane, even one farther away than the sky
+/// disc, the world shows (the fixture's grey), not the sky's red.
+#[test]
+fn the_sky_shows_only_where_the_world_left_the_far_plane() {
+    let Some(gpu) = Gpu::new() else { return };
+    let half = SIZE[0] as usize * SIZE[1] as usize / 2;
+    let far = picture(&gpu, "gbuffers_skybasic", 1.0, &[]);
+    let near = picture(&gpu, "gbuffers_skybasic", 0.9999, &[]);
+    // The sky disc covers the upper half of the view (row 7 sees it 256 blocks away, at a
+    // window depth of 0.9998).
+    for (i, (f, n)) in far[half..].iter().zip(&near[half..]).enumerate() {
+        assert_eq!(*f, [255, 0, 0, 255], "far plane, pixel {i}");
+        assert_eq!(*n, [16, 16, 16, 255], "depth 0.9999, pixel {i}");
+    }
+}

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

@@ -0,0 +1,348 @@
+//! Solid and cutout terrain through `gbuffers_terrain_solid` and `gbuffers_terrain_cutout`
+//! (#9137). The expected programs are what Iris 1.11.7 drew with our probe packs (the PR has
+//! the numbers): with either program the pack draws solid terrain (quads over opaque texels, and
+//! lava) through `gbuffers_terrain_solid` and cutout terrain through `gbuffers_terrain_cutout`,
+//! the missing one falling back to `gbuffers_terrain`; solid terrain keeps a fragment written
+//! with alpha 0.05, cutout terrain loses it. Each quad draws whole with one of them, whatever
+//! its vertices' alphas (with `separateAo`, their own ambient occlusion). The programs here are
+//! the probes', cut down.
+use super::depth_test::{Gpu, SIZE, VERTEX, fixture_frame};
+use super::*;
+use crate::hud::HudBatch;
+use wgpu::{TextureFormat as T, util::DeviceExt};
+
+const RED: [u8; 3] = [255, 0, 0];
+const GREEN: [u8; 3] = [0, 255, 0];
+const BLUE: [u8; 3] = [0, 0, 255];
+
+/// A program writing `rgb` with `alpha` into colortex0.
+fn program(name: &str, rgb: [u8; 3], alpha: f32) -> [(String, String); 2] {
+    let [r, g, b] = rgb.map(|c| f32::from(c) / 255.0);
+    [
+        (
+            format!("{name}.vsh"),
+            "#version 120\nvoid main(){gl_Position=vec4(gl_Vertex.xy,0.0,1.0);}".into(),
+        ),
+        (
+            format!("{name}.fsh"),
+            format!(
+                "#version 120\n/* DRAWBUFFERS:0 */\nvoid main(){{gl_FragData[0]=vec4({r:?},{g:?},{b:?},{alpha:?});}}"
+            ),
+        ),
+    ]
+}
+
+/// Lava's sprite layer in the fixture.
+const LAVA: u16 = 5;
+
+/// The pack (`final` shows colortex0, cleared to black) drawn over three strips of terrain, left
+/// to right: a quad over opaque texels, a cutout quad, a lava quad, all with opaque vertex
+/// colours. Each strip's colour, `None` where nothing drew; `None` overall without a GPU.
+fn strips(programs: &[(&str, [u8; 3], f32)]) -> Option<[Option<[u8; 3]>; 3]> {
+    strips_with_alphas(programs, [255; 4])
+}
+
+/// `strips` with the quads' corners' vertex alphas (bottom left, bottom right, top right, top
+/// left). Fails unless each strip is one colour.
+fn strips_with_alphas(
+    programs: &[(&str, [u8; 3], f32)],
+    alphas: [u8; 4],
+) -> Option<[Option<[u8; 3]>; 3]> {
+    let files = programs
+        .iter()
+        .flat_map(|&(name, rgb, alpha)| program(name, rgb, alpha))
+        .collect();
+    let (strips, _) = strips_of(files, alphas)?;
+    Some(strips)
+}
+
+/// `strips_with_alphas` with the pack's terrain programs' `files`, and the built pack's notes
+/// when it draws no terrain itself (`None` when it does).
+#[allow(clippy::type_complexity)]
+fn strips_of(
+    programs: Vec<(String, String)>,
+    alphas: [u8; 4],
+) -> Option<([Option<[u8; 3]>; 3], Option<Vec<String>>)> {
+    let Some(gpu) = Gpu::new() else {
+        eprintln!("TERRAIN_PARTS_NO_ADAPTER");
+        return None;
+    };
+    let mut files = vec![
+        ("final.vsh".to_owned(), VERTEX.to_owned()),
+        (
+            "final.fsh".to_owned(),
+            "#version 120\nuniform sampler2D colortex0;varying vec2 uv;\
+             const vec4 colortex0ClearColor = vec4(0.0, 0.0, 0.0, 1.0);\
+             void main(){gl_FragColor=vec4(texture2D(colortex0,uv).rgb,1.0);}"
+                .to_owned(),
+        ),
+    ];
+    files.extend(programs);
+    // The game's terrain inputs as far as the parts read them: the sprite layer and the colour.
+    let terrain = horizon_shaders::GbuffersInputs {
+        declarations: "layout(location=0)in vec3 fixture_position;\n\
+                       layout(location=2)in uint hz_v_layer;\n\
+                       layout(location=3)in vec4 hz_v_color;\n"
+            .into(),
+        body: "hz_Vertex=vec4(fixture_position,1.0);hz_Color=vec4(1.0);hz_MultiTexCoord0=vec4(0.0);\
+               hz_MultiTexCoord1=vec4(240.0);hz_MultiTexCoord2=vec4(240.0);hz_Normal=vec3(0.0,0.0,1.0);\n"
+            .into(),
+        ..Default::default()
+    };
+    let inputs = horizon_shaders::GameInputs {
+        terrain_parts: Some(super::super::pack_atlas::terrain_parts(
+            &terrain,
+            &[LAVA, LAVA + 1],
+        )),
+        terrain: Some(terrain),
+        ..Default::default()
+    };
+    const ATTRS: [wgpu::VertexAttribute; 3] =
+        wgpu::vertex_attr_array![0=>Float32x3,2=>Uint32,3=>Unorm8x4];
+    let layouts = [Some(wgpu::VertexBufferLayout {
+        array_stride: 20,
+        step_mode: wgpu::VertexStepMode::Vertex,
+        attributes: &ATTRS,
+    })];
+    let color = gpu.texture(T::Rgba8Unorm);
+    let depth = gpu.texture(T::Depth32Float);
+    let mut post = gpu.load(
+        files,
+        World {
+            atlas: None,
+            material_maps: None,
+            lightmap: color.clone(),
+            terrain: Some(Geometry {
+                buffers: &layouts,
+                table: None,
+                depth_write: true,
+                atlas: None,
+                material_maps: false,
+                ids: None,
+                cull: false,
+            }),
+            block_ids: &[],
+            sprite_rects: &[],
+            celestial: None,
+            gui_size: SIZE,
+            clouds: None,
+            weather: false,
+            hand: false,
+        },
+        inputs,
+    );
+    let opaque = u32::from(crate::mesher::OPAQUE_LAYER);
+    let mut vertices: Vec<u32> = Vec::new();
+    for (i, layer) in [opaque | 1, 2, u32::from(LAVA)].into_iter().enumerate() {
+        let (x0, x1) = (
+            -1.0 + i as f32 * 2.0 / 3.0,
+            -1.0 + (i + 1) as f32 * 2.0 / 3.0,
+        );
+        let corners = [[x0, -1.0], [x1, -1.0], [x1, 1.0], [x0, 1.0]];
+        for corner in [0, 1, 2, 0, 2, 3] {
+            let [x, y] = corners[corner];
+            let color = u32::from(alphas[corner]) << 24 | 0x00FF_FFFF;
+            vertices.extend([x.to_bits(), f32::to_bits(y), 0f32.to_bits(), layer, color]);
+        }
+    }
+    let buffer = gpu
+        .device
+        .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("Terrain parts fixture"),
+            contents: bytemuck::cast_slice(&vertices),
+            usage: wgpu::BufferUsages::VERTEX,
+        });
+    let undrawn = (!post.has_terrain()).then(|| post.notes.clone());
+    let hud = HudBatch::new(SIZE);
+    let frame = fixture_frame(&hud);
+    let pixels = gpu.render(&mut post, &color, &depth, &frame, &mut |rp, list, _, _| {
+        if list == TerrainList::Solid {
+            rp.set_vertex_buffer(0, buffer.slice(..));
+            rp.draw(0..18, 0..1);
+        }
+    });
+    // Every pixel of each strip (columns 0-4, 6-9 and 11-15; 5 and 10 straddle two strips).
+    let colour = |x: usize, y: usize| {
+        let [r, g, b, _] = pixels[y * SIZE[0] as usize + x];
+        Some([r, g, b]).filter(|&c| c != [0, 0, 0])
+    };
+    let strips = [0..5, 6..10, 11..16].map(|columns| {
+        let first = colour(columns.start, 0);
+        for x in columns.clone() {
+            for y in 0..SIZE[1] as usize {
+                assert_eq!(colour(x, y), first, "strip {columns:?} at ({x}, {y})");
+            }
+        }
+        first
+    });
+    Some((strips, undrawn))
+}
+
+#[test]
+fn solid_and_cutout_programs_draw_their_own_terrain() {
+    let programs = [
+        ("gbuffers_terrain", RED, 1.0),
+        ("gbuffers_terrain_solid", GREEN, 1.0),
+        ("gbuffers_terrain_cutout", BLUE, 1.0),
+    ];
+    let Some(got) = strips(&programs) else { return };
+    assert_eq!(got, [Some(GREEN), Some(BLUE), Some(GREEN)]);
+}
+
+#[test]
+fn without_a_cutout_program_cutout_terrain_falls_back_to_gbuffers_terrain() {
+    let programs = [
+        ("gbuffers_terrain", RED, 1.0),
+        ("gbuffers_terrain_solid", GREEN, 1.0),
+    ];
+    let Some(got) = strips(&programs) else { return };
+    assert_eq!(got, [Some(GREEN), Some(RED), Some(GREEN)]);
+}
+
+#[test]
+fn without_a_solid_program_solid_terrain_falls_back_to_gbuffers_terrain() {
+    let programs = [
+        ("gbuffers_terrain", RED, 1.0),
+        ("gbuffers_terrain_cutout", BLUE, 1.0),
+    ];
+    let Some(got) = strips(&programs) else { return };
+    assert_eq!(got, [Some(RED), Some(BLUE), Some(RED)]);
+}
+
+#[test]
+fn solid_terrain_keeps_alpha_0_05_and_cutout_loses_it() {
+    let programs = [
+        ("gbuffers_terrain", RED, 1.0),
+        ("gbuffers_terrain_solid", GREEN, 0.05),
+        ("gbuffers_terrain_cutout", BLUE, 0.05),
+    ];
+    let Some(got) = strips(&programs) else { return };
+    assert_eq!(got, [Some(GREEN), None, Some(GREEN)]);
+    // The solid part through its fallback, as the probe's `gbuffers_terrain` writing 0.05.
+    let programs = [
+        ("gbuffers_terrain", RED, 0.05),
+        ("gbuffers_terrain_cutout", BLUE, 1.0),
+    ];
+    let Some(got) = strips(&programs) else { return };
+    assert_eq!(got, [Some(RED), Some(BLUE), Some(RED)]);
+}
+
+/// With `separateAo` a vertex's alpha is its own ambient occlusion, so the corners of one quad
+/// differ; the quad still draws whole, with its part's program.
+#[test]
+fn a_quad_draws_whole_whatever_its_vertex_alphas() {
+    let programs = [
+        ("gbuffers_terrain", RED, 1.0),
+        ("gbuffers_terrain_solid", GREEN, 1.0),
+        ("gbuffers_terrain_cutout", BLUE, 1.0),
+    ];
+    for alphas in [[255, 160, 255, 160], [128, 255, 200, 64], [160; 4]] {
+        let Some(got) = strips_with_alphas(&programs, alphas) else {
+            return;
+        };
+        assert_eq!(got, [Some(GREEN), Some(BLUE), Some(GREEN)], "{alphas:?}");
+    }
+}
+
+#[test]
+fn a_pack_with_neither_draws_all_terrain_with_gbuffers_terrain() {
+    let Some(got) = strips(&[("gbuffers_terrain", RED, 1.0)]) else {
+        return;
+    };
+    assert_eq!(got, [Some(RED); 3]);
+}
+
+/// A pack whose only terrain program is `gbuffers_terrain_solid` (or `_cutout`) draws that part,
+/// and nothing draws the other: Iris 1.11.7 left it undrawn with our probes `tsc-solidonly` and
+/// `tsc-cutoutonly`.
+#[test]
+fn a_lone_split_program_draws_only_its_own_terrain() {
+    let solid = strips(&[("gbuffers_terrain_solid", GREEN, 1.0)]);
+    let Some(solid) = solid else { return };
+    assert_eq!(solid, [Some(GREEN), None, Some(GREEN)]);
+    let cutout = strips(&[("gbuffers_terrain_cutout", BLUE, 1.0)]);
+    assert_eq!(cutout, Some([None, Some(BLUE), None]));
+}
+
+/// When one part's pipeline can't be built (here a cutout program writing no buffer, which
+/// Horizon skips), the other part doesn't draw alone either: the game draws all terrain.
+#[test]
+fn a_part_that_fails_to_build_takes_the_other_with_it() {
+    let mut files: Vec<(String, String)> = [
+        program("gbuffers_terrain", RED, 1.0),
+        program("gbuffers_terrain_solid", GREEN, 1.0),
+    ]
+    .concat();
+    files.push((
+        "gbuffers_terrain_cutout.vsh".into(),
+        "#version 120\nvoid main(){gl_Position=vec4(gl_Vertex.xy,0.0,1.0);}".into(),
+    ));
+    files.push((
+        "gbuffers_terrain_cutout.fsh".into(),
+        "#version 120\nvoid main(){}".into(),
+    ));
+    let Some((got, undrawn)) = strips_of(files, [255; 4]) else {
+        return;
+    };
+    assert_eq!(got, [None; 3]);
+    let notes = undrawn.expect("the game draws terrain");
+    for note in [
+        "gbuffers_terrain_cutout: writes no buffer; skipped",
+        "gbuffers_terrain_solid: the other part of terrain can't draw",
+    ] {
+        assert!(notes.iter().any(|n| n.starts_with(note)), "{notes:?}");
+    }
+}
+
+/// Iris 1.11.7 with our probe packs pe4u (only `gbuffers_terrain`) and pe4s (only
+/// `gbuffers_terrain_solid` and `gbuffers_terrain_cutout`), each writing one alpha per screen
+/// strip (#9307): solid terrain kept every fragment, alpha 0.0 included, and cutout terrain
+/// kept those above 0.5 (0.51 kept; 0.5, 0.49 and lower discarded), whichever program drew it.
+#[test]
+fn cutout_terrain_keeps_alphas_above_0_5_and_solid_terrain_keeps_all() {
+    for (alpha, cutout) in [(0.0, false), (0.49, false), (0.5, false), (0.51, true)] {
+        let Some(got) = strips(&[("gbuffers_terrain", RED, alpha)]) else {
+            return;
+        };
+        let want = [Some(RED), cutout.then_some(RED), Some(RED)];
+        assert_eq!(got, want, "gbuffers_terrain writing alpha {alpha}");
+        let programs = [
+            ("gbuffers_terrain_solid", GREEN, alpha),
+            ("gbuffers_terrain_cutout", BLUE, alpha),
+        ];
+        let Some(got) = strips(&programs) else { return };
+        let want = [Some(GREEN), cutout.then_some(BLUE), Some(GREEN)];
+        assert_eq!(got, want, "split programs writing alpha {alpha}");
+    }
+}
+
+/// `alphaTestRef` in the same probes: 0 for solid terrain and 0.5 for cutout terrain, through
+/// `gbuffers_terrain` alone or through the split programs.
+#[test]
+fn alpha_test_ref_is_0_for_solid_terrain_and_0_5_for_cutout() {
+    let program = |name: &str| {
+        [
+            (
+                format!("{name}.vsh"),
+                "#version 120\nvoid main(){gl_Position=vec4(gl_Vertex.xy,0.0,1.0);}".to_owned(),
+            ),
+            (
+                format!("{name}.fsh"),
+                "#version 120\nuniform float alphaTestRef;\n/* DRAWBUFFERS:0 */\n\
+                 void main(){gl_FragData[0]=vec4(1.0,alphaTestRef*2.0,0.0,1.0);}"
+                    .to_owned(),
+            ),
+        ]
+    };
+    const YELLOW: [u8; 3] = [255, 255, 0];
+    for names in [
+        &["gbuffers_terrain"][..],
+        &["gbuffers_terrain_solid", "gbuffers_terrain_cutout"],
+    ] {
+        let files = names.iter().flat_map(|n| program(n)).collect();
+        let Some((got, _)) = strips_of(files, [255; 4]) else {
+            return;
+        };
+        assert_eq!(got, [Some(RED), Some(YELLOW), Some(RED)], "{names:?}");
+    }
+}

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

@@ -0,0 +1,130 @@
+//! In gbuffers programs a sampler the game gives no texture reads texture unit 0, the atlas
+//! (OptiFine's shaders.txt: `gtexture` is unit 0 there), and so do `colortex0` to `colortex3`,
+//! which aren't gbuffers samplers in that table. Our probe packs (#9307) read the block atlas
+//! through a sampler name of their own, and through each of `colortex0` to `colortex3` and
+//! `gnormal`, in gbuffers_terrain in Iris 1.11.7.
+use super::depth_test::{Gpu, SIZE, VERTEX, fixture_frame};
+use super::*;
+use crate::hud::HudBatch;
+use wgpu::{TextureFormat as T, util::DeviceExt};
+
+const ATLAS: [u8; 4] = [10, 200, 30, 255];
+
+#[test]
+fn unknown_samplers_and_colortex0_to_3_in_gbuffers_terrain_read_the_atlas() {
+    let Some(gpu) = Gpu::new() else { return };
+    let files = vec![
+        ("final.vsh".to_owned(), VERTEX.to_owned()),
+        (
+            "final.fsh".to_owned(),
+            "#version 120\nuniform sampler2D colortex0;varying vec2 uv;\
+             void main(){gl_FragColor=vec4(texture2D(colortex0,uv).rgb,1.0);}"
+                .to_owned(),
+        ),
+        (
+            "gbuffers_terrain.vsh".to_owned(),
+            "#version 120\nvoid main(){gl_Position=vec4(gl_Vertex.xy,0.0,1.0);}".to_owned(),
+        ),
+        (
+            "gbuffers_terrain.fsh".to_owned(),
+            "#version 120\nuniform sampler2D probeOwnName;\nuniform sampler2D colortex0;\n\
+             uniform sampler2D gdepth;\n/* DRAWBUFFERS:0 */\nvoid main(){\n\
+             \x20   float x = gl_FragCoord.x;\n\
+             \x20   gl_FragData[0] = x < 6.0 ? texture2D(probeOwnName, vec2(0.5))\n\
+             \x20       : x < 11.0 ? texture2D(colortex0, vec2(0.5)) : texture2D(gdepth, vec2(0.5));\n}"
+                .to_owned(),
+        ),
+    ];
+    let terrain = horizon_shaders::GbuffersInputs {
+        declarations: "layout(location=0)in vec3 fixture_position;\n".into(),
+        body: "hz_Vertex=vec4(fixture_position,1.0);hz_Color=vec4(1.0);hz_MultiTexCoord0=vec4(0.0);\
+               hz_MultiTexCoord1=vec4(240.0);hz_MultiTexCoord2=vec4(240.0);hz_Normal=vec3(0.0,0.0,1.0);\n"
+            .into(),
+        ..Default::default()
+    };
+    let inputs = horizon_shaders::GameInputs {
+        terrain: Some(terrain),
+        ..Default::default()
+    };
+    const ATTRS: [wgpu::VertexAttribute; 1] = wgpu::vertex_attr_array![0=>Float32x3];
+    let layouts = [Some(wgpu::VertexBufferLayout {
+        array_stride: 12,
+        step_mode: wgpu::VertexStepMode::Vertex,
+        attributes: &ATTRS,
+    })];
+    let atlas = gpu
+        .device
+        .create_texture_with_data(
+            &gpu.queue,
+            &wgpu::TextureDescriptor {
+                label: Some("Original one-colour atlas"),
+                size: wgpu::Extent3d {
+                    width: 2,
+                    height: 2,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: T::Rgba8Unorm,
+                usage: wgpu::TextureUsages::TEXTURE_BINDING,
+                view_formats: &[],
+            },
+            wgpu::util::TextureDataOrder::LayerMajor,
+            &ATLAS.repeat(4),
+        )
+        .create_view(&Default::default());
+    let color = gpu.texture(T::Rgba8Unorm);
+    let depth = gpu.texture(T::Depth32Float);
+    let mut post = gpu.load(
+        files,
+        World {
+            atlas: Some((atlas, [2, 2])),
+            material_maps: None,
+            lightmap: color.clone(),
+            terrain: Some(Geometry {
+                buffers: &layouts,
+                table: None,
+                depth_write: true,
+                atlas: None,
+                material_maps: false,
+                ids: None,
+                cull: false,
+            }),
+            block_ids: &[],
+            sprite_rects: &[],
+            celestial: None,
+            gui_size: SIZE,
+            clouds: None,
+            weather: false,
+            hand: false,
+        },
+        inputs,
+    );
+    assert!(post.has_terrain(), "{:?}", post.notes);
+    let corners = [[-1.0f32, -1.0], [1.0, -1.0], [1.0, 1.0], [-1.0, 1.0]];
+    let vertices: Vec<f32> = [0, 1, 2, 0, 2, 3]
+        .into_iter()
+        .flat_map(|c| [corners[c][0], corners[c][1], 0.0])
+        .collect();
+    let buffer = gpu
+        .device
+        .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("Original full-screen quad"),
+            contents: bytemuck::cast_slice(&vertices),
+            usage: wgpu::BufferUsages::VERTEX,
+        });
+    let hud = HudBatch::new(SIZE);
+    let frame = fixture_frame(&hud);
+    let pixels = gpu.render(&mut post, &color, &depth, &frame, &mut |rp, list, _, _| {
+        if list == TerrainList::Solid {
+            rp.set_vertex_buffer(0, buffer.slice(..));
+            rp.draw(0..6, 0..1);
+        }
+    });
+    // Columns 0-5 read the pack's own name, 6-10 colortex0 (which the program also writes),
+    // 11-15 gdepth (colortex1).
+    for (i, p) in pixels.iter().enumerate() {
+        assert_eq!(*p, ATLAS, "column {}", i % SIZE[0] as usize);
+    }
+}

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

@@ -0,0 +1,277 @@
+//! Original synthetic weather oracle: no pack assets or external shader algorithms.
+use super::*;
+use std::io::{Cursor, Write};
+use wgpu::util::DeviceExt;
+
+#[test]
+#[ignore = "requires a host GPU; missing adapter is a failure"]
+fn rain_depth_controls_writes_for_rain_snow_and_fallbacks() {
+    let instance = crate::gfx::test_gpu::instance();
+    let adapter = pollster::block_on(instance.request_adapter(&Default::default())).unwrap();
+    eprintln!("Weather depth GPU: {:?}", adapter.get_info());
+    assert_ne!(adapter.get_info().device_type, wgpu::DeviceType::Cpu);
+    let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
+        required_limits: adapter.limits(),
+        ..Default::default()
+    }))
+    .unwrap();
+    let mut depth_failures = Vec::new();
+    for program in ["gbuffers_weather", "gbuffers_textured_lit"] {
+        for (property, writes) in [
+            ("rain.depth=true", true),
+            ("rain.depth=false", false),
+            // An evidence-limited compatibility choice: preserve accepted main here.
+            // The permitted packs do not establish the external omitted-value default.
+            ("", true),
+        ] {
+            let mut post = pack(&device, &queue, &adapter, program, property);
+            // Retain the pipelines for another frame, then resize their targets.
+            for size in [[6, 1], [6, 1], [12, 2]] {
+                post.resize(&device, size);
+                let mut encoder = device.create_command_encoder(&Default::default());
+                let targets = post.targets.as_ref().unwrap();
+                let color = &targets.color[0].as_ref().unwrap()[0];
+                encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                    color_attachments: &[attach(
+                        color,
+                        wgpu::Operations {
+                            load: wgpu::LoadOp::Clear(wgpu::Color::BLUE),
+                            store: wgpu::StoreOp::Store,
+                        },
+                    )],
+                    depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                        view: &targets.depth,
+                        depth_ops: Some(wgpu::Operations {
+                            load: wgpu::LoadOp::Clear(0.5),
+                            store: wgpu::StoreOp::Store,
+                        }),
+                        stencil_ops: None,
+                    }),
+                    ..Default::default()
+                });
+                post.set_weather(Some(geometry(&device)));
+                post.draw_weather(&device, &queue, &mut encoder, size);
+                assert!(post.weather_draw.is_none(), "draw consumes this frame only");
+                assert!(post.has_weather(), "pipelines survive the draw");
+                // A dry frame must neither redraw old quads nor discard the pipelines.
+                post.set_weather(None);
+                post.draw_weather(&device, &queue, &mut encoder, size);
+                assert!(post.has_weather());
+                let targets = post.targets.as_ref().unwrap();
+                let color = targets.color[0].as_ref().unwrap()[0].texture();
+                let colors = readback(&device, &mut encoder, color);
+                let depths = readback(&device, &mut encoder, &targets.depth_texture);
+                queue.submit([encoder.finish()]);
+                for buffer in [&colors, &depths] {
+                    buffer.slice(..).map_async(wgpu::MapMode::Read, |_| {});
+                }
+                device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+                let colors = colors.slice(..).get_mapped_range().unwrap();
+                let depths = depths.slice(..).get_mapped_range().unwrap();
+                for y in 0..size[1] as usize {
+                    for x in 0..size[0] as usize {
+                        let quad = x / (size[0] as usize / 6);
+                        let visible = quad.is_multiple_of(3);
+                        // First quad is in front; second is behind scene depth; third discards.
+                        let expected_color = if visible && quad < 3 {
+                            [128, 0, 127, 255]
+                        } else if visible {
+                            [0, 128, 127, 255]
+                        } else {
+                            [0, 0, 255, 255]
+                        };
+                        let offset = y * 256 + x * 4;
+                        let actual_color = &colors[offset..offset + 4];
+                        for (actual, expected) in actual_color.iter().zip(expected_color) {
+                            assert!(
+                                i16::from(*actual).abs_diff(expected) <= 1,
+                                "{program} {property:?} size={size:?} ({x},{y}): color {actual_color:?}"
+                            );
+                        }
+                        let depth =
+                            f32::from_le_bytes(depths[offset..offset + 4].try_into().unwrap());
+                        let expected_depth = if visible && writes { 0.25 } else { 0.5 };
+                        if depth != expected_depth {
+                            depth_failures.push(format!(
+                                "{program} {property:?} size={size:?} ({x},{y}): depth={depth}, expected={expected_depth}"
+                            ));
+                        }
+                    }
+                }
+                eprintln!(
+                    "Weather oracle {program} {property:?} {size:?}: color, occlusion and discard pass; cumulative depth mismatches={}",
+                    depth_failures.len()
+                );
+            }
+        }
+    }
+    assert!(depth_failures.is_empty(), "{}", depth_failures.join("\n"));
+}
+
+fn pack(
+    device: &wgpu::Device,
+    queue: &wgpu::Queue,
+    adapter: &wgpu::Adapter,
+    program: &str,
+    property: &str,
+) -> PackPost {
+    let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    for (extension, source) in [
+        (
+            "vsh",
+            "#version 120\nvarying vec4 color; varying float marker; void main(){gl_Position=gl_Vertex;color=gl_Color;marker=gl_MultiTexCoord0.x;}",
+        ),
+        (
+            "fsh",
+            "#version 120\nvarying vec4 color; varying float marker; /* DRAWBUFFERS:0 */ void main(){if(marker>1.5) discard;gl_FragData[0]=color;}",
+        ),
+    ] {
+        zip.start_file(
+            format!("shaders/{program}.{extension}"),
+            zip::write::SimpleFileOptions::default(),
+        )
+        .unwrap();
+        zip.write_all(source.as_bytes()).unwrap();
+    }
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-weather-depth",
+        zip.finish().unwrap().into_inner(),
+    )
+    .unwrap();
+    let macros = horizon_shaders::Macros::standard();
+    let properties = horizon_shaders::Properties::parse(property, &macros);
+    let post = horizon_shaders::load_post(
+        &pack,
+        "",
+        &properties,
+        &macros,
+        &horizon_shaders::GameInputs {
+            weather: Some(super::super::pack_weather::inputs()),
+            ..Default::default()
+        },
+    );
+    assert!(post.notes.is_empty(), "{:?}", post.notes);
+    assert_eq!(post.weather.as_ref().unwrap().name, program);
+    let lightmap = device
+        .create_texture(&wgpu::TextureDescriptor {
+            label: None,
+            size: wgpu::Extent3d {
+                width: 1,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::Rgba8Unorm,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING,
+            view_formats: &[],
+        })
+        .create_view(&Default::default());
+    let mut post = PackPost::new(
+        device,
+        queue,
+        adapter,
+        post,
+        wgpu::TextureFormat::Rgba8Unorm,
+        World {
+            atlas: None,
+            material_maps: None,
+            lightmap,
+            terrain: None,
+            block_ids: &[],
+            sprite_rects: &[],
+            celestial: None,
+            gui_size: [1, 1],
+            clouds: None,
+            weather: true,
+            hand: false,
+        },
+    )
+    .expect("weather pack runs");
+    assert!(
+        post.has_weather(),
+        "production weather pipelines must compile: {:?}",
+        post.notes
+    );
+    post.copied |= 1; // Keep colortex0 readable for the independent color oracle.
+    post
+}
+
+fn geometry(device: &wgpu::Device) -> Weather {
+    let mut vertices = Vec::new();
+    let mut indices = Vec::new();
+    for quad in 0..6u32 {
+        let left = quad as f32 / 3.0 - 1.0;
+        let right = (quad + 1) as f32 / 3.0 - 1.0;
+        let z = if quad % 3 == 1 { 0.5 } else { -0.5 };
+        for pos in [
+            [left, -1.0, z],
+            [right, -1.0, z],
+            [right, 1.0, z],
+            [left, 1.0, z],
+        ] {
+            vertices.push(super::super::Vertex {
+                pos,
+                uv: [(quad % 3) as f32, 0.0],
+                layer: 0,
+                color: u32::from_le_bytes(if quad < 3 {
+                    [255, 0, 0, 128]
+                } else {
+                    [0, 255, 0, 128]
+                }),
+                light: 0,
+                normal: [0; 4],
+                glint_uv: [0.0; 2],
+            });
+        }
+        indices.extend([0, 1, 2, 0, 2, 3].map(|i| quad * 4 + i));
+    }
+    let buffer = |contents: &[u8], usage| {
+        device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: None,
+            contents,
+            usage,
+        })
+    };
+    Weather {
+        vertices: buffer(bytemuck::cast_slice(&vertices), wgpu::BufferUsages::VERTEX),
+        indices: buffer(bytemuck::cast_slice(&indices), wgpu::BufferUsages::INDEX),
+        quads: [0..3, 3..6],
+        sprites: [None, None],
+        generation: 1,
+    }
+}
+
+fn readback(
+    device: &wgpu::Device,
+    encoder: &mut wgpu::CommandEncoder,
+    texture: &wgpu::Texture,
+) -> wgpu::Buffer {
+    let buffer = device.create_buffer(&wgpu::BufferDescriptor {
+        label: None,
+        size: u64::from(256 * texture.height()),
+        usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+        mapped_at_creation: false,
+    });
+    encoder.copy_texture_to_buffer(
+        wgpu::TexelCopyTextureInfo {
+            aspect: if texture.format().is_depth_stencil_format() {
+                wgpu::TextureAspect::DepthOnly
+            } else {
+                wgpu::TextureAspect::All
+            },
+            ..texture.as_image_copy()
+        },
+        wgpu::TexelCopyBufferInfo {
+            buffer: &buffer,
+            layout: wgpu::TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(256),
+                rows_per_image: None,
+            },
+        },
+        texture.size(),
+    );
+    buffer
+}

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

@@ -0,0 +1,56 @@
+//! A built-in uniform declared with another GLSL type than the one Iris 1.11.7 gives is disabled
+//! there ("Wrong uniform type ... Disabling that uniform") and reads 0; our probe packs (#9307)
+//! read 0 for each such declaration. Declared with its own type, it keeps its value.
+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";
+
+/// composite declares two floats as `int` and `vec2` and an int as `float`, and writes what it
+/// reads into colortex1; final declares the same names with their own types and adds them.
+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("final.vsh", VERTEX);
+    add(
+        "composite.fsh",
+        "#version 130\nuniform int viewWidth;\nuniform vec2 viewHeight;\nuniform float fogShape;\n\
+         void main() {\n/* DRAWBUFFERS:1 */\n\
+         \x20   gl_FragData[0] = vec4(float(viewWidth), viewHeight.x, fogShape + 1.0, 255.0) / 255.0;\n}\n",
+    );
+    add(
+        "final.fsh",
+        "#version 130\nuniform sampler2D colortex1;\nuniform float viewWidth;\nuniform int fogShape;\n\
+         varying vec2 uv;\nvoid main() {\n\
+         \x20   vec4 c = texture(colortex1, uv);\n\
+         \x20   gl_FragColor = vec4(c.r, c.g + viewWidth * 4.0 / 255.0, c.b + float(fogShape + 2) * 10.0 / 255.0, 1.0);\n}\n",
+    );
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-wrong-uniform-types",
+        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 built_ins_declared_with_another_type_read_zero() {
+    let Some(gpu) = Fixture::new() else { return };
+    let mut post = gpu.build(pack());
+    // 8 pixels wide; post programs read `fogShape` -1. composite reads 0, 0 and 0 (+1 = 1);
+    // final reads 8 (green 32) and -1 (+2 = 1, blue 10).
+    for p in gpu.render(&mut post, [8, 8]) {
+        assert_eq!(p, [0, 32, 11, 255]);
+    }
+}

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

@@ -35,14 +35,8 @@ pub(super) struct ShadowTargets {
     pub depth: (wgpu::Texture, wgpu::TextureView),
     /// `shadowtex1`: a copy of `shadowtex0` taken before translucent terrain, when read.
     pub depth1: Option<(wgpu::Texture, wgpu::TextureView)>,
-    /// `shadowtex0`/`1` as a plain sampler filters them: Iris 1.11.7 reads them linearly unless
-    /// a pack asks for the nearest texel (measured). wgpu filters a depth format only for a
-    /// comparison, so these are `R32Float` copies of the final depths, when read that way.
-    pub linear: [Option<wgpu::TextureView>; 2],
-    /// The rows a depth copy goes through to `linear` (a depth format copies only to a buffer),
-    /// and their stride in bytes.
-    staging: Option<(wgpu::Buffer, u32)>,
-    /// Both sides of each shadowcolor buffer used.
+    /// Both sides of each shadowcolor buffer used; one texture for both when no `shadowcomp`
+    /// program draws into or flips the buffer.
     pub color: [Option<[wgpu::TextureView; 2]>; SHADOW_COLORS],
     /// The clear colour of each buffer cleared every frame.
     pub clears: [Option<[f32; 4]>; SHADOW_COLORS],
@@ -84,15 +78,15 @@ fn target(
 
 impl ShadowTargets {
     /// The buffers of `shadow` the pack uses: `colors` (bit n: shadowcolor n), `depth1` when
-    /// some program reads `shadowtex1`, `linear` (bit n: shadowtex n read through a filtering
-    /// sampler). The resolution is kept within the device's limit.
+    /// some program reads `shadowtex1`, `doubled` (bit n: shadowcolor n needs a B texture). The
+    /// resolution is kept within the device's limit.
     pub fn new(
         device: &wgpu::Device,
         shadow: &horizon_shaders::Shadow,
         formats: [wgpu::TextureFormat; SHADOW_COLORS],
         colors: u16,
+        doubled: u16,
         depth1: bool,
-        linear: u8,
     ) -> Self {
         let size = shadow
             .resolution
@@ -101,8 +95,8 @@ impl ShadowTargets {
         let depth = wgpu::TextureFormat::Depth32Float;
         let color = std::array::from_fn(|n| {
             (colors & 1 << n != 0).then(|| {
-                [0, 1].map(|side| {
-                    let label = format!("Shader pack shadowcolor{n} {}", ["A", "B"][side]);
+                let side = |side: &str| {
+                    let label = format!("Shader pack shadowcolor{n} {side}");
                     target(
                         device,
                         &label,
@@ -111,46 +105,20 @@ impl ShadowTargets {
                         wgpu::TextureUsages::empty(),
                     )
                     .1
-                })
+                };
+                let a = side("A");
+                let b = if doubled & 1 << n != 0 {
+                    side("B")
+                } else {
+                    a.clone()
+                };
+                [a, b]
             })
         });
-        let linear = [0, 1].map(|n| {
-            (linear & 1 << n != 0).then(|| {
-                let label = format!("Shader pack shadowtex{n} (filtered)");
-                device
-                    .create_texture(&wgpu::TextureDescriptor {
-                        label: Some(&label),
-                        size: wgpu::Extent3d {
-                            width: size,
-                            height: size,
-                            depth_or_array_layers: 1,
-                        },
-                        mip_level_count: 1,
-                        sample_count: 1,
-                        dimension: wgpu::TextureDimension::D2,
-                        format: wgpu::TextureFormat::R32Float,
-                        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-                        view_formats: &[],
-                    })
-                    .create_view(&Default::default())
-            })
-        });
-        let staging = linear.iter().any(Option::is_some).then(|| {
-            let stride = (size * 4).next_multiple_of(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT);
-            let buffer = device.create_buffer(&wgpu::BufferDescriptor {
-                label: Some("Shader pack shadow depth rows"),
-                size: u64::from(stride) * u64::from(size),
-                usage: wgpu::BufferUsages::COPY_SRC | wgpu::BufferUsages::COPY_DST,
-                mapped_at_creation: false,
-            });
-            (buffer, stride)
-        });
         Self {
             size,
             depth: target(device, "Shader pack shadowtex0", size, depth, copy),
             depth1: depth1.then(|| target(device, "Shader pack shadowtex1", size, depth, copy)),
-            linear,
-            staging,
             color,
             clears: std::array::from_fn(|n| {
                 let b = &shadow.colors[n];
@@ -256,38 +224,4 @@ impl ShadowTargets {
             );
         }
     }
-
-    /// `linear`: the filtered copies of the depths the shadow pass left (`shadowtex1` from its
-    /// copy before translucent geometry).
-    pub fn copy_linear(&self, encoder: &mut wgpu::CommandEncoder) {
-        let Some((buffer, stride)) = &self.staging else {
-            return;
-        };
-        for (n, linear) in self.linear.iter().enumerate() {
-            let Some(linear) = linear else {
-                continue;
-            };
-            let depth = match (n, &self.depth1) {
-                (1, Some(d)) => &d.0,
-                _ => &self.depth.0,
-            };
-            let rows = wgpu::TexelCopyBufferInfo {
-                buffer,
-                layout: wgpu::TexelCopyBufferLayout {
-                    offset: 0,
-                    bytes_per_row: Some(*stride),
-                    rows_per_image: None,
-                },
-            };
-            encoder.copy_texture_to_buffer(
-                wgpu::TexelCopyTextureInfo {
-                    aspect: wgpu::TextureAspect::DepthOnly,
-                    ..depth.as_image_copy()
-                },
-                rows,
-                depth.size(),
-            );
-            encoder.copy_buffer_to_texture(rows, linear.texture().as_image_copy(), depth.size());
-        }
-    }
 }

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

@@ -94,10 +94,12 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
             ("vaColor".into(), "hz_Color".into()),
             ("vaNormal".into(), "hz_Normal".into()),
         ],
-        // At the far plane: the sky shows only where nothing else drew, and it writes no depth.
-        after: "    gl_Position.z = gl_Position.w;\n".into(),
+        // Tested at the far plane: the sky shows only where nothing else drew, and it writes no
+        // depth. Its fragments read their own depth, as in Iris.
+        after: String::new(),
         alpha_test: None,
         item_id_declared: false,
+        far_depth: true,
     }
 }
 
@@ -121,9 +123,10 @@ pub fn celestial_inputs() -> horizon_shaders::GbuffersInputs {
             ("vaColor".into(), "hz_Color".into()),
             ("vaNormal".into(), "hz_Normal".into()),
         ],
-        after: "    gl_Position.z = gl_Position.w;\n".into(),
+        after: String::new(),
         alpha_test: None,
         item_id_declared: false,
+        far_depth: true,
     }
 }
 
@@ -153,6 +156,38 @@ fn disc(y: f32, kind: u32, out: &mut Vec<Vertex>) {
     }
 }
 
+/// Cover the horizon and downward sky rays as well as the upper vanilla disc.
+/// Uncovered directions retain the buffer's clear colour, affecting later sky/fog
+/// compositing. Enclosing the camera gives the sky program fragments there too.
+/// Depth stays at the far plane through `inputs`, so terrain remains in front.
+fn horizon(out: &mut Vec<Vertex>) {
+    let corners = [
+        [-512.0, -512.0, -512.0],
+        [512.0, -512.0, -512.0],
+        [512.0, 512.0, -512.0],
+        [-512.0, 512.0, -512.0],
+        [-512.0, -512.0, 512.0],
+        [512.0, -512.0, 512.0],
+        [512.0, 512.0, 512.0],
+        [-512.0, 512.0, 512.0],
+    ];
+    for [a, b, c, d] in [
+        [0, 1, 2, 3],
+        [4, 7, 6, 5],
+        [0, 4, 5, 1],
+        [3, 2, 6, 7],
+        [0, 3, 7, 4],
+        [1, 5, 6, 2],
+    ] {
+        for i in [a, b, c, a, c, d] {
+            out.push(Vertex {
+                pos: corners[i],
+                kind: SKY,
+            });
+        }
+    }
+}
+
 pub(super) struct PackSky {
     vertices: wgpu::Buffer,
     celestial: wgpu::Buffer,
@@ -166,6 +201,7 @@ pub(super) struct PackSky {
 impl PackSky {
     pub fn new(device: &wgpu::Device) -> Self {
         let mut v = Vec::new();
+        horizon(&mut v);
         disc(16.0, SKY, &mut v);
         let sky = 0..v.len() as u32;
         let apex = Vertex {

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

@@ -0,0 +1,218 @@
+//! Original GPU probe of a pack's `ftransform()`, in gbuffers and shadow programs.
+
+use wgpu::util::DeviceExt;
+
+/// Iris 1.11.7's `ftransform()` read back with a probe pack of ours (#8464) has the bits of
+/// `gl_ProjectionMatrix * (gl_ModelViewMatrix * gl_Vertex)` at every vertex our probes read: the
+/// model-view matrix first, then the projection, not their product matrix. These matrices tell
+/// the two apart (one rounding against two): the model-view matrix takes 16777 from x, so the
+/// vertex at 16777.25 comes out at exactly 0.25, and a third of that is one rounding; the product
+/// matrix holds a third of 16777 rounded to a float, which leaves an error near 1e-4 after the
+/// subtraction.
+#[test]
+fn ftransform_applies_the_model_view_matrix_before_the_projection() {
+    let instance = crate::gfx::test_gpu::instance();
+    let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
+        return;
+    };
+    let (device, queue) = pollster::block_on(adapter.request_device(&Default::default())).unwrap();
+    let third = 1.0f32 / 3.0;
+    let model_view = glam::Mat4::from_translation(glam::Vec3::new(-16777.0, 2.0, 0.0));
+    let projection = glam::Mat4::from_scale(glam::Vec3::new(third, 0.5, 1.0));
+    let vertices = [[16777.25f32, 1.0, -3.0], [16778.0, -2.0, 5.0]];
+    // `0.25 * third` and `1.0 * third` are exact products: one rounding of each.
+    let expected = [[0.25 * third, 1.5, -3.0, 1.0], [third, 0.0, 5.0, 1.0]];
+    let mut failures = Vec::new();
+    for shadow in [false, true] {
+        let got = ftransform(&device, &queue, model_view, projection, &vertices, shadow);
+        for ((v, want), got) in vertices.iter().zip(&expected).zip(&got) {
+            if got.map(f32::to_bits) != want.map(f32::to_bits) {
+                failures.push(format!("{v:?}, shadow={shadow}: {got:?} != {want:?}"));
+            }
+        }
+    }
+    assert!(failures.is_empty(), "{}", failures.join("\n"));
+}
+
+/// `ftransform()` of each of `vertices` in a gbuffers program (or a shadow program, with the
+/// matrices as the shadow camera's), read back from a point per vertex as float bits.
+fn ftransform(
+    device: &wgpu::Device,
+    queue: &wgpu::Queue,
+    model_view: glam::Mat4,
+    projection: glam::Mat4,
+    vertices: &[[f32; 3]],
+    shadow: bool,
+) -> Vec<[f32; 4]> {
+    let pp = |code: &str| horizon_shaders::Preprocessed {
+        code: code.to_owned(),
+        ..Default::default()
+    };
+    let vertex = pp(&format!(
+        "varying vec4 probe;\nvoid main() {{\n    probe = ftransform();\n    \
+         gl_Position = vec4((float(gl_VertexID) + 0.5) * {} - 1.0, 0.0, 0.0, 1.0);\n}}",
+        2.0 / vertices.len() as f32,
+    ));
+    // An integer target keeps the float bits on any adapter.
+    let fragment = pp(
+        "varying vec4 probe;\nlayout(location = 0) out uvec4 bits;\n\
+         void main() { bits = floatBitsToUint(probe); }",
+    );
+    let inputs = horizon_shaders::GbuffersInputs {
+        declarations: "layout(location = 0) in vec3 hz_v_pos;".into(),
+        body: "    hz_Vertex = vec4(hz_v_pos, 1.0);\n    hz_Color = vec4(1.0);\n".into(),
+        ..Default::default()
+    };
+    let program = if shadow {
+        horizon_shaders::translate_shadow(&vertex, &fragment, &inputs)
+    } else {
+        horizon_shaders::translate_gbuffers(
+            &vertex,
+            &fragment,
+            horizon_shaders::Target::Buffers,
+            &inputs,
+        )
+    }
+    .unwrap();
+    let prefix = if shadow { "shadow" } else { "gbuffer" };
+    let mut block = program.interface.initial_values.clone();
+    block.resize(program.interface.uniform_size.max(16) as usize, 0);
+    for (name, matrix) in [("ModelView", model_view), ("Projection", projection)] {
+        let name = format!("{prefix}{name}");
+        let at = (program.interface.uniforms.iter())
+            .find(|u| u.name == name)
+            .unwrap_or_else(|| panic!("no {name}"))
+            .offset as usize;
+        block[at..at + 64].copy_from_slice(bytemuck::cast_slice(&matrix.to_cols_array()));
+    }
+    let uniform = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+        label: None,
+        contents: &block,
+        usage: wgpu::BufferUsages::UNIFORM,
+    });
+    let data = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+        label: None,
+        contents: bytemuck::cast_slice(vertices),
+        usage: wgpu::BufferUsages::VERTEX,
+    });
+    let group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+        label: None,
+        entries: &[wgpu::BindGroupLayoutEntry {
+            binding: 0,
+            visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+            ty: wgpu::BindingType::Buffer {
+                ty: wgpu::BufferBindingType::Uniform,
+                has_dynamic_offset: false,
+                min_binding_size: None,
+            },
+            count: None,
+        }],
+    });
+    let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+        label: None,
+        layout: &group_layout,
+        entries: &[wgpu::BindGroupEntry {
+            binding: 0,
+            resource: uniform.as_entire_binding(),
+        }],
+    });
+    let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+        label: None,
+        bind_group_layouts: &[Some(&group_layout)],
+        ..Default::default()
+    });
+    let module = |module| {
+        device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)),
+        })
+    };
+    let vs = module(program.vertex);
+    let fs = module(program.fragment);
+    let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: None,
+        layout: Some(&layout),
+        vertex: wgpu::VertexState {
+            module: &vs,
+            entry_point: Some("main"),
+            compilation_options: Default::default(),
+            buffers: &[Some(wgpu::VertexBufferLayout {
+                array_stride: 12,
+                step_mode: wgpu::VertexStepMode::Vertex,
+                attributes: &wgpu::vertex_attr_array![0 => Float32x3],
+            })],
+        },
+        primitive: wgpu::PrimitiveState {
+            topology: wgpu::PrimitiveTopology::PointList,
+            ..Default::default()
+        },
+        depth_stencil: None,
+        multisample: Default::default(),
+        fragment: Some(wgpu::FragmentState {
+            module: &fs,
+            entry_point: Some("main"),
+            compilation_options: Default::default(),
+            targets: &[Some(wgpu::ColorTargetState {
+                format: wgpu::TextureFormat::Rgba32Uint,
+                blend: None,
+                write_mask: wgpu::ColorWrites::ALL,
+            })],
+        }),
+        multiview_mask: None,
+        cache: None,
+    });
+    let output = device.create_texture(&wgpu::TextureDescriptor {
+        label: None,
+        size: wgpu::Extent3d {
+            width: vertices.len() as u32,
+            height: 1,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba32Uint,
+        usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+        view_formats: &[],
+    });
+    let read = device.create_buffer(&wgpu::BufferDescriptor {
+        label: None,
+        size: vertices.len() as u64 * 16,
+        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+        mapped_at_creation: false,
+    });
+    let mut encoder = device.create_command_encoder(&Default::default());
+    {
+        let view = output.create_view(&Default::default());
+        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: None,
+            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                view: &view,
+                depth_slice: None,
+                resolve_target: None,
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
+                    store: wgpu::StoreOp::Store,
+                },
+            })],
+            ..Default::default()
+        });
+        pass.set_pipeline(&pipeline);
+        pass.set_bind_group(0, &group, &[]);
+        pass.set_vertex_buffer(0, data.slice(..));
+        pass.draw(0..vertices.len() as u32, 0..1);
+    }
+    encoder.copy_texture_to_buffer(
+        output.as_image_copy(),
+        wgpu::TexelCopyBufferInfo {
+            buffer: &read,
+            layout: wgpu::TexelCopyBufferLayout::default(),
+        },
+        output.size(),
+    );
+    queue.submit([encoder.finish()]);
+    read.slice(..).map_async(wgpu::MapMode::Read, |_| {});
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+    let mapped = read.slice(..).get_mapped_range().unwrap();
+    bytemuck::cast_slice::<u8, [f32; 4]>(&mapped).to_vec()
+}

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

@@ -45,6 +45,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
             reference: 0.1,
         }),
         item_id_declared: false,
+        far_depth: false,
     }
 }
 

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

@@ -475,7 +475,8 @@ impl<T> Resident<T> {
                     }
                     let oy = f64::from(self.min_y + y * 16) - camera.y;
                     let min = Vec3::new(min_x, oy as f32, min_z);
-                    let (bmin, bmax) = section_box(min, self.bounds[slot as usize]);
+                    let bounds = self.bounds[slot as usize].filter(|_| frustum.tight());
+                    let (bmin, bmax) = section_box(min, bounds);
                     if !frustum.intersects(bmin, bmax) {
                         continue;
                     }

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

@@ -319,7 +319,7 @@ mod tests {
     #[test]
     fn a_native_weather_stage_validates() {
         use horizon_shader_api::stages::StageKind;
-        let source = StageKind::Weather.prelude()
+        let source = StageKind::Weather.prelude(horizon_shader_api::Api::V0_1)
             + "fn weather(input: WeatherInput) -> vec4<f32> {\n    \
                return input.color * vec4(input.light, input.position.x, f32(input.snow));\n}\n";
         let text = native_source(&source);

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

@@ -0,0 +1,208 @@
+//! NORMAL world text: alpha blended, back-face culled, ordinary depth writes.
+pub(super) fn pipeline(
+    device: &wgpu::Device,
+    layout: Option<&wgpu::PipelineLayout>,
+    shader: &wgpu::ShaderModule,
+    format: wgpu::TextureFormat,
+) -> wgpu::RenderPipeline {
+    let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2];
+    device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: Some("Normal world text"),
+        layout,
+        vertex: wgpu::VertexState {
+            module: shader,
+            entry_point: Some("vs_entity"),
+            compilation_options: Default::default(),
+            buffers: &[Some(wgpu::VertexBufferLayout {
+                array_stride: std::mem::size_of::<super::Vertex>() as u64,
+                step_mode: wgpu::VertexStepMode::Vertex,
+                attributes: &attributes,
+            })],
+        },
+        primitive: wgpu::PrimitiveState {
+            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: shader,
+            entry_point: Some("fs_entity"),
+            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,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use wgpu::util::DeviceExt;
+    #[test]
+    #[ignore = "requires a Vulkan/Metal/DX12 adapter"]
+    fn world_text_blends_culls_and_obeys_world_depth() {
+        let instance = crate::gfx::test_gpu::instance();
+        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).unwrap();
+        let (device, queue) =
+            pollster::block_on(adapter.request_device(&Default::default())).unwrap();
+        // Use the production pipeline/vertex layout with a pass-through shader
+        // to isolate its actual depth, winding and blend behavior from lighting.
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Wgsl(
+                r#"
+struct Out { @builtin(position) pos:vec4<f32>, @location(0) color:vec4<f32> }
+@vertex fn vs_entity(@location(0) pos:vec3<f32>, @location(3) color:vec4<f32>)->Out {
+ return Out(vec4(pos,1.0),color);
+}
+@fragment fn fs_entity(v:Out)->@location(0) vec4<f32> { return v.color; }
+"#
+                .into(),
+            ),
+        });
+        let pipeline = pipeline(&device, None, &shader, wgpu::TextureFormat::Rgba8Unorm);
+        let texture = |format, usage| {
+            device.create_texture(&wgpu::TextureDescriptor {
+                label: None,
+                size: wgpu::Extent3d {
+                    width: 4,
+                    height: 1,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format,
+                usage,
+                view_formats: &[],
+            })
+        };
+        let color = texture(
+            wgpu::TextureFormat::Rgba8Unorm,
+            wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+        );
+        let depth = texture(
+            wgpu::TextureFormat::Depth32Float,
+            wgpu::TextureUsages::RENDER_ATTACHMENT,
+        );
+        let mut vertices = Vec::new();
+        let mut indices = Vec::new();
+        let mut quad = |pixel: u32, z: f32, color: [u8; 4], back: bool| {
+            let x = -1.0 + pixel as f32 * 0.5;
+            let first = vertices.len() as u32;
+            for pos in [
+                [x, -1.0, z],
+                [x + 0.5, -1.0, z],
+                [x + 0.5, 1.0, z],
+                [x, 1.0, z],
+            ] {
+                vertices.push(super::super::Vertex {
+                    pos,
+                    uv: [0.0; 2],
+                    color: u32::from_le_bytes(color),
+                    layer: 0,
+                    light: 0,
+                    normal: [0; 4],
+                    glint_uv: [0.0; 2],
+                });
+            }
+            for i in if back {
+                [0, 2, 1, 0, 3, 2]
+            } else {
+                [0, 1, 2, 0, 2, 3]
+            } {
+                indices.push(first + i);
+            }
+        };
+        quad(0, 0.6, [255, 0, 0, 255], false);
+        // A hair behind: the entity model pipeline's 128-ulp depth bias
+        // would incorrectly put the green quad in front of the red surface.
+        quad(0, 0.599_999, [0, 255, 0, 255], false);
+        quad(1, 0.8, [0, 255, 0, 255], false);
+        quad(1, 0.7, [255, 0, 0, 255], false);
+        quad(2, 0.5, [255, 0, 0, 128], false);
+        quad(3, 0.5, [255, 255, 0, 255], true);
+        let buffer = |data: &[u8], usage| {
+            device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: None,
+                contents: data,
+                usage,
+            })
+        };
+        let vertex = buffer(bytemuck::cast_slice(&vertices), wgpu::BufferUsages::VERTEX);
+        let index = buffer(bytemuck::cast_slice(&indices), wgpu::BufferUsages::INDEX);
+        let readback = device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: 256,
+            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+            mapped_at_creation: false,
+        });
+        let mut encoder = device.create_command_encoder(&Default::default());
+        {
+            let color = color.create_view(&Default::default());
+            let depth = depth.create_view(&Default::default());
+            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &color,
+                    depth_slice: None,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::BLUE),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                    view: &depth,
+                    depth_ops: Some(wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(0.0),
+                        store: wgpu::StoreOp::Store,
+                    }),
+                    stencil_ops: None,
+                }),
+                ..Default::default()
+            });
+            pass.set_pipeline(&pipeline);
+            pass.set_vertex_buffer(0, vertex.slice(..));
+            pass.set_index_buffer(index.slice(..), wgpu::IndexFormat::Uint32);
+            pass.draw_indexed(0..indices.len() as u32, 0, 0..1);
+        }
+        encoder.copy_texture_to_buffer(
+            color.as_image_copy(),
+            wgpu::TexelCopyBufferInfo {
+                buffer: &readback,
+                layout: wgpu::TexelCopyBufferLayout {
+                    offset: 0,
+                    bytes_per_row: Some(256),
+                    rows_per_image: None,
+                },
+            },
+            color.size(),
+        );
+        queue.submit([encoder.finish()]);
+        let (tx, rx) = std::sync::mpsc::channel();
+        readback.map_async(wgpu::MapMode::Read, .., move |result| {
+            tx.send(result).unwrap()
+        });
+        device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+        rx.recv().unwrap().unwrap();
+        let pixels = readback.get_mapped_range(..).unwrap();
+        assert_eq!(
+            &pixels[..16],
+            &[
+                255, 0, 0, 255, 0, 255, 0, 255, 128, 0, 127, 255, 0, 0, 255, 255
+            ]
+        );
+    }
+}

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

@@ -532,6 +532,67 @@ pub fn smooth_gradients_offered() -> bool {
     SMOOTH_GRADIENTS_OFFERED.load(std::sync::atomic::Ordering::Relaxed)
 }
 
+/// Whether GPU Culling (`Graphics::gpu_culling`) can be switched on here, and why not: set when a
+/// renderer starts, and again when its pass can't be set up or its buffers stop fitting in video
+/// memory. Where it isn't offered the settings grey its switch out with the reason, and the saved
+/// value waits for a renderer that offers it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum GpuCullingOffer {
+    /// No count draws the GPU wrote, compute shaders or working first instances (OpenGL, Metal,
+    /// Vulkan without `VK_KHR_draw_indirect_count`, Intel Gen11/Gen12's Vulkan driver), vanilla
+    /// frames drawn flat, or a pass the driver couldn't build.
+    Unsupported = 0,
+    /// A software adapter (WARP, lavapipe): the pass would run on the CPU, beside the frame.
+    Software = 1,
+    /// Its buffers stopped fitting in video memory: off until the next renderer.
+    OutOfMemory = 2,
+    /// DX12 with flat page groups, whose count draws leave each draw's base vertex out of
+    /// what the near sections' packed faces are read by (`gpu_culling::loses_base_vertex`).
+    Dx12 = 3,
+    /// The graphics device was lost while its frames were drawn (`lose_gpu_culling`): off
+    /// for the renderers after it, until Horizon restarts.
+    DeviceLost = 5,
+    Offered = 4,
+}
+impl GpuCullingOffer {
+    /// The greyed switch's tooltip; `None` where it is offered.
+    pub fn reason(self) -> Option<&'static str> {
+        match self {
+            Self::Unsupported => Some("Your GPU or graphics API doesn't support it."),
+            Self::Software => Some("Not with software rendering, which runs it on the CPU."),
+            Self::OutOfMemory => Some("Out of video memory: off until the next start."),
+            Self::Dx12 => Some("Not on DirectX 12 yet: try the Vulkan graphics API."),
+            Self::DeviceLost => Some("The graphics device was lost: off until the next start."),
+            Self::Offered => None,
+        }
+    }
+}
+static GPU_CULLING_OFFER: std::sync::atomic::AtomicU8 =
+    std::sync::atomic::AtomicU8::new(GpuCullingOffer::Unsupported as u8);
+pub fn offer_gpu_culling(offer: GpuCullingOffer) {
+    GPU_CULLING_OFFER.store(offer as u8, std::sync::atomic::Ordering::Relaxed);
+}
+pub fn gpu_culling_offer() -> GpuCullingOffer {
+    match GPU_CULLING_OFFER.load(std::sync::atomic::Ordering::Relaxed) {
+        1 => GpuCullingOffer::Software,
+        2 => GpuCullingOffer::OutOfMemory,
+        3 => GpuCullingOffer::Dx12,
+        4 => GpuCullingOffer::Offered,
+        5 => GpuCullingOffer::DeviceLost,
+        _ => GpuCullingOffer::Unsupported,
+    }
+}
+/// Set once the graphics device was lost while GPU culling drew the frames (the game's
+/// `recover_device`): the renderers made after it don't offer it (`GpuCullingOffer::DeviceLost`),
+/// so a fault in its frames can't lose the device again after every recovery.
+static GPU_CULLING_LOST: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+pub fn lose_gpu_culling() {
+    GPU_CULLING_LOST.store(true, std::sync::atomic::Ordering::Relaxed);
+}
+pub fn gpu_culling_lost() -> bool {
+    GPU_CULLING_LOST.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.
@@ -608,8 +669,15 @@ pub struct Graphics {
     pub blue_map: crate::bluemap::Settings,
     /// Skip sections hidden behind closed ones (vanilla's occlusion graph).
     pub cave_culling: bool,
+    /// Near solid terrain culled, and its draws listed, on the GPU (`gfx::gpu_culling`), where it
+    /// is offered (`gpu_culling_offer`). Off by default (GPU Culling, Performance graphics); it
+    /// applies at once, and no preset sets it. Every save writes it, so a default turned on later
+    /// needs a new key, as `batchTranslucent` did.
+    pub gpu_culling: bool,
     /// Skip drawing entities hidden behind opaque terrain, synchronously or asynchronously.
     pub entity_culling: EntityCullingMode,
+    /// Minimum entity population for coarse AABB culling; zero disables it.
+    pub entity_culling_precheck: u32,
     /// Skip particles outside the view or hidden behind opaque terrain.
     pub particle_culling: ParticleCullingMode,
     /// Terrain leaf faces inside a canopy (see [`LeafCullingMode`]); `Off` draws
@@ -716,7 +784,9 @@ impl Default for Graphics {
             far_detail: FarDetail::Full,
             blue_map: crate::bluemap::Settings::default(),
             cave_culling: true,
+            gpu_culling: false,
             entity_culling: EntityCullingMode::Off,
+            entity_culling_precheck: 64,
             particle_culling: ParticleCullingMode::Off,
             leaf_culling: LeafCullingMode::Off,
             cache_shulker_boxes: false,
@@ -812,7 +882,11 @@ impl Graphics {
                 }
                 "blueMapAutoDetect" => g.blue_map.auto_detect = flag(g.blue_map.auto_detect),
                 "caveCulling" => g.cave_culling = flag(g.cave_culling),
+                "gpuCulling" => g.gpu_culling = flag(g.gpu_culling),
                 "entityCulling" => g.entity_culling = EntityCullingMode::parse(value),
+                "entityCullingPrecheck" => {
+                    g.entity_culling_precheck = number(g.entity_culling_precheck).min(512)
+                }
                 "particleCulling" => g.particle_culling = ParticleCullingMode::parse(value),
                 "leafCulling" => g.leaf_culling = LeafCullingMode::parse(value),
                 "blockEntityCache" => {
@@ -906,12 +980,13 @@ impl Graphics {
     }
     pub fn serialize(&self) -> String {
         let mut text = format!(
-            "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:{}\nhdrLighting:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\nbatchTranslucent:{}\nhdrSmoothGradients:{}\n",
+            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nentityCullingPrecheck:{}\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:{}\nhdrLighting:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\nbatchTranslucent:{}\nhdrSmoothGradients:{}\ngpuCulling:{}\n",
             self.preset.name(),
             self.lod_distance,
             self.far_detail.name(),
             bool_text(self.cave_culling),
             self.entity_culling.name(),
+            self.entity_culling_precheck,
             self.particle_culling.name(),
             self.leaf_culling.name(),
             bool_text(self.cache_shulker_boxes),
@@ -959,6 +1034,7 @@ impl Graphics {
             self.shader_pack,
             bool_text(self.translucent_batching),
             bool_text(self.hdr_smooth_gradients),
+            bool_text(self.gpu_culling),
         );
         text += &self.blue_map.serialize();
         text
@@ -1097,7 +1173,9 @@ mod tests {
                 servers: Vec::new(),
             },
             cave_culling: false,
+            gpu_culling: true,
             entity_culling: EntityCullingMode::Synchronous,
+            entity_culling_precheck: 128,
             particle_culling: ParticleCullingMode::Asynchronous,
             leaf_culling: LeafCullingMode::SolidAggressive,
             cache_shulker_boxes: true,
@@ -1183,6 +1261,9 @@ mod tests {
         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);
+        // GPU Culling is opt-in: only the file or its switch turns it on.
+        assert!(!Graphics::default().gpu_culling);
+        assert!(Graphics::parse("gpuCulling:true\n").gpu_culling);
         // 0 is Auto; anything else is a peak the slider reaches.
         assert_eq!(Graphics::parse("hdrPeak:0\n").hdr_peak, 0);
         assert_eq!(Graphics::parse("hdrPeak:50\n").hdr_peak, 200);

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

@@ -256,7 +256,15 @@ pub fn decode_image_bytes(data: &[u8]) -> Result<(u32, u32, Vec<u8>)> {
     match ImageFormat::sniff(data) {
         Some(ImageFormat::WebP) => decode_webp(data),
         Some(ImageFormat::Jpeg) => decode_jpeg(data),
-        Some(ImageFormat::Png) | None => decode_bytes(data),
+        // A PNG's IHDR states the size before the decoder sizes its pixel
+        // buffer, so it is checked there like the WebP and JPEG headers: the
+        // PNG reader alone would trust the header and allocate it.
+        Some(ImageFormat::Png) | None => {
+            if let Some((width, height)) = png_bytes_size(data) {
+                check_fetched_size(u64::from(width), u64::from(height))?;
+            }
+            decode_bytes(data)
+        }
     }
 }
 
@@ -308,15 +316,19 @@ fn within_budget(files: &[&PathBuf], budget: u64) -> HashSet<PathBuf> {
         .map(|p| (*p).clone())
         .collect()
 }
+/// A PNG's width and height from its first 24 bytes (`IHDR`), before any
+/// pixel buffer is made.
+fn png_bytes_size(data: &[u8]) -> Option<(u32, u32)> {
+    let header = data.get(..24)?;
+    if header[..8] != *b"\x89PNG\r\n\x1a\n" || header[12..16] != *b"IHDR" {
+        return None;
+    }
+    let field = |at: usize| u32::from_be_bytes(header[at..at + 4].try_into().unwrap_or_default());
+    Some((field(16), field(20)))
+}
 /// A PNG's width and height, from its header alone.
 fn png_size(path: &Path) -> Option<(u32, u32)> {
-    let header: [u8; 24] = horizon_core::prepared_files::read_head(path, 24)
-        .ok()?
-        .try_into()
-        .ok()?;
-    let field = |at: usize| u32::from_be_bytes(header[at..at + 4].try_into().unwrap_or_default());
-    (header[..8] == *b"\x89PNG\r\n\x1a\n" && header[12..16] == *b"IHDR")
-        .then(|| (field(16), field(20)))
+    png_bytes_size(&horizon_core::prepared_files::read_head(path, 24).ok()?)
 }
 fn walk(dir: &Path, out: &mut Vec<PathBuf>) {
     // A prepared root's folder: from its data file, without listing the disk.
@@ -1928,7 +1940,7 @@ impl HudBatch {
         color: u32,
         shadow: bool,
     ) -> f32 {
-        self.styled_text(atlas, text, x, y, color, shadow, false)
+        self.styled_text(atlas, text, x, y, color, shadow, false, None)
     }
     /// `text_styled` for text drawn in the world (`TextRenderable.render`
     /// with `flat` false): each quad's `depth` is its z in text units, the
@@ -1944,7 +1956,42 @@ impl HudBatch {
         color: u32,
         shadow: bool,
     ) -> f32 {
-        self.styled_text(atlas, text, x, y, color, shadow, true)
+        self.styled_text(atlas, text, x, y, color, shadow, true, None)
+    }
+    /// `Font.drawInBatch8xOutline`: eight glyph offsets in the outline color,
+    /// then the original text. Returns (advance, first front-text vertex), so
+    /// world rendering can use POLYGON_OFFSET for the front and NORMAL for
+    /// its outline. Offsets use each glyph's own shadow offset (unihex: 0.5).
+    pub fn text_styled_outline_world(
+        &mut self,
+        atlas: &HudAtlas,
+        text: &crate::text::Text,
+        x: f32,
+        y: f32,
+        color: u32,
+        outline: u32,
+    ) -> (f32, usize) {
+        for dx in -1..=1 {
+            for dy in -1..=1 {
+                if dx != 0 || dy != 0 {
+                    self.styled_text(
+                        atlas,
+                        text,
+                        x,
+                        y,
+                        color,
+                        false,
+                        true,
+                        Some((outline, [dx as f32, dy as f32])),
+                    );
+                }
+            }
+        }
+        let front = self.vertices.len();
+        (
+            self.styled_text(atlas, text, x, y, color, false, true, None),
+            front,
+        )
     }
     #[allow(clippy::too_many_arguments)]
     fn styled_text(
@@ -1956,6 +2003,7 @@ impl HudBatch {
         color: u32,
         shadow: bool,
         world: bool,
+        outline: Option<(u32, [f32; 2])>,
     ) -> f32 {
         // StringDecomposer.iterateFormatted inside Font.drawInternal:
         // `§` codes inside a span restyle what follows and are not drawn.
@@ -2023,10 +2071,11 @@ impl HudBatch {
         }
         self.patches.extend(font.take_patches());
         let white = font.white();
-        let has_shadow = shadow
-            || glyphs
-                .iter()
-                .any(|glyph| glyph.3.is_some_and(|color| color != 0));
+        let has_shadow = outline.is_none()
+            && (shadow
+                || glyphs
+                    .iter()
+                    .any(|glyph| glyph.3.is_some_and(|color| color != 0)));
         let passes: &[bool] = if has_shadow { &[true, false] } else { &[false] };
         // ARGB.scaleRGB(color, 0.25): the default shadow colour.
         let shade = |c: u32| {
@@ -2061,8 +2110,9 @@ impl HudBatch {
                 } else {
                     shade(*c)
                 };
-                let has_shadow = (custom_shadow.is_some_and(|argb| argb != 0)
-                    || custom_shadow.is_none() && shadow)
+                let has_shadow = outline.is_none()
+                    && (custom_shadow.is_some_and(|argb| argb != 0)
+                        || custom_shadow.is_none() && shadow)
                     && !(world && shadow_color == 0);
                 if is_shadow && !has_shadow {
                     continue;
@@ -2072,7 +2122,11 @@ impl HudBatch {
                 } else {
                     (0.0, *c)
                 };
-                let (px, py) = (*gx + dx, y + dx);
+                let (px, py, col) = if let Some((color, [dx, dy])) = outline {
+                    (*gx + dx * g.offset, y + dy * g.offset, color)
+                } else {
+                    (*gx + dx, y + dx, col)
+                };
                 if let Some(object) = object {
                     // `PlainTextRenderable.render`: sprite glyphs use the same
                     // shadow colour and offset as text, with the front at SHADOW_DEPTH.
@@ -2916,6 +2970,41 @@ mod tests {
         assert!(check_fetched_size(16_383, 16_383).is_err());
     }
 
+    /// A fetched PNG is refused by the size its own header claims, before the
+    /// reader makes the pixel buffer: a few hundred bytes of payload would
+    /// otherwise ask for 64 MiB or much more.
+    #[test]
+    fn a_fetched_png_is_refused_by_the_size_its_header_claims() {
+        let mut encoded = Vec::new();
+        {
+            let mut encoder = png::Encoder::new(&mut encoded, 2, 2);
+            encoder.set_color(png::ColorType::Rgba);
+            encoder.set_depth(png::BitDepth::Eight);
+            let mut writer = encoder.write_header().unwrap();
+            writer.write_image_data(&[7; 16]).unwrap();
+            writer.finish().unwrap();
+        }
+        assert!(matches!(
+            ImageFormat::sniff(&encoded),
+            Some(ImageFormat::Png)
+        ));
+        assert_eq!(
+            decode_image_bytes(&encoded).expect("a small PNG decodes").0,
+            2
+        );
+
+        // The same image, its IHDR claiming one pixel row past the limit: the
+        // CRC is ignored on purpose, so this stands in for a hostile header.
+        let ihdr = encoded.windows(4).position(|w| w == b"IHDR").expect("IHDR");
+        encoded[ihdr + 4..ihdr + 8].copy_from_slice(&4097u32.to_be_bytes());
+        encoded[ihdr + 8..ihdr + 12].copy_from_slice(&4096u32.to_be_bytes());
+        let refused = decode_image_bytes(&encoded).expect_err("the size is refused");
+        assert!(
+            refused.to_string().contains("too large to decode"),
+            "{refused}"
+        );
+    }
+
     /// Only the network path reads WebP and JPEG: a resource pack's texture
     /// stays PNG-only, as vanilla's `NativeImage.read` is.
     #[test]
@@ -3819,6 +3908,44 @@ texture=wide",
         assert_eq!(fonts.font.width("abba"), width);
     }
     #[test]
+    fn outlined_world_text_keeps_font_metrics_and_overrides_outline_color() {
+        let root = two_glyph_font("world-outline");
+        let atlas = HudAtlas::build(&root).unwrap();
+        let _ = fs::remove_dir_all(&root);
+        let mut batch = HudBatch::new([1, 1]);
+        let text = crate::text::Text::colored("ab", 0xff0000);
+        let outline = rgba(1, 2, 3, 128);
+        let (advance, front) =
+            batch.text_styled_outline_world(&atlas, &text, 10.0, 20.0, u32::MAX, outline);
+        assert_eq!((advance, front, batch.vertices.len()), (10.0, 96, 108));
+        assert!(batch.vertices[..front].iter().all(|v| v.color == outline));
+        assert!(
+            batch.vertices[front..]
+                .iter()
+                .all(|v| v.color == rgba(255, 0, 0, 255))
+        );
+        // Eight independently offset silhouettes, retaining both glyphs and
+        // the bitmap font's advance (a=4, b=6); front text has no shadow.
+        for (i, [dx, dy]) in [
+            [-1.0, -1.0],
+            [-1.0, 0.0],
+            [-1.0, 1.0],
+            [0.0, -1.0],
+            [0.0, 1.0],
+            [1.0, -1.0],
+            [1.0, 0.0],
+            [1.0, 1.0],
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let at = batch.vertices[i * 12].pos;
+            let main = batch.vertices[front].pos;
+            assert_eq!(at, [main[0] + dx, main[1] + dy]);
+            assert_eq!(batch.vertices[i * 12 + 6].pos[0] - at[0], 4.0);
+        }
+    }
+    #[test]
     fn obfuscated_glyphs_keep_the_width() {
         let root = two_glyph_font("obfuscated");
         let fonts = HudAtlas::fonts(&root).unwrap();

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

@@ -32,6 +32,7 @@ pub mod collisions;
 pub mod command_block;
 pub mod connected;
 pub mod containers;
+pub mod controller_ui;
 pub mod crash;
 pub mod datapack;
 pub mod dynamic_light;
@@ -91,6 +92,7 @@ pub mod sculk;
 pub mod section_mask;
 pub mod server_terrain;
 pub mod settings;
+pub mod settings_shell;
 pub mod shader_options;
 pub mod shader_pack_list;
 pub mod signs;
@@ -107,6 +109,7 @@ mod sprite_cache;
 pub mod sprites;
 pub mod streaming;
 pub mod structure_block;
+pub mod studio_ui;
 pub mod tab_list;
 pub mod telemetry;
 pub mod test_block;

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

@@ -4025,9 +4025,12 @@ mod tests {
         );
         // A chunk covers only one quarter of this parent's 32² cell. Both
         // opaque terrain and water must leave precisely that 16² footprint.
+        // Only active tiles enter the mesher snapshot, even when samples are ready.
+        lod.active.insert(key);
         lod.covered.insert((-1, -2));
         lod.covered_bounds = Some([-16, -32, 0, -16]);
         let mesh = lod.mesh(key);
+        lod.active.remove(&key);
         let top_area = |vertices: &[TerrainVertex], y: f32| {
             vertices
                 .as_chunks::<4>()
@@ -4213,14 +4216,19 @@ mod tests {
             &lod.reduced[&(-1, -1)].columns,
             &lod.saved[&(-1, -1)]
         ));
-        assert!(
+        let reduced_spans = |lod: &Lod| {
             lod.snapshot()
                 .visited_source(-16, -16, 2)
                 .unwrap()
                 .get()
                 .spans
-                .is_empty()
-        );
+                .iter()
+                .map(|span| (span.min, span.max, span.state))
+                .collect::<Vec<_>>()
+        };
+        // Reduction keeps a block held by any column of the footprint, so
+        // this single-column build survives the cached two-block reduction.
+        assert_eq!(reduced_spans(&lod), vec![(120, 121, stone)]);
         let old = lod.saved[&(-1, -1)].clone();
         lod.observe(Arc::new(chunk.clone()), &facts);
         receive_observed(&mut lod);
@@ -4233,30 +4241,43 @@ mod tests {
             &lod.reduced[&(-1, -1)].columns,
             &lod.saved[&(-1, -1)]
         ));
+        assert_eq!(
+            reduced_spans(&lod),
+            vec![(120, 121, stone), (130, 131, stone)]
+        );
         // A seed reduction arriving after the edit cannot restore old data.
         lod.finish_detail((-1, -1), ReducedColumns::new(old));
         assert_eq!(lod.ready[&fine][0].surface.unwrap().height, 131);
+        assert_eq!(
+            reduced_spans(&lod),
+            vec![(120, 121, stone), (130, 131, stone)]
+        );
 
         // Exercise the actual worker/update seam: a parent stays displayed
-        // until all four child meshes can replace it in the same update.
+        // until all four child meshes have arrived, possibly over several updates.
         let camera = [-256.0, 100.0, -256.0];
         lod.area = Some(([-16, -16], 2, 64, 0, false, None));
         lod.plan.roots = vec![key];
         lod.plan.nodes.insert(key);
         // As a replan does (`update` only selects after a change).
         lod.reselect = true;
-        let await_meshes = |lod: &mut Lod| {
+        let await_meshes = |lod: &mut Lod, count: usize| {
             let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
+            let mut uploaded = Vec::new();
             loop {
-                let meshes = lod.update(camera, 2, 64, None, None);
-                if !meshes.is_empty() {
-                    return meshes;
+                uploaded.extend(lod.update(camera, 2, 64, None, None));
+                if uploaded.len() >= count {
+                    return uploaded;
                 }
+                assert!(
+                    lod.removed().is_empty(),
+                    "retired before replacement meshes"
+                );
                 assert!(std::time::Instant::now() < deadline, "mesh worker stalled");
                 std::thread::sleep(std::time::Duration::from_millis(1));
             }
         };
-        let uploaded = await_meshes(&mut lod);
+        let uploaded = await_meshes(&mut lod, 1);
         assert_eq!(uploaded.len(), 1);
         assert_eq!(uploaded[0].0, key);
         assert!(lod.active.contains(&key));
@@ -4266,13 +4287,7 @@ mod tests {
             lod.ready.insert(child, lod.ready[&key].clone());
         }
         lod.reselect = true;
-        assert!(lod.update(camera, 2, 64, None, None).is_empty());
-        assert!(
-            lod.active.contains(&key),
-            "parent retired before child meshes"
-        );
-        assert!(lod.removed().is_empty());
-        let uploaded = await_meshes(&mut lod);
+        let uploaded = await_meshes(&mut lod, 4);
         assert_eq!(uploaded.len(), 4);
         assert!(
             key.children()
@@ -4376,6 +4391,7 @@ mod tests {
                 .insert(parent, Arc::new(vec![Column::default(); 256]));
         }
         lod.active = [near, far].into_iter().collect();
+        lod.wanted_stale = true;
         lod.shared.jobs.lock().unwrap().clear();
         lod.sample_jobs = SAMPLE_JOBS;
         lod.pending = (0..SAMPLE_JOBS - 1)
@@ -4401,6 +4417,7 @@ mod tests {
         lod.plan.split.clear();
         lod.detail_masks.clear();
         lod.covered = [(0, 0)].into_iter().collect();
+        lod.full = lod.covered.clone();
         lod.detail_request_pending = false;
         lod.detail_request_at = std::time::Instant::now() - std::time::Duration::from_secs(1);
         lod.request_detail([0, 0]);

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

@@ -354,7 +354,9 @@ fn heightmap(column: &Column, mut fluid: impl FnMut(&Span) -> bool) -> Column {
     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.
+        // The bed is under all of the water, however many spans the water
+        // takes: a chunk's own columns shade it a span a light level, a
+        // previewed far column one span for the run.
         spans.push(ground(under));
         spans.push(Span {
             min: under.max,

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

@@ -1412,6 +1412,9 @@ pub struct Mesher<'a> {
     pub shader_pack_lighting: bool,
     /// OptiFine/Iris separate ambient occlusion: vertex RGB does not include AO, and AO factor is passed in vertex alpha.
     pub separate_ao: bool,
+    /// A `shaders/` pack draws the terrain (with or without its `oldLighting`): fluid tops are
+    /// split into triangles as Iris splits them (`fluid::splits_north_east`).
+    pub shader_pack: bool,
     pub assets: &'a Assets,
     pub render: &'a RenderAssets,
     pub tables: &'a MeshTables,
@@ -1503,6 +1506,7 @@ impl Mesher<'_> {
                             self.nether_shading,
                             self.shader_pack_lighting,
                             self.separate_ao,
+                            self.shader_pack,
                         );
                         fluid::tesselate(self.tables, shade, pad, water, &mut out, [x, y, z]);
                     }

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

@@ -188,13 +188,28 @@ impl FluidFlowWorld for FlowView<'_> {
         Ok(self.info[state as usize].sturdy & 1 << d as u8 != 0)
     }
 }
+/// Whether a `shaders/` pack's fluid top with these corner heights is split into triangles along
+/// its north-east to south-west diagonal, as Iris 1.11.7 draws it, rather than along vanilla's
+/// north-west to south-east one (`FluidRenderer.tesselate` puts its vertices NW, SW, SE, NE, and
+/// `RenderSystem`'s quad indices join vertex 0 to 2).
+///
+/// Our probe packs' readings of Iris (#8464) fit this: a top is split along the diagonal whose
+/// corners differ more in height, and a top whose north-west and south-east corners are level
+/// (a still, flat top among them) along north-east to south-west. It is a fit, not Iris's code:
+/// it covers every lava top we read and every still top but one, and misses 26 of the 343 water
+/// tops we read (undiagnosed).
+pub(super) fn splits_north_east(nw: f32, ne: f32, sw: f32, se: f32) -> bool {
+    let (along_nw, along_ne) = ((nw - se).abs(), (ne - sw).abs());
+    along_nw < along_ne || along_nw == 0.0
+}
 /// Emits one fluid cell at section-relative `[x, y, z]`.
-/// `(nether, shader_pack_lighting, separate_ao)`: the Nether's face shading, only the up-face value
-/// when a shader pack lights the faces (`Mesher::shader_pack_lighting`), and whether to keep pure
-/// alpha for separate AO.
+/// `(nether, shader_pack_lighting, separate_ao, shader_pack)`: the Nether's face shading, only the
+/// up-face value when a shader pack lights the faces (`Mesher::shader_pack_lighting`), whether to
+/// keep pure alpha for separate AO, and whether a `shaders/` pack draws the terrain
+/// (`Mesher::shader_pack`: tops split as Iris splits them, [`splits_north_east`]).
 pub(super) fn tesselate(
     tables: &MeshTables,
-    (nether, shader_pack_lighting, separate_ao): (bool, bool, bool),
+    (nether, shader_pack_lighting, separate_ao, shader_pack): (bool, bool, bool, bool),
     pad: &Padded,
     water_color: u32,
     out: &mut SectionMesh,
@@ -383,13 +398,19 @@ pub(super) fn tesselate(
                 !same(s) && !s.solid
             })
         });
+        let mut corners = [
+            ([fx, fy + nw, fz], uv[0]),
+            ([fx, fy + sw, fz + 1.0], uv[1]),
+            ([fx + 1.0, fy + se, fz + 1.0], uv[2]),
+            ([fx + 1.0, fy + ne, fz], uv[3]),
+        ];
+        // Starting from the south-west corner joins it to the north-east one (0 to 2), with the
+        // same winding.
+        if shader_pack && splits_north_east(nw, ne, sw, se) {
+            corners.rotate_left(1);
+        }
         quad(
-            [
-                ([fx, fy + nw, fz], uv[0]),
-                ([fx, fy + sw, fz + 1.0], uv[1]),
-                ([fx + 1.0, fy + se, fz + 1.0], uv[2]),
-                ([fx + 1.0, fy + ne, fz], uv[3]),
-            ],
+            corners,
             layer,
             color(cardinal(D::Up)),
             light([x, y, z]),
@@ -492,6 +513,49 @@ mod tests {
         }
         assert!(atan2(f64::NAN, 1.0).is_nan());
     }
+    /// Corner heights read back from Iris 1.11.7 with a probe pack of ours (#8464), from water
+    /// and lava spreading over a floor and from a still lake, and whether Iris split each top
+    /// along north-east to south-west. Each height is the vanilla average it reads as (for
+    /// example 13/27 for 0.48047 + 0.001), less `FluidRenderer`'s 0.001.
+    #[test]
+    fn fluid_tops_split_where_iris_splits_them() {
+        let h = |num: f32, den: f32| num / den - 0.001;
+        // (north-west, north-east, south-west, south-east)
+        let cases = [
+            // Still and flat: a lake's water, a lava pool.
+            ([h(8.0, 9.0); 4], true),
+            ([h(96.0, 117.0); 4], true),
+            // Level along one axis: both diagonals equally steep.
+            (
+                [h(5.0, 9.0), h(13.0, 27.0), h(5.0, 9.0), h(13.0, 27.0)],
+                false,
+            ),
+            (
+                [h(100.0, 117.0), h(100.0, 117.0), h(2.0, 3.0), h(2.0, 3.0)],
+                false,
+            ),
+            // North-west to south-east steeper.
+            ([h(5.0, 9.0), h(4.0, 9.0), h(4.0, 9.0), h(7.0, 18.0)], false),
+            ([h(7.0, 18.0), h(4.0, 9.0), h(4.0, 9.0), h(5.0, 9.0)], false),
+            ([h(5.0, 6.0), h(4.0, 9.0), h(2.0, 9.0), h(2.0, 9.0)], false),
+            // North-east to south-west steeper.
+            ([h(1.0, 2.0), h(5.0, 9.0), h(7.0, 18.0), h(4.0, 9.0)], true),
+            (
+                [h(4.0, 9.0), h(2.0, 9.0), h(96.0, 117.0), h(4.0, 9.0)],
+                true,
+            ),
+            // North-west and south-east level: a saddle.
+            ([h(4.0, 9.0), h(7.0, 18.0), h(7.0, 18.0), h(4.0, 9.0)], true),
+        ];
+        for ([nw, ne, sw, se], iris) in cases {
+            assert_eq!(
+                splits_north_east(nw, ne, sw, se),
+                iris,
+                "{:?}",
+                [nw, ne, sw, se]
+            );
+        }
+    }
     #[test]
     fn coverage_of_full_and_partial_faces() {
         assert_eq!(coverage(&VoxelShape::block(), Direction::North), 1.0);

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

@@ -73,6 +73,7 @@ fn mesh(
         nether_shading: false,
         shader_pack_lighting: false,
         separate_ao: false,
+        shader_pack: false,
         assets: &f.assets,
         render: &f.render,
         tables: &f.tables,