Merge pull request #5800 from 1038april/feat/ram-limit-game

🤖 Agent: Review by Ludovic's AI agent (Claude). Opt-in RAM limit; off, it costs one atomic store per frame. kacpherek's grace-period point is fixed and tested. I merged main again (ram_limit next to random_textures, render_distance_in_use next to the leaf-culling remesh). Verify green on this head.

.github/workflows/mojang-republish.yml

@@ -0,0 +1,31 @@
+name: mojang republish
+# Hourly: does Mojang's version manifest list a pinned-version JSON that research-lock.json does not know?
+# If so, one issue "Mojang republished <version>: <sha8>" with the hashes and a lock snippet
+# (tools/ci/mojang_republish.py). Reads only Mojang's public manifest.
+#   gh workflow run "mojang republish" -f dry_run=true
+on:
+  schedule:
+    - cron: '23 * * * *'  # hourly: a republished JSON breaks horizon-prepare for every new player until accepted
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        description: Only print what it would do with issues
+        type: boolean
+        default: false
+permissions:
+  contents: read
+  issues: write
+concurrency:
+  group: mojang-republish
+  cancel-in-progress: false
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - name: Check the manifest
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: python3 tools/ci/mojang_republish.py ${{ inputs.dry_run && '--dry-run' || '' }}

AGENTS.md

@@ -56,6 +56,7 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 | `horizon-friends`, `horizon-relay` | Play with Friends: invite codes, encrypted tunnel, the relay ([docs/play-with-friends.md](docs/play-with-friends.md)) |
 | `horizon-mods`, `cargo-horizon-mod` | Content mods (`.hmod`: manifest, content fence, no code), the registry index and `.hpack`, and `cargo horizon-mod` (`new`, `build`, `run`, `check`, `registry`) ([docs/mods.md](docs/mods.md)). Code mods are native, built by the launcher ([docs/native-mods.md](docs/native-mods.md)) |
 | `horizon-port-pack` | Porting Java modpacks ([docs/modpacks.md](docs/modpacks.md)) |
+| `horizon-optifine` | OptiFine-format pack files below every feature that reads them: `.properties`, the name/range/block matchers, paths and `optifine/` folders, and custom entity models (`cem/`: `.jem`/`.jpm` parsing and baking) |
 | `horizon-shader-api` | Horizon's own WGSL shader packs ([docs/api/shaders.md](docs/api/shaders.md)): `horizon-shaders.toml`, the `.hshader` package; shared by the game, the launcher and the registry |
 | `horizon-shaders` | Shader packs (the `shaders/` folder format), rebuilt clean-room from a written spec of the format; no wgpu |
 | `horizon-theme` | Design tokens and fonts for the launcher, the game's own menus and the website |

Cargo.lock

@@ -1323,6 +1323,7 @@ dependencies = [
  "horizon-items",
  "horizon-mods",
  "horizon-narrator",
+ "horizon-optifine",
  "horizon-protocol",
  "horizon-server-files",
  "horizon-shader-api",
@@ -1334,6 +1335,9 @@ dependencies = [
  "log",
  "miniz_oxide 0.8.9",
  "naga",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
+ "objc2-foundation 0.3.2",
  "open",
  "png",
  "pollster",
@@ -1391,6 +1395,7 @@ dependencies = [
  "horizon-hdr",
  "horizon-items",
  "horizon-narrator",
+ "horizon-optifine",
  "horizon-protocol",
  "horizon-shader-api",
  "horizon-shaders",
@@ -1475,6 +1480,7 @@ dependencies = [
  "horizon-client-core",
  "horizon-core",
  "horizon-world",
+ "log",
  "serde",
  "serde_json",
 ]
@@ -1506,6 +1512,15 @@ dependencies = [
  "windows 0.62.2",
 ]
 
+[[package]]
+name = "horizon-optifine"
+version = "0.1.0"
+dependencies = [
+ "horizon-bench",
+ "log",
+ "regex",
+]
+
 [[package]]
 name = "horizon-port-pack"
 version = "0.1.0"
@@ -1609,6 +1624,7 @@ version = "0.1.0"
 dependencies = [
  "bytemuck",
  "naga",
+ "png",
  "serde",
  "serde_json",
  "sha2",

Cargo.toml

@@ -30,6 +30,7 @@ members = [
     "crates/cargo-horizon-mod",
     "crates/horizon-port-pack",
     "crates/horizon-shaders",
+    "crates/horizon-optifine",
     "crates/horizon-shader-api",
     "crates/horizon-release-sign",
     "xtask",

THIRD_PARTY_NOTICES.md

@@ -66,3 +66,28 @@ with Microsoft accounts
 The four-square Microsoft symbol in `launcher/src/microsoft.rs` reproduces the squares, positions and
 colours of Microsoft's official `ms-symbollockup_mssymbol_19.svg` from that page, unmodified. Microsoft
 and its logo are trademarks of the Microsoft group of companies; Horizon is not endorsed by Microsoft.
+
+## CIT Resewn
+
+`crates/horizon-optifine/src/cit.rs` and `crates/horizon-client-render/src/cit.rs` follow the
+condition semantics of [CIT Resewn Continuation](https://github.com/EthanVisagie/CIT-Resewn-Continuation-1.21.11)
+(at `b792f9a`), a continuation of [CIT Resewn](https://github.com/SHsuperCM/CITResewn) by SHsuperCM: the
+1.21 component paths, enchantment levels, percent damage, text matching and rule ordering. It is
+licensed under the MIT license:
+
+> Copyright (c) 2021 SHsuperCM
+>
+> 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.

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

@@ -6,5 +6,5 @@ authors = []
 # A content mod: blocks, items and mob effects from data/ and assets/, no code (API 0.2).
 api = "0.2"
 side = "both"
-# registries: "May add blocks, items and mob effects to your worlds".
+# registries: "May add blocks, items, mob effects and entity types to your worlds".
 capabilities = ["registries"]

crates/horizon-anticheat/src/lib.rs

@@ -281,6 +281,13 @@ pub struct Player {
     pub ground: Option<(u64, f64)>,
     /// The client ticks the prediction plays again (only while it runs).
     pub record: Option<Box<prediction::Record>>,
+    /// Sprinting as the client's own commands left it (ServerboundPlayerCommandPacket's
+    /// START_SPRINTING and STOP_SPRINTING: LocalPlayer.wasSprinting), which the record's ticks take.
+    /// Not the server's player: a hit with extra knockback stops its sprint
+    /// (Player.causeExtraKnockback), the client's own `Player.attack` doesn't (a mob's `hurtClient`
+    /// is false), and once the server's flag reaches it LocalPlayer.aiStep starts the sprint again
+    /// while the sprint key is held, with nothing to say: wasSprinting never changed.
+    pub sprinting: bool,
     /// The attacks of the client tick being heard.
     pub attacks: combat::Attacks,
 }

crates/horizon-anticheat/src/prediction.rs

@@ -39,6 +39,11 @@ pub enum Change {
     /// movement speed (the client takes the modifiers as sent, so a sprint modifier the packet
     /// lacks is gone while the client sprints), None when it didn't (the client keeps its own).
     Attributes { sprint: Option<bool> },
+    /// ClientboundSetEntityDataPacket for the player itself with its shared flags: their sprinting
+    /// bit, which the client takes as sent (SynchedEntityData.assignValues sets the flag alone, its
+    /// speed modifier and wasSprinting stay). A client whose sprint the server cleared this way
+    /// starts it again in its next aiStep, which adds the modifier back, and says nothing.
+    Sprinting(bool),
     /// ClientboundUpdateMobEffectPacket or ClientboundRemoveMobEffectPacket for the player itself:
     /// the server's effects, as they are when the replay reaches it. (Their attribute modifiers
     /// are the server's: they reach the client as attributes.)

crates/horizon-client-render/Cargo.toml

@@ -17,6 +17,9 @@ horizon-hdr = { path = "../horizon-hdr" }
 horizon-items = { path = "../horizon-items" }
 # The narrator option's status and whether the narrator is there (Options.narrator).
 horizon-narrator = { path = "../horizon-narrator" }
+# OptiFine-format pack files: random entity textures (hud.rs), connected textures
+# (connected.rs) and custom item texture rules (cit.rs).
+horizon-optifine = { path = "../horizon-optifine" }
 horizon-protocol = { path = "../horizon-protocol" }
 horizon-shader-api = { path = "../horizon-shader-api" }
 horizon-shaders = { path = "../horizon-shaders" }

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

@@ -96,6 +96,13 @@ pub struct RenderAssets {
     pub translucent_layers: Vec<bool>,
     /// Each layer's `MipmapGenerator` settings.
     pub sprite_mips: Vec<crate::mipmap::Settings>,
+    /// The resource packs' LabPBR maps (normals, specular), layer by layer at `pbr_size`:
+    /// empty when they ship none.
+    pub pbr_normals: Vec<u8>,
+    pub pbr_specular: Vec<u8>,
+    pub pbr_size: u32,
+    /// OptiFine connected textures (empty without `optifine/ctm` files).
+    pub connected: crate::connected::ConnectedTextures,
 }
 fn invalid(message: &str) -> io::Error {
     io::Error::new(io::ErrorKind::InvalidData, message)
@@ -235,9 +242,34 @@ impl RenderAssets {
         for stage in 0..10 {
             sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
         }
-        if draws {
+        let connected = if draws {
             crate::native_emissive::load(root, &mut sprites);
-        }
+            // A side's sprite, for rules that connect by tile: the first quad facing it.
+            let catalog = &models.catalog;
+            let mut found = Vec::new();
+            crate::connected::ConnectedTextures::load(
+                root,
+                registry,
+                &mut sprites,
+                |state, face| {
+                    let side = horizon_assets::model::Direction::ALL[face as usize];
+                    catalog
+                        .models_at(
+                            state,
+                            horizon_core::position::BlockPos::new(0, 0, 0),
+                            &mut found,
+                        )
+                        .ok()?;
+                    found
+                        .iter()
+                        .flat_map(|m| &m.faces)
+                        .find(|f| f.quad.facing == side)
+                        .map(|f| f.layer)
+                },
+            )
+        } else {
+            Default::default()
+        };
         sprites.save_disk_cache();
         if draws {
             sprites.finish();
@@ -259,6 +291,10 @@ impl RenderAssets {
             sprite_layers: sprites.layers,
             translucent_layers: sprites.translucent,
             sprite_mips: sprites.mips,
+            pbr_normals: sprites.normals,
+            pbr_specular: sprites.specular,
+            pbr_size: sprites.pbr_size,
+            connected,
         })
     }
 }

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

@@ -1179,6 +1179,15 @@ impl Audio {
         self.sync_volumes();
         self.engine.tick(paused, ctx, &mut self.backend);
     }
+    /// The `uiSoundReserve` extra: positional sounds leave
+    /// `sound_engine::HEARD_RESERVE` static channels free (off: vanilla's pool).
+    pub fn set_listener_reserve(&mut self, on: bool) {
+        self.engine.listener_reserve = if on {
+            crate::sound_engine::HEARD_RESERVE
+        } else {
+            0
+        };
+    }
     /// `SoundManager.pauseAllExcept(MUSIC, UI)`.
     pub fn pause(&mut self) {
         self.engine.pause_all_except(
@@ -1226,6 +1235,17 @@ impl Audio {
             self.play(event, Some(at), volume, pitch);
             return;
         }
+        self.play_after(
+            event,
+            at,
+            volume,
+            pitch,
+            (distance_sqr.sqrt() / 40.0 * 20.0) as i32,
+        );
+    }
+    /// `play` at a world position, starting `ticks` sound-engine ticks (20 a
+    /// second) from now: `SoundEngine.playDelayed`.
+    pub fn play_after(&mut self, event: &str, at: [f64; 3], volume: f32, pitch: f32, ticks: i32) {
         let seed = self.random.next_long();
         if let Some(capture) = self.capture.as_mut() {
             capture.push((event.to_owned(), at, volume, pitch));
@@ -1239,8 +1259,7 @@ impl Audio {
         let instance =
             SoundInstance::at(&event, source, volume, pitch, LegacyRandom::new(seed), at);
         let id = self.engine.add(instance, false);
-        self.engine
-            .play_delayed(id, (distance_sqr.sqrt() / 40.0 * 20.0) as i32);
+        self.engine.play_delayed(id, ticks);
     }
     /// `play` for this client only: a sound a packet's handler plays
     /// (`playLocalSound`), which the guests play from that packet themselves.

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

@@ -387,6 +387,52 @@ impl Biomes {
     }
 }
 
+/// A biome's colours as a mod may change them (`native_biome_colors`), each
+/// 0xRRGGBB: what tints grass (before the dark forest's modifier; the swamp's
+/// noise colours replace it), leaves and vines, dry foliage (leaf litter) and
+/// water.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct BiomeColors {
+    pub grass: u32,
+    pub foliage: u32,
+    pub dry_foliage: u32,
+    pub water: u32,
+}
+
+impl Biomes {
+    /// This table with each biome's colours passed through `f`, given the
+    /// biome's name (`minecraft:plains`) and its colours; None when `f`
+    /// changed none. Bits past 0xFFFFFF are dropped.
+    pub fn with_colors(&self, mut f: impl FnMut(&str, &mut BiomeColors)) -> Option<Self> {
+        let mut out = self.clone();
+        let mut changed = false;
+        for b in &mut out.list {
+            let before = BiomeColors {
+                grass: b.grass,
+                foliage: b.foliage,
+                dry_foliage: b.dry_foliage,
+                water: b.water,
+            };
+            let mut colors = before;
+            f(&b.name, &mut colors);
+            let after = BiomeColors {
+                grass: colors.grass & 0xFF_FFFF,
+                foliage: colors.foliage & 0xFF_FFFF,
+                dry_foliage: colors.dry_foliage & 0xFF_FFFF,
+                water: colors.water & 0xFF_FFFF,
+            };
+            if after != before {
+                changed = true;
+                b.grass = after.grass;
+                b.foliage = after.foliage;
+                b.dry_foliage = after.dry_foliage;
+                b.water = after.water;
+            }
+        }
+        changed.then_some(out)
+    }
+}
+
 /// A 24-bit colour as sRGB components in 0..1.
 pub fn rgb(c: u32) -> [f32; 3] {
     [16, 8, 0].map(|shift| (c >> shift & 255) as f32 / 255.0)
@@ -534,6 +580,81 @@ mod pack_tests {
     }
 }
 
+#[cfg(test)]
+mod color_tests {
+    use super::*;
+    use serde_json::json;
+
+    fn biomes() -> Biomes {
+        let maps = Colormaps {
+            grass: Vec::new(),
+            foliage: Vec::new(),
+            dry: Vec::new(),
+        };
+        let effects = |grass: u32, modifier: &str| {
+            json!({"effects": {"grass_color": grass, "foliage_color": 0x112233,
+                "dry_foliage_color": 0x445566, "water_color": 0x3F76E4,
+                "grass_color_modifier": modifier}})
+        };
+        let list = vec![
+            BiomeInfo::from_json("minecraft:plains".into(), &effects(0x91BD59, "none"), &maps),
+            BiomeInfo::from_json(
+                "minecraft:dark_forest".into(),
+                &effects(0x91BD59, "dark_forest"),
+                &maps,
+            ),
+        ];
+        Biomes {
+            builtin: Arc::new(list.clone()),
+            index: list
+                .iter()
+                .enumerate()
+                .map(|(i, b)| (b.name.clone(), i as u16))
+                .collect(),
+            list,
+            info_noise: SimplexNoise::with_skipped_offsets(&mut LegacyRandom::new(2345), true),
+            colormaps: Arc::new(maps),
+            packs: BTreeMap::new(),
+        }
+    }
+
+    #[test]
+    fn a_change_reaches_the_tints_the_mesher_reads() {
+        let autumn = biomes()
+            .with_colors(|name, c| {
+                c.foliage = 0xD2691E;
+                if name == "minecraft:plains" {
+                    c.grass = 0xBFA055;
+                }
+            })
+            .expect("changed");
+        let plains = autumn.id("minecraft:plains");
+        assert_eq!(autumn.grass(plains, 0.0, 0.0), 0xBFA055);
+        assert_eq!(autumn.get(plains).foliage, 0xD2691E);
+        assert_eq!(autumn.get(plains).dry_foliage, 0x445566);
+        assert_eq!(autumn.get(plains).water, 0x3F76E4);
+        // The dark forest's modifier still darkens its (unchanged) grass:
+        // ((0x91BD59 & 0xFEFEFE) + 0x28340A) >> 1.
+        let dark = autumn.id("minecraft:dark_forest");
+        assert_eq!(autumn.grass(dark, 0.0, 0.0), 0x5C7831);
+        assert_eq!(autumn.get(dark).foliage, 0xD2691E);
+    }
+
+    #[test]
+    fn no_change_gives_none_and_alpha_bits_are_dropped() {
+        assert!(biomes().with_colors(|_, _| {}).is_none());
+        assert!(
+            biomes()
+                .with_colors(|_, c| c.water |= 0xFF00_0000)
+                .is_none()
+        );
+        let blue = biomes()
+            .with_colors(|_, c| c.water = 0xFF00_00FF)
+            .expect("changed");
+        assert_eq!(blue.get(0).water, 0x0000FF);
+    }
+}
+
 #[cfg(test)]
 mod blend_tests {
     use super::*;

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

@@ -885,25 +885,26 @@ impl BlockEntityRenderer {
         let mut renderer = Self::new(models, registry);
         renderer.visibility = Some(Mutex::new(visibility));
         // Sherd items: provides_pottery_pattern -> decorated_pot_pattern asset id.
-        if let Ok(bytes) = std::fs::read(root.join("items.json")) {
-            let items: Value = serde_json::from_slice(&bytes)?;
-            for (item, components) in items.as_object().into_iter().flatten() {
-                let Some(pattern) = components["minecraft:provides_pottery_pattern"].as_str()
-                else {
-                    continue;
-                };
-                let name = pattern.strip_prefix("minecraft:").unwrap_or(pattern);
-                let file = root.join(format!("data/minecraft/decorated_pot_pattern/{name}.json"));
-                let Ok(def) = std::fs::read(file) else {
-                    continue;
-                };
-                let def: Value = serde_json::from_slice(&def)?;
-                if let Some(asset) = def["asset_id"].as_str() {
-                    let asset = asset.strip_prefix("minecraft:").unwrap_or(asset);
-                    renderer
-                        .pot_patterns
-                        .insert(item.clone(), format!("entity/decorated_pot/{asset}"));
-                }
+        let items = match horizon_world::item_defaults::read(root) {
+            Ok(items) => items,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Default::default(),
+            Err(e) => return Err(e.into()),
+        };
+        for (item, components) in &items {
+            let Some(pattern) = components["minecraft:provides_pottery_pattern"].as_str() else {
+                continue;
+            };
+            let name = pattern.strip_prefix("minecraft:").unwrap_or(pattern);
+            let file = root.join(format!("data/minecraft/decorated_pot_pattern/{name}.json"));
+            let Ok(def) = std::fs::read(file) else {
+                continue;
+            };
+            let def: Value = serde_json::from_slice(&def)?;
+            if let Some(asset) = def["asset_id"].as_str() {
+                let asset = asset.strip_prefix("minecraft:").unwrap_or(asset);
+                renderer
+                    .pot_patterns
+                    .insert(item.clone(), format!("entity/decorated_pot/{asset}"));
             }
         }
         Ok(renderer)

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

@@ -160,6 +160,18 @@ pub struct Brewing {
 }
 impl Brewing {
     pub fn load(root: &Path, items: &Items, overlay: &PackOverlay) -> Self {
+        // NeoForge's load conditions: a file whose don't hold is silently
+        // absent. Vanilla's brewing recipes carry none; a pack's can.
+        let mods: Vec<String> = {
+            let mut mods = horizon_items::content_namespaces::mod_ids(root);
+            if !mods.iter().any(|m| m == "minecraft") {
+                mods.push("minecraft".to_owned());
+            }
+            mods
+        };
+        let conditions_hold = |v: &Value| {
+            horizon_world::conditions::conditions_hold(v, &|id: &str| mods.iter().any(|m| m == id))
+        };
         let mut sources: Vec<(String, Value)> =
             fs::read_dir(root.join("data/minecraft/recipe/brewing"))
                 .into_iter()
@@ -191,6 +203,11 @@ impl Brewing {
                 None => sources.push((id.to_owned(), v)),
             }
         }
+        // The gate answers the merged file, as the crafting loader's does:
+        // a false-conditioned pack file leaves the lower one gone too.
+        // The data's recipe filters, over the final set.
+        let filters = horizon_items::recipe_filters::RecipeFilters::load(root, overlay);
+        sources.retain_mut(|(id, v)| conditions_hold(v) && filters.apply(id, v));
         sources.sort_by(|a, b| a.0.cmp(&b.0));
         let mut recipes = Vec::new();
         for (id, v) in sources {

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

@@ -501,6 +501,19 @@ impl Camera {
         entity: &CameraEntity,
         partial: f32,
         camera_type: CameraType,
+        clip: impl FnMut([f64; 3], [f64; 3]) -> Option<[f64; 3]>,
+    ) {
+        self.align_with_entity_distance(entity, partial, camera_type, |distance| distance, clip);
+    }
+    /// Adjust the detached distance after entity/mount scaling, before collision clipping.
+    /// Only finite overrides in 0..=1024 blocks are accepted (within the game's ray budget).
+    /// First-person views do not call `adjust_distance`.
+    pub fn align_with_entity_distance(
+        &mut self,
+        entity: &CameraEntity,
+        partial: f32,
+        camera_type: CameraType,
+        adjust_distance: impl FnOnce(f32) -> f32,
         mut clip: impl FnMut([f64; 3], [f64; 3]) -> Option<[f64; 3]>,
     ) {
         self.set_rotation(entity.view_y_rot(partial), entity.view_x_rot(partial));
@@ -528,10 +541,14 @@ impl Camera {
                 mount_scale = s;
                 mount_distance = d as f32;
             }
-            let zoom = self.max_zoom(
-                java_max(scale * distance, mount_scale * mount_distance),
-                &mut clip,
-            );
+            let vanilla = java_max(scale * distance, mount_scale * mount_distance);
+            let adjusted = adjust_distance(vanilla);
+            let distance = if adjusted.is_finite() && (0.0..=1024.0).contains(&adjusted) {
+                adjusted
+            } else {
+                vanilla
+            };
+            let zoom = self.max_zoom(distance, &mut clip);
             self.move_by(-zoom, 0.0, 0.0);
         } else if let Some(LivingCamera {
             sleeping: Some(bed),
@@ -969,6 +986,100 @@ mod tests {
         assert!(camera.position[2] > -1.1 && camera.position[2] < -0.9);
     }
     #[test]
+    fn detached_distance_override_keeps_collision_clipping() {
+        let entity = CameraEntity {
+            position: [0.0; 3],
+            previous: [0.0; 3],
+            x_rot: 0.0,
+            y_rot: 0.0,
+            x_rot_o: 0.0,
+            y_rot_o: 0.0,
+            eye_height: 1.62,
+            living: Some(LivingCamera {
+                scale: 2.0,
+                camera_distance: 3.0,
+                sleeping: None,
+                dead: None,
+            }),
+            mount: Some((3.0, 4.0)),
+        };
+        for kind in [CameraType::ThirdPersonBack, CameraType::ThirdPersonFront] {
+            let mut camera = Camera::default();
+            let mut calls = 0;
+            let mut rays = 0;
+            let z = if kind.is_mirrored() { 1.0 } else { -1.0 };
+            camera.align_with_entity_distance(
+                &entity,
+                1.0,
+                kind,
+                |distance| {
+                    assert_eq!(distance, 12.0);
+                    8.0
+                },
+                |_, _| None,
+            );
+            assert!((camera.position[2] - z * 8.0).abs() < 1e-5);
+            camera.align_with_entity_distance(
+                &entity,
+                1.0,
+                kind,
+                |distance| {
+                    calls += 1;
+                    assert_eq!(distance, 12.0);
+                    8.0
+                },
+                |_, _| {
+                    rays += 1;
+                    Some([0.0, 0.0, z])
+                },
+            );
+            assert_eq!((calls, rays), (1, 8));
+            assert!((camera.position[2] - z).abs() < 0.2);
+        }
+    }
+    #[test]
+    fn detached_distance_rejects_invalid_values_and_accepts_zero() {
+        let entity = CameraEntity {
+            position: [0.0; 3],
+            previous: [0.0; 3],
+            x_rot: 0.0,
+            y_rot: 0.0,
+            x_rot_o: 0.0,
+            y_rot_o: 0.0,
+            eye_height: 1.62,
+            living: None,
+            mount: None,
+        };
+        for distance in [f32::NAN, f32::INFINITY, -1.0, 1025.0] {
+            let mut camera = Camera::default();
+            camera.align_with_entity_distance(
+                &entity,
+                1.0,
+                CameraType::ThirdPersonBack,
+                |_| distance,
+                |_, _| None,
+            );
+            assert!((camera.position[2] + 4.0).abs() < 1e-6);
+        }
+        let mut camera = Camera::default();
+        camera.align_with_entity_distance(
+            &entity,
+            1.0,
+            CameraType::ThirdPersonBack,
+            |_| 0.0,
+            |_, _| None,
+        );
+        assert_eq!(camera.position, camera.eye);
+        camera.align_with_entity_distance(
+            &entity,
+            1.0,
+            CameraType::FirstPerson,
+            |_| panic!("first person has no detached distance"),
+            |_, _| None,
+        );
+        assert_eq!(camera.position, camera.eye);
+    }
+    #[test]
     fn fov_modifier_combines_speed_flight_and_bow() {
         let mut p = FovPlayer {
             flying: false,

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

@@ -29,6 +29,10 @@ pub type Signature = horizon_protocol::secure_chat::Signature;
 /// How long a message shows before a deletion replaces it
 /// (`ChatComponent.deleteMessageOrDelay`: `addedTime + 60`).
 const DELETION_DELAY: u64 = 60;
+/// The smooth chat extra: the ticks a new line takes to slide in and fade in,
+/// and how far left of its place it starts (GUI pixels).
+const INTRO_TICKS: f32 = 5.0;
+const INTRO_WIDTH: f32 = 12.0;
 
 /// `ChatVisiblity`: the Chat option's three values.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -233,14 +237,10 @@ impl Tag {
 
 /// `ChatComponent.AlphaCalculator.timeBased`: opaque for 180 ticks, then
 /// fading out quadratically over 20.
-fn time_alpha(ticks: u64, added: u64) -> f32 {
-    let delta = ticks as i64 - added as i64;
-    let mut t = delta as f64 / 200.0;
-    t = 1.0 - t;
-    t *= 10.0;
-    t = t.clamp(0.0, 1.0);
-    t *= t;
-    t as f32
+fn time_alpha(ticks: f32, added: u64) -> f32 {
+    let mut t = 1.0 - (ticks - added as f32) / 200.0;
+    t = (t * 10.0).clamp(0.0, 1.0);
+    t * t
 }
 #[derive(Default)]
 pub struct Chat {
@@ -256,6 +256,11 @@ pub struct Chat {
     scroll: usize,
     new_since_scroll: bool,
     pub options: ChatOptions,
+    /// The smooth chat extra: a new line slides in from the left while it
+    /// fades in, instead of appearing whole.
+    pub smooth: bool,
+    /// The smooth chat extra: no indicator bar at the left of a line.
+    pub hide_indicator: bool,
     /// Messages printed to stdout as `[CHAT]` (vanilla logs them).
     pub log: bool,
     /// Messages added since the start, for the control socket's events.
@@ -555,7 +560,7 @@ impl Chat {
     }
     /// `ChatComponent.extractRenderState` (background mode unless `focused`)
     /// on a screen `height` GUI pixels tall at `Hud.tickCount` `ticks`.
-    pub fn layout(&self, height: i32, ticks: u64, focused: bool) -> Vec<GuiDraw> {
+    pub fn layout(&self, height: i32, ticks: f32, focused: bool) -> Vec<GuiDraw> {
         let total = self.lines.len();
         if total == 0 {
             return Vec::new();
@@ -569,28 +574,47 @@ impl Chat {
         let entry_height = o.line_height();
         let bottom_to_text =
             (8.0 * (o.line_spacing + 1.0) - 4.0 * o.line_spacing + 0.5).floor() as i32;
+        // Vanilla's 200-tick fade reads the whole GUI ticks
+        // (`Gui.getGuiTicks`); only the smooth chat extra eases it per frame.
+        let fade_ticks = if self.smooth { ticks } else { ticks.floor() };
         let alpha_of = |line: &Line| {
             if focused {
                 1.0
             } else {
-                time_alpha(ticks, line.added)
+                time_alpha(fade_ticks, line.added)
             }
         };
+        // The smooth chat extra: how far into its intro a line is, 0 at the
+        // tick it was added and 1 once it has arrived, as (alpha, offset x).
+        let intro_of = |line: &Line| {
+            if focused || !self.smooth {
+                return (1.0, 0.0);
+            }
+            let t = ((ticks - line.added as f32) / INTRO_TICKS).clamp(0.0, 1.0);
+            let eased = 1.0 - (1.0 - t) * (1.0 - t);
+            (eased, (eased - 1.0) * INTRO_WIDTH)
+        };
         let visible = total
             .saturating_sub(self.scroll)
             .min(self.lines_per_page(focused));
-        let lines: Vec<(usize, &Line, f32)> = (0..visible)
+        let lines: Vec<(usize, &Line, f32, f32)> = (0..visible)
             .rev()
             .map(|i| (i, &self.lines[i + self.scroll]))
-            .map(|(i, line)| (i, line, alpha_of(line)))
-            .filter(|(_, _, alpha)| *alpha > 1.0e-5)
+            .map(|(i, line)| {
+                let (eased, slide) = intro_of(line);
+                (i, line, alpha_of(line) * eased, slide)
+            })
+            .filter(|(_, _, alpha, _)| *alpha > 1.0e-5)
             .collect();
         let mut out = vec![GuiDraw::Push(vec![
             PoseOp::Scale(scale, scale),
             PoseOp::Translate(4.0, 0.0),
         ])];
-        for &(i, _, alpha) in &lines {
+        for &(i, _, alpha, slide) in &lines {
             let bottom = chat_bottom - i as i32 * entry_height;
+            if slide != 0.0 {
+                out.push(GuiDraw::Push(vec![PoseOp::Translate(slide, 0.0)]));
+            }
             out.push(hud_layout::fill(
                 -4,
                 bottom - entry_height,
@@ -598,9 +622,15 @@ impl Chat {
                 bottom,
                 hud_layout::as8(alpha * background_opacity) << 24,
             ));
+            if slide != 0.0 {
+                out.push(GuiDraw::Pop);
+            }
         }
-        for &(i, line, alpha) in &lines {
+        for &(i, line, alpha, slide) in &lines {
             let bottom = chat_bottom - i as i32 * entry_height;
+            if slide != 0.0 {
+                out.push(GuiDraw::Push(vec![PoseOp::Translate(slide, 0.0)]));
+            }
             let opacity = alpha * text_opacity;
             let color = hud_layout::white(opacity);
             if color >> 24 != 0 {
@@ -612,7 +642,7 @@ impl Chat {
                     shadow: true,
                 });
             }
-            if let Some(tag) = &line.tag {
+            if let Some(tag) = line.tag.as_ref().filter(|_| !self.hide_indicator) {
                 let color = hud_layout::as8(opacity) << 24 | tag.color & 0xFF_FFFF;
                 out.push(hud_layout::fill(
                     -4,
@@ -622,6 +652,9 @@ impl Chat {
                     color,
                 ));
             }
+            if slide != 0.0 {
+                out.push(GuiDraw::Pop);
+            }
         }
         if focused {
             let count = lines.len() as i32;
@@ -658,7 +691,7 @@ impl Chat {
     }
     /// Draws [`Chat::layout`] into the HUD batch, and with the chat screen
     /// open the restricted prompt above the lines.
-    pub fn draw(&self, batch: &mut HudBatch, atlas: &HudAtlas, ticks: u64, focused: bool) {
+    pub fn draw(&self, batch: &mut HudBatch, atlas: &HudAtlas, ticks: f32, focused: bool) {
         let draws = self.layout(batch.height as i32, ticks, focused);
         hud_layout::paint(batch, atlas, &draws);
         if focused && self.abilities.any_restriction() {

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

@@ -39,6 +39,61 @@ fn add(chat: &mut Chat, font: &Font, content: Text) {
     }
 }
 
+#[test]
+fn smooth_chat_slides_a_line_in_and_can_hide_the_indicator() {
+    let mut chat = Chat {
+        smooth: true,
+        ..Chat::default()
+    };
+    chat.lines.push(Line {
+        added: 0,
+        content: Text::literal("hi"),
+        tag: Some(std::sync::Arc::new(Tag::system_single_player(
+            SYSTEM_INDICATOR,
+        ))),
+    });
+    let text_alpha = |draws: &[GuiDraw]| {
+        draws.iter().find_map(|d| match d {
+            GuiDraw::Text { color, .. } => Some(color >> 24),
+            _ => None,
+        })
+    };
+    // The slide is the negative translate the line carries while it moves.
+    let slide = |draws: &[GuiDraw]| {
+        draws.iter().find_map(|d| match d {
+            GuiDraw::Push(ops) => ops.iter().find_map(|op| match op {
+                PoseOp::Translate(x, _) if *x < 0.0 => Some(*x),
+                _ => None,
+            }),
+            _ => None,
+        })
+    };
+    // The tick it arrives: fully faded out, so nothing is drawn.
+    assert_eq!(text_alpha(&chat.layout(361, 0.0, false)), None);
+    // Halfway through the intro: left of its place and still faint.
+    let halfway = chat.layout(361, INTRO_TICKS / 2.0, false);
+    assert!(slide(&halfway).is_some_and(|x| (-INTRO_WIDTH..0.0).contains(&x)));
+    let faded = text_alpha(&halfway).expect("the line shows halfway through");
+    // Settled: in place and as opaque as vanilla's line.
+    let settled = chat.layout(361, INTRO_TICKS, false);
+    assert_eq!(slide(&settled), None);
+    assert!(text_alpha(&settled).expect("settled") > faded);
+    // The extra off draws the line whole on the tick it arrives, as vanilla.
+    chat.smooth = false;
+    let plain = chat.layout(361, 0.0, false);
+    assert_eq!(slide(&plain), None);
+    assert_eq!(text_alpha(&plain), text_alpha(&settled));
+    // The indicator bar is the -4 to -2 fill at the left of the line.
+    let bar = |draws: &[GuiDraw]| {
+        draws
+            .iter()
+            .any(|d| matches!(d, GuiDraw::Fill { x0: -4, x1: -2, .. }))
+    };
+    assert!(bar(&plain));
+    chat.hide_indicator = true;
+    assert!(!bar(&chat.layout(361, 0.0, false)));
+}
+
 #[test]
 fn clicking_seed_copies_the_raw_value_only_inside_the_link() {
     let font = font();
@@ -95,7 +150,7 @@ fn click_targets_match_rendered_spans_when_scaled_wrapped_and_scrolled() {
             for scroll in [0, 3, 12] {
                 chat.scroll = scroll;
                 let mut links = 0;
-                for draw in chat.layout(361, 0, true) {
+                for draw in chat.layout(361, 0.0, true) {
                     if let GuiDraw::Text { text, x, y, .. } = draw {
                         let mut at = x as f64;
                         for (c, style) in text.chars() {

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

@@ -233,6 +233,9 @@ pub struct SkullSkin {
     /// `ResolvableProfile.nameOrId` when the profile is `Dynamic` (a name or
     /// an id only): the key `skins::Resolver` resolves it by.
     pub dynamic: Option<NameOrId>,
+    /// `PlayerSkin.Patch.body`: the profile's `texture`, a resource pack
+    /// texture drawn instead of any skin.
+    pub texture: Option<String>,
     pub fallback: &'static str,
 }
 /// `Either<String, UUID>`: the key a `Dynamic` `ResolvableProfile` resolves

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

@@ -0,0 +1,662 @@
+//! OptiFine's Custom Item Textures (and CIT Resewn's): the rules of the enabled packs'
+//! `optifine/cit/**/*.properties`, read from the overlay resource root. The rules themselves are
+//! `horizon_optifine::cit`'s.
+
+pub use horizon_optifine::cit::{Hand, Kind, Rule};
+
+use horizon_client_core::component::name_text;
+use horizon_client_core::scoreboard::comp_text;
+use horizon_items::item_data::{canon_tag, encode_components};
+use horizon_items::items::ItemStack;
+use horizon_optifine::cit::{ComponentTest, Source, ValueTest};
+use horizon_optifine::{Properties, properties_files_in};
+use horizon_world::nbt::{JavaString, Tag, parse_snbt};
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::fs;
+use std::hash::{DefaultHasher, Hash, Hasher};
+use std::path::Path;
+use std::sync::Mutex;
+
+/// Every rule under the root's `optifine/cit/`, `mcpatcher/cit/` and CIT Resewn's
+/// `citresewn/cit/` folders, the one chosen first when several match first (`Rule::priority`).
+/// The pack's global `cit.properties` is not a rule.
+pub fn load_rules(root: &Path) -> Vec<Rule> {
+    let tops = ["optifine", "mcpatcher", "citresewn"];
+    let mut rules: Vec<Rule> = properties_files_in(root, &tops, "cit")
+        .into_iter()
+        .filter(|path| !path.ends_with("/cit.properties"))
+        .filter_map(|path| {
+            // Java reads `.properties` as Latin-1: a pack saved that way still loads.
+            let bytes = fs::read(root.join(&path)).ok()?;
+            let text = String::from_utf8(bytes)
+                .unwrap_or_else(|e| e.into_bytes().iter().map(|&b| char::from(b)).collect());
+            let rule = Rule::parse(&path, &Properties::parse_equals_first(&text), |p| {
+                root.join(p).is_file()
+            });
+            if rule.is_none() {
+                log::warn!("custom item textures: {path} is not a rule Horizon can read");
+            }
+            rule
+        })
+        .collect();
+    rules.sort_by(Rule::priority);
+    rules
+}
+
+/// The rules with an index by item and a cache of what each stack matched.
+#[derive(Debug, Default)]
+pub struct CitRules {
+    pub rules: Vec<Rule>,
+    /// Per kind (`Kind as usize`), the rules naming each item, in priority order.
+    by_item: [HashMap<String, Vec<u32>>; 4],
+    /// Enchantment rules without `items`, in priority order.
+    any_item: Vec<u32>,
+    /// Per rule, per component test: its literal read as SNBT and as a JSON text component.
+    literals: Vec<Vec<Prepared>>,
+    selected: Mutex<HashMap<u64, Option<u32>>>,
+    enchanted: Mutex<HashMap<u64, Vec<u32>>>,
+}
+
+#[derive(Debug, Default)]
+struct Prepared {
+    snbt: Option<Tag>,
+    json: Option<String>,
+}
+
+/// Cache entries kept before the cache starts over.
+const CACHE_LIMIT: usize = 4096;
+
+impl CitRules {
+    /// The enabled packs' rules under the overlay resource root.
+    pub fn load(root: &Path) -> Self {
+        Self::new(load_rules(root))
+    }
+
+    /// `rules` in priority order, the winner first.
+    pub fn new(rules: Vec<Rule>) -> Self {
+        let mut by_item: [HashMap<String, Vec<u32>>; 4] = Default::default();
+        let mut any_item = Vec::new();
+        for (i, rule) in rules.iter().enumerate() {
+            let i = i as u32;
+            if rule.kind == Kind::Enchantment && rule.items.is_empty() {
+                any_item.push(i);
+            }
+            for item in &rule.items {
+                let list = by_item[rule.kind as usize].entry(item.clone()).or_default();
+                if list.last() != Some(&i) {
+                    list.push(i);
+                }
+            }
+        }
+        let literals = rules
+            .iter()
+            .map(|r| r.components.iter().map(prepare).collect())
+            .collect();
+        Self {
+            rules,
+            by_item,
+            any_item,
+            literals,
+            ..Default::default()
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.rules.is_empty()
+    }
+
+    /// The winning rule of `kind` (Item, Armor or Elytra) for this stack, as an index into `rules`.
+    pub fn select(
+        &self,
+        kind: Kind,
+        stack: &ItemStack,
+        hand: Hand,
+        max_damage: u32,
+    ) -> Option<usize> {
+        let candidates = self.by_item[kind as usize].get(&*stack.item)?;
+        let comps = encode_components(stack);
+        let key = cache_key((0, kind, hand), stack, max_damage, comps.as_ref());
+        if let Some(hit) = lock(&self.selected).get(&key) {
+            return hit.map(|i| i as usize);
+        }
+        let found = candidates
+            .iter()
+            .copied()
+            .find(|&i| self.matches(i, stack, Some(hand), max_damage, comps.as_ref()));
+        remember(&self.selected, key, found);
+        found.map(|i| i as usize)
+    }
+
+    /// Every matching Enchantment rule, in priority order (layers are the glint PR's business).
+    pub fn enchantments(&self, stack: &ItemStack, max_damage: u32) -> Vec<usize> {
+        let named = self.by_item[Kind::Enchantment as usize]
+            .get(&*stack.item)
+            .map_or(&[][..], Vec::as_slice);
+        if named.is_empty() && self.any_item.is_empty() {
+            return Vec::new();
+        }
+        let comps = encode_components(stack);
+        let key = cache_key(
+            (1, Kind::Enchantment, Hand::Any),
+            stack,
+            max_damage,
+            comps.as_ref(),
+        );
+        let hit = lock(&self.enchanted).get(&key).cloned();
+        let found = hit.unwrap_or_else(|| {
+            let mut all: Vec<u32> = named.iter().chain(&self.any_item).copied().collect();
+            all.sort_unstable();
+            all.retain(|&i| self.matches(i, stack, None, max_damage, comps.as_ref()));
+            remember(&self.enchanted, key, all.clone());
+            all
+        });
+        found.into_iter().map(|i| i as usize).collect()
+    }
+
+    /// Whether rule `i` matches; `hand` None skips the hand test (enchantment glints).
+    fn matches(
+        &self,
+        i: u32,
+        stack: &ItemStack,
+        hand: Option<Hand>,
+        max_damage: u32,
+        comps: Option<&Tag>,
+    ) -> bool {
+        let rule = &self.rules[i as usize];
+        if hand.is_some_and(|h| rule.hand != Hand::Any && rule.hand != h) {
+            return false;
+        }
+        let count = i32::try_from(stack.count).unwrap_or(i32::MAX);
+        if rule.stack_size.as_ref().is_some_and(|r| !r.contains(count)) {
+            return false;
+        }
+        // CIT Resewn: only damageable items have damage.
+        let damage = if max_damage > 0 { stack.damage } else { 0 };
+        if rule
+            .damage
+            .as_ref()
+            .is_some_and(|d| !d.matches(damage, max_damage))
+        {
+            return false;
+        }
+        let enchantments = stack.crafting_enchantments();
+        let listed = |id: &str| rule.enchantments.iter().any(|e| e == id);
+        if !rule.enchantments.is_empty() && !enchantments.iter().any(|(id, _)| listed(id)) {
+            return false;
+        }
+        if let Some(levels) = &rule.enchantment_levels {
+            let level_in_range = enchantments.iter().any(|(id, level)| {
+                (rule.enchantments.is_empty() || listed(id))
+                    && levels.contains(i32::try_from(*level).unwrap_or(i32::MAX))
+            });
+            if !level_in_range {
+                return false;
+            }
+        }
+        let literals = &self.literals[i as usize];
+        rule.components
+            .iter()
+            .zip(literals)
+            .all(|(test, lit)| component_test(test, lit, stack, comps) != test.negate)
+    }
+}
+
+fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
+    m.lock().unwrap_or_else(|e| e.into_inner())
+}
+
+fn remember<V>(cache: &Mutex<HashMap<u64, V>>, key: u64, value: V) {
+    let mut cache = lock(cache);
+    if cache.len() >= CACHE_LIMIT {
+        cache.clear();
+    }
+    cache.insert(key, value);
+}
+
+/// What a cached answer depends on; `query` tells `select` from `enchantments`.
+fn cache_key(query: (u8, Kind, Hand), stack: &ItemStack, max: u32, comps: Option<&Tag>) -> u64 {
+    let mut h = DefaultHasher::new();
+    (query.0, query.1 as u8, query.2 as u8, &*stack.item).hash(&mut h);
+    (stack.count, stack.damage, max, comps).hash(&mut h);
+    h.finish()
+}
+
+fn prepare(test: &ComponentTest) -> Prepared {
+    let ValueTest::Literal(lit) = &test.value else {
+        return Prepared::default();
+    };
+    let text = lit.text.trim();
+    let snbt = match parse_snbt(text) {
+        Ok((tag, read)) if read == text.len() && text.starts_with(['{', '[']) => Some(tag),
+        _ => None,
+    };
+    let json = json_plain(text);
+    Prepared { snbt, json }
+}
+
+/// The plain text of `s` read as a JSON text component.
+fn json_plain(s: &str) -> Option<String> {
+    if !s.starts_with(['{', '[', '"']) {
+        return None;
+    }
+    let value: serde_json::Value = serde_json::from_str(s).ok()?;
+    Some(comp_text(&value).plain())
+}
+
+/// Whether one test passes, before its `negate`.
+fn component_test(
+    test: &ComponentTest,
+    lit: &Prepared,
+    stack: &ItemStack,
+    comps: Option<&Tag>,
+) -> bool {
+    let legacy;
+    let (root, text_depth) = match &test.source {
+        Source::Component(id) => {
+            let depth = match id.as_str() {
+                "minecraft:custom_name" | "minecraft:item_name" => Some(0),
+                "minecraft:lore" => Some(1),
+                _ => None,
+            };
+            (comps.and_then(|c| c.get(id)), depth)
+        }
+        Source::LegacyEnchantments { stored } => {
+            let levels = if *stored {
+                stack.stored_enchantments()
+            } else {
+                stack.enchantments()
+            };
+            legacy = Tag::List(
+                levels
+                    .iter()
+                    .map(|(id, lvl)| {
+                        let lvl = i16::try_from(*lvl).unwrap_or(i16::MAX);
+                        Tag::compound([
+                            ("id", Tag::String((&**id).into())),
+                            ("lvl", Tag::Short(lvl)),
+                        ])
+                    })
+                    .collect(),
+            );
+            (Some(&legacy), None)
+        }
+    };
+    // Fields the component leaves out when 0, which pre-1.20.5 items always wrote.
+    let defaulted;
+    let root = match (&test.source, root, test.path.first()) {
+        (Source::Component(id), Some(Tag::Compound(map)), Some(field))
+            if matches!(
+                (id.as_str(), field.as_str()),
+                ("minecraft:written_book_content", "generation")
+                    | ("minecraft:fireworks", "flight_duration")
+            ) && !map.contains_key(&JavaString::from(field.as_str())) =>
+        {
+            let mut map = map.clone();
+            map.insert(JavaString::from(field.as_str()), Tag::Int(0));
+            defaulted = Tag::Compound(map);
+            Some(&defaulted)
+        }
+        (_, root, _) => root,
+    };
+    let Some(root) = root else {
+        return matches!(test.value, ValueTest::Exists(false));
+    };
+    if let ValueTest::Exists(want) = test.value {
+        return walk(root, &test.path, 0, &mut |_, _| true) == want;
+    }
+    walk(root, &test.path, 0, &mut |tag, depth| {
+        value_test(&test.value, lit, tag, text_depth == Some(depth))
+    })
+}
+
+/// Visits what `path` reaches from `tag`, true once `visit` is.
+fn walk(
+    tag: &Tag,
+    path: &[String],
+    depth: usize,
+    visit: &mut dyn FnMut(&Tag, usize) -> bool,
+) -> bool {
+    let Some((seg, rest)) = path.split_first() else {
+        return visit(tag, depth);
+    };
+    let mut next = |t: &Tag| walk(t, rest, depth + 1, visit);
+    let len = match tag {
+        Tag::Compound(map) if seg == "*" => return map.values().any(&mut next),
+        Tag::Compound(map) => return map.get(&JavaString::from(seg.as_str())).is_some_and(next),
+        Tag::List(v) => v.len(),
+        Tag::ByteArray(v) => v.len(),
+        Tag::IntArray(v) => v.len(),
+        Tag::LongArray(v) => v.len(),
+        _ => return false,
+    };
+    let element = |i: usize| match tag {
+        Tag::List(v) => Cow::Borrowed(&v[i]),
+        Tag::ByteArray(v) => Cow::Owned(Tag::Byte(v[i] as i8)),
+        Tag::IntArray(v) => Cow::Owned(Tag::Int(v[i])),
+        Tag::LongArray(v) => Cow::Owned(Tag::Long(v[i])),
+        _ => Cow::Owned(Tag::End),
+    };
+    if seg == "count" {
+        return next(&Tag::Int(i32::try_from(len).unwrap_or(i32::MAX)));
+    }
+    if seg == "*" {
+        return (0..len).any(|i| next(&element(i)));
+    }
+    seg.parse::<usize>()
+        .ok()
+        .filter(|&i| i < len)
+        .is_some_and(|i| next(&element(i)))
+}
+
+fn int_value(tag: &Tag) -> Option<i64> {
+    match *tag {
+        Tag::Byte(v) => Some(v.into()),
+        Tag::Short(v) => Some(v.into()),
+        Tag::Int(v) => Some(v.into()),
+        Tag::Long(v) => Some(v),
+        _ => None,
+    }
+}
+
+/// A number as Java's `String.valueOf` writes it (`3`, `3.0`).
+fn decimal(tag: &Tag) -> Option<String> {
+    let s = match *tag {
+        Tag::Float(b) => f32::from_bits(b).to_string(),
+        Tag::Double(b) => f64::from_bits(b).to_string(),
+        _ => return int_value(tag).map(|v| v.to_string()),
+    };
+    Some(if s.contains(['.', 'e', 'N', 'i']) {
+        s
+    } else {
+        s + ".0"
+    })
+}
+
+/// `text` against a string, its JSON text, or the plain text of a text component.
+fn text_matches(tag: &Tag, is_text: bool, text: impl Fn(&str) -> bool) -> bool {
+    match tag {
+        Tag::String(s) => {
+            let s = s.to_string_lossy();
+            text(&s)
+                || (is_text && text(&name_text(tag).plain()))
+                || json_plain(&s).is_some_and(|p| text(&p))
+        }
+        Tag::Compound(_) | Tag::List(_) => is_text && text(&name_text(tag).plain()),
+        _ => false,
+    }
+}
+
+fn value_test(test: &ValueTest, lit: &Prepared, tag: &Tag, is_text: bool) -> bool {
+    match test {
+        ValueTest::Exists(_) => true,
+        ValueTest::Range(r) => {
+            int_value(tag).is_some_and(|v| i32::try_from(v).is_ok_and(|v| r.contains(v)))
+        }
+        ValueTest::Raw(name) => name.matches(&canon_tag(tag)),
+        ValueTest::Text(name) => match decimal(tag) {
+            Some(n) => name.matches(&n),
+            None => text_matches(tag, is_text, |s| name.matches(s)),
+        },
+        ValueTest::Literal(l) => match tag {
+            Tag::Float(b) => l.text.trim().parse::<f32>().ok() == Some(f32::from_bits(*b)),
+            Tag::Double(b) => l.float == Some(f64::from_bits(*b)),
+            Tag::Compound(_) | Tag::List(_)
+                if lit.snbt.as_ref().is_some_and(|e| contains(e, tag)) =>
+            {
+                true
+            }
+            _ => match int_value(tag) {
+                Some(v) => l.int == Some(v),
+                None => text_matches(tag, is_text, |s| {
+                    s == l.text || lit.json.as_deref() == Some(s)
+                }),
+            },
+        },
+    }
+}
+
+/// `NbtUtils.compareNbt(expected, actual, true)`: every key and element of `expected` found in
+/// `actual`.
+fn contains(expected: &Tag, actual: &Tag) -> bool {
+    match (expected, actual) {
+        (Tag::Compound(e), Tag::Compound(a)) => e
+            .iter()
+            .all(|(k, v)| a.get(k).is_some_and(|a| contains(v, a))),
+        (Tag::List(e), Tag::List(a)) if e.is_empty() => a.is_empty(),
+        (Tag::List(e), Tag::List(a)) => e.iter().all(|e| a.iter().any(|a| contains(e, a))),
+        _ => expected == actual,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Arc;
+
+    /// Rules from (file stem, properties), sorted as `load_rules` sorts them.
+    fn rules(files: &[(&str, &str)]) -> CitRules {
+        let mut rules: Vec<Rule> = files
+            .iter()
+            .map(|(stem, text)| {
+                let path = format!("assets/minecraft/optifine/cit/{stem}.properties");
+                let text = format!("texture=x\n{text}");
+                Rule::parse(&path, &Properties::parse_equals_first(&text), |_| true).unwrap()
+            })
+            .collect();
+        rules.sort_by(Rule::priority);
+        CitRules::new(rules)
+    }
+
+    fn stem(cit: &CitRules, i: Option<usize>) -> Option<&str> {
+        let path = &cit.rules[i?].path;
+        path.rsplit('/').next()?.strip_suffix(".properties")
+    }
+
+    fn item(cit: &CitRules, stack: ItemStack) -> Option<&str> {
+        stem(cit, cit.select(Kind::Item, &stack, Hand::Main, 0))
+    }
+
+    fn new(id: &str) -> ItemStack {
+        ItemStack::new(&format!("minecraft:{id}"), 1)
+    }
+
+    fn string(s: &str) -> Tag {
+        Tag::String(s.into())
+    }
+
+    fn with(id: &str, component: &str, tag: Tag) -> ItemStack {
+        let mut stack = new(id);
+        let component = format!("minecraft:{component}");
+        stack.data_mut().other.push((component, tag));
+        stack
+    }
+
+    fn enchanted(id: &str, levels: &[(&str, u32)]) -> ItemStack {
+        let mut stack = new(id);
+        let levels = levels
+            .iter()
+            .map(|(e, l)| (Arc::from(format!("minecraft:{e}")), *l));
+        stack.data_mut().enchantments = levels.collect();
+        stack
+    }
+
+    #[test]
+    fn heavier_rules_win_and_kinds_stay_apart() {
+        let cit = rules(&[
+            ("plain", "items=stick"),
+            ("heavy", "items=stick\nweight=2\nstackSize=2-"),
+            ("offhand", "items=stick\nweight=5\nhand=off"),
+            ("armor", "type=armor\nitems=stick"),
+            ("wings", "type=elytra"),
+        ]);
+        assert_eq!(item(&cit, new("stick")), Some("plain"));
+        assert_eq!(
+            item(&cit, ItemStack::new("minecraft:stick", 3)),
+            Some("heavy")
+        );
+        let pick = |kind, id, hand, max| stem(&cit, cit.select(kind, &new(id), hand, max));
+        assert_eq!(pick(Kind::Item, "stick", Hand::Off, 0), Some("offhand"));
+        assert_eq!(item(&cit, new("stone")), None);
+        assert_eq!(item(&cit, new("elytra")), None);
+        assert_eq!(pick(Kind::Elytra, "elytra", Hand::Main, 432), Some("wings"));
+        assert_eq!(pick(Kind::Armor, "stick", Hand::Main, 0), Some("armor"));
+    }
+
+    #[test]
+    fn names_match_by_their_plain_text() {
+        let cit = rules(&[
+            ("glob", "items=stick\nnbt.display.Name=ipattern:*sword"),
+            ("exact", "items=stone\ncomponents.custom_name=My Sword"),
+            ("json", "items=dirt\nnbt.display.Name=[\"My \",\"Sword\"]"),
+        ]);
+        let named = |id: &str, name: Tag| {
+            let mut stack = new(id);
+            stack.data_mut().custom_name = Some(name);
+            stack
+        };
+        let styled = Tag::compound([("text", string("My Sword")), ("color", string("red"))]);
+        assert_eq!(item(&cit, named("stick", styled.clone())), Some("glob"));
+        assert_eq!(item(&cit, named("stick", string("Blade"))), None);
+        assert_eq!(item(&cit, new("stick")), None);
+        assert_eq!(item(&cit, named("stone", styled.clone())), Some("exact"));
+        assert_eq!(item(&cit, named("dirt", styled)), Some("json"));
+    }
+
+    #[test]
+    fn lore_lines_and_list_counts() {
+        let cit = rules(&[
+            (
+                "any_line",
+                "items=stick\nnbt.display.Lore.*=ipattern:*legendary*",
+            ),
+            ("two_lines", "items=stone\ncomponents.lore.count=2"),
+        ]);
+        let bold = Tag::compound([("text", string("A LEGENDARY item")), ("bold", Tag::Byte(1))]);
+        let lore = Tag::List(vec![string("Common"), bold]);
+        assert_eq!(
+            item(&cit, with("stick", "lore", lore.clone())),
+            Some("any_line")
+        );
+        assert_eq!(item(&cit, with("stone", "lore", lore)), Some("two_lines"));
+        let one = Tag::List(vec![string("A legendary item")]);
+        assert_eq!(item(&cit, with("stone", "lore", one)), None);
+    }
+
+    #[test]
+    fn custom_data_existence_and_negation() {
+        let cit = rules(&[
+            (
+                "aote",
+                "items=stick\nweight=2\nnbt.ExtraAttributes.id=ASPECT_OF_THE_END",
+            ),
+            (
+                "not_hyp",
+                "items=stick\nweight=1\ncomponent.custom_data.ExtraAttributes.id=!HYP",
+            ),
+            ("unnamed", "items=stick\nnbt.display.Name=exists:false"),
+        ]);
+        let data = |id: &str| {
+            let attributes =
+                Tag::compound([("ExtraAttributes", Tag::compound([("id", string(id))]))]);
+            with("stick", "custom_data", attributes)
+        };
+        assert_eq!(item(&cit, data("ASPECT_OF_THE_END")), Some("aote"));
+        assert_eq!(item(&cit, data("MIDAS")), Some("not_hyp"));
+        assert_eq!(item(&cit, data("HYP")), Some("unnamed"));
+        let mut named = data("HYP");
+        named.data_mut().custom_name = Some(string("Hyperion"));
+        assert_eq!(item(&cit, named), None);
+    }
+
+    #[test]
+    fn legacy_enchantment_lists_and_model_data() {
+        let cit = rules(&[
+            (
+                "sharp",
+                "items=stick\nnbt.Enchantments.*.id=minecraft:sharpness\nnbt.Enchantments.0.lvl=5",
+            ),
+            ("cmd", "items=stone\nnbt.CustomModelData=3"),
+            (
+                "cmd_snbt",
+                "items=dirt\ncomponents.custom_model_data={floats:[3.0f]}",
+            ),
+        ]);
+        assert_eq!(
+            item(&cit, enchanted("stick", &[("sharpness", 5)])),
+            Some("sharp")
+        );
+        assert_eq!(item(&cit, enchanted("stick", &[("sharpness", 4)])), None);
+        let model = |id: &str, f: f32| {
+            let floats = Tag::List(vec![Tag::Float(f.to_bits()), Tag::Float(7f32.to_bits())]);
+            with(id, "custom_model_data", Tag::compound([("floats", floats)]))
+        };
+        assert_eq!(item(&cit, model("stone", 3.0)), Some("cmd"));
+        assert_eq!(item(&cit, model("stone", 3.5)), None);
+        assert_eq!(item(&cit, model("dirt", 3.0)), Some("cmd_snbt"));
+        assert_eq!(item(&cit, model("dirt", 2.0)), None);
+    }
+
+    #[test]
+    fn fields_left_out_at_zero_read_as_zero() {
+        let cit = rules(&[("zero", "items=firework_rocket\nnbt.Fireworks.Flight=0")]);
+        let mut rocket = new("firework_rocket");
+        rocket.data_mut().fireworks = Some((0, Vec::new()));
+        assert_eq!(item(&cit, rocket.clone()), Some("zero"));
+        rocket.data_mut().fireworks = Some((2, Vec::new()));
+        assert_eq!(item(&cit, rocket), None);
+    }
+
+    #[test]
+    fn damage_counts_only_for_damageable_items() {
+        let cit = rules(&[
+            ("worn", "items=diamond_sword\ndamage=50-100%"),
+            ("new", "items=stick\ndamage=0"),
+        ]);
+        let damaged = |id: &str, damage: u32, max: u32| {
+            let mut stack = new(id);
+            stack.damage = damage;
+            stem(&cit, cit.select(Kind::Item, &stack, Hand::Main, max))
+        };
+        // Half of 1561 is 780.5.
+        assert_eq!(damaged("diamond_sword", 780, 1561), None);
+        assert_eq!(damaged("diamond_sword", 781, 1561), Some("worn"));
+        assert_eq!(damaged("stick", 5, 0), Some("new"));
+    }
+
+    #[test]
+    fn enchantment_levels_and_rules_for_any_item() {
+        let cit = rules(&[
+            (
+                "sharp3",
+                "items=stick\nenchantments=sharpness\nenchantmentLevels=3-",
+            ),
+            ("any3", "items=stone\nenchantmentLevels=3-"),
+            ("glint", "type=enchantment\nenchantments=sharpness"),
+            (
+                "sword_glint",
+                "type=enchantment\nitems=diamond_sword\nweight=2",
+            ),
+        ]);
+        let mixed = [("sharpness", 2), ("unbreaking", 3)];
+        assert_eq!(item(&cit, enchanted("stick", &mixed)), None);
+        assert_eq!(
+            item(&cit, enchanted("stick", &[("sharpness", 4)])),
+            Some("sharp3")
+        );
+        assert_eq!(item(&cit, enchanted("stone", &mixed)), Some("any3"));
+        let glints = |stack: ItemStack| -> Vec<&str> {
+            let found = cit.enchantments(&stack, 0).into_iter();
+            found.map(|i| stem(&cit, Some(i)).unwrap()).collect()
+        };
+        let sharp = [("sharpness", 1)];
+        assert_eq!(
+            glints(enchanted("diamond_sword", &sharp)),
+            ["sword_glint", "glint"]
+        );
+        assert_eq!(glints(enchanted("stick", &sharp)), ["glint"]);
+        assert!(glints(new("stick")).is_empty());
+        // Glints are never an item's texture.
+        assert_eq!(item(&cit, enchanted("diamond_sword", &sharp)), None);
+    }
+}

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

@@ -1,7 +1,15 @@
 //! Cloud visibility and flat/fancy cell geometry (`CloudRenderer`).
+/// `EnvironmentAttributes.CLOUD_HEIGHT`'s default, and the overworld's `visual/cloud_height`.
+pub const CLOUD_HEIGHT: f64 = 192.33;
+
+/// Whether the cloud color has any packed alpha (vanilla gates the clouds on it).
+pub fn has_color(alpha: f32) -> bool {
+    (alpha.clamp(0.0, 1.0) * 255.0) as u8 > 0
+}
+
 /// `LevelRenderer`: skip OFF clouds and colors with no packed alpha.
 pub fn visible(mode: &str, alpha: f32) -> bool {
-    mode != "false" && (alpha.clamp(0.0, 1.0) * 255.0) as u8 > 0
+    mode != "false" && has_color(alpha)
 }
 
 /// `buildFlatCell`: bottom plane, in both windings for the culled cloud pipeline.
@@ -110,7 +118,7 @@ impl Input<'_> {
         z -= (z / th).floor() * th;
         let cell_x = (x / 12.0).floor() as i64;
         let cell_z = (z / 12.0).floor() as i64;
-        let bottom = (192.33 - self.camera.y) as f32;
+        let bottom = (CLOUD_HEIGHT - self.camera.y) as f32;
         let key = MeshKey {
             cell_x,
             cell_z,

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

@@ -0,0 +1,724 @@
+//! OptiFine connected textures (`optifine/ctm`) at mesh time. The active packs' rules are read
+//! once at load, their tiles become sprite layers, and each block state and sprite layer gets
+//! the short list of rules that can touch it; meshing a face then walks only those lists
+//! ([`ConnectedTextures::pick`]). Without CTM files there are no rules and nothing changes.
+//!
+//! The rules and the tile geometry are `horizon_optifine::ctm`'s.
+
+use crate::sprites::Sprites;
+use horizon_optifine::ctm::{
+    self, Connect, Method, Orient, Rule, Tile,
+    connect::{self as geometry, Axes, Axis, Face},
+};
+use horizon_world::block_state_properties::BlockProperties;
+use horizon_world::registry::{BlockRegistry, BlockStateId};
+use std::{collections::HashMap, path::Path};
+
+/// A tile as the mesher draws it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TileLayer {
+    Layer {
+        layer: u16,
+        /// The sprite has fractional alpha (drawn in the translucent pass).
+        translucent: bool,
+        /// Every texel is opaque (drawn without an alpha test).
+        opaque: bool,
+    },
+    /// Try the next rule.
+    Skip,
+    /// The face's own sprite.
+    Default,
+}
+
+/// What a face draws.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Pick {
+    /// Its own sprite.
+    Keep,
+    Tile(TileLayer),
+    /// `ctm_compact`: a tile per quarter of the sprite (top-left, top-right, bottom-left,
+    /// bottom-right).
+    Quarters([TileLayer; 4]),
+}
+
+struct LoadedRule {
+    rule: Rule,
+    tiles: Vec<TileLayer>,
+}
+
+#[derive(Clone, Copy, Default)]
+struct StateInfo {
+    /// Index of the state's block (`connect=block`).
+    block: u32,
+    axis: Option<Axis>,
+    /// `half=upper`: `linked` random tiles follow the lower half.
+    upper: bool,
+}
+
+#[derive(Default)]
+pub struct ConnectedTextures {
+    rules: Vec<LoadedRule>,
+    /// By block state, then by sprite layer: ranges of `lists` (rule indices, in rule order).
+    by_state: Vec<(u32, u32)>,
+    by_layer: Vec<(u32, u32)>,
+    lists: Vec<u16>,
+    states: Vec<StateInfo>,
+    /// By block state: the sprite of its model's face on each side (`connect=tile`); empty
+    /// when no rule connects by tile.
+    face_layers: Vec<[u16; 6]>,
+}
+
+/// `list` appended to `lists`, as its range there.
+fn push_list(lists: &mut Vec<u16>, list: &[u16]) -> (u32, u32) {
+    let start = lists.len() as u32;
+    lists.extend_from_slice(list);
+    (start, list.len() as u32)
+}
+
+/// The sprite name of a texture resource path: `ns:path` under `textures/`, else the path
+/// itself (as [`Sprites::insert_file`] names a tile).
+fn sprite_name(resource: &str) -> String {
+    let parts = resource
+        .strip_prefix("assets/")
+        .and_then(|p| p.split_once('/'))
+        .and_then(|(ns, p)| Some((ns, p.strip_prefix("textures/")?.strip_suffix(".png")?)));
+    match parts {
+        Some((ns, path)) => format!("{ns}:{path}"),
+        None => resource.to_owned(),
+    }
+}
+
+impl ConnectedTextures {
+    /// The rules under `root`, with their tiles inserted into `sprites` (before it finishes).
+    /// `face_layer` answers a block state's sprite on a side, for rules that connect by tile.
+    pub fn load(
+        root: &Path,
+        registry: &BlockRegistry,
+        sprites: &mut Sprites,
+        mut face_layer: impl FnMut(BlockStateId, Face) -> Option<u32>,
+    ) -> Self {
+        let mut rules = ctm::load(root);
+        // Rules no face can use load no tiles: overlays (not drawn yet), and custom names (section
+        // meshes see no block entity).
+        rules.retain(|r| !r.method.is_overlay() && r.name.is_none());
+        // Rule indices are `u16`.
+        rules.truncate(usize::from(u16::MAX));
+        if rules.is_empty() {
+            return Self::default();
+        }
+        let loaded = rules
+            .into_iter()
+            .filter_map(|rule| {
+                let tiles = rule
+                    .tiles
+                    .iter()
+                    .map(|tile| match tile {
+                        Tile::Skip => Ok(TileLayer::Skip),
+                        Tile::Default => Ok(TileLayer::Default),
+                        Tile::Texture(path) => {
+                            // A tile among the textures is that sprite, under its own name.
+                            let layer = match sprite_name(path) {
+                                name if name != *path => sprites.insert(root, &name)?,
+                                _ => sprites.insert_file(root, path)?,
+                            };
+                            Ok(TileLayer::Layer {
+                                layer: u16::try_from(layer)?,
+                                translucent: sprites.translucent[layer as usize],
+                                opaque: sprites.opaque[layer as usize],
+                            })
+                        }
+                    })
+                    .collect::<crate::Result<Vec<_>>>();
+                match tiles {
+                    Ok(tiles) => Some(LoadedRule { rule, tiles }),
+                    Err(e) => {
+                        log::warn!("Horizon: connected textures {}: a tile: {e}", rule.path);
+                        None
+                    }
+                }
+            })
+            .collect();
+        let states = (0..registry.len() as u32).map(|id| {
+            registry
+                .state(BlockStateId(id))
+                .map(|s| (s.name.as_str(), &s.properties))
+        });
+        let mut out = Self::build(loaded, states, |name| sprites.layers.get(name).copied());
+        if out.rules.iter().any(|r| r.rule.connect == Connect::Tile) {
+            out.face_layers = (0..registry.len() as u32)
+                .map(|id| {
+                    Face::ALL
+                        .map(|f| face_layer(BlockStateId(id), f).map_or(u16::MAX, |l| l as u16))
+                })
+                .collect();
+        }
+        out
+    }
+
+    /// The lookups for `rules` (already ordered) over every block state (`None` for an id the
+    /// registry skips), `layer` answering a sprite name's layer.
+    fn build<'a>(
+        rules: Vec<LoadedRule>,
+        states: impl Iterator<Item = Option<(&'a str, &'a BlockProperties)>>,
+        layer: impl Fn(&str) -> Option<u32>,
+    ) -> Self {
+        let mut out = Self {
+            rules,
+            ..Self::default()
+        };
+        let mut blocks = HashMap::new();
+        let mut by_layer: Vec<Vec<u16>> = Vec::new();
+        // Block rules by the block each entry names, so a state tests only its own.
+        let mut by_block: HashMap<&str, Vec<u16>> = HashMap::new();
+        for (i, r) in out.rules.iter().enumerate() {
+            let i = i as u16;
+            for tile in &r.rule.match_tiles {
+                if let Some(l) = layer(&sprite_name(tile)) {
+                    let l = l as usize;
+                    if by_layer.len() <= l {
+                        by_layer.resize(l + 1, Vec::new());
+                    }
+                    if by_layer[l].last() != Some(&i) {
+                        by_layer[l].push(i);
+                    }
+                }
+            }
+            for m in &r.rule.match_blocks {
+                let list = by_block.entry(m.id.as_str()).or_default();
+                if list.last() != Some(&i) {
+                    list.push(i);
+                }
+            }
+        }
+        for list in by_layer {
+            let range = push_list(&mut out.lists, &list);
+            out.by_layer.push(range);
+        }
+        let mut list = Vec::new();
+        for state in states {
+            let Some((name, props)) = state else {
+                out.by_state.push((0, 0));
+                out.states.push(StateInfo::default());
+                continue;
+            };
+            let next = blocks.len() as u32;
+            let block = *blocks.entry(name).or_insert(next);
+            let prop = |k: &str| props.get(k).map(String::as_str);
+            out.states.push(StateInfo {
+                block,
+                axis: match prop("axis") {
+                    Some("x") => Some(Axis::X),
+                    Some("y") => Some(Axis::Y),
+                    Some("z") => Some(Axis::Z),
+                    _ => None,
+                },
+                upper: prop("half") == Some("upper"),
+            });
+            list.clear();
+            if let Some(candidates) = by_block.get(name) {
+                list.extend(
+                    candidates
+                        .iter()
+                        .filter(|&&i| out.rules[usize::from(i)].rule.matches_block(name, prop)),
+                );
+            }
+            let range = push_list(&mut out.lists, &list);
+            out.by_state.push(range);
+        }
+        out
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.rules.is_empty()
+    }
+
+    fn list(&self, ranges: &[(u32, u32)], i: usize) -> &[u16] {
+        ranges.get(i).map_or(&[], |&(start, len)| {
+            &self.lists[start as usize..(start + len) as usize]
+        })
+    }
+
+    /// What the `face` of the block `state` at `pos` draws, for a quad with sprite `layer`.
+    /// `neighbour` answers the state at an offset from the block; `biome` its biome, asked only
+    /// by rules that test one.
+    pub fn pick<'b>(
+        &self,
+        state: u32,
+        layer: u16,
+        face: Face,
+        pos: [i32; 3],
+        neighbour: impl Fn([i32; 3]) -> u32,
+        biome: impl Fn() -> Option<&'b str>,
+    ) -> Pick {
+        let (mut by_state, mut by_layer) = (
+            self.list(&self.by_state, state as usize),
+            self.list(&self.by_layer, layer as usize),
+        );
+        // Both lists are in rule order: walk them as one. A rule naming blocks and tiles needs
+        // both (it is in both lists); one naming either needs that one.
+        loop {
+            let (i, block, tile) = match (by_state.split_first(), by_layer.split_first()) {
+                (None, None) => return Pick::Keep,
+                (Some((&x, rest)), Some((&y, other))) if x == y => {
+                    (by_state, by_layer) = (rest, other);
+                    (x, true, true)
+                }
+                (Some((&x, rest)), Some((&y, _))) if x < y => {
+                    by_state = rest;
+                    (x, true, false)
+                }
+                (Some((&x, rest)), None) => {
+                    by_state = rest;
+                    (x, true, false)
+                }
+                (_, Some((&y, rest))) => {
+                    by_layer = rest;
+                    (y, false, true)
+                }
+            };
+            let r = &self.rules[usize::from(i)];
+            if (block || r.rule.match_blocks.is_empty())
+                && (tile || r.rule.match_tiles.is_empty())
+                && let Some(pick) = self.apply(r, state, layer, face, pos, &neighbour, &biome)
+            {
+                return pick;
+            }
+        }
+    }
+
+    /// One rule on a face: `None` when it doesn't apply or picks `<skip>`.
+    #[allow(clippy::too_many_arguments)]
+    fn apply<'b>(
+        &self,
+        r: &LoadedRule,
+        state: u32,
+        layer: u16,
+        face: Face,
+        pos: [i32; 3],
+        neighbour: &impl Fn([i32; 3]) -> u32,
+        biome: &impl Fn() -> Option<&'b str>,
+    ) -> Option<Pick> {
+        let rule = &r.rule;
+        // `Rule::applies_at`, with the biome looked up only for rules that test one. Rules with
+        // a custom name are not loaded.
+        if rule.faces & face.bit() == 0
+            || rule.heights.as_ref().is_some_and(|h| !h.contains(pos[1]))
+        {
+            return None;
+        }
+        if let Some(biomes) = &rule.biomes
+            && !biome().is_some_and(|b| biomes.matches(b))
+        {
+            return None;
+        }
+        let info = self.states.get(state as usize).copied().unwrap_or_default();
+        let joins = |offset: [i32; 3]| {
+            let other = neighbour(offset);
+            match rule.connect {
+                Connect::Block => {
+                    self.states.get(other as usize).map(|s| s.block) == Some(info.block)
+                }
+                Connect::State => other == state,
+                Connect::Tile => self
+                    .face_layers
+                    .get(other as usize)
+                    .is_some_and(|f| f[face as usize] == layer),
+            }
+        };
+        let axes = |face| match (rule.orient, info.axis) {
+            (Orient::StateAxis, Some(axis)) => Axes::column(face, axis),
+            // `orient=texture` follows the quad's own UVs; vanilla cubes are what it is used on.
+            _ => Axes::cube(face),
+        };
+        let mask = || geometry::neighbours(axes(face), face.normal(), rule.inner_seams, joins);
+        let tile = |i: usize| r.tiles.get(i).copied().unwrap_or(TileLayer::Default);
+        let index = match rule.method {
+            Method::Ctm => geometry::ctm_index(mask()),
+            Method::CtmCompact => {
+                let mask = mask();
+                let case = geometry::ctm_index(mask) as u8;
+                match rule.compact_overrides.iter().find(|&&(c, _)| c == case) {
+                    Some(&(_, t)) => t,
+                    None => {
+                        let quarters = geometry::compact_quarters(mask).map(|q| tile(q.into()));
+                        return if quarters.contains(&TileLayer::Skip) {
+                            None
+                        } else {
+                            Some(Pick::Quarters(quarters))
+                        };
+                    }
+                }
+            }
+            Method::Horizontal => geometry::horizontal(mask()),
+            Method::Vertical => geometry::vertical(mask()),
+            Method::HorizontalVertical => geometry::horizontal_vertical(mask()),
+            Method::VerticalHorizontal => geometry::vertical_horizontal(mask()),
+            Method::Top => {
+                // Only sides join the block above: the top and bottom go on to the next rule.
+                if matches!(face, Face::Up | Face::Down) {
+                    return None;
+                }
+                if !joins([0, 1, 0]) {
+                    return Some(Pick::Keep);
+                }
+                0
+            }
+            Method::Fixed => 0,
+            Method::Random => {
+                let face = geometry::symmetric_face(face, rule.symmetry);
+                let pos = if rule.linked && info.upper {
+                    [pos[0], pos[1] - 1, pos[2]]
+                } else {
+                    pos
+                };
+                geometry::random_index(pos, face, rule.random_loops, &rule.weights, r.tiles.len())
+            }
+            Method::Repeat => {
+                let face = geometry::symmetric_face(face, rule.symmetry);
+                geometry::repeat_index(pos, axes(face), rule.width, rule.height)
+            }
+            // Overlays are not loaded yet.
+            _ => return None,
+        };
+        match tile(index) {
+            TileLayer::Skip => None,
+            TileLayer::Default => Some(Pick::Keep),
+            t => Some(Pick::Tile(t)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_optifine::Properties;
+
+    /// A tile whose layer says which tile of its rule it is: rule `r`'s tile `i` is layer
+    /// `1000 * (r + 1) + i`.
+    fn rules(files: &[(&str, &str)]) -> Vec<LoadedRule> {
+        let mut rules: Vec<Rule> = files
+            .iter()
+            .map(|(path, text)| {
+                Rule::parse(
+                    &format!("assets/minecraft/optifine/ctm/{path}"),
+                    &Properties::parse(text),
+                )
+                .unwrap()
+                .unwrap()
+            })
+            .collect();
+        ctm::sort(&mut rules);
+        rules
+            .into_iter()
+            .enumerate()
+            .map(|(n, rule)| LoadedRule {
+                tiles: rule
+                    .tiles
+                    .iter()
+                    .enumerate()
+                    .map(|(i, t)| match t {
+                        Tile::Skip => TileLayer::Skip,
+                        Tile::Default => TileLayer::Default,
+                        Tile::Texture(_) => TileLayer::Layer {
+                            layer: (1000 * (n + 1) + i) as u16,
+                            translucent: false,
+                            opaque: false,
+                        },
+                    })
+                    .collect(),
+                rule,
+            })
+            .collect()
+    }
+
+    /// State 0 air, 1 glass, 2 stone, 3 and 4 oak logs (axis y, x), 5 and 6 a door (lower,
+    /// upper); the stone sprite is layer 7.
+    fn world(files: &[(&str, &str)]) -> ConnectedTextures {
+        let props = |pairs: &[(&str, &str)]| -> BlockProperties {
+            pairs
+                .iter()
+                .map(|(k, v)| (k.to_string(), v.to_string()))
+                .collect()
+        };
+        let states = [
+            ("minecraft:air", props(&[])),
+            ("minecraft:glass", props(&[])),
+            ("minecraft:stone", props(&[])),
+            ("minecraft:oak_log", props(&[("axis", "y")])),
+            ("minecraft:oak_log", props(&[("axis", "x")])),
+            ("minecraft:oak_door", props(&[("half", "lower")])),
+            ("minecraft:oak_door", props(&[("half", "upper")])),
+        ];
+        ConnectedTextures::build(
+            rules(files),
+            states.iter().map(|(n, p)| Some((*n, p))),
+            |name| (name == "minecraft:block/stone").then_some(7),
+        )
+    }
+
+    fn tile(layer: u16) -> Pick {
+        Pick::Tile(TileLayer::Layer {
+            layer,
+            translucent: false,
+            opaque: false,
+        })
+    }
+
+    /// `pick` on `face` of the block at the origin among `blocks` (offset, state).
+    fn pick_in(
+        ctm: &ConnectedTextures,
+        state: u32,
+        layer: u16,
+        face: Face,
+        blocks: &[([i32; 3], u32)],
+    ) -> Pick {
+        let at = |o: [i32; 3]| blocks.iter().find(|(p, _)| *p == o).map_or(0, |b| b.1);
+        ctm.pick(state, layer, face, [0, 64, 0], at, || None)
+    }
+
+    const GLASS: &str = "matchBlocks=glass\nmethod=ctm\ntiles=0-46";
+
+    #[test]
+    fn glass_joins_its_neighbours() {
+        let ctm = world(&[("glass.properties", GLASS)]);
+        // Alone: tile 0. A north face's right is west: glass there is the left end of a row.
+        assert_eq!(pick_in(&ctm, 1, 3, Face::North, &[]), tile(1000));
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([-1, 0, 0], 1)]),
+            tile(1001)
+        );
+        // Glass all around in the face's plane: the middle tile, 26.
+        let ring: Vec<_> = [-1, 0, 1]
+            .into_iter()
+            .flat_map(|x| [-1, 0, 1].map(|y| ([x, y, 0], 1)))
+            .collect();
+        assert_eq!(pick_in(&ctm, 1, 3, Face::North, &ring), tile(1026));
+        // Stone beside it doesn't join; stone has no rule.
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([-1, 0, 0], 2)]),
+            tile(1000)
+        );
+        assert_eq!(pick_in(&ctm, 2, 7, Face::North, &[]), Pick::Keep);
+    }
+
+    #[test]
+    fn rule_order_faces_and_skips() {
+        let ctm = world(&[
+            (
+                "a_sides.properties",
+                "matchBlocks=stone\nmethod=fixed\ntiles=<skip>\nfaces=sides",
+            ),
+            ("b_glass.properties", GLASS),
+            ("stone.properties", "method=fixed\ntiles=x\nfaces=top"),
+            ("z.properties", "matchBlocks=stone\nmethod=fixed\ntiles=y"),
+        ]);
+        // The tile rule (stone.properties, by its file name) comes first, on the top face only.
+        assert_eq!(pick_in(&ctm, 2, 7, Face::Up, &[]), tile(1000));
+        // Sides: a_sides skips, so z draws.
+        assert_eq!(pick_in(&ctm, 2, 7, Face::North, &[]), tile(4000));
+        // The tile rule follows the sprite, whatever the block: glass with the stone sprite.
+        assert_eq!(pick_in(&ctm, 1, 7, Face::Up, &[]), tile(1000));
+    }
+
+    #[test]
+    fn compact_quarters_and_overrides() {
+        let ctm = world(&[(
+            "glass.properties",
+            "matchBlocks=glass\nmethod=ctm_compact\ntiles=0-5\nctm.1=5",
+        )]);
+        let layer = |i: u16| TileLayer::Layer {
+            layer: 1000 + i,
+            translucent: false,
+            opaque: false,
+        };
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[]),
+            Pick::Quarters([layer(0); 4])
+        );
+        // Joined right only is case 1, replaced whole by tile 5.
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([-1, 0, 0], 1)]),
+            tile(1005)
+        );
+        // Joined left only (east of a north face): quarters [3, 0, 3, 0].
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([1, 0, 0], 1)]),
+            Pick::Quarters([layer(3), layer(0), layer(3), layer(0)])
+        );
+    }
+
+    #[test]
+    fn logs_turn_with_their_axis() {
+        let ctm = world(&[(
+            "log.properties",
+            "matchBlocks=oak_log\nmethod=vertical\ntiles=0-3",
+        )]);
+        // An upright log with a log above: the bottom of a column.
+        assert_eq!(
+            pick_in(&ctm, 3, 3, Face::North, &[([0, 1, 0], 3)]),
+            tile(1000)
+        );
+        // A log lying along x: on its north face the texture's up points east, so a log to the
+        // east (same block, other axis state) is above it.
+        assert_eq!(
+            pick_in(&ctm, 4, 3, Face::North, &[([1, 0, 0], 4)]),
+            tile(1000)
+        );
+        assert_eq!(
+            pick_in(&ctm, 4, 3, Face::North, &[([0, 1, 0], 4)]),
+            tile(1003)
+        );
+    }
+
+    #[test]
+    fn top_and_connect_state() {
+        let ctm = world(&[(
+            "block_oak_log.properties",
+            "method=top\ntiles=0\nconnect=state",
+        )]);
+        assert_eq!(
+            pick_in(&ctm, 3, 3, Face::North, &[([0, 1, 0], 3)]),
+            tile(1000)
+        );
+        // The other axis is another state.
+        assert_eq!(
+            pick_in(&ctm, 3, 3, Face::North, &[([0, 1, 0], 4)]),
+            Pick::Keep
+        );
+        assert_eq!(pick_in(&ctm, 3, 3, Face::Up, &[([0, 1, 0], 3)]), Pick::Keep);
+    }
+
+    #[test]
+    fn linked_random_follows_the_lower_half() {
+        let ctm = world(&[(
+            "door.properties",
+            "matchBlocks=oak_door\nmethod=random\ntiles=0-7\nlinked=true",
+        )]);
+        let mut tiles = std::collections::HashSet::new();
+        for x in 0..20 {
+            let lower = ctm.pick(5, 3, Face::North, [x, 64, 0], |_| 0, || None);
+            let upper = ctm.pick(6, 3, Face::North, [x, 65, 0], |_| 0, || None);
+            assert_eq!(lower, upper, "{x}");
+            tiles.insert(format!("{lower:?}"));
+        }
+        assert!(tiles.len() > 3, "the doors are not all alike");
+    }
+
+    #[test]
+    fn heights_and_biomes() {
+        let ctm = world(&[(
+            "glass.properties",
+            "matchBlocks=glass\nmethod=fixed\ntiles=0\nheights=0-63\nbiomes=desert",
+        )]);
+        let at =
+            |y, biome: &'static str| ctm.pick(1, 3, Face::Up, [0, y, 0], |_| 0, || Some(biome));
+        assert_eq!(at(10, "minecraft:desert"), tile(1000));
+        assert_eq!(at(64, "minecraft:desert"), Pick::Keep);
+        assert_eq!(at(10, "minecraft:plains"), Pick::Keep);
+    }
+
+    #[test]
+    fn connect_by_tile_reads_the_neighbours_same_side() {
+        let mut ctm = world(&[(
+            "glass.properties",
+            "matchBlocks=glass\nmethod=horizontal\nconnect=tile\ntiles=0-3",
+        )]);
+        // Stone shows the glass sprite (3) on its north side; the door only on its south.
+        let mut faces = vec![[9u16; 6]; 7];
+        faces[1][Face::North as usize] = 3;
+        faces[2][Face::North as usize] = 3;
+        faces[5][Face::South as usize] = 3;
+        ctm.face_layers = faces;
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([-1, 0, 0], 2)]),
+            tile(1000)
+        );
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([-1, 0, 0], 5)]),
+            tile(1003)
+        );
+    }
+
+    #[test]
+    fn repeat_and_rows_then_columns() {
+        let ctm = world(&[(
+            "glass.properties",
+            "matchBlocks=glass\nmethod=repeat\nwidth=2\nheight=2\ntiles=0-3",
+        )]);
+        let at = |pos| ctm.pick(1, 3, Face::North, pos, |_| 0, || None);
+        assert_eq!(at([0, 64, 0]), tile(1000));
+        // The north face's right is west; rows run down.
+        assert_eq!(at([-1, 64, 0]), tile(1001));
+        assert_eq!(at([0, 63, 0]), tile(1002));
+        let hv = world(&[(
+            "glass.properties",
+            "matchBlocks=glass\nmethod=horizontal+vertical\ntiles=0-6",
+        )]);
+        // Alone in its row, glass above: the column's bottom, tile 4.
+        assert_eq!(
+            pick_in(&hv, 1, 3, Face::North, &[([0, 1, 0], 1)]),
+            tile(1004)
+        );
+        assert_eq!(
+            pick_in(&hv, 1, 3, Face::North, &[([-1, 0, 0], 1)]),
+            tile(1000)
+        );
+    }
+
+    #[test]
+    fn skips_defaults_and_narrowed_rules() {
+        let ctm = world(&[
+            (
+                "a.properties",
+                "matchBlocks=glass\nmethod=ctm_compact\ntiles=<skip> 1-4",
+            ),
+            (
+                "b.properties",
+                "matchBlocks=glass\nmethod=fixed\ntiles=0\nfaces=sides",
+            ),
+            (
+                "c.properties",
+                "matchBlocks=glass\nmethod=fixed\ntiles=<default>",
+            ),
+            ("d.properties", "matchBlocks=glass\nmethod=fixed\ntiles=0"),
+            (
+                "e.properties",
+                "matchBlocks=stone\nmatchTiles=glass_pane_top\nmethod=fixed\ntiles=0",
+            ),
+        ]);
+        // e names a tile, so it is tried first (tile 1000s), but needs a stone with the pane
+        // sprite. a's skipped quarter drops it; b (3000s) draws the sides; on top c draws the
+        // glass itself, which stops d.
+        assert_eq!(pick_in(&ctm, 1, 3, Face::North, &[]), tile(3000));
+        assert_eq!(pick_in(&ctm, 1, 3, Face::Up, &[]), Pick::Keep);
+        assert_eq!(pick_in(&ctm, 2, 7, Face::Up, &[]), Pick::Keep);
+        let both = world(&[(
+            "e.properties",
+            "matchBlocks=glass\nmatchTiles=stone\nmethod=fixed\ntiles=0",
+        )]);
+        assert_eq!(pick_in(&both, 1, 7, Face::Up, &[]), tile(1000));
+        assert_eq!(pick_in(&both, 1, 3, Face::Up, &[]), Pick::Keep);
+        assert_eq!(pick_in(&both, 2, 7, Face::Up, &[]), Pick::Keep);
+        // `top` passes the top face on.
+        let top = world(&[
+            ("block_glass.properties", "method=top\ntiles=0"),
+            (
+                "z.properties",
+                "matchBlocks=glass\nmethod=fixed\ntiles=0\nfaces=top",
+            ),
+        ]);
+        assert_eq!(pick_in(&top, 1, 3, Face::Up, &[]), tile(2000));
+    }
+
+    #[test]
+    fn sprite_names() {
+        assert_eq!(
+            sprite_name("assets/minecraft/textures/block/dirt.png"),
+            "minecraft:block/dirt"
+        );
+        assert_eq!(
+            sprite_name("assets/minecraft/optifine/ctm/glass/0.png"),
+            "assets/minecraft/optifine/ctm/glass/0.png"
+        );
+    }
+}

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

@@ -9,6 +9,59 @@ pub use crate::chunk::block_entity::{
 use crate::items::ItemStack;
 use std::collections::HashMap;
 
+/// a content mod's menu type (`data/<id>/horizon/menu/`, vanilla's
+/// `MenuType`): its container slots, its data slots (`ContainerData`) and the
+/// slots players only take from.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ModMenuType {
+    pub id: &'static str,
+    pub slots: usize,
+    pub data_slots: usize,
+    pub results: Vec<usize>,
+}
+
+static MOD_MENU_TYPES: std::sync::OnceLock<Vec<ModMenuType>> = std::sync::OnceLock::new();
+
+/// registers the content mods' menu types, `(id, slots, data slots,
+/// results)`, a list set once per process (false when it already was).
+pub fn register_mod_menu_types(
+    menus: impl IntoIterator<Item = (String, usize, usize, Vec<usize>)>,
+) -> bool {
+    if MOD_MENU_TYPES.get().is_some() {
+        return false;
+    }
+    let menus = menus
+        .into_iter()
+        .map(|(id, slots, data_slots, results)| ModMenuType {
+            id: Box::leak(id.into_boxed_str()),
+            slots,
+            data_slots,
+            results,
+        });
+    MOD_MENU_TYPES.set(menus.collect()).is_ok()
+}
+
+/// the content mods' menu types, in registry order.
+pub fn mod_menu_types() -> &'static [ModMenuType] {
+    MOD_MENU_TYPES.get().map_or(&[], Vec::as_slice)
+}
+
+/// the mod menu type named `id`, kept out of line: a vanilla menu never
+/// looks one up.
+#[cold]
+#[inline(never)]
+pub fn mod_menu_type(id: &str) -> Option<&'static ModMenuType> {
+    mod_menu_types().iter().find(|m| m.id == id)
+}
+
+/// whether a client of `brand` can be sent menu type `menu`: a vanilla
+/// client reads the type through `ByteBufCodecs.registry(Registries.MENU)`,
+/// and an id it lacks (`IdMap.byIdOrThrow`) disconnects it, so it is sent
+/// vanilla's only. A Horizon client has the server's (the content identity).
+pub fn menu_reaches(brand: &str, menu: &str) -> bool {
+    brand == "horizon" || menu.starts_with("minecraft:")
+}
+
 impl FurnaceKind {
     pub fn recipe_type(self) -> &'static str {
         match self {
@@ -196,6 +249,7 @@ impl SkullSkin {
         Self {
             download,
             dynamic,
+            texture: crate::skins::profile_texture_nbt(profile),
             fallback,
         }
     }
@@ -610,6 +664,15 @@ mod tests {
     use super::*;
     use horizon_core::random::{LegacyRandom, RandomSource};
 
+    /// a client that isn't Horizon's is sent vanilla's menu types only.
+    #[test]
+    fn a_mod_menu_type_reaches_horizon_clients_only() {
+        assert!(menu_reaches("horizon", "ruby:press"));
+        assert!(!menu_reaches("vanilla", "ruby:press"));
+        assert!(!menu_reaches("fabric", "ruby:press"));
+        assert!(menu_reaches("vanilla", "minecraft:generic_9x3"));
+    }
+
     #[test]
     fn campfire_slots_take_food_cook_it_and_cool_down() {
         let mut c = Campfire::default();

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

@@ -195,6 +195,14 @@ fn read(path: &str) -> Option<String> {
     std::fs::read_to_string(path).ok()
 }
 
+fn windows_processor_name(query: &str) -> Option<String> {
+    query.lines().find_map(|line| {
+        let (_, value) = line.split_once("REG_SZ")?;
+        let value = value.trim();
+        (!value.is_empty()).then(|| value.to_owned())
+    })
+}
+
 /// `PRETTY_NAME` of /etc/os-release and the kernel, or the system's own version string.
 fn operating_system() -> String {
     let arch = std::env::consts::ARCH;
@@ -235,6 +243,18 @@ pub fn cpu() -> String {
         })
     } else if cfg!(target_os = "macos") {
         command_output("sysctl", &["-n", "machdep.cpu.brand_string"])
+    } else if cfg!(windows) {
+        command_output(
+            "reg",
+            &[
+                "query",
+                r"HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0",
+                "/v",
+                "ProcessorNameString",
+            ],
+        )
+        .and_then(|query| windows_processor_name(&query))
+        .or_else(|| std::env::var("PROCESSOR_IDENTIFIER").ok())
     } else {
         std::env::var("PROCESSOR_IDENTIFIER").ok()
     };
@@ -354,7 +374,8 @@ fn deliver(home: &Path, report: Report) -> Option<PathBuf> {
     );
     crate::logging::flush();
     crate::telemetry::keep_crash(home, &report);
-    match report.save(home) {
+    // A player of a shared game folder (`--player-dir`) finds the report beside its own log.
+    match report.save(crate::logging::player_dir_override().unwrap_or(home)) {
         Ok(path) => {
             eprintln!("{SAVED_LINE}{}", path.display());
             Some(path)
@@ -386,6 +407,30 @@ pub fn report_watchdog(home: &Path, side: &'static str, message: String) -> Opti
     )
 }
 
+/// The report for a game that went over the player's RAM limit (`ram_limit`), written by the
+/// watcher thread: it says nothing about where the memory went, so it carries no stack. The player
+/// chose this limit, so it is no bug to send (`telemetry::keep_crash`), and leaving that out ends
+/// the game seconds sooner: it keeps running, over its limit, until the report is written.
+pub fn report_memory_limit(home: &Path, side: &'static str, message: String) {
+    if REPORTED.swap(true, Ordering::SeqCst) {
+        return;
+    }
+    let report = Report {
+        time: Local::now(),
+        description: "RAM limit reached".into(),
+        error: message,
+        stack: String::new(),
+        thread: thread_name(side),
+        side,
+        details: system_details(side),
+        log: crate::logging::recent_lines(),
+    };
+    match report.save(home) {
+        Ok(path) => eprintln!("{SAVED_LINE}{}", path.display()),
+        Err(e) => eprintln!("Horizon: could not save a crash report: {e}"),
+    }
+}
+
 fn payload_text(payload: &(dyn std::any::Any + Send)) -> String {
     payload
         .downcast_ref::<&str>()
@@ -636,6 +681,22 @@ pub fn debug_crash_after() -> Option<std::time::Duration> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn windows_registry_cpu_name_is_read_without_the_registry_columns() {
+        let query = r#"
+HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor\0
+    ProcessorNameString    REG_SZ    13th Gen Intel(R) Core(TM) i7-13700F
+"#;
+        assert_eq!(
+            windows_processor_name(query).as_deref(),
+            Some("13th Gen Intel(R) Core(TM) i7-13700F")
+        );
+        assert_eq!(
+            windows_processor_name("ProcessorNameString REG_SZ   "),
+            None
+        );
+    }
+
     #[test]
     fn a_release_reports_its_built_in_version() {
         // release.yml builds with HORIZON_VERSION (docs/versioning.md): `v0.2.3`, wherever it is installed.

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

@@ -575,7 +575,7 @@ pub struct DataStore {
     /// `item_modifier` files, for `/item modify`.
     pub item_modifiers: BTreeMap<String, serde_json::Value>,
     /// The content tables' raw files from the packs after the built-in one:
-    /// `recipe/`, `loot_table/`, `advancement/`, `dialog/` and `tags/…/` files, by
+    /// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `dialog/` and `tags/…/` files, by
     /// `<kind-dir>/<ns>:<path>`, each id's files in pack order. The tables
     /// merge them over what they read from the resource root.
     pub files: BTreeMap<String, Vec<Vec<u8>>>,
@@ -583,7 +583,7 @@ pub struct DataStore {
     pub errors: Vec<(String, String)>,
 }
 /// `<kind-dir>/<ns>:<path>` for a pack file the content tables read:
-/// `recipe/`, `loot_table/`, `advancement/`, `trade_set/`,
+/// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `trade_set/`,
 /// `villager_trade/`, `dialog/` or `tags/<sub>/`, where the id keeps the sub
 /// path so a nested tag kind stays addressable.
 fn content_id(file: &str) -> Option<String> {
@@ -591,7 +591,8 @@ fn content_id(file: &str) -> Option<String> {
     let (ns, rest) = rest.split_once('/')?;
     let (kind, rest) = rest.split_once('/')?;
     let kind = match kind {
-        "recipe" | "loot_table" | "advancement" | "trade_set" | "villager_trade" | "dialog" => kind,
+        "recipe" | "recipe_filter" | "loot_table" | "advancement" | "trade_set"
+        | "villager_trade" | "dialog" => kind,
         // A tag id is `{ns}:{path-under-tags}` (`tags/worldgen/biome/
         // test:sub/mytag`), the whole path after the namespace, so nested
         // registries keep their directory (`TagLoader`'s id shape).
@@ -628,6 +629,7 @@ impl DataStore {
                 "loot_table",
                 "predicate",
                 "recipe",
+                "recipe_filter",
                 "tags",
                 "trade_set",
                 "villager_trade",

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

@@ -320,6 +320,13 @@ fn shadow_color(in: Out) -> vec4<f32> {
 }
 
 fn celestial_color(in: Out) -> vec4<f32> {
+    // RenderPipelines.DRAGON_RAYS / rendertype_lightning.fsh: untextured
+    // vertex colour, with fog fading both RGB and alpha before additive blending.
+    if in.overlay == 37u {
+        let fog = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
+                      linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
+        return in.color * (1.0 - fog);
+    }
     return textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
 }
 @fragment fn fs_celestial(in: Out) -> @location(0) vec4<f32> {

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

@@ -141,6 +141,8 @@ pub struct Sky {
     pub fog_end: f32,
     /// `visual/cloud_fog_end_distance`.
     pub cloud_fog_end: f32,
+    /// `visual/cloud_height`.
+    pub cloud_height: f32,
 }
 impl Environment {
     pub fn load(root: &Path) -> Result<Self> {
@@ -309,6 +311,10 @@ impl Environment {
                 .base
                 .get("minecraft:visual/cloud_fog_end_distance")
                 .map_or(2048.0, |v| v[0]),
+            cloud_height: self
+                .base
+                .get("minecraft:visual/cloud_height")
+                .map_or(crate::clouds::CLOUD_HEIGHT as f32, |v| v[0]),
         }
     }
 }

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

@@ -96,8 +96,13 @@ pub struct Extras {
     pub minimap_rotate: bool,
     /// Retry lost multiplayer connections (`reconnect`).
     pub auto_reconnect: bool,
+    /// Positional sounds leave a few static sound channels free for UI sounds
+    /// and others played to the listener (`sound_engine::HEARD_RESERVE`).
+    pub ui_sound_reserve: bool,
     /// The player's own name tag over its model in third person.
     pub own_name_tag: bool,
+    /// No particles from breaking or mining a block (other particles stay).
+    pub hide_block_particles: bool,
     /// Mouse Tweaks-style drags in the inventory and storage containers.
     pub mouse_tweaks: bool,
     /// With them, the wheel over a slot moves its items one at a time.
@@ -106,6 +111,10 @@ pub struct Extras {
     pub sort: bool,
     /// A vanilla key name: sorts the part under the cursor.
     pub sort_key: String,
+    /// A new chat line slides in from the left while it fades in (`Chat::layout`).
+    pub chat_animation: bool,
+    /// The indicator bar at the left of a chat line (on by default, as vanilla).
+    pub chat_indicator: bool,
     /// No AI: every AI feature hidden and off (`horizon_core::no_ai`; the launcher writes it too).
     pub no_ai: bool,
     /// Agents may control the game the player starts: it opens its control socket for
@@ -113,6 +122,8 @@ pub struct Extras {
     pub agent_control: bool,
     /// "Playing Horizon" on the player's Discord profile (`discord_presence`; on by default).
     pub discord_presence: bool,
+    /// Another controller can join P1's world (`splitscreen`, off by default).
+    pub splitscreen: bool,
 }
 impl Default for Extras {
     fn default() -> Self {
@@ -138,14 +149,19 @@ impl Default for Extras {
             minimap_zoom: 1.0,
             minimap_rotate: false,
             auto_reconnect: false,
+            ui_sound_reserve: false,
             own_name_tag: false,
+            hide_block_particles: false,
             mouse_tweaks: false,
             mouse_tweaks_wheel: true,
             sort: false,
             sort_key: "key.keyboard.unknown".into(),
+            chat_animation: false,
+            chat_indicator: true,
             no_ai: false,
             agent_control: false,
             discord_presence: true,
+            splitscreen: false,
         }
     }
 }
@@ -213,14 +229,19 @@ impl Extras {
                 }
                 "minimapRotate" => e.minimap_rotate = flag(e.minimap_rotate),
                 "autoReconnect" => e.auto_reconnect = flag(e.auto_reconnect),
+                "uiSoundReserve" => e.ui_sound_reserve = flag(e.ui_sound_reserve),
                 "ownNameTag" => e.own_name_tag = flag(e.own_name_tag),
+                "hideBlockParticles" => e.hide_block_particles = flag(e.hide_block_particles),
                 "mouseTweaks" => e.mouse_tweaks = flag(e.mouse_tweaks),
                 "mouseTweaksWheel" => e.mouse_tweaks_wheel = flag(e.mouse_tweaks_wheel),
                 "sort" => e.sort = flag(e.sort),
                 "sortKey" if value.starts_with("key.") => e.sort_key = value.to_owned(),
+                "chatAnimation" => e.chat_animation = flag(e.chat_animation),
+                "chatIndicator" => e.chat_indicator = flag(e.chat_indicator),
                 horizon_core::no_ai::KEY => e.no_ai = flag(e.no_ai),
                 "agentControl" => e.agent_control = flag(e.agent_control),
                 "discordPresence" => e.discord_presence = flag(e.discord_presence),
+                "splitscreen" => e.splitscreen = flag(e.splitscreen),
                 _ => {}
             }
         }
@@ -228,7 +249,7 @@ impl Extras {
     }
     pub fn serialize(&self) -> String {
         format!(
-            "fullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nmovedToMods:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nownNameTag:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\n{}:{}\nagentControl:{}\ndiscordPresence:{}\n",
+            "fullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nmovedToMods:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nuiSoundReserve:{}\nownNameTag:{}\nhideBlockParticles:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\nchatAnimation:{}\nchatIndicator:{}\n{}:{}\nagentControl:{}\ndiscordPresence:{}\nsplitscreen:{}\n",
             bool_text(self.fullbright),
             bool_text(self.dynamic_lights),
             bool_text(self.zoom),
@@ -254,15 +275,20 @@ impl Extras {
             self.minimap_zoom,
             bool_text(self.minimap_rotate),
             bool_text(self.auto_reconnect),
+            bool_text(self.ui_sound_reserve),
             bool_text(self.own_name_tag),
+            bool_text(self.hide_block_particles),
             bool_text(self.mouse_tweaks),
             bool_text(self.mouse_tweaks_wheel),
             bool_text(self.sort),
             self.sort_key,
+            bool_text(self.chat_animation),
+            bool_text(self.chat_indicator),
             horizon_core::no_ai::KEY,
             bool_text(self.no_ai),
             bool_text(self.agent_control),
             bool_text(self.discord_presence),
+            bool_text(self.splitscreen),
         )
     }
     /// Binds the extra key `name` (`SORT_KEY`); false for
@@ -383,16 +409,24 @@ pub enum Item {
     Fullbright,
     DynamicLights,
     OwnNameTag,
+    HideBlockParticles,
     AutoReconnect,
+    UiSoundReserve,
     MouseTweaks,
     MouseTweaksWheel,
     Sort,
     SortKey,
+    /// A new chat line slides in and fades in (`Chat::layout`).
+    ChatAnimation,
+    /// The coloured bar at the left of a chat line.
+    ChatIndicator,
     /// Not on the Extras page: Horizon Settings shows No AI, its AI Agent page Agent Control.
     NoAi,
     AgentControl,
     /// On the Horizon Settings page.
     DiscordPresence,
+    /// On the Splitscreen settings page.
+    Splitscreen,
 }
 /// The Extras page: headers and items.
 pub fn rows() -> Vec<Result<Item, &'static str>> {
@@ -403,13 +437,20 @@ pub fn rows() -> Vec<Result<Item, &'static str>> {
         Ok(DynamicLights),
         Err("Third person"),
         Ok(OwnNameTag),
+        Err("Particles"),
+        Ok(HideBlockParticles),
         Err("Inventory"),
         Ok(MouseTweaks),
         Ok(MouseTweaksWheel),
         Ok(Sort),
         Ok(SortKey),
+        Err("Chat"),
+        Ok(ChatAnimation),
+        Ok(ChatIndicator),
         Err("Multiplayer"),
         Ok(AutoReconnect),
+        Err("Sound"),
+        Ok(UiSoundReserve),
     ]
 }
 impl Item {
@@ -418,24 +459,32 @@ impl Item {
             Item::Fullbright => "Fullbright",
             Item::DynamicLights => "Dynamic lights",
             Item::OwnNameTag => "Own name tag",
+            Item::HideBlockParticles => "Hide block-break particles",
             Item::AutoReconnect => "Auto-reconnect",
+            Item::UiSoundReserve => "Keep channels for UI sounds",
             Item::MouseTweaks => "Mouse Tweaks controls",
             Item::MouseTweaksWheel => "Scroll wheel moves items",
             Item::Sort => "Sort buttons",
             Item::SortKey => "Sort key",
+            Item::ChatAnimation => "Smooth chat",
+            Item::ChatIndicator => "Message indicator",
             Item::NoAi => "No AI",
             Item::AgentControl => "Agent Control",
             Item::DiscordPresence => "Discord Rich Presence",
+            Item::Splitscreen => "Splitscreen",
         }
     }
     /// The switch this setting belongs to: it does nothing while that is off.
     pub fn parent(self) -> Option<Item> {
         use Item::*;
         Some(match self {
+            UiSoundReserve => return None,
             MouseTweaksWheel => MouseTweaks,
             SortKey => Sort,
-            Fullbright | DynamicLights | OwnNameTag | MouseTweaks | Sort | AutoReconnect | NoAi
-            | AgentControl | DiscordPresence => {
+            ChatIndicator => ChatAnimation,
+            Fullbright | DynamicLights | OwnNameTag | HideBlockParticles | MouseTweaks | Sort
+            | AutoReconnect | NoAi | AgentControl | DiscordPresence | Splitscreen
+            | ChatAnimation => {
                 return None;
             }
         })
@@ -450,9 +499,15 @@ impl Item {
             Item::OwnNameTag => {
                 "Shows your name above your head in third person, as other players see it. Hidden when the server hides your team's names or you're invisible."
             }
+            Item::HideBlockParticles => {
+                "Hides the debris particles that burst from a broken block and crumble off the one you mine. Other particles stay."
+            }
             Item::AutoReconnect => {
                 "Rejoins a server after a lost connection or a restart, never after a kick or ban."
             }
+            Item::UiSoundReserve => {
+                "Sounds in the world leave 16 of the 247 sound channels free, so a flood of them (a big explosion) can't silence menu clicks."
+            }
             Item::MouseTweaks => {
                 "Right-drag places one per slot, left-drag gathers the held item, Shift + left-drag moves every slot."
             }
@@ -465,12 +520,19 @@ impl Item {
             Item::SortKey => {
                 "Sorts the part under the cursor. Click, then press a key; Escape unbinds it."
             }
+            Item::ChatAnimation => {
+                "A new chat line slides in from the left while it fades in, instead of appearing whole."
+            }
+            Item::ChatIndicator => "The coloured bar at the left of a chat line.",
             Item::NoAi => {
                 "Hides and turns off every AI feature: agent control, horizon-ctl and the MCP servers. The launcher's switch too."
             }
             Item::DiscordPresence => {
                 "Shows Playing Horizon on your Discord profile while Discord runs: menus, single player or multiplayer, the dimension and the time played. Never a world's name or a server's address."
             }
+            Item::Splitscreen => {
+                "In a world, another controller can join as a new player: press A when it asks, then pick a profile and where to play."
+            }
             Item::AgentControl => {
                 "Your own AI agent can play this game through horizon-ctl or an MCP client, on this computer only."
             }
@@ -481,10 +543,15 @@ impl Item {
         use crate::graphics_style::Cost;
         match self {
             Item::Fullbright => Some(Cost::None),
+            Item::UiSoundReserve => Some(Cost::None),
             Item::DynamicLights => Some(Cost::Low),
-            Item::OwnNameTag | Item::AutoReconnect | Item::MouseTweaks | Item::Sort => {
-                Some(Cost::None)
-            }
+            Item::ChatAnimation => Some(Cost::None),
+            Item::OwnNameTag
+            | Item::HideBlockParticles
+            | Item::AutoReconnect
+            | Item::MouseTweaks
+            | Item::Sort
+            | Item::Splitscreen => Some(Cost::None),
             _ => None,
         }
     }
@@ -494,13 +561,18 @@ impl Item {
             Item::Fullbright => e.fullbright,
             Item::DynamicLights => e.dynamic_lights,
             Item::OwnNameTag => e.own_name_tag,
+            Item::HideBlockParticles => e.hide_block_particles,
             Item::AutoReconnect => e.auto_reconnect,
+            Item::UiSoundReserve => e.ui_sound_reserve,
             Item::MouseTweaks => e.mouse_tweaks,
             Item::MouseTweaksWheel => e.mouse_tweaks_wheel,
             Item::Sort => e.sort,
+            Item::ChatAnimation => e.chat_animation,
+            Item::ChatIndicator => e.chat_indicator,
             Item::NoAi => e.no_ai,
             Item::AgentControl => e.agent_control,
             Item::DiscordPresence => e.discord_presence,
+            Item::Splitscreen => e.splitscreen,
             _ => return None,
         })
     }
@@ -521,13 +593,18 @@ impl Item {
             Item::Fullbright => e.fullbright = !e.fullbright,
             Item::DynamicLights => e.dynamic_lights = !e.dynamic_lights,
             Item::OwnNameTag => e.own_name_tag = !e.own_name_tag,
+            Item::HideBlockParticles => e.hide_block_particles = !e.hide_block_particles,
             Item::AutoReconnect => e.auto_reconnect = !e.auto_reconnect,
+            Item::UiSoundReserve => e.ui_sound_reserve = !e.ui_sound_reserve,
             Item::MouseTweaks => e.mouse_tweaks = !e.mouse_tweaks,
             Item::MouseTweaksWheel => e.mouse_tweaks_wheel = !e.mouse_tweaks_wheel,
             Item::Sort => e.sort = !e.sort,
+            Item::ChatAnimation => e.chat_animation = !e.chat_animation,
+            Item::ChatIndicator => e.chat_indicator = !e.chat_indicator,
             Item::NoAi => e.no_ai = !e.no_ai,
             Item::AgentControl => e.agent_control = !e.agent_control,
             Item::DiscordPresence => e.discord_presence = !e.discord_presence,
+            Item::Splitscreen => e.splitscreen = !e.splitscreen,
             Item::SortKey => {}
         }
     }
@@ -549,7 +626,8 @@ mod tests {
         let d = Extras::default();
         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);
+        assert!(!d.mouse_tweaks && !d.sort && !d.own_name_tag && !d.ui_sound_reserve);
+        assert!(!d.hide_block_particles);
         assert!(d.discord_presence);
         assert_eq!(Extras::parse(""), d);
         assert_eq!(Extras::parse(&d.serialize()), d);
@@ -575,11 +653,22 @@ mod tests {
         e.auto_reconnect = true;
         Item::OwnNameTag.cycle(&mut e, false);
         assert_eq!(Item::OwnNameTag.switch(&e), Some(true));
+        assert_eq!(Item::HideBlockParticles.switch(&e), Some(false));
+        Item::HideBlockParticles.cycle(&mut e, false);
+        assert!(e.hide_block_particles);
+        assert_eq!(Item::HideBlockParticles.switch(&e), Some(true));
+        let only = Extras::parse("hideBlockParticles:true\n");
+        assert!(only.hide_block_particles && !only.own_name_tag);
         e.mouse_tweaks = true;
         e.mouse_tweaks_wheel = false;
         e.sort = true;
         e.sort_key = "key.keyboard.r".into();
+        e.chat_animation = true;
+        e.chat_indicator = false;
         e.discord_presence = false;
+        assert!(!e.splitscreen);
+        Item::Splitscreen.cycle(&mut e, false);
+        assert_eq!(Item::Splitscreen.switch(&e), Some(true));
         assert_eq!(Extras::parse(&e.serialize()), e);
     }
 

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

@@ -1,85 +1,3 @@
-//! A fast, non-cryptographic hasher (the Fx hash used by rustc) for hot maps
-//! keyed by small integers, such as chunk coordinates. Iteration order of
-//! such maps carries no meaning: the default hasher's is random anyway.
-use std::hash::{BuildHasherDefault, Hasher};
-
-const SEED: u64 = 0xf135_7aea_2e62_a9c5;
-
-#[derive(Clone, Copy, Default)]
-pub struct FxHasher {
-    hash: u64,
-}
-impl FxHasher {
-    #[inline]
-    fn add(&mut self, word: u64) {
-        self.hash = self.hash.wrapping_add(word).wrapping_mul(SEED);
-    }
-}
-impl Hasher for FxHasher {
-    #[inline]
-    fn write(&mut self, bytes: &[u8]) {
-        let (words, rest) = bytes.as_chunks::<8>();
-        for word in words {
-            self.add(u64::from_le_bytes(*word));
-        }
-        if !rest.is_empty() {
-            let mut word = [0u8; 8];
-            word[..rest.len()].copy_from_slice(rest);
-            self.add(u64::from_le_bytes(word));
-        }
-    }
-    #[inline]
-    fn write_u8(&mut self, i: u8) {
-        self.add(u64::from(i));
-    }
-    #[inline]
-    fn write_u16(&mut self, i: u16) {
-        self.add(u64::from(i));
-    }
-    #[inline]
-    fn write_u32(&mut self, i: u32) {
-        self.add(u64::from(i));
-    }
-    #[inline]
-    fn write_u64(&mut self, i: u64) {
-        self.add(i);
-    }
-    #[inline]
-    fn write_usize(&mut self, i: usize) {
-        self.add(i as u64);
-    }
-    #[inline]
-    fn write_i32(&mut self, i: i32) {
-        self.add(u64::from(i as u32));
-    }
-    #[inline]
-    fn finish(&self) -> u64 {
-        // The multiply leaves the low bits weakest; hash tables use them.
-        self.hash.rotate_left(26)
-    }
-}
-pub type FxBuild = BuildHasherDefault<FxHasher>;
-pub type FxHashMap<K, V> = std::collections::HashMap<K, V, FxBuild>;
-pub type FxHashSet<K> = std::collections::HashSet<K, FxBuild>;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn nearby_chunks_spread_over_buckets() {
-        let mut map: FxHashMap<(i32, i32), i32> = FxHashMap::default();
-        for x in -40..40 {
-            for z in -40..40 {
-                map.insert((x, z), x * z);
-            }
-        }
-        assert_eq!(map.len(), 6400);
-        assert_eq!(map[&(-7, 13)], -91);
-        let mut low = std::collections::HashSet::new();
-        for x in 0..64 {
-            low.insert(std::hash::BuildHasher::hash_one(&FxBuild::default(), (x, 0)) & 63);
-        }
-        assert!(low.len() > 32, "low bits vary: {}", low.len());
-    }
-}
+//! The Fx hasher for hot maps keyed by small integers: kept in horizon-core
+//! (the scheduled ticks use it too), and reachable here under its old path.
+pub use horizon_core::fast_hash::*;

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

@@ -112,6 +112,8 @@ struct Region {
     cursor: (u32, u32),
     row: u32,
     pending: Vec<Patch>,
+    /// A glyph did not fit since the last `Font::begin_frame`.
+    full: bool,
 }
 struct Cache {
     /// Every font by id, the default one first (the common lookup).
@@ -546,6 +548,7 @@ impl Region {
             self.row = 0;
         }
         if y + h > region.1 {
+            self.full = true;
             return None;
         }
         let (ax, ay) = (x, region.0 + y);
@@ -603,6 +606,7 @@ impl Font {
                     cursor: (0, 0),
                     row: 0,
                     pending: Vec::new(),
+                    full: false,
                 },
                 random: horizon_core::random::LegacyRandom::new(
                     std::time::SystemTime::now()
@@ -669,8 +673,19 @@ impl Font {
         }
         cache.region.cursor = (0, 0);
         cache.region.row = 0;
+        cache.region.full = false;
         self.generation.set(next_generation());
     }
+    /// Call once per frame before any text is laid out. When the dynamic
+    /// region ran out of room (vanilla's glyph textures grow instead), the
+    /// glyphs are forgotten so they are rasterized again from the start; it
+    /// waits for the frame boundary because quads already queued hold the old
+    /// rects.
+    pub fn begin_frame(&self) {
+        if self.cache.borrow().region.full {
+            self.reset_cache();
+        }
+    }
     /// Changes whenever a glyph may come out different: another font, a
     /// cache reset (glyphs move in the atlas) or other font options. Text laid
     /// out under one epoch can be kept until it changes.
@@ -706,7 +721,16 @@ impl Font {
         if let Some(g) = set.glyphs.get(&c) {
             return *g;
         }
-        let glyph = self.resolve(set, region, c).unwrap_or(self.missing);
+        let was_full = std::mem::replace(&mut region.full, false);
+        let found = self.resolve(set, region, c);
+        // No room: the missing glyph for now, not remembered, so the
+        // character is tried again once `begin_frame` cleared the region.
+        let overflowed = std::mem::replace(&mut region.full, was_full);
+        region.full |= overflowed;
+        if overflowed {
+            return self.missing;
+        }
+        let glyph = found.unwrap_or(self.missing);
         set.glyphs.insert(c, glyph);
         glyph
     }
@@ -1418,4 +1442,56 @@ mod tests {
         font.reset_cache();
         assert_eq!(font.glyph('a').advance, 2.0);
     }
+
+    #[test]
+    fn a_full_glyph_region_recovers_at_the_next_frame() {
+        // Two 8x8 glyphs from a sheet outside the atlas; the region holds one row.
+        let sheet = png(16, 8, |x, _| x % 8 < 4);
+        let default = br#"{"providers":[{"type":"bitmap","file":"pack:font/s.png","ascent":7,"chars":["ab"]}]}"#;
+        let root = root(
+            "full",
+            &[
+                ("assets/minecraft/font/default.json", default),
+                ("assets/pack/textures/font/s.png", &sheet),
+            ],
+        );
+        // A 10 wide atlas fits one 8 pixel glyph per row; the region two rows.
+        let font = Font::load(&root, &HashMap::new(), &[], (10, 64), (0, 8), white());
+        let _ = std::fs::remove_dir_all(&root);
+        let epoch = font.epoch();
+        let a = font.glyph('a');
+        assert!(a.rect.is_some());
+        // No room for 'b': missing for now, and asked again next time.
+        assert!(font.glyph('b').rect.is_none());
+        assert!(font.glyph('b').rect.is_none());
+        assert_eq!(font.epoch(), epoch);
+        font.begin_frame();
+        assert_ne!(font.epoch(), epoch);
+        let b = font.glyph('b');
+        assert!(b.rect.is_some());
+        assert_eq!(b.advance, a.advance);
+        // Nothing overflowed since: the next frame keeps the glyphs.
+        let epoch = font.epoch();
+        font.begin_frame();
+        assert_eq!(font.epoch(), epoch);
+    }
+
+    #[test]
+    fn a_character_without_a_provider_does_not_reset_the_region() {
+        let sheet = png(8, 8, |x, _| x < 4);
+        let default = br#"{"providers":[{"type":"bitmap","file":"pack:font/s.png","ascent":7,"chars":["a"]}]}"#;
+        let root = root(
+            "nofill",
+            &[
+                ("assets/minecraft/font/default.json", default),
+                ("assets/pack/textures/font/s.png", &sheet),
+            ],
+        );
+        let font = Font::load(&root, &HashMap::new(), &[], (10, 64), (0, 8), white());
+        let _ = std::fs::remove_dir_all(&root);
+        let epoch = font.epoch();
+        assert!(font.glyph('z').rect.is_none());
+        font.begin_frame();
+        assert_eq!(font.epoch(), epoch);
+    }
 }

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

@@ -299,6 +299,7 @@ impl SpriteAnimator {
         uploads: &mut Uploads,
         tick: u64,
         active: Option<&[u64]>,
+        timing: Option<&mut super::pack_timing::PassTiming>,
     ) {
         if self.collect(tick, active) == 0 {
             return;
@@ -341,7 +342,7 @@ impl SpriteAnimator {
         }
         let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
             label: Some("Animated sprites"),
-            timestamp_writes: None,
+            timestamp_writes: timing.and_then(|t| t.compute_writes("Animated sprites")),
         });
         pass.set_pipeline(pipeline);
         for group in &mut self.groups {
@@ -859,7 +860,7 @@ mod tests {
         for tick in [0, 0, 1, 2, 3, 4, 7, 7, 12, 30] {
             let mut encoder = device.create_command_encoder(&Default::default());
             let shown: Vec<_> = animator.sprites.iter().map(|s| s.shown).collect();
-            animator.animate(&mut encoder, &mut uploads, tick, None);
+            animator.animate(&mut encoder, &mut uploads, tick, None, None);
             writes.push(
                 animator
                     .sprites

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

@@ -1,12 +1,21 @@
 //! One vertex buffer for every terrain section: sections own ranges of it, so
 //! a frame binds it once and draws every section with indirect multi-draw.
+//! Translucent quads can have an arena of their own (`Arena::translucent`),
+//! with pages up to `LARGE_PAGE_BYTES`, and their sorted indices too
+//! (`Arena::translucent_indices`): their back-to-front list then stays in one
+//! page of each and draws in a few multi-draws.
 use std::collections::BTreeMap;
 
 /// Ranges are rounded up to this many vertices to limit fragmentation, and
 /// start at multiples of it (`flat` names sections by these blocks).
 pub const GRAIN: u64 = 256;
-/// The largest page, in bytes.
+/// The largest page of the section arena, and of arenas shaders bind whole
+/// as storage, in bytes.
 pub const PAGE_BYTES: u64 = 256 << 20;
+/// The largest page of an arena no shader binds as storage: under 2 GiB, where
+/// DirectX 12 and OpenGL cap buffers (`i32::MAX`), with room for the bytes
+/// wgpu-core adds to vertex buffers; the device's own limit still applies.
+pub const LARGE_PAGE_BYTES: u64 = (1 << 31) - (1 << 20);
 
 /// Free vertex ranges: start -> length, never adjacent.
 #[derive(Debug, PartialEq)]
@@ -118,7 +127,7 @@ impl Arena {
         } else {
             wgpu::BufferUsages::VERTEX
         };
-        Self::with_usage(device, stride, capacity, usage)
+        Self::with_usage(device, stride, capacity, usage, PAGE_BYTES)
     }
     /// Sorted translucent indices; `storage` when compute passes read them.
     pub fn indices(device: &wgpu::Device, capacity: u64, storage: bool) -> Self {
@@ -127,16 +136,54 @@ impl Arena {
         } else {
             wgpu::BufferUsages::INDEX
         };
-        Self::with_usage(device, 4, capacity, usage)
+        Self::with_usage(device, 4, capacity, usage, PAGE_BYTES)
+    }
+    /// Translucent quads' vertices, which no shader reads as storage: pages
+    /// up to `LARGE_PAGE_BYTES`. The section arena's compaction never runs on
+    /// it (`Renderer::compact_arena`): a page this large has no others to
+    /// empty into, and the compaction moves sections' `page` ranges, not their
+    /// `translucent_at`.
+    pub fn translucent(device: &wgpu::Device, stride: u64, capacity: u64) -> Self {
+        let usage = wgpu::BufferUsages::VERTEX;
+        Self::with_usage(device, stride, capacity, usage, LARGE_PAGE_BYTES)
+    }
+    /// Sorted indices of the translucent arena's quads: pages up to
+    /// `LARGE_PAGE_BYTES` as its own, so its draws keep to one index page too.
+    pub fn translucent_indices(device: &wgpu::Device, capacity: u64) -> Self {
+        let usage = wgpu::BufferUsages::INDEX;
+        Self::with_usage(device, 4, capacity, usage, LARGE_PAGE_BYTES)
+    }
+    /// The sorted-index arena and, when `split`, the translucent arena
+    /// (vertices of `stride`), both with large pages, which no shader binds;
+    /// otherwise translucent quads stay in the section arena, and the indices
+    /// in pages flat draws (`flat`) bind as storage.
+    pub fn translucent_arenas(
+        device: &wgpu::Device,
+        stride: u64,
+        flat: bool,
+        split: bool,
+    ) -> (Self, Option<Self>) {
+        if split {
+            let indices = Self::translucent_indices(device, 1 << 16);
+            (indices, Some(Self::translucent(device, stride, 1 << 18)))
+        } else {
+            (Self::indices(device, 1 << 16, flat), None)
+        }
     }
     fn with_usage(
         device: &wgpu::Device,
         stride: u64,
         capacity: u64,
         usage: wgpu::BufferUsages,
+        page_bytes: u64,
     ) -> Self {
-        // 256 MiB pages, or less where the device's buffers are smaller.
-        let bytes = device.limits().max_buffer_size.min(PAGE_BYTES);
+        // Pages of `page_bytes`, or less where the device's buffers (or the
+        // storage bindings that read them whole) are smaller.
+        let limits = device.limits();
+        let mut bytes = limits.max_buffer_size.min(page_bytes);
+        if usage.contains(wgpu::BufferUsages::STORAGE) {
+            bytes = bytes.min(limits.max_storage_buffer_binding_size);
+        }
         let page_limit = (bytes / stride) / GRAIN * GRAIN;
         let capacity = capacity.next_multiple_of(GRAIN).min(page_limit);
         Self {
@@ -151,11 +198,16 @@ impl Arena {
             video_memory_full: false,
         }
     }
-    /// A buffer of `capacity` vertices in video memory or, when that is full
-    /// and the device allows it, in system memory: Vulkan drivers fail an
-    /// allocation rather than page like OpenGL ones, and wgpu's default error
-    /// handler panics. `None` when neither has room.
-    fn create(&mut self, device: &wgpu::Device, capacity: u64) -> Option<(wgpu::Buffer, bool)> {
+    /// A buffer of `capacity` vertices in video memory or, when that is full,
+    /// `spill` allows it and so does the device, in system memory: Vulkan
+    /// drivers fail an allocation rather than page like OpenGL ones, and
+    /// wgpu's default error handler panics. `None` when neither has room.
+    fn create(
+        &mut self,
+        device: &wgpu::Device,
+        capacity: u64,
+        spill: bool,
+    ) -> Option<(wgpu::Buffer, bool)> {
         let usage = self.usage | wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::COPY_SRC;
         #[cfg(test)]
         let local = (!self.video_memory_full)
@@ -167,9 +219,10 @@ impl Arena {
         local.or_else(|| {
             // Mappable buffers are placed in host-visible memory, which the
             // allocator takes from system memory once video memory is full.
-            if !device
-                .features()
-                .contains(wgpu::Features::MAPPABLE_PRIMARY_BUFFERS)
+            if !spill
+                || !device
+                    .features()
+                    .contains(wgpu::Features::MAPPABLE_PRIMARY_BUFFERS)
             {
                 return None;
             }
@@ -234,7 +287,7 @@ impl Arena {
             && self.closing != Some(last as u32)
         {
             let current = page.capacity;
-            let grown = (current * 2).max(current + len).min(self.page_limit);
+            let grown = self.grown(current, len);
             if (grown - current >= len || grown == self.page_limit)
                 && self.grow(device, encoder, last, grown)
                 && let Some(start) = self.pages[last].as_mut().unwrap().free.take(len)
@@ -250,9 +303,9 @@ impl Arena {
         .max(len)
         .min(self.page_limit);
         // A page just large enough when memory is short.
-        let ((buffer, host), capacity) = match self.create(device, capacity) {
+        let ((buffer, host), capacity) = match self.create(device, capacity, true) {
             Some(buffer) => (buffer, capacity),
-            None if capacity > len => (self.create(device, len)?, len),
+            None if capacity > len => (self.create(device, len, true)?, len),
             None => return None,
         };
         let mut free = FreeList::new(capacity);
@@ -392,8 +445,17 @@ impl Arena {
             }
         }
     }
+    /// The capacity the newest page grows to for a range of `len`: double, but
+    /// by at most `PAGE_BYTES` past that size, so a large page is never left
+    /// half empty (nor held twice during the copy) by hundreds of MiB.
+    fn grown(&self, current: u64, len: u64) -> u64 {
+        let step = current.min(PAGE_BYTES / self.stride);
+        (current + step).max(current + len).min(self.page_limit)
+    }
     /// Moves a page into a larger buffer; false (the page unchanged) when
-    /// there is no memory for it.
+    /// there is no memory for it. A page past `PAGE_BYTES` grows in video
+    /// memory only: moving all of it to system memory would slow every frame
+    /// that draws it, so a new page takes the range instead (and may spill).
     fn grow(
         &mut self,
         device: &wgpu::Device,
@@ -402,7 +464,8 @@ impl Arena {
         capacity: u64,
     ) -> bool {
         let capacity = capacity.next_multiple_of(GRAIN).min(self.page_limit);
-        let Some((buffer, host)) = self.create(device, capacity) else {
+        let spill = capacity * self.stride <= PAGE_BYTES;
+        let Some((buffer, host)) = self.create(device, capacity, spill) else {
             return false;
         };
         let old = self.pages[page].as_mut().expect("live arena page");
@@ -474,6 +537,26 @@ mod tests {
         .ok()
     }
 
+    /// A device with the adapter's own limits, as the renderer opens it: page
+    /// caps past the default 256 MiB buffer limit show there.
+    fn device_at_limits() -> Option<(wgpu::Device, wgpu::Queue)> {
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
+        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
+        pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
+            required_limits: adapter.limits(),
+            ..Default::default()
+        }))
+        .ok()
+    }
+
+    /// `device` and `device_at_limits`: the default limits bind 128 MiB of a storage
+    /// buffer, half their 256 MiB buffers, so storage pages shrink to the binding there;
+    /// the adapter's own let large pages past 256 MiB.
+    fn devices() -> Vec<(wgpu::Device, wgpu::Queue)> {
+        let devices = [device(), device_at_limits()];
+        devices.into_iter().flatten().collect()
+    }
+
     /// `Arena::alloc`, with the copies of a grow submitted at once.
     fn alloc(
         arena: &mut Arena,
@@ -588,6 +671,119 @@ mod tests {
         }
     }
 
+    /// The renderer's half of that compaction (`move_off_page`) moves what each
+    /// section holds in the section arena, data and all. Split, that is its
+    /// solid quads alone, and nothing of a section without any, whose (0, 0)
+    /// names no range of page 0; else solid and translucent quads together,
+    /// `translucent_at` along.
+    #[test]
+    fn compaction_moves_what_sections_hold_in_the_section_arena() {
+        use super::super::{SectionGpu, move_off_page};
+        let Some((device, queue)) = device() else {
+            eprintln!("no GPU adapter: skipped");
+            return;
+        };
+        let stride = std::mem::size_of::<crate::mesher::TerrainVertex>() as u64;
+        let section = |(page, start), translucent_at, solid, translucent| SectionGpu {
+            page,
+            start,
+            translucent_at,
+            solid,
+            sides: crate::mesher::Sides::unsorted(solid),
+            translucent,
+            sort: super::super::translucency::SortState::new(Vec::new()),
+            sorted_indices: None,
+            flat_id: None,
+            fading: None,
+            leaving: None,
+            animated_layers: Box::new([]),
+        };
+        for split in [true, false] {
+            let mut arena = Arena::new(&device, stride, 4 * GRAIN, false);
+            arena.page_limit = 4 * GRAIN;
+            // Page 0: two sections' grains and two free ones; page 1: one taken.
+            let (_, a) = alloc(&mut arena, &device, &queue, GRAIN).unwrap();
+            let (_, b) = alloc(&mut arena, &device, &queue, GRAIN).unwrap();
+            let (_, rest) = alloc(&mut arena, &device, &queue, 2 * GRAIN).unwrap();
+            assert_eq!(alloc(&mut arena, &device, &queue, GRAIN), Some((1, 0)));
+            arena.release(0, rest, 2 * GRAIN);
+            // Split, a grain of solid quads each (the first's translucent ones, and
+            // all of a water section's, in the translucent arena); else a grain of
+            // solid and translucent quads, and one of translucent quads alone.
+            let mut sections = if split {
+                vec![
+                    section((0, a), (0, 0), 64, 64),
+                    section((0, 0), (0, GRAIN), 0, 64),
+                    section((0, b), (0, 0), 64, 0),
+                ]
+            } else {
+                vec![
+                    section((0, a), (0, a + 128), 32, 32),
+                    section((0, b), (0, b), 0, 64),
+                ]
+            };
+            // A range's first and last vertex hold its section's number, and the
+            // first translucent one of a mixed range that plus 100.
+            let write = |(page, at): (u32, u64), value: usize| {
+                let bytes = (value as u32).to_le_bytes();
+                queue.write_buffer(arena.buffer(page), at * stride, &bytes);
+            };
+            for (i, s) in sections.iter().enumerate() {
+                if let Some((page, start, len)) = s.vertex_ranges(split).0 {
+                    write((page, start), i);
+                    write((page, start + len - 1), i);
+                    if !split && s.solid > 0 && s.translucent > 0 {
+                        write(s.translucent_at, 100 + i);
+                    }
+                }
+            }
+            let before: Vec<_> = sections
+                .iter()
+                .map(|s| (s.page, s.start, s.translucent_at))
+                .collect();
+            arena.close(0);
+            let mut encoder = device.create_command_encoder(&Default::default());
+            let meshes = sections.iter_mut();
+            assert!(move_off_page(
+                &mut arena,
+                &mut encoder,
+                None,
+                meshes,
+                0,
+                split,
+                u64::MAX
+            ));
+            queue.submit([encoder.finish()]);
+            let word =
+                |(page, at): (u32, u64)| read(&device, &queue, arena.buffer(page), at * stride);
+            for (i, s) in sections.iter().enumerate() {
+                let Some((page, start, len)) = s.vertex_ranges(split).0 else {
+                    assert_eq!(
+                        (s.page, s.start, s.translucent_at),
+                        before[i],
+                        "split {split}"
+                    );
+                    continue;
+                };
+                assert_eq!(page, 1, "split {split}");
+                assert_eq!(word((page, start)), i as u32);
+                assert_eq!(word((page, start + len - 1)), i as u32);
+                if !split {
+                    assert_eq!(s.translucent_at, (page, start + u64::from(s.solid) * 4));
+                    if s.solid > 0 {
+                        assert_eq!(word(s.translucent_at), 100 + i as u32);
+                    }
+                }
+            }
+            // Page 0 empties without a range given twice, and page 1 took a grain
+            // per section moved: one is left.
+            arena.trim();
+            assert!(!arena.has_page(0), "split {split}");
+            assert!(arena.alloc_existing(GRAIN).is_some(), "split {split}");
+            assert_eq!(arena.alloc_existing(GRAIN), None, "split {split}");
+        }
+    }
+
     #[test]
     fn empty_pages_are_reclaimed_without_moving_live_ranges() {
         let Some((device, queue)) = device() else {
@@ -630,6 +826,96 @@ mod tests {
         assert!(arena.pages.is_empty());
     }
 
+    /// Every arena's pages stay within its cap and the device's limits: the
+    /// whole-page storage bindings of flat draws and shader packs included.
+    #[test]
+    fn pages_stay_within_their_caps_and_the_device_limits() {
+        let devices = devices();
+        if devices.is_empty() {
+            eprintln!("no GPU adapter: skipped");
+            return;
+        }
+        let bytes = |a: &Arena| a.page_vertices() * a.stride;
+        for (device, _) in &devices {
+            let limits = device.limits();
+            for storage in [false, true] {
+                for arena in [
+                    Arena::new(device, 24, GRAIN, storage),
+                    Arena::indices(device, GRAIN, storage),
+                ] {
+                    assert!(bytes(&arena) <= PAGE_BYTES.min(limits.max_buffer_size));
+                    let binding = limits.max_storage_buffer_binding_size;
+                    assert!(!storage || bytes(&arena) <= binding);
+                }
+            }
+            for large in [
+                Arena::translucent(device, 24, GRAIN),
+                Arena::translucent_indices(device, GRAIN),
+            ] {
+                assert!(bytes(&large) <= LARGE_PAGE_BYTES.min(limits.max_buffer_size));
+                assert!(!large.usage.contains(wgpu::BufferUsages::STORAGE));
+            }
+        }
+    }
+
+    /// The translucent arena comes with the split layout alone, and only then
+    /// are the index pages large. Otherwise, as while a shader pack's terrain
+    /// draws flat (gfx's `translucent_split`), translucent quads keep to the
+    /// section arena, and flat draws (`flat`) bind the index pages as storage.
+    #[test]
+    fn translucent_arenas_follow_the_layout() {
+        let devices = devices();
+        if devices.is_empty() {
+            eprintln!("no GPU adapter: skipped");
+            return;
+        }
+        let mut exercised = false;
+        for (device, _) in &devices {
+            let limits = device.limits();
+            let large = limits.max_buffer_size > PAGE_BYTES;
+            exercised |= large;
+            for flat in [false, true] {
+                for split in [false, true] {
+                    let case = format!("large {large}, flat {flat}, split {split}");
+                    let (indices, translucent) = Arena::translucent_arenas(device, 24, flat, split);
+                    assert_eq!(translucent.is_some(), split, "{case}");
+                    let bytes = indices.page_vertices() * 4;
+                    let storage = indices.usage.contains(wgpu::BufferUsages::STORAGE);
+                    assert_eq!(storage, flat && !split, "{case}");
+                    assert!(!storage || bytes <= limits.max_storage_buffer_binding_size);
+                    assert_eq!(bytes > PAGE_BYTES, split && large, "{case}");
+                    if let Some(t) = translucent {
+                        assert_eq!(t.page_vertices() * 24 > PAGE_BYTES, large, "{case}");
+                    }
+                }
+            }
+        }
+        if !exercised {
+            eprintln!("buffers end at PAGE_BYTES here: large pages not exercised");
+        }
+    }
+
+    /// Pages double up to `PAGE_BYTES`, then grow by `PAGE_BYTES` at most.
+    #[test]
+    fn large_pages_grow_by_bounded_steps() {
+        let Some((device, _)) = device() else {
+            eprintln!("no GPU adapter: skipped");
+            return;
+        };
+        let mut arena = Arena::translucent(&device, 24, GRAIN);
+        // Exercise the policy past the test device's own buffer limit.
+        arena.page_limit = LARGE_PAGE_BYTES / 24 / GRAIN * GRAIN;
+        let step = PAGE_BYTES / 24;
+        assert_eq!(arena.grown(1 << 18, GRAIN), 1 << 19);
+        assert_eq!(arena.grown(step, GRAIN), 2 * step);
+        assert_eq!(arena.grown(3 * step, GRAIN), 4 * step);
+        assert_eq!(arena.grown(3 * step, step + GRAIN), 4 * step + GRAIN);
+        assert_eq!(
+            arena.grown(arena.page_limit - GRAIN, GRAIN),
+            arena.page_limit
+        );
+    }
+
     #[test]
     fn clearing_an_arena_releases_buffers_and_can_allocate_again() {
         let Some((device, queue)) = device() else {
@@ -638,7 +924,9 @@ mod tests {
         };
         for mut arena in [
             Arena::new(&device, 28, GRAIN, false),
+            Arena::translucent(&device, 24, GRAIN),
             Arena::indices(&device, GRAIN, false),
+            Arena::translucent_indices(&device, GRAIN),
         ] {
             alloc(&mut arena, &device, &queue, GRAIN).unwrap();
             assert_eq!(arena.bytes(), arena.stride * GRAIN);

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

@@ -0,0 +1,224 @@
+//! The colour of block light for Horizon's shader packs (`[[lights]]`, docs/api/shaders.md):
+//! a grid of cells around the camera, each holding the colour of the light sources that
+//! reach it, averaged by how near each is, which the material stage reads through the
+//! prelude's `block_light_color`. Block light keeps its own brightness (the light engine's,
+//! which walls stop): the grid only tints it, so it needs no occlusion of its own.
+//!
+//! The grid is rebuilt on the CPU when the camera moves on to another 16-block step or the
+//! light sources change, from the sources the section meshes list (`SectionMesh::lights`).
+
+use crate::fast_hash::FxHashMap;
+use glam::{DVec3, Vec3};
+
+use super::SectionKey;
+
+/// Cells along each side of the grid.
+pub const SIZE: u32 = 64;
+/// The side of a cell, in blocks: the grid spans 128 blocks.
+pub const CELL: f32 = 2.0;
+/// The grid moves in steps of this many blocks.
+const STEP: i32 = 16;
+/// The most sources one rebuild splats, the nearest first (a lava lake lists thousands).
+const MAX_SOURCES: usize = 2048;
+/// `[[lights]]` colours go up to 4; the cells keep them over 4 in 8 bits.
+const COLOR_RANGE: f32 = 4.0;
+
+/// The light a block state gives off: its `[[lights]]` colour and its level, 1 to 15.
+pub type LightTable = FxHashMap<u32, ([f32; 3], u8)>;
+
+pub struct BlockLight {
+    texture: wgpu::Texture,
+    pub view: wgpu::TextureView,
+    /// `block_light_grid`: the grid's corner, camera-relative, and the side of a cell.
+    pub grid: wgpu::Buffer,
+    table: LightTable,
+    /// The world corner and the sources' revision the texture was last built for.
+    built: Option<([i32; 3], u64)>,
+}
+
+impl BlockLight {
+    pub fn new(device: &wgpu::Device, table: LightTable) -> Self {
+        let texture = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some("Native shader pack block light colours"),
+            size: wgpu::Extent3d {
+                width: SIZE,
+                height: SIZE,
+                depth_or_array_layers: SIZE,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D3,
+            format: wgpu::TextureFormat::Rgba8Unorm,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+            view_formats: &[],
+        });
+        let grid = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Native shader pack block light grid"),
+            size: 16,
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        Self {
+            view: texture.create_view(&Default::default()),
+            texture,
+            grid,
+            table,
+            built: None,
+        }
+    }
+
+    /// Places the grid around `camera`, rebuilding it when it moved or `revision` (of
+    /// `sections`' sources) changed.
+    pub fn update(
+        &mut self,
+        queue: &wgpu::Queue,
+        camera: DVec3,
+        sections: &FxHashMap<SectionKey, Vec<([i32; 3], u32)>>,
+        revision: u64,
+    ) {
+        let half = (SIZE as f32 * CELL / 2.0) as f64;
+        let origin = ((camera - half) / f64::from(STEP))
+            .floor()
+            .as_ivec3()
+            .to_array()
+            .map(|v| v * STEP);
+        let corner = (glam::IVec3::from(origin).as_dvec3() - camera).as_vec3();
+        queue.write_buffer(
+            &self.grid,
+            0,
+            bytemuck::cast_slice(&[corner.x, corner.y, corner.z, CELL]),
+        );
+        if self.built == Some((origin, revision)) {
+            return;
+        }
+        self.built = Some((origin, revision));
+        let cells = build(&self.table, origin, camera, sections);
+        queue.write_texture(
+            self.texture.as_image_copy(),
+            &cells,
+            wgpu::TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(SIZE * 4),
+                rows_per_image: Some(SIZE),
+            },
+            self.texture.size(),
+        );
+    }
+}
+
+/// The cells of the grid with its corner at `origin`: RGBA8, x fastest, then y, then z.
+fn build(
+    table: &LightTable,
+    origin: [i32; 3],
+    camera: DVec3,
+    sections: &FxHashMap<SectionKey, Vec<([i32; 3], u32)>>,
+) -> Vec<u8> {
+    let n = SIZE as usize;
+    let mut cells = vec![0u8; n * n * n * 4];
+    if table.is_empty() {
+        return cells;
+    }
+    let span = SIZE as i32 * CELL as i32;
+    // Sections the grid or the light reaching into it (15 blocks) touches.
+    let lo = origin.map(|v| (v - 15).div_euclid(16));
+    let hi = origin.map(|v| (v + span + 15).div_euclid(16));
+    let mut sources: Vec<(Vec3, [f32; 3], f32, f64)> = Vec::new();
+    for (key, lights) in sections {
+        let key = [key.0, key.1 + crate::chunk::MIN_Y.div_euclid(16), key.2];
+        if (0..3).any(|i| key[i] < lo[i] || key[i] > hi[i]) {
+            continue;
+        }
+        for &(pos, state) in lights {
+            let Some(&(color, level)) = table.get(&state) else {
+                continue;
+            };
+            let center = glam::IVec3::from(pos).as_dvec3() + 0.5;
+            let local = (center - glam::IVec3::from(origin).as_dvec3()).as_vec3();
+            sources.push((
+                local,
+                color,
+                f32::from(level),
+                center.distance_squared(camera),
+            ));
+        }
+    }
+    if sources.len() > MAX_SOURCES {
+        sources.select_nth_unstable_by(MAX_SOURCES, |a, b| a.3.total_cmp(&b.3));
+        sources.truncate(MAX_SOURCES);
+    }
+    let mut sum = vec![[0.0f32; 4]; n * n * n];
+    for (at, color, reach, _) in sources {
+        let first = ((at - reach) / CELL).floor().max(Vec3::ZERO).as_ivec3();
+        let last = ((at + reach) / CELL)
+            .ceil()
+            .min(Vec3::splat(SIZE as f32 - 1.0))
+            .as_ivec3();
+        for z in first.z..=last.z {
+            for y in first.y..=last.y {
+                for x in first.x..=last.x {
+                    let cell = (Vec3::new(x as f32, y as f32, z as f32) + 0.5) * CELL;
+                    let d = cell.distance(at);
+                    if d >= reach {
+                        continue;
+                    }
+                    // As block light falls off: strongest at the source, gone at its level.
+                    let w = (1.0 - d / reach).powi(2);
+                    let s = &mut sum[x as usize + n * (y as usize + n * z as usize)];
+                    s[0] += color[0] * w;
+                    s[1] += color[1] * w;
+                    s[2] += color[2] * w;
+                    s[3] += w;
+                }
+            }
+        }
+    }
+    for (cell, s) in cells.as_chunks_mut::<4>().0.iter_mut().zip(&sum) {
+        if s[3] <= 0.0 {
+            continue;
+        }
+        let byte = |v: f32| (v.clamp(0.0, 1.0) * 255.0).round() as u8;
+        for i in 0..3 {
+            cell[i] = byte(s[i] / s[3] / COLOR_RANGE);
+        }
+        cell[3] = byte(s[3]);
+    }
+    cells
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_source_tints_the_cells_it_reaches_with_its_colour() {
+        let mut table = LightTable::default();
+        table.insert(7, ([2.0, 1.0, 0.0], 14));
+        let mut sections = FxHashMap::default();
+        // A torch at world (8, 64, 8): section y = (64 - MIN_Y) / 16.
+        let sy = (64 - crate::chunk::MIN_Y) / 16;
+        sections.insert((0, sy, 0), vec![([8, 64, 8], 7)]);
+        let camera = DVec3::new(8.0, 64.0, 8.0);
+        let origin = [-64, 0, -64];
+        let cells = build(&table, origin, camera, &sections);
+        let n = SIZE as usize;
+        let at = |p: [i32; 3]| {
+            let c = p
+                .iter()
+                .zip(origin)
+                .map(|(v, o)| ((v - o) as f32 / CELL) as usize)
+                .collect::<Vec<_>>();
+            let i = (c[0] + n * (c[1] + n * c[2])) * 4;
+            [cells[i], cells[i + 1], cells[i + 2], cells[i + 3]]
+        };
+        let near = at([8, 64, 8]);
+        // The colour over 4, whatever the weight: (2, 1, 0) / 4.
+        assert_eq!(&near[..3], &[128, 64, 0]);
+        assert!(near[3] > 150);
+        assert_eq!(at([8, 64, 40]), [0; 4], "past its level, nothing");
+        assert!(
+            build(&LightTable::default(), origin, camera, &sections)
+                .iter()
+                .all(|&b| b == 0)
+        );
+    }
+}

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

@@ -528,7 +528,11 @@ impl Cull {
 
     /// Between the phases (`InShader`): draw the tested boxes in a pass of
     /// their own that reads phase 1's depth, bound by `bind_depth`.
-    pub fn test_pass(&self, encoder: &mut wgpu::CommandEncoder) {
+    pub fn test_pass(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        timing: Option<&mut super::pack_timing::PassTiming>,
+    ) {
         let (Some(Group { group, .. }), Some(DepthGroup { view, group: depth })) =
             (&self.group, &self.depth_group)
         else {
@@ -539,6 +543,7 @@ impl Cull {
         }
         let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("Section culling"),
+            timestamp_writes: timing.and_then(|t| t.writes("Occlusion test")),
             color_attachments: &[],
             depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
                 view,
@@ -580,23 +585,25 @@ impl Cull {
         self.current = Some(self.next);
     }
 
-    /// After the frame's submission: start reading its results back.
-    pub fn submitted(&mut self) {
-        let Some(i) = self.current.take() else {
-            return;
-        };
+    /// The frame's results to read back, started by calling it right after the frame's
+    /// submission (on the submit thread, when the frame goes there).
+    pub fn submitted(&mut self) -> Option<impl FnOnce() + Send + 'static> {
+        let i = self.current.take()?;
         let r = &self.readbacks[i];
         let state = r.state.clone();
         state.store(PENDING, Ordering::Release);
-        r.buffer
-            .slice(..r.slots.len() as u64 * 4)
-            .map_async(wgpu::MapMode::Read, move |result| {
-                state.store(
-                    if result.is_ok() { MAPPED } else { FREE },
-                    Ordering::Release,
-                );
-            });
+        let (buffer, bytes) = (r.buffer.clone(), r.slots.len() as u64 * 4);
         self.next = (i + 1) % READBACKS;
+        Some(move || {
+            buffer
+                .slice(..bytes)
+                .map_async(wgpu::MapMode::Read, move |result| {
+                    state.store(
+                        if result.is_ok() { MAPPED } else { FREE },
+                        Ordering::Release,
+                    );
+                });
+        })
     }
 
     fn make_group(

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

@@ -20,6 +20,8 @@ const MATERIALS: usize = 10;
 /// (`RenderTypes.entityTranslucent`, `entityTranslucentEmissive`, `eyes`,
 /// `breezeWind`). Only the improved transparency path reads it.
 pub const OIT_ENTITY: u32 = 1 << 24;
+/// `RenderPipelines.DRAGON_RAYS`: untextured colour, additive with depth writes.
+pub const DRAGON_RAYS_OVERLAY: u32 = 37;
 /// Tags quads as drawn by a render type vanilla gives an `OitPipelineSet`
 /// (`OIT_ENTITY`): improved transparency draws them in its stages.
 pub fn mark_oit(quads: &mut [Vertex]) {
@@ -79,6 +81,11 @@ pub(super) struct EntityBatch {
 }
 
 impl EntityBatch {
+    /// After `update`: quads only a native pack's shadow pass draws, at the buffer's end.
+    pub(super) fn append_shadow_only(&mut self, shadow_only: &[Vertex]) {
+        self.combined.extend_from_slice(shadow_only);
+    }
+
     pub(super) fn update(
         &mut self,
         entities: &[Vertex],

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

@@ -258,13 +258,20 @@ impl EntityOutline {
         frame: &wgpu::TextureView,
         entity_group: &wgpu::BindGroup,
         indices: &wgpu::Buffer,
+        mut timing: Option<&mut super::pack_timing::PassTiming>,
     ) {
         let Some(t) = self.targets.as_ref().filter(|_| self.quads > 0) else {
             return;
         };
         let clear = wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT);
         {
-            let mut pass = begin(encoder, "Entity outline", &t.outline, clear);
+            let mut pass = begin(
+                encoder,
+                "Entity outline",
+                &t.outline,
+                clear,
+                timing.as_deref_mut(),
+            );
             pass.set_pipeline(&self.silhouette);
             pass.set_bind_group(0, entity_group, &[]);
             pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32);
@@ -280,7 +287,7 @@ impl EntityOutline {
             ("Entity outline blit", frame, wgpu::LoadOp::Load),
         ];
         for (i, (label, view, load)) in steps.into_iter().enumerate() {
-            let mut pass = begin(encoder, label, view, load);
+            let mut pass = begin(encoder, label, view, load, timing.as_deref_mut());
             pass.set_pipeline(&self.passes[i]);
             pass.set_bind_group(0, &t.groups[i], &[]);
             pass.draw(0..3, 0..1);
@@ -293,6 +300,7 @@ fn begin<'e>(
     label: &str,
     view: &wgpu::TextureView,
     load: wgpu::LoadOp<wgpu::Color>,
+    timing: Option<&mut super::pack_timing::PassTiming>,
 ) -> wgpu::RenderPass<'e> {
     let attachments = [Some(wgpu::RenderPassColorAttachment {
         view,
@@ -305,6 +313,7 @@ fn begin<'e>(
     })];
     encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
         label: Some(label),
+        timestamp_writes: timing.and_then(|t| t.writes(label)),
         color_attachments: &attachments,
         ..Default::default()
     })

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

@@ -62,7 +62,13 @@ pub struct Call {
 }
 
 pub struct Flat {
+    /// The solid draws in one pass (`fs_solid`), where the GPU doesn't hide pixels
+    /// by tiles (`split_solid` in `Renderer::draw_frame`: elsewhere than Metal).
     pub solid: wgpu::RenderPipeline,
+    /// The solid draws in two passes over the same draws (terrain.wgsl's `opaque_quad`):
+    /// the quads with no cutout first, through a shader that never discards, then the rest.
+    pub solid_opaque: wgpu::RenderPipeline,
+    pub solid_cutout: wgpu::RenderPipeline,
     /// The solid draws as the water mirror's camera draws them (`fs_solid_mirror`).
     pub solid_mirror: wgpu::RenderPipeline,
     pub translucent: wgpu::RenderPipeline,
@@ -286,7 +292,7 @@ fn plan(
 }
 
 impl Flat {
-    /// `pipeline(layout, label, fragment entry, blend, cull)` builds a
+    /// `pipeline(layout, label, vertex entry, fragment entry, blend, cull)` builds a
     /// terrain pipeline as the per-section ones, without the origin buffer.
     pub fn new(
         device: &wgpu::Device,
@@ -297,6 +303,7 @@ impl Flat {
             &wgpu::PipelineLayout,
             &str,
             &str,
+            &str,
             Option<wgpu::BlendState>,
             Option<wgpu::Face>,
         ) -> wgpu::RenderPipeline,
@@ -354,11 +361,35 @@ impl Flat {
         let storage_usage = wgpu::BufferUsages::STORAGE;
         let back = Some(wgpu::Face::Back);
         Self {
-            solid: pipeline(&layout, "Terrain solid (flat)", "fs_solid", None, back),
+            solid: pipeline(
+                &layout,
+                "Terrain solid (flat)",
+                "vs_terrain_flat",
+                "fs_solid",
+                None,
+                back,
+            ),
+            solid_opaque: pipeline(
+                &layout,
+                "Terrain solid opaque (flat)",
+                "vs_terrain_flat_opaque",
+                "fs_opaque",
+                None,
+                back,
+            ),
+            solid_cutout: pipeline(
+                &layout,
+                "Terrain solid cutout (flat)",
+                "vs_terrain_flat_cutout",
+                "fs_solid",
+                None,
+                back,
+            ),
             // The mirror flips the winding: its solid terrain culls the front.
             solid_mirror: pipeline(
                 &layout,
                 "Terrain solid mirrored (flat)",
+                "vs_terrain_flat",
                 "fs_solid_mirror",
                 None,
                 Some(wgpu::Face::Front),
@@ -366,6 +397,7 @@ impl Flat {
             translucent: pipeline(
                 &layout,
                 "Terrain translucent (flat)",
+                "vs_terrain_flat",
                 "fs_translucent",
                 Some(wgpu::BlendState::ALPHA_BLENDING),
                 back,
@@ -490,6 +522,7 @@ impl Flat {
         phase2: Option<&wgpu::Buffer>,
         origins: impl Iterator<Item = (u32, [f32; 4])>,
         sorted_page: impl Fn(u32) -> wgpu::Buffer,
+        timing: Option<&mut super::pack_timing::PassTiming>,
     ) -> bool {
         self.phase2_group = None;
         let phase1_draws = if phase2.is_some() {
@@ -668,7 +701,7 @@ impl Flat {
             .collect();
         let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
             label: Some("Flatten section draws"),
-            timestamp_writes: None,
+            timestamp_writes: timing.and_then(|t| t.compute_writes("Flatten")),
         });
         pass.set_pipeline(&self.flatten);
         for (group, count) in &groups {
@@ -700,13 +733,17 @@ impl Flat {
         true
     }
     /// After occlusion culling's test: copies the phase 2 draws it saw.
-    pub fn flatten_phase2(&self, encoder: &mut wgpu::CommandEncoder) {
+    pub fn flatten_phase2(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        timing: Option<&mut super::pack_timing::PassTiming>,
+    ) {
         let Some((group, count)) = &self.phase2_group else {
             return;
         };
         let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
             label: Some("Flatten phase 2 section draws"),
-            timestamp_writes: None,
+            timestamp_writes: timing.and_then(|t| t.compute_writes("Flatten phase 2")),
         });
         pass.set_pipeline(&self.flatten_seen);
         pass.set_bind_group(0, group, &[]);

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

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

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

@@ -10,8 +10,8 @@
 //! priorities and vectors) and fill the game field's holes from a pyramid; mask what each
 //! frame can't see; blend the two frames along both fields; fill what is left from a
 //! pyramid of the result. What differs from AMD's, all forced by WGSL or by Horizon:
-//! the game's motion vectors are computed from the depth and `Inputs::reproject` (the
-//! camera's, so what moves on its own relies on the optical flow); textures AMD updates
+//! the game's motion vectors are the camera's, from the depth and `Inputs::reproject`,
+//! except where `Inputs::object_motion` has an entity's own; textures AMD updates
 //! with image atomics are storage buffers; SPD's single-pass pyramids are a pass per
 //! level; and there is no HUD-less pass, as Horizon draws its HUD over the made frame.
 
@@ -33,6 +33,9 @@ pub struct Inputs<'a> {
     /// `world_post::reprojection`): the motion vectors are the camera's, from this and
     /// the depth.
     pub reproject: Mat4,
+    /// What moved on its own: `motion::FORMAT` at `render_size`, xy its motion vector
+    /// (FSR's convention, in UV) where z is 1, used over the camera's.
+    pub object_motion: &'a wgpu::TextureView,
     pub near: f32,
     pub far: f32,
     /// Vertical field of view, radians.
@@ -442,6 +445,7 @@ impl Interpolation {
             &[
                 (0, params()),
                 (2, view(inputs.depth)),
+                (34, view(inputs.object_motion)),
                 (5, view(&r.dilated_depth)),
                 (6, view(&r.dilated_mv)),
                 (9, whole(&r.rec_prev_depth)),
@@ -644,10 +648,12 @@ mod tests {
     /// Runs `frames` (pattern shifts) through the optical flow and the interpolation with
     /// a camera that moves by `reproject` each frame, and returns the mean error of the
     /// last made frame's interior against `expected`, and the last two real frames'.
+    /// `object`: every pixel's own motion vector (UV), as if all of it moved on its own.
     fn interpolate(
         seed: u32,
         shifts: &[[i32; 2]],
         reproject: Mat4,
+        object: Option<[f32; 2]>,
         expected: [i32; 2],
     ) -> Option<[f32; 3]> {
         let (device, queue) = of::device()?;
@@ -682,6 +688,35 @@ mod tests {
             ..Default::default()
         });
         queue.submit([encoder.finish()]);
+        let object_motion = device.create_texture(&wgpu::TextureDescriptor {
+            label: None,
+            size: wgpu::Extent3d {
+                width: size[0],
+                height: size[1],
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: super::super::motion::FORMAT,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+            view_formats: &[],
+        });
+        if let Some(mv) = object {
+            let texel = [mv[0], mv[1], 1.0, 0.0].map(|v| half::f16::from_f32(v).to_bits());
+            let texels: Vec<u16> = (0..size[0] * size[1]).flat_map(|_| texel).collect();
+            queue.write_texture(
+                object_motion.as_image_copy(),
+                bytemuck::cast_slice(&texels),
+                wgpu::TexelCopyBufferLayout {
+                    offset: 0,
+                    bytes_per_row: Some(size[0] * 8),
+                    rows_per_image: None,
+                },
+                object_motion.size(),
+            );
+        }
+        let object_motion = object_motion.create_view(&Default::default());
         let mut flow = OpticalFlow::new(&device, size);
         let mut interpolation = Interpolation::new(&device, size);
         let frames: Vec<_> = shifts
@@ -731,6 +766,7 @@ mod tests {
                     render_size: size,
                     jitter: [0.0; 2],
                     reproject: if i == 0 { Mat4::IDENTITY } else { reproject },
+                    object_motion: &object_motion,
                     near: 0.05,
                     far: 512.0,
                     fov_y: 1.2,
@@ -776,7 +812,8 @@ mod tests {
     fn moves_what_the_optical_flow_follows_halfway() {
         let mut shifts = vec![[0, 0]; 20];
         shifts.push([16, 8]);
-        let Some([made, previous, current]) = interpolate(100, &shifts, Mat4::IDENTITY, [8, 4])
+        let Some([made, previous, current]) =
+            interpolate(100, &shifts, Mat4::IDENTITY, None, [8, 4])
         else {
             return;
         };
@@ -795,7 +832,26 @@ mod tests {
         // What is at a pixel now was 16 pixels to its right last frame.
         let reproject = Mat4::from_translation(glam::Vec3::new(32.0 / size[0], 0.0, 0.0));
         let shifts = [[0, 0], [-16, 0], [-32, 0], [-48, 0]];
-        let Some([made, previous, current]) = interpolate(1, &shifts, reproject, [-40, 0]) else {
+        let Some([made, previous, current]) = interpolate(1, &shifts, reproject, None, [-40, 0])
+        else {
+            return;
+        };
+        assert!(
+            made * 4.0 < previous.min(current),
+            "{made} against {previous} and {current}"
+        );
+    }
+
+    /// Something moving on its own with its own motion vectors (the camera still): the
+    /// made frame is halfway, as with the camera's.
+    #[test]
+    fn moves_what_has_its_own_motion_vectors_halfway() {
+        let size = [512.0, 288.0];
+        let shifts = [[0, 0], [16, 8], [32, 16], [48, 24]];
+        let mv = [-16.0 / size[0], -8.0 / size[1]];
+        let Some([made, previous, current]) =
+            interpolate(1, &shifts, Mat4::IDENTITY, Some(mv), [40, 20])
+        else {
             return;
         };
         assert!(

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

@@ -24,7 +24,8 @@
 // for Horizon, for an SDR back buffer, inverted finite depth, the whole screen as the
 // interpolation rect and no distortion field. What differs from AMD's (interpolation.rs
 // lists why):
-// - the motion vectors come from the depth and the camera (`prepare`), already unjittered;
+// - the motion vectors are the camera's, from the depth (`prepare`), already unjittered,
+//   or an entity's own where `object_motion` has one;
 // - the vector fields and reconstructed depths are storage buffers of atomics;
 // - both inpainting pyramids are a pass per level, and textures of their own;
 // - the interpolation writes one texture and the inpainting another (rgba16float can't
@@ -85,6 +86,8 @@ struct Params {
 @group(0) @binding(31) var interpolated_out: texture_storage_2d<rgba16float, write>;
 @group(0) @binding(32) var interpolated: texture_2d<f32>;
 @group(0) @binding(33) var output: texture_storage_2d<rgba16float, write>;
+// What moved on its own (motion.wgsl): xy its motion vector where z is 1.
+@group(0) @binding(34) var object_motion: texture_2d<f32>;
 
 const EPSILON: f32 = 1e-03;
 const RECONSTRUCTED_DEPTH_WEIGHT_THRESHOLD: f32 = EPSILON;
@@ -355,7 +358,11 @@ fn prepare_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
             }
         }
     }
-    let mv = camera_motion_vector(nearest_coord, load_input_depth(nearest_coord));
+    let object = textureLoad(object_motion, nearest_coord, 0);
+    var mv = camera_motion_vector(nearest_coord, load_input_depth(nearest_coord));
+    if object.z > 0.5 {
+        mv = object.xy;
+    }
     textureStore(dilated_depth_out, p, vec4(nearest, 0.0, 0.0, 0.0));
     textureStore(dilated_mv_out, p, vec4(mv, 0.0, 0.0));
     // ReconstructPrevDepth

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

@@ -0,0 +1,306 @@
+//! Motion vectors for what moves on its own, for frame generation: the camera's motion
+//! vectors (from the depth) see mobs and dropped items as still. The game tags each
+//! entity's vertices with its id (`Frame::entity_motion`); an entity whose vertices have
+//! the same shape as last frame's (the same count, UVs and layers) gets each vertex's
+//! own motion, limbs and spin included, drawn into a texture at the render size
+//! (`motion.wgsl`) that the interpolation reads before the camera's.
+
+use crate::mesher::Vertex;
+use glam::{DVec3, Mat4, Vec3};
+use std::collections::HashMap;
+
+/// `motion.wgsl`'s `Params`.
+#[repr(C)]
+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+struct Params {
+    jittered: [[f32; 4]; 4],
+    current: [[f32; 4]; 4],
+    previous: [[f32; 4]; 4],
+}
+
+/// A vertex this frame and where it was last frame, both relative to this frame's camera.
+#[repr(C)]
+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+struct MotionVertex {
+    position: [f32; 3],
+    previous: [f32; 3],
+    uv: [f32; 2],
+    /// 1 for a translucent item, whose texture says where it shows.
+    translucent: u32,
+}
+
+pub struct ObjectMotion {
+    pipeline: wgpu::RenderPipeline,
+    atlas: wgpu::TextureView,
+    sampler: wgpu::Sampler,
+    params: wgpu::Buffer,
+    vertices: wgpu::Buffer,
+    /// Triangles of the entities matched this frame.
+    staged: Vec<MotionVertex>,
+    /// Last frame's vertices by entity, and its camera.
+    tracked: HashMap<u64, Vec<Vertex>>,
+    camera: DVec3,
+    target: Option<([u32; 2], wgpu::TextureView)>,
+}
+
+pub const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
+
+impl ObjectMotion {
+    /// `atlas`: the entities' texture atlas.
+    pub fn new(device: &wgpu::Device, atlas: wgpu::TextureView) -> Self {
+        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Frame generation motion"),
+            source: wgpu::ShaderSource::Wgsl(include_str!("motion.wgsl").into()),
+        });
+        let attributes =
+            wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3, 2 => Float32x2, 3 => Uint32];
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("Frame generation motion"),
+            layout: None,
+            vertex: wgpu::VertexState {
+                module: &module,
+                entry_point: Some("vs_motion"),
+                compilation_options: Default::default(),
+                buffers: &[Some(wgpu::VertexBufferLayout {
+                    array_stride: std::mem::size_of::<MotionVertex>() as u64,
+                    step_mode: wgpu::VertexStepMode::Vertex,
+                    attributes: &attributes,
+                })],
+            },
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: &module,
+                entry_point: Some("fs_motion"),
+                compilation_options: Default::default(),
+                targets: &[Some(FORMAT.into())],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        Self {
+            pipeline,
+            atlas,
+            sampler: device.create_sampler(&Default::default()),
+            params: device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some("Frame generation motion"),
+                size: std::mem::size_of::<Params>() as u64,
+                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
+            }),
+            vertices: vertex_buffer(device, 1 << 12),
+            staged: Vec::new(),
+            tracked: HashMap::new(),
+            camera: DVec3::ZERO,
+            target: None,
+        }
+    }
+
+    /// Forget last frame's entities: the next frame has no motion of its own.
+    pub fn reset(&mut self) {
+        self.tracked.clear();
+    }
+
+    /// Match this frame's `entities` (relative to `camera`) to last frame's by the ids
+    /// `spans` gives their vertices (start, id; 0 for none, each up to the next start), and
+    /// keep them for the next frame.
+    pub fn track(&mut self, entities: &[Vertex], spans: &[(u32, u64)], camera: DVec3) {
+        self.staged.clear();
+        let shift = (self.camera - camera).as_vec3();
+        let mut tracked = HashMap::with_capacity(self.tracked.len());
+        for (i, &(start, id)) in spans.iter().enumerate() {
+            let end = spans.get(i + 1).map_or(entities.len(), |s| s.0 as usize);
+            let Some(now) = entities
+                .get(start as usize..end)
+                .filter(|v| id != 0 && !v.is_empty())
+            else {
+                continue;
+            };
+            if let Some(then) = self.tracked.remove(&id)
+                && then.len() == now.len()
+                && then
+                    .iter()
+                    .zip(now)
+                    .all(|(a, b)| a.uv == b.uv && a.layer == b.layer)
+            {
+                let pair = |i: usize| MotionVertex {
+                    position: now[i].pos,
+                    previous: (Vec3::from(then[i].pos) + shift).into(),
+                    uv: now[i].uv,
+                    translucent: u32::from(matches!(
+                        now[i].layer,
+                        super::super::entity_batch::TRANSLUCENT_ITEM_OVERLAY
+                            | super::super::entity_batch::TRANSLUCENT_GLINT_ITEM_OVERLAY
+                    )),
+                };
+                for q in (0..now.len() / 4).map(|q| q * 4) {
+                    self.staged
+                        .extend([q, q + 1, q + 2, q, q + 2, q + 3].map(pair));
+                }
+            }
+            tracked.insert(id, now.to_vec());
+        }
+        self.tracked = tracked;
+        self.camera = camera;
+    }
+
+    /// Draw the matched entities' motion vectors at `size` (the world's render size),
+    /// where `depth` (the world's) shows them; the rest of the texture is 0.
+    #[allow(clippy::too_many_arguments)]
+    pub fn draw(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        encoder: &mut wgpu::CommandEncoder,
+        depth: &wgpu::TextureView,
+        size: [u32; 2],
+        jittered: Mat4,
+        current: Mat4,
+        previous: Mat4,
+    ) -> wgpu::TextureView {
+        if self.target.as_ref().is_none_or(|t| t.0 != size) {
+            let texture = device.create_texture(&wgpu::TextureDescriptor {
+                label: Some("Frame generation motion"),
+                size: wgpu::Extent3d {
+                    width: size[0],
+                    height: size[1],
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: FORMAT,
+                usage: wgpu::TextureUsages::RENDER_ATTACHMENT
+                    | wgpu::TextureUsages::TEXTURE_BINDING
+                    | wgpu::TextureUsages::COPY_SRC,
+                view_formats: &[],
+            });
+            self.target = Some((size, texture.create_view(&Default::default())));
+        }
+        let target = self.target.as_ref().expect("made above").1.clone();
+        let bytes: &[u8] = bytemuck::cast_slice(&self.staged);
+        if bytes.len() as u64 > self.vertices.size() {
+            self.vertices = vertex_buffer(device, (bytes.len() as u64).next_power_of_two());
+        }
+        if !bytes.is_empty() {
+            queue.write_buffer(&self.vertices, 0, bytes);
+        }
+        let params = Params {
+            jittered: jittered.to_cols_array_2d(),
+            current: current.to_cols_array_2d(),
+            previous: previous.to_cols_array_2d(),
+        };
+        queue.write_buffer(&self.params, 0, bytemuck::bytes_of(&params));
+        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("Frame generation motion"),
+            layout: &self.pipeline.get_bind_group_layout(0),
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: self.params.as_entire_binding(),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::TextureView(depth),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 2,
+                    resource: wgpu::BindingResource::TextureView(&self.atlas),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 3,
+                    resource: wgpu::BindingResource::Sampler(&self.sampler),
+                },
+            ],
+        });
+        let attachments = [Some(wgpu::RenderPassColorAttachment {
+            view: &target,
+            resolve_target: None,
+            depth_slice: None,
+            ops: wgpu::Operations {
+                load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
+                store: wgpu::StoreOp::Store,
+            },
+        })];
+        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: Some("Frame generation motion"),
+            color_attachments: &attachments,
+            ..Default::default()
+        });
+        if !self.staged.is_empty() {
+            pass.set_pipeline(&self.pipeline);
+            pass.set_bind_group(0, &group, &[]);
+            pass.set_vertex_buffer(0, self.vertices.slice(..bytes.len() as u64));
+            pass.draw(0..self.staged.len() as u32, 0..1);
+        }
+        drop(pass);
+        target
+    }
+}
+
+fn vertex_buffer(device: &wgpu::Device, size: u64) -> wgpu::Buffer {
+    device.create_buffer(&wgpu::BufferDescriptor {
+        label: Some("Frame generation motion vertices"),
+        size,
+        usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
+        mapped_at_creation: false,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn shader_validates() {
+        let module = naga::front::wgsl::parse_str(include_str!("motion.wgsl")).unwrap();
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::empty(),
+        )
+        .validate(&module)
+        .unwrap();
+    }
+
+    fn quad(x: f32, uv: f32) -> Vec<Vertex> {
+        (0..4)
+            .map(|i| Vertex {
+                pos: [x + i as f32, 0.0, -5.0],
+                uv: [uv, 0.0],
+                ..bytemuck::Zeroable::zeroed()
+            })
+            .collect()
+    }
+
+    /// An entity seen last frame gets its vertices' own motion, in this frame's camera
+    /// space; a new one, one whose shape changed and untagged geometry get none.
+    #[test]
+    fn tracks_each_entity_by_id() {
+        let Some((device, queue)) = super::super::optical_flow::tests::device() else {
+            return;
+        };
+        let atlas = super::super::optical_flow::tests::upload(&device, &queue, [1, 1], &[0; 4]);
+        let mut motion = ObjectMotion::new(&device, atlas);
+        let mut entities = quad(0.0, 0.0);
+        entities.extend(quad(10.0, 0.5));
+        motion.track(&entities, &[(0, 7), (4, 8)], DVec3::ZERO);
+        assert!(motion.staged.is_empty());
+        // Entity 7 moved 1 block right, the camera 2 blocks right; entity 8 became
+        // another item; 9 is new; then untagged geometry.
+        let mut entities = quad(-1.0, 0.0);
+        entities.extend(quad(10.0, 0.25));
+        entities.extend(quad(20.0, 0.0));
+        entities.extend(quad(30.0, 0.0));
+        motion.track(
+            &entities,
+            &[(0, 7), (4, 8), (8, 9), (12, 0)],
+            DVec3::new(2.0, 0.0, 0.0),
+        );
+        assert_eq!(motion.staged.len(), 6);
+        let v = motion.staged[0];
+        assert_eq!(v.position, [-1.0, 0.0, -5.0]);
+        assert_eq!(v.previous, [-2.0, 0.0, -5.0]);
+        assert_eq!(motion.tracked.len(), 3);
+    }
+}

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

@@ -0,0 +1,58 @@
+// Frame generation's motion vectors for what moves on its own (mobs, dropped items): each
+// vertex drawn where the world pass drew it, with where it was last frame; only the pixels
+// the world shows it at keep its vector: where the depth is its own, or, for translucent
+// items (which don't write depth), where its texture shows and nothing is in front.
+
+struct Params {
+    // The world's projection this frame (TAA's jitter in it), the same without the jitter,
+    // and last frame's projection from this frame's camera.
+    jittered: mat4x4<f32>,
+    current: mat4x4<f32>,
+    previous: mat4x4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var depth: texture_depth_2d;
+@group(0) @binding(2) var atlas: texture_2d<f32>;
+@group(0) @binding(3) var atlas_sampler: sampler;
+
+struct Out {
+    @builtin(position) clip: vec4<f32>,
+    @location(0) current: vec4<f32>,
+    @location(1) previous: vec4<f32>,
+    @location(2) uv: vec2<f32>,
+    // 1: a translucent item.
+    @location(3) @interpolate(flat) translucent: u32,
+};
+
+@vertex fn vs_motion(@location(0) position: vec3<f32>, @location(1) previous: vec3<f32>,
+    @location(2) uv: vec2<f32>, @location(3) translucent: u32) -> Out {
+    var out: Out;
+    out.uv = uv;
+    out.translucent = translucent;
+    out.clip = params.jittered * vec4(position, 1.0);
+    out.current = params.current * vec4(position, 1.0);
+    out.previous = params.previous * vec4(previous, 1.0);
+    return out;
+}
+
+// xy: the motion vector in UV (to where the pixel was last frame, FSR's convention), z: 1.
+@fragment fn fs_motion(in: Out) -> @location(0) vec4<f32> {
+    let stored = textureLoad(depth, vec2<i32>(in.clip.xy), 0);
+    let tolerance = stored * 1e-3 + 1e-7;
+    // Not what the world shows here: a transparent texel, or behind something.
+    if in.translucent != 0u {
+        let alpha = textureSampleLevel(atlas, atlas_sampler, in.uv, 0.0).a;
+        if alpha < 0.1 || in.clip.z < stored - tolerance {
+            discard;
+        }
+    } else if abs(in.clip.z - stored) > tolerance {
+        discard;
+    }
+    if in.previous.w <= 0.0 {
+        discard;
+    }
+    let now = in.current.xy / in.current.w;
+    let then = in.previous.xy / in.previous.w;
+    return vec4((then - now) * vec2(0.5, -0.5), 1.0, 0.0);
+}

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

@@ -366,7 +366,11 @@ impl Hdr {
     /// Keeps the world as drawn so far, before the hand and HUD cover it, then zeroes the
     /// frame's alpha: the world's marks live on in the copy, and whatever draws from here
     /// on raises the alpha where it covers the world.
-    pub fn keep_world(&self, encoder: &mut wgpu::CommandEncoder) {
+    pub fn keep_world(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        timing: Option<&mut super::pack_timing::PassTiming>,
+    ) {
         let Some(t) = &self.targets else {
             return;
         };
@@ -387,6 +391,7 @@ impl Hdr {
         })];
         let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("Horizon HDR UI mask"),
+            timestamp_writes: timing.and_then(|t| t.writes("HDR UI mask")),
             color_attachments: &attachments,
             ..Default::default()
         });
@@ -397,7 +402,11 @@ impl Hdr {
     /// After the hand: its pixels' alpha goes down to 1/255, below anything the HUD and
     /// menus leave, so HDR output tells the hand (the world's brightness, never lifted)
     /// from the UI (UI Brightness).
-    pub fn mark_hand(&self, encoder: &mut wgpu::CommandEncoder) {
+    pub fn mark_hand(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        timing: Option<&mut super::pack_timing::PassTiming>,
+    ) {
         let Some(t) = &self.targets else {
             return;
         };
@@ -413,6 +422,7 @@ impl Hdr {
         })];
         let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("Horizon HDR hand mark"),
+            timestamp_writes: timing.and_then(|t| t.writes("HDR hand mark")),
             color_attachments: &attachments,
             ..Default::default()
         });
@@ -434,6 +444,7 @@ impl Hdr {
         encoder: &mut wgpu::CommandEncoder,
         target: &wgpu::Texture,
         world: bool,
+        timing: Option<&mut super::pack_timing::PassTiming>,
     ) {
         let Some(t) = &self.targets else {
             return;
@@ -443,7 +454,7 @@ impl Hdr {
             0,
             bytemuck::cast_slice(&self.params(world, self.output == Output::Pq)),
         );
-        Self::draw(encoder, &self.pipeline, &t.group, target);
+        Self::draw(encoder, &self.pipeline, &t.group, target, timing);
     }
 
     /// The frame `present` writes, as HDR10 (BT.2020, PQ, 10 bits a channel) whatever
@@ -494,7 +505,7 @@ impl Hdr {
             0,
             bytemuck::cast_slice(&self.params(world, true)),
         );
-        Self::draw(encoder, &self.capture_pipeline, &group, &texture);
+        Self::draw(encoder, &self.capture_pipeline, &group, &texture, None);
         Some(texture)
     }
 
@@ -528,6 +539,7 @@ impl Hdr {
         pipeline: &wgpu::RenderPipeline,
         group: &wgpu::BindGroup,
         target: &wgpu::Texture,
+        timing: Option<&mut super::pack_timing::PassTiming>,
     ) {
         let view = target.create_view(&Default::default());
         let attachments = [Some(wgpu::RenderPassColorAttachment {
@@ -541,6 +553,7 @@ impl Hdr {
         })];
         let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("Horizon HDR"),
+            timestamp_writes: timing.and_then(|t| t.writes("HDR output")),
             color_attachments: &attachments,
             ..Default::default()
         });

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

@@ -1,4 +1,4 @@
-//! Far meshes share the terrain arena and passes, with their actual bounds
+//! Far meshes share the terrain arenas and passes, with their actual bounds
 //! rather than the 16³ boxes used by the near-section residency walk.
 use super::{Frustum, Renderer, SectionGpu};
 use crate::{

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

@@ -18,6 +18,14 @@ const PREFIX: &str = "horizon_terrain_";
 /// The entries around the pack's `material`: vanilla's vertex work without the lightmap
 /// product, then the material, the alpha test and fog as `fs_solid` and `fs_translucent` do.
 const ENTRIES: &str = "
+// The manifest's `[material] fog`: false when the pack fogs its surfaces itself.
+override horizon_material_fog: bool = true;
+fn horizon_material_fogged(color: vec4<f32>, spherical: f32, cylindrical: f32) -> vec4<f32> {
+    if horizon_material_fog {
+        return horizon_terrain_apply_fog(color, spherical, cylindrical);
+    }
+    return color;
+}
 struct HorizonMaterialOut {
     @builtin(position) clip: vec4<f32>,
     @location(0) uv: vec2<f32>,
@@ -79,26 +87,89 @@ fn horizon_material_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color
     return horizon_material_vertex(position, horizon_terrain_terrain_uv(uv, origin.w), layer,
         color, light, origin.xyz);
 }
+// The prelude's `block_normal_map` and `block_specular_map`: the resource packs' LabPBR maps
+// in the pack's frame group (3), one array each, a blank 1x1 without them.
+@group(3) @binding(12) var horizon_pbr_normals: texture_2d_array<f32>;
+@group(3) @binding(13) var horizon_pbr_specular: texture_2d_array<f32>;
+fn horizon_block_pbr_present() -> bool {
+    return textureDimensions(horizon_pbr_normals).x > 1u;
+}
+fn horizon_block_pbr_size() -> vec2<f32> {
+    return vec2<f32>(textureDimensions(horizon_pbr_normals).xy);
+}
+fn horizon_block_pbr(uv: vec2<f32>, layer: u32, lod: f32, map: u32) -> vec4<f32> {
+    if !horizon_block_pbr_present() || layer >= textureNumLayers(horizon_pbr_normals) {
+        return select(vec4<f32>(0.5, 0.5, 1.0, 1.0), vec4<f32>(0.0), map == 1u);
+    }
+    let s = horizon_terrain_sprite_sampler;
+    // The maps may be smaller than the colour: the same footprint is fewer of their texels.
+    let scale = f32(textureDimensions(horizon_terrain_sprites).x)
+        / f32(textureDimensions(horizon_pbr_normals).x);
+    let l = max(lod - log2(scale), 0.0);
+    if map == 0u {
+        return textureSampleLevel(horizon_pbr_normals, s, uv, i32(layer), l);
+    }
+    return textureSampleLevel(horizon_pbr_specular, s, uv, i32(layer), l);
+}
+// The prelude's `block_texture`: a sprite of the terrain's arrays at a mip level.
+fn horizon_block_size() -> vec2<f32> {
+    return vec2<f32>(textureDimensions(horizon_terrain_sprites).xy);
+}
+fn horizon_block_sample(uv: vec2<f32>, layer: u32, lod: f32) -> vec4<f32> {
+    let s = horizon_terrain_sprite_sampler;
+    let l = i32(layer % horizon_terrain_SPRITE_SPLIT);
+    switch layer / horizon_terrain_SPRITE_SPLIT {
+        case 0u: { return textureSampleLevel(horizon_terrain_sprites, s, uv, l, lod); }
+        case 1u: { return textureSampleLevel(horizon_terrain_sprites_1, s, uv, l, lod); }
+        case 2u: { return textureSampleLevel(horizon_terrain_sprites_2, s, uv, l, lod); }
+        case 3u: { return textureSampleLevel(horizon_terrain_sprites_3, s, uv, l, lod); }
+        case 4u: { return textureSampleLevel(horizon_terrain_sprites_4, s, uv, l, lod); }
+        case 5u: { return textureSampleLevel(horizon_terrain_sprites_5, s, uv, l, lod); }
+        case 6u: { return textureSampleLevel(horizon_terrain_sprites_6, s, uv, l, lod); }
+        default: { return textureSampleLevel(horizon_terrain_sprites_7, s, uv, l, lod); }
+    }
+}
 fn horizon_material_color(in: HorizonMaterialOut, translucent: bool) -> vec4<f32> {
     let albedo = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu);
+    horizon_block_layer = in.layer & 0x7fffu;
+    // The mip level of this point in the texture: its texels, as the sampler would pick.
+    let texels = in.uv * horizon_block_size();
+    let footprint = max(dot(dpdx(texels), dpdx(texels)), dot(dpdy(texels), dpdy(texels)));
+    horizon_block_lod = max(0.5 * log2(max(footprint, 1e-8)), 0.0);
     // Water draws translucent and lava solid, so the pass resolves the fluid kind.
     let fluid = select(0u, select(2u, 1u, translucent), in.fluid_quad != 0u);
     let normal = horizon_material_normal(in.position);
+    horizon_material_face_normal = normal;
+    horizon_surface = vec4<f32>(0.0);
     let tangent = horizon_material_tangent(in.position, in.uv, normal);
     return material(MaterialInput(albedo, in.tint, in.light, in.lightmap, in.position, in.uv,
-        translucent, horizon_sprite_tags(in.layer & 0x7fffu), in.clip.xy / frame.resolution,
+        translucent, horizon_sprite_tags(in.layer & 0x7fffu),
+        horizon_sprite_material(in.layer & 0x7fffu), in.clip.xy / frame.resolution,
         in.face, fluid, in.emission, normal, tangent)).color;
 }
-@fragment fn horizon_material_fs_solid(in: HorizonMaterialOut) -> @location(0) vec4<f32> {
+var<private> horizon_material_face_normal: vec3<f32>;
+struct HorizonMaterialSolid {
+    @location(0) color: vec4<f32>,
+    // The surface target's data: `set_surface`'s, then the fragment's depth, which the post
+    // stage's `surface_at` compares with the final depth.
+    @location(1) surface: vec4<f32>,
+}
+@fragment fn horizon_material_fs_solid(in: HorizonMaterialOut) -> HorizonMaterialSolid {
     let color = horizon_material_color(in, false);
     // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout.
     if color.a < 0.5 && (in.layer & 0x8000u) == 0u { discard; }
-    return horizon_terrain_apply_fog(vec4(color.rgb, 1.0), in.spherical, in.cylindrical);
+    if horizon_surface.w == 0.0 {
+        set_surface(horizon_material_face_normal, 0.0, 0.0);
+    }
+    var out: HorizonMaterialSolid;
+    out.color = horizon_material_fogged(vec4(color.rgb, 1.0), in.spherical, in.cylindrical);
+    out.surface = vec4(horizon_surface.xyz, in.clip.z);
+    return out;
 }
 @fragment fn horizon_material_fs_translucent(in: HorizonMaterialOut) -> @location(0) vec4<f32> {
     let color = horizon_material_color(in, true);
     if color.a < 0.01 { discard; }
-    return horizon_terrain_apply_fog(color, in.spherical, in.cylindrical);
+    return horizon_material_fogged(color, in.spherical, in.cylindrical);
 }
 ";
 
@@ -115,6 +186,16 @@ pub struct TerrainShape<'a> {
     /// The pack's tags of each tagged sprite layer, as `(layer, bits)`
     /// (`Manifest::sprite_tags`).
     pub sprite_tags: &'a [(u32, u32)],
+    /// The pack's material id of each sprite layer with one, as `(layer, id)`
+    /// (`Manifest::sprite_materials`).
+    pub sprite_materials: &'a [(u32, u32)],
+    /// The entities' group 0 (their atlas), for the shadow pass's entity draw.
+    pub entities: &'a wgpu::BindGroupLayout,
+    /// The weather's groups 0 and 1 (the entities' atlas, the fall clock), for the weather
+    /// stage.
+    pub weather_groups: [&'a wgpu::BindGroupLayout; 2],
+    /// The resource packs' LabPBR maps (normals, specular), when they ship any.
+    pub pbr: Option<&'a [wgpu::Texture; 2]>,
 }
 
 /// The pack's terrain pipelines: solid (with the cutout test) and translucent, for the
@@ -123,6 +204,8 @@ pub struct NativeMaterial {
     pub solid: wgpu::RenderPipeline,
     pub translucent: wgpu::RenderPipeline,
     pub flat: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>,
+    /// The stage calls `set_surface`: its solid pipelines also write the surface target.
+    pub writes_surface: bool,
 }
 
 /// terrain.wgsl's terrain section (its globals, bindings, sampling, lighting and fog), with
@@ -134,12 +217,14 @@ fn vanilla_terrain() -> String {
     )
 }
 
-/// `horizon_sprite_tags(layer)`: the bits of `MaterialInput.tags` of each sprite layer.
-fn sprite_tags(tags: &[(u32, u32)]) -> String {
-    let mut out = String::from("fn horizon_sprite_tags(layer: u32) -> u32 {\n    switch layer {\n");
-    let mut tags = tags.to_vec();
-    tags.sort_unstable_by_key(|&(layer, bits)| (bits, layer));
-    for group in tags.chunk_by(|a, b| a.1 == b.1) {
+/// The function `name(layer)`, the value of each sprite layer in `table` and 0 for the rest:
+/// `horizon_sprite_tags` (`MaterialInput.tags`) and `horizon_sprite_material`
+/// (`MaterialInput.material`).
+fn layer_table(name: &str, table: &[(u32, u32)]) -> String {
+    let mut out = format!("fn {name}(layer: u32) -> u32 {{\n    switch layer {{\n");
+    let mut table = table.to_vec();
+    table.sort_unstable_by_key(|&(layer, value)| (value, layer));
+    for group in table.chunk_by(|a, b| a.1 == b.1) {
         let layers: Vec<String> = group.iter().map(|(layer, _)| format!("{layer}u")).collect();
         out += &format!(
             "        case {}: {{ return {}u; }}\n",
@@ -150,18 +235,28 @@ fn sprite_tags(tags: &[(u32, u32)]) -> String {
     out + "        default: { return 0u; }\n    }\n}\n"
 }
 
-/// The terrain shader for the pack's material stage `source`, with its sprite `tags`.
-fn shader_source(source: &str, tags: &[(u32, u32)]) -> String {
+/// The terrain shader for the pack's material stage `source`, with its sprite `tags` and
+/// `materials`.
+/// The surface target (the post stage's `scene_surface`): x the normal (two snorm16 in its
+/// bits), y smoothness, z the pack's data, w the fragment's depth.
+pub const SURFACE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba32Float;
+
+fn shader_source(source: &str, tags: &[(u32, u32)], materials: &[(u32, u32)]) -> String {
     format!(
-        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{ENTRIES}",
+        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{}{ENTRIES}",
         vanilla_terrain(),
-        sprite_tags(tags)
+        layer_table("horizon_sprite_tags", tags),
+        layer_table("horizon_sprite_material", materials)
     )
 }
 
 /// The material's naga module, its errors in the stage's file.
-fn module(stage: &CheckedStage, tags: &[(u32, u32)]) -> Result<naga::Module, String> {
-    let text = shader_source(&stage.source, tags);
+fn module(
+    stage: &CheckedStage,
+    tags: &[(u32, u32)],
+    materials: &[(u32, u32)],
+) -> Result<naga::Module, String> {
+    let text = shader_source(&stage.source, tags, materials);
     naga::front::wgsl::parse_str(&text)
         .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))
 }
@@ -174,14 +269,17 @@ impl NativeMaterial {
         frame: &NativeFrame,
         stage: &CheckedStage,
         constants: &[(String, f64)],
+        fog: bool,
     ) -> Result<Self, String> {
-        let module = module(stage, shape.sprite_tags)?;
+        let writes_surface = horizon_shader_api::stages::calls_set_surface(&stage.source);
+        let module = module(stage, shape.sprite_tags, shape.sprite_materials)?;
         let mut constants = present_constants(&module, constants);
         let sprite_names = [
             "horizon_terrain_SPRITE_ARRAYS",
             "horizon_terrain_SPRITE_SPLIT",
         ];
         constants.extend(sprite_names.into_iter().zip(shape.sprites));
+        constants.push(("horizon_material_fog", f64::from(u8::from(fog))));
         let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
         let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some(&stage.label),
@@ -220,6 +318,18 @@ impl NativeMaterial {
                 constants: &constants,
                 ..Default::default()
             };
+            let solid_targets = [
+                Some(wgpu::ColorTargetState {
+                    format: shape.format,
+                    blend,
+                    write_mask: wgpu::ColorWrites::ALL,
+                }),
+                Some(wgpu::ColorTargetState {
+                    format: SURFACE_FORMAT,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                }),
+            ];
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                 label: Some(&stage.label),
                 layout: Some(layout),
@@ -245,11 +355,11 @@ impl NativeMaterial {
                     module: &module,
                     entry_point: Some(fragment),
                     compilation_options: options,
-                    targets: &[Some(wgpu::ColorTargetState {
-                        format: shape.format,
-                        blend,
-                        write_mask: wgpu::ColorWrites::ALL,
-                    })],
+                    targets: if fragment == "horizon_material_fs_solid" && writes_surface {
+                        &solid_targets
+                    } else {
+                        &solid_targets[..1]
+                    },
                 }),
                 multiview_mask: None,
                 cache: None,
@@ -294,6 +404,7 @@ impl NativeMaterial {
             solid,
             translucent,
             flat,
+            writes_surface,
         })
     }
 }
@@ -346,14 +457,20 @@ mod tests {
                 return Surface(apply_fog(sprite(lit)) + (behind + frame_of) * 0.0);\n}\n";
         let stage = stage(own);
         let tags = [(7, 1), (3, 1), (9, 2)];
-        assert!(sprite_tags(&tags).contains("case 3u, 7u: { return 1u; }"));
-        let module = module(&stage, &tags).unwrap();
+        let materials = [(5, 1000)];
+        assert!(layer_table("t", &tags).contains("case 3u, 7u: { return 1u; }"));
+        let module = module(&stage, &tags, &materials).unwrap();
         let info = naga::valid::Validator::new(
             naga::valid::ValidationFlags::all(),
             naga::valid::Capabilities::all(),
         )
         .validate(&module)
-        .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&shader_source(&stage.source, &tags))));
+        .unwrap_or_else(|e| {
+            panic!(
+                "{}",
+                e.emit_to_string(&shader_source(&stage.source, &tags, &materials))
+            )
+        });
         let entries: Vec<&str> = module
             .entry_points
             .iter()

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

@@ -5,6 +5,7 @@ use horizon_shader_api::{Report, StageKind};
 
 use super::native_material::{NativeMaterial, TerrainShape};
 use super::native_post::{NativeFrame, NativePost};
+use super::native_shadow::NativeShadow;
 use super::native_sky::NativeSky;
 use super::pack_timing::PassTiming;
 
@@ -13,6 +14,13 @@ pub struct NativePack {
     pub sky: Option<NativeSky>,
     pub material: Option<NativeMaterial>,
     pub post: Option<NativePost>,
+    /// With a sky stage, what of Minecraft's sky still draws over it (`[sky]`).
+    pub vanilla_clouds: bool,
+    pub vanilla_sun: bool,
+    pub vanilla_stars: bool,
+    pub weather: Option<wgpu::RenderPipeline>,
+    /// The draw of the shadow map the stages read, if the pack asks for one.
+    pub shadow: Option<NativeShadow>,
     /// GPU time of each pass, while the renderer asks for it (`pack_timing.rs`).
     pub timing: Option<PassTiming>,
 }
@@ -24,12 +32,24 @@ impl NativePack {
     /// refused.
     pub fn new(
         device: &wgpu::Device,
+        queue: &wgpu::Queue,
         terrain: &TerrainShape<'_>,
         report: Report,
         constants: &[(String, f64)],
+        lights: super::block_light::LightTable,
     ) -> Result<(Self, Vec<String>), String> {
         let (globals, format) = (terrain.globals, terrain.format);
-        let mut frame = NativeFrame::new(device);
+        let textures = super::native_post::pack_textures(device, queue, &report);
+        let settings = report
+            .shadow
+            .as_ref()
+            .map(|settings| super::native_shadow::fitted(device, settings));
+        let mut frame = NativeFrame::new(device, settings.as_ref(), textures, lights, terrain.pbr);
+        let shadow = report
+            .shadow
+            .as_ref()
+            .map(|s| NativeShadow::new(device, terrain, &frame, &s.solid_materials))
+            .transpose()?;
         // The mirror is drawn for a material that reads it, while `[reflection] option` is on.
         let option = report.reflection.as_ref().and_then(|r| r.option.as_ref());
         frame.reflects = report
@@ -43,6 +63,34 @@ impl NativePack {
                     .find(|(k, _)| k == id)
                     .is_none_or(|(_, v)| *v != 0.0)
             });
+        let fog = report.material_fog;
+        let keeps = |key: fn(&horizon_shader_api::Stage) -> Option<bool>| {
+            report.sky.as_ref().and_then(key).unwrap_or(true)
+        };
+        let vanilla_clouds = keeps(|s| s.clouds);
+        let vanilla_sun = keeps(|s| s.sun);
+        let vanilla_stars = keeps(|s| s.stars);
+        let weather = report
+            .stages
+            .iter()
+            .find(|s| s.kind == StageKind::Weather)
+            .map(|stage| {
+                super::weather::native_pipeline(
+                    device,
+                    format,
+                    terrain.weather_groups[0],
+                    terrain.weather_groups[1],
+                    &frame,
+                    stage,
+                    constants,
+                )
+            })
+            .transpose()?;
+        let weather_label = report
+            .stages
+            .iter()
+            .find(|s| s.kind == StageKind::Weather)
+            .map(|s| s.label.clone());
         let (post, others): (Vec<_>, Vec<_>) = report
             .stages
             .into_iter()
@@ -55,10 +103,10 @@ impl NativePack {
         let material = others
             .iter()
             .find(|s| s.kind == StageKind::Material)
-            .map(|stage| NativeMaterial::new(device, terrain, &frame, stage, constants))
+            .map(|stage| NativeMaterial::new(device, terrain, &frame, stage, constants, fog))
             .transpose()?;
         let post = (!post.is_empty())
-            .then(|| NativePost::new(device, post, constants, format, &frame))
+            .then(|| NativePost::new(device, post, &report.manifest, constants, format, &frame))
             .transpose()?;
         let mut labels: Vec<String> = sky.iter().map(|s| s.label.clone()).collect();
         labels.extend(
@@ -67,6 +115,7 @@ impl NativePack {
                 .filter(|s| material.is_some() && s.kind == StageKind::Material)
                 .map(|s| s.label.clone()),
         );
+        labels.extend(weather_label);
         if let Some(post) = &post {
             labels.extend(post.labels().into_iter().map(str::to_owned));
         }
@@ -75,6 +124,11 @@ impl NativePack {
             sky,
             material,
             post,
+            vanilla_clouds,
+            vanilla_sun,
+            vanilla_stars,
+            weather,
+            shadow,
             timing: None,
         };
         Ok((pack, labels))
@@ -82,6 +136,9 @@ impl NativePack {
 
     /// Whether the pack draws anything the game runs today.
     pub fn draws(&self) -> bool {
-        self.sky.is_some() || self.material.is_some() || self.post.is_some()
+        self.sky.is_some()
+            || self.material.is_some()
+            || self.weather.is_some()
+            || self.post.is_some()
     }
 }

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

@@ -14,16 +14,74 @@ use super::Frame;
 const INTERMEDIATE: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
 
 /// The world's colour and depth views a set of bind groups was made for.
-type WorldViews = (wgpu::TextureView, wgpu::TextureView);
+type WorldViews = (wgpu::TextureView, wgpu::TextureView, wgpu::TextureView);
+
+/// Where a post pass draws.
+#[derive(Clone, Copy, PartialEq)]
+enum Writes {
+    /// One of the chain's two targets.
+    Chain(usize),
+    /// A pack target (`[[post]] output`).
+    Target(usize),
+    /// The screen: the last pass.
+    Screen,
+}
+
+/// A post pass's target, and the chain's picture it reads as `previous` (the world's for
+/// none).
+#[derive(Clone, Copy)]
+struct PassPlan {
+    writes: Writes,
+    reads: Option<usize>,
+}
+
+/// The passes' plan for `outputs` (each pass's `[[post]] output`, by target index): the chain's
+/// passes write its targets in turn, each reading what the one before wrote; a pass with an
+/// output writes that and reads the chain's picture, which goes on past it.
+fn plan(outputs: &[Option<usize>]) -> Vec<PassPlan> {
+    let mut current = None;
+    outputs
+        .iter()
+        .enumerate()
+        .map(|(i, output)| {
+            let reads = current;
+            let writes = match output {
+                _ if i + 1 == outputs.len() => Writes::Screen,
+                Some(t) => Writes::Target(*t),
+                None => {
+                    let slot = usize::from(current == Some(0));
+                    current = Some(slot);
+                    Writes::Chain(slot)
+                }
+            };
+            PassPlan { writes, reads }
+        })
+        .collect()
+}
+
+/// A pack target's size: `scale` of the world's `size`, at least a texel.
+fn scaled(size: [u32; 2], scale: f32) -> [u32; 2] {
+    size.map(|s| ((s as f32 * scale).ceil() as u32).max(1))
+}
 
 pub struct NativePost {
     passes: Vec<(String, wgpu::RenderPipeline)>,
     layout: wgpu::BindGroupLayout,
+    /// The pack's textures.
+    textures: Vec<(wgpu::TextureView, wgpu::Sampler)>,
     frame: wgpu::Buffer,
     linear: wgpu::Sampler,
     nearest: wgpu::Sampler,
     /// Two targets of the world's size, written in turn (none with a single pass).
     targets: Option<([u32; 2], [wgpu::TextureView; 2])>,
+    /// The frame's shadow map, its comparison sampler (bindings 6 and 7), the translucent map
+    /// and its colour (bindings 9 and 10).
+    shadow: (
+        wgpu::TextureView,
+        wgpu::Sampler,
+        wgpu::TextureView,
+        wgpu::TextureView,
+    ),
     /// Last frame's input to the last pass (`history`, binding 8), made with the targets,
     /// and a black 1×1 in its place before then.
     history: Option<wgpu::Texture>,
@@ -32,6 +90,12 @@ pub struct NativePost {
     groups: Option<(WorldViews, bool, Vec<wgpu::BindGroup>)>,
     /// Whether `history` contains the last frame's input to the last pass.
     history_valid: bool,
+    /// What each pass writes and reads (`[[post]] output`).
+    plan: Vec<PassPlan>,
+    /// The pack's targets' scales (`Manifest::post_targets`), and their views for the world's
+    /// size.
+    scales: Vec<f32>,
+    named: Option<([u32; 2], Vec<wgpu::TextureView>)>,
     /// The screen's colour format, the world target's too.
     format: wgpu::TextureFormat,
 }
@@ -39,9 +103,16 @@ pub struct NativePost {
 /// The `frame` every stage of a pack reads (group 3, binding 0), written once a frame, and
 /// what the material stage reads besides.
 pub struct NativeFrame {
+    /// The solid terrain's second target, the post stage's `scene_surface`.
+    surface: wgpu::Texture,
+    pub surface_view: wgpu::TextureView,
     pub(super) buffer: wgpu::Buffer,
     /// Group 3 of the sky and material stages.
     pub layout: wgpu::BindGroupLayout,
+    /// The pack's `[[textures]]` and their samplers, bound for every stage.
+    pub textures: Vec<(wgpu::TextureView, wgpu::Sampler)>,
+    /// The colour of block light around the camera (`[[lights]]`), bindings 9 and 10.
+    pub block_light: super::block_light::BlockLight,
     pub group: wgpu::BindGroup,
     /// The world's depth before translucent terrain (the material stage's `opaque_depth`,
     /// binding 6), copied each frame.
@@ -49,11 +120,17 @@ pub struct NativeFrame {
     /// The world's colour before translucent terrain (`opaque_color`, binding 11), copied
     /// with it; 1×1 while the world draws straight to the window.
     pub opaque_color: wgpu::Texture,
+    /// The resource packs' LabPBR maps (bindings 12 and 13: normals, specular), a blank 1x1
+    /// without them.
+    pbr: [wgpu::TextureView; 2],
     /// The material stage's `reflection` (binding 1): this frame's water mirror, else
     /// `blank`; and its sampler (binding 2).
     reflection: wgpu::TextureView,
     blank: wgpu::TextureView,
     reflection_sampler: wgpu::Sampler,
+    /// The shadow map the stages read, and the camera that draws it when the pack asks for one.
+    pub shadow_map: super::native_shadow::ShadowMap,
+    shadow_camera: Option<horizon_shaders::Shadow>,
     /// Whether the pack's material reads `reflection` (`NativePack::new`): else no mirror
     /// is drawn and `has_reflection` stays 0.
     pub reflects: bool,
@@ -140,23 +217,64 @@ fn eased(value: f32, target: f32, half_life: f32, dt: f32) -> f32 {
 }
 
 impl NativeFrame {
-    pub fn new(device: &wgpu::Device) -> Self {
+    /// The frame of a pack with the `[shadow]` settings `shadow`, if any, and the
+    /// block light colours `lights`.
+    pub fn new(
+        device: &wgpu::Device,
+        shadow: Option<&horizon_shader_api::manifest::Shadow>,
+        textures: Vec<(wgpu::TextureView, wgpu::Sampler)>,
+        lights: super::block_light::LightTable,
+        pbr: Option<&[wgpu::Texture; 2]>,
+    ) -> Self {
         let buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Native shader pack frame"),
             size: size_of::<FrameInputs>() as u64,
             usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
+        let mut entries = vec![
+            frame_entry(wgpu::ShaderStages::VERTEX_FRAGMENT),
+            texture_entry(1, wgpu::TextureSampleType::Float { filterable: true }),
+            sampler_entry(2),
+            texture_entry(3, wgpu::TextureSampleType::Depth),
+            comparison_entry(4),
+            texture_entry(6, wgpu::TextureSampleType::Depth),
+            texture_entry(7, wgpu::TextureSampleType::Depth),
+            texture_entry(8, wgpu::TextureSampleType::Float { filterable: true }),
+            texture_entry(11, wgpu::TextureSampleType::Float { filterable: false }),
+            pbr_entry(12),
+            pbr_entry(13),
+        ];
+        let block_light_entries = [
+            wgpu::BindGroupLayoutEntry {
+                binding: 9,
+                visibility: wgpu::ShaderStages::FRAGMENT,
+                ty: wgpu::BindingType::Texture {
+                    sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                    view_dimension: wgpu::TextureViewDimension::D3,
+                    multisampled: false,
+                },
+                count: None,
+            },
+            wgpu::BindGroupLayoutEntry {
+                binding: 10,
+                visibility: wgpu::ShaderStages::FRAGMENT,
+                ty: wgpu::BindingType::Buffer {
+                    ty: wgpu::BufferBindingType::Uniform,
+                    has_dynamic_offset: false,
+                    min_binding_size: None,
+                },
+                count: None,
+            },
+        ];
+        entries.extend(block_light_entries);
+        entries.extend(pack_texture_entries(textures.len()));
         let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
             label: Some("Native shader pack frame"),
-            entries: &[
-                frame_entry(wgpu::ShaderStages::VERTEX_FRAGMENT),
-                texture_entry(1, wgpu::TextureSampleType::Float { filterable: true }),
-                sampler_entry(2),
-                texture_entry(6, wgpu::TextureSampleType::Depth),
-                texture_entry(11, wgpu::TextureSampleType::Float { filterable: false }),
-            ],
+            entries: &entries,
         });
+        let surface = surface_target(device, [1, 1]);
+        let surface_view = surface.create_view(&Default::default());
         let opaque_depth = depth_copy(device, [1, 1]);
         let opaque_color = color_copy(device, [1, 1], wgpu::TextureFormat::Rgba8Unorm);
         let blank = copy_target(
@@ -172,23 +290,62 @@ impl NativeFrame {
             min_filter: wgpu::FilterMode::Linear,
             ..Default::default()
         });
+        let shadow_map = super::native_shadow::ShadowMap::new(device, shadow);
+        let block_light = super::block_light::BlockLight::new(device, lights);
+        let array_view = |texture: &wgpu::Texture| {
+            texture.create_view(&wgpu::TextureViewDescriptor {
+                dimension: Some(wgpu::TextureViewDimension::D2Array),
+                ..Default::default()
+            })
+        };
+        let pbr = match pbr {
+            Some(maps) => maps.each_ref().map(array_view),
+            None => {
+                // Two layers: one would make a 2D texture on the OpenGL backend.
+                let blank = device.create_texture(&wgpu::TextureDescriptor {
+                    label: Some("Native shader pack LabPBR (none)"),
+                    size: wgpu::Extent3d {
+                        width: 1,
+                        height: 1,
+                        depth_or_array_layers: 2,
+                    },
+                    mip_level_count: 1,
+                    sample_count: 1,
+                    dimension: wgpu::TextureDimension::D2,
+                    format: wgpu::TextureFormat::Rgba8Unorm,
+                    usage: wgpu::TextureUsages::TEXTURE_BINDING,
+                    view_formats: &[],
+                });
+                [array_view(&blank), array_view(&blank)]
+            }
+        };
         let group = Self::group(
             device,
             &layout,
             &buffer,
             (&blank, &reflection_sampler),
-            &opaque_depth,
-            &opaque_color,
+            &shadow_map,
+            (&opaque_depth, &opaque_color),
+            &textures,
+            &block_light,
+            &pbr,
         );
         Self {
+            textures,
+            block_light,
+            pbr,
             buffer,
             layout,
             group,
+            surface,
+            surface_view,
             opaque_depth,
             opaque_color,
             reflection: blank.clone(),
             blank,
             reflection_sampler,
+            shadow_map,
+            shadow_camera: shadow.map(super::native_shadow::camera),
             reflects: false,
             last: None,
             eye: [f32::NAN; 4],
@@ -199,43 +356,93 @@ impl NativeFrame {
         }
     }
 
+    /// What the shadow camera sees this frame, for the renderer's shadow lists.
+    pub fn shadow_view(&self, frame: &Frame) -> Option<super::pack_post::ShadowView> {
+        let camera = self.shadow_camera.as_ref()?;
+        Some(super::pack_post::ShadowView {
+            cull: super::pack_uniforms::shadow_culling(frame, camera),
+            light: super::pack_uniforms::shadow_light(frame, camera),
+            // The light's box culls: on the ground it reaches further than `distance` along
+            // the sun's azimuth while the sun is low.
+            distance: None,
+            unculled: None,
+        })
+    }
+
     fn group(
         device: &wgpu::Device,
         layout: &wgpu::BindGroupLayout,
         buffer: &wgpu::Buffer,
         (reflection, sampler): (&wgpu::TextureView, &wgpu::Sampler),
-        opaque_depth: &wgpu::Texture,
-        opaque_color: &wgpu::Texture,
+        shadow: &super::native_shadow::ShadowMap,
+        (opaque_depth, opaque_color): (&wgpu::Texture, &wgpu::Texture),
+        textures: &[(wgpu::TextureView, wgpu::Sampler)],
+        block_light: &super::block_light::BlockLight,
+        pbr: &[wgpu::TextureView; 2],
     ) -> wgpu::BindGroup {
+        let opaque_depth = opaque_depth.create_view(&Default::default());
+        let opaque_color = opaque_color.create_view(&Default::default());
+        let mut entries = vec![
+            wgpu::BindGroupEntry {
+                binding: 0,
+                resource: buffer.as_entire_binding(),
+            },
+            wgpu::BindGroupEntry {
+                binding: 1,
+                resource: wgpu::BindingResource::TextureView(reflection),
+            },
+            wgpu::BindGroupEntry {
+                binding: 2,
+                resource: wgpu::BindingResource::Sampler(sampler),
+            },
+            wgpu::BindGroupEntry {
+                binding: 3,
+                resource: wgpu::BindingResource::TextureView(&shadow.view),
+            },
+            wgpu::BindGroupEntry {
+                binding: 4,
+                resource: wgpu::BindingResource::Sampler(&shadow.sampler),
+            },
+            wgpu::BindGroupEntry {
+                binding: 7,
+                resource: wgpu::BindingResource::TextureView(&shadow.translucent_view),
+            },
+            wgpu::BindGroupEntry {
+                binding: 8,
+                resource: wgpu::BindingResource::TextureView(&shadow.color_view),
+            },
+            wgpu::BindGroupEntry {
+                binding: 6,
+                resource: wgpu::BindingResource::TextureView(&opaque_depth),
+            },
+            wgpu::BindGroupEntry {
+                binding: 11,
+                resource: wgpu::BindingResource::TextureView(&opaque_color),
+            },
+            wgpu::BindGroupEntry {
+                binding: 12,
+                resource: wgpu::BindingResource::TextureView(&pbr[0]),
+            },
+            wgpu::BindGroupEntry {
+                binding: 13,
+                resource: wgpu::BindingResource::TextureView(&pbr[1]),
+            },
+        ];
+        entries.extend([
+            wgpu::BindGroupEntry {
+                binding: 9,
+                resource: wgpu::BindingResource::TextureView(&block_light.view),
+            },
+            wgpu::BindGroupEntry {
+                binding: 10,
+                resource: block_light.grid.as_entire_binding(),
+            },
+        ]);
+        entries.extend(pack_texture_group_entries(textures));
         device.create_bind_group(&wgpu::BindGroupDescriptor {
             label: Some("Native shader pack frame"),
             layout,
-            entries: &[
-                wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: buffer.as_entire_binding(),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 1,
-                    resource: wgpu::BindingResource::TextureView(reflection),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 2,
-                    resource: wgpu::BindingResource::Sampler(sampler),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 6,
-                    resource: wgpu::BindingResource::TextureView(
-                        &opaque_depth.create_view(&Default::default()),
-                    ),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 11,
-                    resource: wgpu::BindingResource::TextureView(
-                        &opaque_color.create_view(&Default::default()),
-                    ),
-                },
-            ],
+            entries: &entries,
         })
     }
 
@@ -268,6 +475,14 @@ impl NativeFrame {
         self.regroup(device);
     }
 
+    /// Sizes the surface target: the world's while a material stage writes it, else a blank.
+    pub fn fit_surface(&mut self, device: &wgpu::Device, size: [u32; 2]) {
+        if [self.surface.width(), self.surface.height()] != size {
+            self.surface = surface_target(device, size);
+            self.surface_view = self.surface.create_view(&Default::default());
+        }
+    }
+
     /// Binds `view` as this frame's `reflection` (`None`: the blank). The mirror is drawn
     /// before the stages read it.
     pub fn set_reflection(&mut self, device: &wgpu::Device, view: Option<&wgpu::TextureView>) {
@@ -284,8 +499,11 @@ impl NativeFrame {
             &self.layout,
             &self.buffer,
             (&self.reflection, &self.reflection_sampler),
-            &self.opaque_depth,
-            &self.opaque_color,
+            &self.shadow_map,
+            (&self.opaque_depth, &self.opaque_color),
+            &self.textures,
+            &self.block_light,
+            &self.pbr,
         );
     }
 
@@ -295,7 +513,13 @@ impl NativeFrame {
         let now = std::time::Instant::now();
         let since = self.wetness.1.map_or(0.0, |t| (now - t).as_secs_f32());
         self.wetness = (wetness(self.wetness.0, frame.pack.rain, since), Some(now));
-        let mut inputs = frame_inputs(frame, size, seconds, self.frames);
+        let mut inputs = frame_inputs(
+            frame,
+            size,
+            seconds,
+            self.frames,
+            self.shadow_camera.as_ref(),
+        );
         inputs.wetness = self.wetness.0;
         if !self.reflects {
             inputs.has_reflection = 0;
@@ -364,6 +588,24 @@ pub fn present_constants<'a>(
         .collect()
 }
 
+/// The solid terrain's surface target of `size`, drawn and read.
+fn surface_target(device: &wgpu::Device, size: [u32; 2]) -> wgpu::Texture {
+    device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("Native shader pack surface"),
+        size: wgpu::Extent3d {
+            width: size[0],
+            height: size[1],
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: super::native_material::SURFACE_FORMAT,
+        usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
+        view_formats: &[],
+    })
+}
+
 fn texture_entry(binding: u32, sample_type: wgpu::TextureSampleType) -> wgpu::BindGroupLayoutEntry {
     wgpu::BindGroupLayoutEntry {
         binding,
@@ -377,6 +619,29 @@ fn texture_entry(binding: u32, sample_type: wgpu::TextureSampleType) -> wgpu::Bi
     }
 }
 
+/// A LabPBR map's array, read by the material entries (`native_material.rs`).
+fn pbr_entry(binding: u32) -> wgpu::BindGroupLayoutEntry {
+    wgpu::BindGroupLayoutEntry {
+        binding,
+        visibility: wgpu::ShaderStages::FRAGMENT,
+        ty: wgpu::BindingType::Texture {
+            sample_type: wgpu::TextureSampleType::Float { filterable: true },
+            view_dimension: wgpu::TextureViewDimension::D2Array,
+            multisampled: false,
+        },
+        count: None,
+    }
+}
+
+fn comparison_entry(binding: u32) -> wgpu::BindGroupLayoutEntry {
+    wgpu::BindGroupLayoutEntry {
+        binding,
+        visibility: wgpu::ShaderStages::FRAGMENT,
+        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Comparison),
+        count: None,
+    }
+}
+
 fn sampler_entry(binding: u32) -> wgpu::BindGroupLayoutEntry {
     wgpu::BindGroupLayoutEntry {
         binding,
@@ -392,22 +657,44 @@ impl NativePost {
     pub fn new(
         device: &wgpu::Device,
         stages: Vec<CheckedStage>,
+        manifest: &horizon_shader_api::Manifest,
         constants: &[(String, f64)],
         format: wgpu::TextureFormat,
         frame: &NativeFrame,
     ) -> Result<Self, String> {
+        let targets = manifest.post_targets();
+        let outputs: Vec<Option<usize>> = manifest
+            .post
+            .iter()
+            .map(|p| {
+                let name = p.output.as_deref()?;
+                targets.iter().position(|t| t.0 == name)
+            })
+            .collect();
+        let plan = plan(&outputs);
         let float = wgpu::TextureSampleType::Float { filterable: true };
+        let mut entries = vec![
+            frame_entry(wgpu::ShaderStages::FRAGMENT),
+            texture_entry(1, float),
+            texture_entry(2, wgpu::TextureSampleType::Depth),
+            texture_entry(3, float),
+            sampler_entry(4),
+            sampler_entry(5),
+            texture_entry(6, wgpu::TextureSampleType::Depth),
+            comparison_entry(7),
+            texture_entry(8, float),
+            texture_entry(9, wgpu::TextureSampleType::Depth),
+            texture_entry(10, float),
+            texture_entry(11, wgpu::TextureSampleType::Float { filterable: false }),
+        ];
+        entries.extend(pack_texture_entries(frame.textures.len()));
+        entries
+            .extend((0..targets.len() as u32).map(|j| {
+                texture_entry(horizon_shader_api::stages::POST_TARGET_BINDING + j, float)
+            }));
         let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
             label: Some("Native shader pack post"),
-            entries: &[
-                frame_entry(wgpu::ShaderStages::FRAGMENT),
-                texture_entry(1, float),
-                texture_entry(2, wgpu::TextureSampleType::Depth),
-                texture_entry(3, float),
-                sampler_entry(4),
-                sampler_entry(5),
-                texture_entry(8, float),
-            ],
+            entries: &entries,
         });
         let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] = Default::default();
         groups[GROUP as usize] = Some(&layout);
@@ -446,7 +733,11 @@ impl NativePost {
                     entry_point: Some("horizon_fs_post"),
                     compilation_options: options,
                     targets: &[Some(wgpu::ColorTargetState {
-                        format: if i + 1 == count { format } else { INTERMEDIATE },
+                        format: if plan[i].writes == Writes::Screen {
+                            format
+                        } else {
+                            INTERMEDIATE
+                        },
                         blend: None,
                         write_mask: wgpu::ColorWrites::ALL,
                     })],
@@ -470,7 +761,14 @@ impl NativePost {
         Ok(Self {
             passes,
             layout,
+            textures: frame.textures.clone(),
             frame: frame.buffer.clone(),
+            shadow: (
+                frame.shadow_map.view.clone(),
+                frame.shadow_map.sampler.clone(),
+                frame.shadow_map.translucent_view.clone(),
+                frame.shadow_map.color_view.clone(),
+            ),
             linear: sampler("Native shader pack linear", wgpu::FilterMode::Linear),
             nearest: sampler("Native shader pack nearest", wgpu::FilterMode::Nearest),
             targets: None,
@@ -478,6 +776,9 @@ impl NativePost {
             history_blank: history_target(device, "Native shader pack history blank", [1, 1]),
             groups: None,
             history_valid: false,
+            scales: targets.iter().map(|t| t.1).collect(),
+            named: None,
+            plan,
             format,
         })
     }
@@ -490,11 +791,43 @@ impl NativePost {
     fn prepare(
         &mut self,
         device: &wgpu::Device,
-        world: (&wgpu::TextureView, &wgpu::TextureView),
+        world: (&wgpu::TextureView, &wgpu::TextureView, &wgpu::TextureView),
         size: [u32; 2],
         history_reset: bool,
     ) {
-        if self.passes.len() > 1 && self.targets.as_ref().is_none_or(|t| t.0 != size) {
+        if !self.scales.is_empty() && self.named.as_ref().is_none_or(|n| n.0 != size) {
+            let views = self
+                .scales
+                .iter()
+                .map(|&scale| {
+                    let size = scaled(size, scale);
+                    device
+                        .create_texture(&wgpu::TextureDescriptor {
+                            label: Some("Native shader pack target"),
+                            size: wgpu::Extent3d {
+                                width: size[0],
+                                height: size[1],
+                                depth_or_array_layers: 1,
+                            },
+                            mip_level_count: 1,
+                            sample_count: 1,
+                            dimension: wgpu::TextureDimension::D2,
+                            format: INTERMEDIATE,
+                            usage: wgpu::TextureUsages::RENDER_ATTACHMENT
+                                | wgpu::TextureUsages::TEXTURE_BINDING,
+                            view_formats: &[],
+                        })
+                        .create_view(&Default::default())
+                })
+                .collect();
+            self.named = Some((size, views));
+            self.groups = None;
+        }
+        let chain = self
+            .plan
+            .iter()
+            .any(|p| matches!(p.writes, Writes::Chain(_)));
+        if chain && self.targets.as_ref().is_none_or(|t| t.0 != size) {
             let target = |label| {
                 device
                     .create_texture(&wgpu::TextureDescriptor {
@@ -531,8 +864,11 @@ impl NativePost {
         if self
             .groups
             .as_ref()
-            .is_some_and(|((color, depth), blank, _)| {
-                color == world.0 && depth == world.1 && *blank == blank_history
+            .is_some_and(|((color, depth, surface), blank, _)| {
+                color == world.0
+                    && depth == world.1
+                    && surface == world.2
+                    && *blank == blank_history
             })
         {
             return;
@@ -545,50 +881,91 @@ impl NativePost {
                 .expect("history exists after a post stage has more than one pass")
         }
         .create_view(&Default::default());
+        let blank = self.history_blank.create_view(&Default::default());
         let groups = (0..self.passes.len())
             .map(|i| {
-                // Pass i reads what pass i - 1 wrote: target (i - 1) % 2, the world for the first.
-                let previous = match (&self.targets, i) {
-                    (Some((_, t)), 1..) => &t[(i - 1) % 2],
+                // The chain's picture so far: the world's before its first pass.
+                let previous = match (&self.targets, self.plan[i].reads) {
+                    (Some((_, t)), Some(slot)) => &t[slot],
                     _ => world.0,
                 };
+                let mut entries = vec![
+                    wgpu::BindGroupEntry {
+                        binding: 0,
+                        resource: self.frame.as_entire_binding(),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 1,
+                        resource: wgpu::BindingResource::TextureView(world.0),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 2,
+                        resource: wgpu::BindingResource::TextureView(world.1),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 3,
+                        resource: wgpu::BindingResource::TextureView(previous),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 4,
+                        resource: wgpu::BindingResource::Sampler(&self.linear),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 5,
+                        resource: wgpu::BindingResource::Sampler(&self.nearest),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 6,
+                        resource: wgpu::BindingResource::TextureView(&self.shadow.0),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 7,
+                        resource: wgpu::BindingResource::Sampler(&self.shadow.1),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 8,
+                        resource: wgpu::BindingResource::TextureView(&history),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 9,
+                        resource: wgpu::BindingResource::TextureView(&self.shadow.2),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 11,
+                        resource: wgpu::BindingResource::TextureView(world.2),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 10,
+                        resource: wgpu::BindingResource::TextureView(&self.shadow.3),
+                    },
+                ];
+                entries.extend(pack_texture_group_entries(&self.textures));
+                // The pack's targets, a blank one in place of the one this pass writes.
+                if let Some((_, views)) = &self.named {
+                    entries.extend(views.iter().enumerate().map(|(j, view)| {
+                        let view = if self.plan[i].writes == Writes::Target(j) {
+                            &blank
+                        } else {
+                            view
+                        };
+                        wgpu::BindGroupEntry {
+                            binding: horizon_shader_api::stages::POST_TARGET_BINDING + j as u32,
+                            resource: wgpu::BindingResource::TextureView(view),
+                        }
+                    }));
+                }
                 device.create_bind_group(&wgpu::BindGroupDescriptor {
                     label: Some("Native shader pack post"),
                     layout: &self.layout,
-                    entries: &[
-                        wgpu::BindGroupEntry {
-                            binding: 0,
-                            resource: self.frame.as_entire_binding(),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 1,
-                            resource: wgpu::BindingResource::TextureView(world.0),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 2,
-                            resource: wgpu::BindingResource::TextureView(world.1),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 3,
-                            resource: wgpu::BindingResource::TextureView(previous),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 4,
-                            resource: wgpu::BindingResource::Sampler(&self.linear),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 5,
-                            resource: wgpu::BindingResource::Sampler(&self.nearest),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 8,
-                            resource: wgpu::BindingResource::TextureView(&history),
-                        },
-                    ],
+                    entries: &entries,
                 })
             })
             .collect();
-        self.groups = Some(((world.0.clone(), world.1.clone()), blank_history, groups));
+        self.groups = Some((
+            (world.0.clone(), world.1.clone(), world.2.clone()),
+            blank_history,
+            groups,
+        ));
     }
 
     /// Runs the passes over the world target `world` (colour, depth) of `size`, the last onto
@@ -597,7 +974,7 @@ impl NativePost {
         &mut self,
         device: &wgpu::Device,
         encoder: &mut wgpu::CommandEncoder,
-        world: (&wgpu::TextureView, &wgpu::TextureView),
+        world: (&wgpu::TextureView, &wgpu::TextureView, &wgpu::TextureView),
         screen: &wgpu::TextureView,
         size: [u32; 2],
         history_reset: bool,
@@ -611,8 +988,9 @@ impl NativePost {
             return;
         };
         for (i, ((label, pipeline), group)) in self.passes.iter().zip(groups).enumerate() {
-            let view = match &self.targets {
-                Some((_, t)) if i + 1 < self.passes.len() => &t[i % 2],
+            let view = match (self.plan[i].writes, &self.targets, &self.named) {
+                (Writes::Chain(slot), Some((_, t)), _) => &t[slot],
+                (Writes::Target(j), _, Some((_, n))) => &n[j],
                 _ => screen,
             };
             let attachments = [Some(wgpu::RenderPassColorAttachment {
@@ -634,14 +1012,17 @@ impl NativePost {
             pass.set_bind_group(GROUP, group, &[]);
             pass.draw(0..3, 0..1);
         }
-        // The last pass's input becomes next frame's `history`, once that pass has read this
-        // frame's.
-        let count = self.passes.len();
-        if count > 1
+        // The chain's last picture becomes next frame's `history`, once every pass has read
+        // this frame's.
+        let before_last = &self.plan[..self.plan.len() - 1];
+        if let Some(Writes::Chain(slot)) = before_last
+            .iter()
+            .rfind(|p| matches!(p.writes, Writes::Chain(_)))
+            .map(|p| p.writes)
             && let (Some(history), Some((_, targets))) = (&self.history, &self.targets)
         {
             encoder.copy_texture_to_texture(
-                targets[(count - 2) % 2].texture().as_image_copy(),
+                targets[slot].texture().as_image_copy(),
                 history.as_image_copy(),
                 history.size(),
             );
@@ -676,7 +1057,13 @@ fn wetness(wetness: f32, rain: f32, dt: f32) -> f32 {
 }
 
 /// The frame as packs read it (docs/api/shaders-reference.md), from the renderer's `Frame`.
-pub fn frame_inputs(frame: &Frame, size: [u32; 2], seconds: f32, index: u32) -> FrameInputs {
+pub fn frame_inputs(
+    frame: &Frame,
+    size: [u32; 2],
+    seconds: f32,
+    index: u32,
+    shadow: Option<&horizon_shaders::Shadow>,
+) -> FrameInputs {
     let aspect = size[0] as f32 / size[1].max(1) as f32;
     let view = crate::camera::view_matrix(frame.yaw, frame.pitch);
     let projection = super::world_projection(frame.fov_degrees, aspect, frame.depth_far)
@@ -748,11 +1135,147 @@ pub fn frame_inputs(frame: &Frame, size: [u32; 2], seconds: f32, index: u32) ->
         water_plane: frame.water_plane.unwrap_or(0.0),
         has_reflection: u32::from(frame.water_plane.is_some()),
         reflection_resolution: reflection_size(size).map(|s| s as f32),
+        mods: pack.mod_params,
+        light_direction: match shadow {
+            Some(s) => super::pack_uniforms::shadow_light(frame, s),
+            None => Vec3::Y,
+        }
+        .to_array(),
+        has_shadow: u32::from(shadow.is_some()),
+        shadow_view_proj: m(shadow.map_or(Mat4::IDENTITY, |s| {
+            super::pack_uniforms::shadow_culling(frame, s)
+        })),
+        shadow_distance: shadow.map_or(0.0, |s| s.distance),
+        shadow_distortion: shadow.map_or(0.0, |s| {
+            super::native_shadow::distortion(s.distance, s.resolution)
+        }),
+        shadow_resolution: shadow.map_or(0.0, |s| s.resolution as f32),
+        shadow_center_texel: shadow.map_or(0.0, |s| {
+            let k = super::native_shadow::distortion(s.distance, s.resolution);
+            2.0 * s.distance / s.resolution.max(1) as f32 * (1.0 - k)
+        }),
     }
 }
 
+/// The pack's `[[textures]]` (`check::Image`s), uploaded with samplers as the manifest says.
+pub fn pack_textures(
+    device: &wgpu::Device,
+    queue: &wgpu::Queue,
+    report: &horizon_shader_api::Report,
+) -> Vec<(wgpu::TextureView, wgpu::Sampler)> {
+    report
+        .textures
+        .iter()
+        .map(|(t, image)| {
+            let texture = wgpu::util::DeviceExt::create_texture_with_data(
+                device,
+                queue,
+                &wgpu::TextureDescriptor {
+                    label: Some(&t.id),
+                    size: wgpu::Extent3d {
+                        width: image.width,
+                        height: image.height,
+                        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: &[],
+                },
+                wgpu::util::TextureDataOrder::LayerMajor,
+                &image.rgba,
+            );
+            let filter = if t.linear {
+                wgpu::FilterMode::Linear
+            } else {
+                wgpu::FilterMode::Nearest
+            };
+            let address = if t.repeat {
+                wgpu::AddressMode::Repeat
+            } else {
+                wgpu::AddressMode::ClampToEdge
+            };
+            let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+                label: Some(&t.id),
+                address_mode_u: address,
+                address_mode_v: address,
+                mag_filter: filter,
+                min_filter: filter,
+                ..Default::default()
+            });
+            (texture.create_view(&Default::default()), sampler)
+        })
+        .collect()
+}
+
+/// Layout entries of `count` pack textures and their samplers.
+pub(super) fn pack_texture_entries(count: usize) -> Vec<wgpu::BindGroupLayoutEntry> {
+    use horizon_shader_api::stages::{TEXTURE_BINDING, TEXTURE_SAMPLER_BINDING};
+    (0..count as u32)
+        .flat_map(|i| {
+            [
+                wgpu::BindGroupLayoutEntry {
+                    binding: TEXTURE_BINDING + i,
+                    visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+                    ty: wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: TEXTURE_SAMPLER_BINDING + i,
+                    visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                    count: None,
+                },
+            ]
+        })
+        .collect()
+}
+
+/// Group entries of the pack's textures, as `pack_texture_entries` lays them out.
+pub(super) fn pack_texture_group_entries(
+    textures: &[(wgpu::TextureView, wgpu::Sampler)],
+) -> Vec<wgpu::BindGroupEntry<'_>> {
+    use horizon_shader_api::stages::{TEXTURE_BINDING, TEXTURE_SAMPLER_BINDING};
+    textures
+        .iter()
+        .enumerate()
+        .flat_map(|(i, (view, sampler))| {
+            [
+                wgpu::BindGroupEntry {
+                    binding: TEXTURE_BINDING + i as u32,
+                    resource: wgpu::BindingResource::TextureView(view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: TEXTURE_SAMPLER_BINDING + i as u32,
+                    resource: wgpu::BindingResource::Sampler(sampler),
+                },
+            ]
+        })
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
+    #[test]
+    fn a_pass_with_an_output_leaves_the_chain_as_it_was() {
+        use super::{Writes, plan};
+        // Bloom into a target, a pass of the chain, a second target, the picture.
+        let p = plan(&[Some(0), None, Some(1), None, None]);
+        let writes: Vec<_> = p.iter().map(|p| p.writes).collect();
+        assert!(writes[0] == Writes::Target(0));
+        assert!(writes[1] == Writes::Chain(0));
+        assert!(writes[2] == Writes::Target(1));
+        assert!(writes[3] == Writes::Chain(1));
+        assert!(writes[4] == Writes::Screen);
+        let reads: Vec<_> = p.iter().map(|p| p.reads).collect();
+        assert_eq!(reads, [None, None, Some(0), Some(0), Some(1)]);
+    }
     #[test]
     fn eased_values_start_at_the_target_and_halve_the_distance() {
         use super::eased;
@@ -814,7 +1337,7 @@ mod tests {
             .into();
         let report = check(&Pack::from_files(files).unwrap()).unwrap();
         let format = wgpu::TextureFormat::Rgba8Unorm;
-        let frame = NativeFrame::new(&device);
+        let frame = NativeFrame::new(&device, None, Vec::new(), Default::default(), None);
         queue.write_buffer(
             &frame.buffer,
             0,
@@ -823,6 +1346,7 @@ mod tests {
         let mut post = NativePost::new(
             &device,
             report.stages,
+            &report.manifest,
             &[("gain".into(), 1.0)],
             format,
             &frame,
@@ -870,7 +1394,7 @@ mod tests {
         post.run(
             &device,
             &mut encoder,
-            (&color, &depth),
+            (&color, &depth, &frame.surface_view),
             &view,
             [4, 4],
             true,
@@ -933,8 +1457,16 @@ file = \"b.wgsl\"
             .into();
         let report = check(&Pack::from_files(files).unwrap()).unwrap();
         let format = wgpu::TextureFormat::Rgba8Unorm;
-        let frame = NativeFrame::new(&device);
-        let mut post = NativePost::new(&device, report.stages, &[], format, &frame).unwrap();
+        let frame = NativeFrame::new(&device, None, Vec::new(), Default::default(), None);
+        let mut post = NativePost::new(
+            &device,
+            report.stages,
+            &report.manifest,
+            &[],
+            format,
+            &frame,
+        )
+        .unwrap();
         let usage = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
         let color = texture(&device, format, usage).create_view(&Default::default());
         let depth = texture(&device, wgpu::TextureFormat::Depth32Float, usage)
@@ -969,7 +1501,7 @@ file = \"b.wgsl\"
             post.run(
                 &device,
                 &mut encoder,
-                (&color, &depth),
+                (&color, &depth, &frame.surface_view),
                 &view,
                 [4, 4],
                 history_reset,

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

@@ -6,6 +6,19 @@
 use super::Vertex;
 use super::pack_draw::EntitySpan;
 use glam::{DVec3, Mat4};
+use std::sync::atomic::{AtomicBool, Ordering};
+
+static MODS_BUILT_IN: AtomicBool = AtomicBool::new(false);
+
+/// The game was built with native mods (the game sets it at start): one of them may draw in
+/// [`native_world_drawn`], so the first-person hand keeps its own pass after it.
+pub fn set_mods_built_in(on: bool) {
+    MODS_BUILT_IN.store(on, Ordering::Relaxed);
+}
+/// Whether [`native_world_drawn`] may draw ([`set_mods_built_in`]).
+pub fn world_drawn_hooked() -> bool {
+    MODS_BUILT_IN.load(Ordering::Relaxed)
+}
 
 /// What a mod can draw with once the world is drawn: after the sky, terrain, entities,
 /// particles, weather and the world post pass, before the first-person hand, the HUD and the

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

@@ -0,0 +1,673 @@
+//! The shadow map of Horizon's own shader packs (`[shadow]`, docs/shaders.md): each frame the
+//! solid terrain and entities the light (the sun by day, the moon by night) sees are drawn into a square depth
+//! map, which the material and post stages read as `shadow_map`; translucent terrain goes over a
+//! copy of it, `shadow_map_translucent`, with its colour in `shadow_color`. The shadow camera is the one
+//! `shaders/` packs use (`pack_uniforms::shadow_camera`), so the renderer's shadow visibility and
+//! draw lists (`ShadowView`) serve both; the map's texels are distorted toward the camera as the
+//! prelude's `shadow_position` undoes.
+
+use horizon_shader_api::{Frame as FrameInputs, manifest::Shadow as Settings, stages::GROUP};
+use horizon_shaders::Shadow;
+
+use super::native_material::TerrainShape;
+use super::wgsl_prefix::{TERRAIN, prefixed, section};
+
+const PREFIX: &str = "horizon_terrain_";
+
+/// The shadow pass's entries: terrain's vertices through the shadow camera, distorted, and the
+/// cutout test (leaves' and plants' holes let the light through).
+const ENTRIES: &str = "
+struct HorizonShadowOut {
+    @builtin(position) clip: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+    @location(1) @interpolate(flat) layer: u32,
+    @location(2) tint: vec3<f32>,
+    @location(3) @interpolate(flat) fluid: u32,
+}
+// `color` is the vertex colour: the tint, and the fluid flag in its alpha's high nibble
+// (mesher.rs's `fluid_face`).
+fn horizon_shadow_vertex(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f32>)
+    -> HorizonShadowOut {
+    let clip = frame.shadow_view_proj * vec4(pos, 1.0);
+    let xy = shadow_distort(clip.xy);
+    var out: HorizonShadowOut;
+    out.clip = vec4(xy, clamp(clip.z, 0.0, 1.0), 1.0);
+    out.uv = uv;
+    out.layer = layer;
+    out.tint = color.rgb;
+    let high = u32(round(color.a * 255.0)) >> 4u;
+    out.fluid = u32(high >= 8u && (high & 7u) < 6u);
+    return out;
+}
+@vertex fn horizon_shadow_vs(
+    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
+    @location(2) layer: u32, @location(3) color: vec4<f32>,
+    @location(5) origin: vec4<f32>) -> HorizonShadowOut {
+    return horizon_shadow_vertex(position + origin.xyz, horizon_terrain_terrain_uv(uv, origin.w), layer, color);
+}
+@vertex fn horizon_shadow_vs_flat(
+    @builtin(vertex_index) index: u32,
+    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>, @location(2) layer: u32,
+    @location(3) color: vec4<f32>
+) -> HorizonShadowOut {
+    let origin = horizon_terrain_slot_origins[horizon_terrain_block_slots[index >> 8u]];
+    return horizon_shadow_vertex(position + origin.xyz, horizon_terrain_terrain_uv(uv, origin.w), layer, color);
+}
+@fragment fn horizon_shadow_fs(in: HorizonShadowOut) {
+    // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout.
+    let alpha = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu).a;
+    if alpha < 0.5 && (in.layer & 0x8000u) == 0u && !horizon_shadow_solid(in.layer & 0x7fffu) { discard; }
+}
+// Translucent terrain: its colour where it is the nearest thing the light passes through;
+// alpha 1 marks a fluid, other surfaces keep their alpha below it.
+@fragment fn horizon_shadow_fs_translucent(in: HorizonShadowOut) -> @location(0) vec4<f32> {
+    let color = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu);
+    if color.a < 0.01 { discard; }
+    return vec4(color.rgb * in.tint, select(min(color.a, 0.99), 1.0, in.fluid != 0u));
+}
+";
+
+/// The entity draw of the shadow pass: the renderer's opaque entity quads (`EntityBatch`'s first
+/// material) through the shadow camera, with their texture's cutout. The sky's bodies, clouds,
+/// beacon beams and breaking cracks share that buffer but are unlit (entity.wgsl's overlays) and
+/// cast nothing. A quad's layer holds the overlay in its low 16 bits.
+const ENTITY_ENTRIES: &str = "
+@group(0) @binding(1) var horizon_atlas: texture_2d<f32>;
+@group(0) @binding(2) var horizon_atlas_sampler: sampler;
+struct HorizonEntityShadowOut {
+    @builtin(position) clip: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+    @location(1) alpha: f32,
+}
+@vertex fn horizon_entity_shadow_vs(@location(0) position: vec3<f32>,
+    @location(1) uv: vec2<f32>, @location(2) layer: u32, @location(3) color: vec4<f32>)
+    -> HorizonEntityShadowOut {
+    let clip = frame.shadow_view_proj * vec4(position, 1.0);
+    let xy = shadow_distort(clip.xy);
+    let overlay = layer & 0xffffu;
+    // As entity.wgsl's `unlit`.
+    let unlit = overlay == 2u || overlay == 4u || overlay == 6u
+        || (overlay >= 9u && overlay <= 12u);
+    var out: HorizonEntityShadowOut;
+    // Unlit geometry lands outside the clip volume.
+    out.clip = select(vec4(xy, clamp(clip.z, 0.0, 1.0), 1.0), vec4(2.0, 2.0, 2.0, 1.0), unlit);
+    out.uv = uv;
+    out.alpha = color.a;
+    return out;
+}
+@fragment fn horizon_entity_shadow_fs(in: HorizonEntityShadowOut) {
+    let alpha = textureSampleLevel(horizon_atlas, horizon_atlas_sampler, in.uv, 0.0).a;
+    if alpha * in.alpha < 0.5 { discard; }
+}
+";
+
+/// `shadow_color`'s format.
+const SHADOW_COLOR: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
+
+/// The shader pack's shadow camera for `settings`: orthographic over `distance` each side,
+/// 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.
+pub fn camera(settings: &Settings) -> Shadow {
+    Shadow {
+        resolution: settings.resolution,
+        distance: settings.distance,
+        render_mul: 1.0,
+        interval: SNAP,
+        euclidean_snap: true,
+        near: 256.0,
+        far: super::pack_uniforms::SHADOW_EYE + 2.0 * settings.distance + 384.0,
+        ..Shadow::default()
+    }
+}
+
+/// `settings` with the resolution `device` can make.
+pub fn fitted(device: &wgpu::Device, settings: &Settings) -> Settings {
+    Settings {
+        resolution: settings
+            .resolution
+            .min(device.limits().max_texture_dimension_2d),
+        ..settings.clone()
+    }
+}
+
+/// The cell the shadow camera keeps to, in blocks along the world's axes: the player stays
+/// within 7 blocks of the centre (half the cell on each axis), where the map is still over
+/// three times as fine as at its edge.
+const SNAP: f32 = 8.0;
+
+/// The ground one shadow texel covers right under the camera, in blocks: a 32nd, half a texture
+/// pixel, so shadow edges near the player stay as sharp as the blocks casting them.
+const CENTRE_TEXEL: f32 = 1.0 / 32.0;
+
+/// How strongly the map is distorted toward its centre (`Frame::shadow_distortion`).
+/// `xy / (|xy| k + 1 - k)` magnifies the centre by 1 / (1 - k); an undistorted texel covers
+/// 2 distance / resolution blocks, so k is what brings that down to `CENTRE_TEXEL`. None when
+/// the map is already that fine; at most 0.95, past which the edge of the map gets too few texels.
+pub fn distortion(distance: f32, resolution: u32) -> f32 {
+    let texel = 2.0 * distance / resolution.max(1) as f32;
+    (1.0 - CENTRE_TEXEL / texel).clamp(0.0, 0.95)
+}
+
+/// The shadow map: a square depth map of the pack's resolution, or a 1×1 one (cleared to "far",
+/// so everything is lit) for a pack without `[shadow]`; the same with translucent terrain drawn
+/// in, and that terrain's colour.
+pub struct ShadowMap {
+    depth: wgpu::Texture,
+    pub view: wgpu::TextureView,
+    translucent: wgpu::Texture,
+    pub translucent_view: wgpu::TextureView,
+    pub color_view: wgpu::TextureView,
+    pub sampler: wgpu::Sampler,
+    /// The 1×1 map still holds the zeroes it was made with.
+    blank_uncleared: bool,
+}
+
+impl ShadowMap {
+    pub fn new(device: &wgpu::Device, settings: Option<&Settings>) -> Self {
+        let size = settings.map_or(1, |s| s.resolution);
+        let texture = |label, format, usage| {
+            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,
+                usage: wgpu::TextureUsages::TEXTURE_BINDING
+                    | wgpu::TextureUsages::RENDER_ATTACHMENT
+                    | usage,
+                view_formats: &[],
+            })
+        };
+        let depth = texture(
+            "Native shader pack shadow map",
+            wgpu::TextureFormat::Depth32Float,
+            wgpu::TextureUsages::COPY_SRC,
+        );
+        let translucent = texture(
+            "Native shader pack translucent shadow map",
+            wgpu::TextureFormat::Depth32Float,
+            wgpu::TextureUsages::COPY_DST,
+        );
+        let color = texture(
+            "Native shader pack shadow colour",
+            SHADOW_COLOR,
+            wgpu::TextureUsages::empty(),
+        );
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: Some("Native shader pack shadow comparison"),
+            compare: Some(wgpu::CompareFunction::LessEqual),
+            mag_filter: wgpu::FilterMode::Linear,
+            min_filter: wgpu::FilterMode::Linear,
+            ..Default::default()
+        });
+        Self {
+            view: depth.create_view(&Default::default()),
+            depth,
+            translucent_view: translucent.create_view(&Default::default()),
+            translucent,
+            color_view: color.create_view(&Default::default()),
+            sampler,
+            blank_uncleared: settings.is_none(),
+        }
+    }
+
+    /// A depth pass into the map that clears it to "far".
+    pub fn begin<'e>(
+        &self,
+        encoder: &'e mut wgpu::CommandEncoder,
+        label: &str,
+        timing: Option<&mut super::pack_timing::PassTiming>,
+    ) -> wgpu::RenderPass<'e> {
+        self.depth_pass(encoder, label, wgpu::LoadOp::Clear(1.0), timing)
+    }
+
+    /// A depth pass that adds to the map. Entities draw here, after the translucent map was
+    /// copied: where one casts, the solid map is the darker and decides.
+    pub fn begin_entities<'e>(
+        &self,
+        encoder: &'e mut wgpu::CommandEncoder,
+        label: &str,
+    ) -> wgpu::RenderPass<'e> {
+        self.depth_pass(encoder, label, wgpu::LoadOp::Load, None)
+    }
+
+    fn depth_pass<'e>(
+        &self,
+        encoder: &'e mut wgpu::CommandEncoder,
+        label: &str,
+        load: wgpu::LoadOp<f32>,
+        timing: Option<&mut super::pack_timing::PassTiming>,
+    ) -> wgpu::RenderPass<'e> {
+        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: Some(label),
+            timestamp_writes: timing.and_then(|t| t.writes(label)),
+            color_attachments: &[],
+            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                view: &self.view,
+                depth_ops: Some(wgpu::Operations {
+                    load,
+                    store: wgpu::StoreOp::Store,
+                }),
+                stencil_ops: None,
+            }),
+            ..Default::default()
+        })
+    }
+
+    /// The translucent pass: the solid terrain's map copied into the translucent one, which it
+    /// goes on drawing into, and the colour cleared to white (nothing to pass through).
+    pub fn begin_translucent<'e>(
+        &self,
+        encoder: &'e mut wgpu::CommandEncoder,
+        label: &str,
+        timing: Option<&mut super::pack_timing::PassTiming>,
+    ) -> wgpu::RenderPass<'e> {
+        encoder.copy_texture_to_texture(
+            self.depth.as_image_copy(),
+            self.translucent.as_image_copy(),
+            self.depth.size(),
+        );
+        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: Some(label),
+            timestamp_writes: timing.and_then(|t| t.writes(label)),
+            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                view: &self.color_view,
+                resolve_target: None,
+                depth_slice: None,
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
+                    store: wgpu::StoreOp::Store,
+                },
+            })],
+            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                view: &self.translucent_view,
+                depth_ops: Some(wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: wgpu::StoreOp::Store,
+                }),
+                stencil_ops: None,
+            }),
+            ..Default::default()
+        })
+    }
+
+    /// Clears the 1×1 map of a pack without `[shadow]` once.
+    pub fn clear_blank(&mut self, encoder: &mut wgpu::CommandEncoder) {
+        if std::mem::take(&mut self.blank_uncleared) {
+            drop(self.begin(encoder, "Native shader pack shadow map clear", None));
+            drop(self.begin_translucent(encoder, "Native shader pack shadow colour clear", None));
+        }
+    }
+}
+
+/// The pipelines that draw terrain into the shadow map, for the renderer's instanced draws and,
+/// where they run, its flat ones, and the frame they read (group 3, the uniform alone: the
+/// stages' own group 3 also holds the map being drawn).
+pub struct NativeShadow {
+    pub solid: wgpu::RenderPipeline,
+    pub flat: Option<wgpu::RenderPipeline>,
+    /// The translucent terrain's draws into the translucent map and the colour, instanced and
+    /// flat.
+    pub translucent: wgpu::RenderPipeline,
+    pub flat_translucent: Option<wgpu::RenderPipeline>,
+    /// The entities' draw, with the entities' group 0 (`ENTITY_ENTRIES`).
+    pub entity: wgpu::RenderPipeline,
+    pub group: wgpu::BindGroup,
+}
+
+/// The entity draw's shader.
+fn entity_source() -> String {
+    format!(
+        "{}@group({GROUP}) @binding(0) var<uniform> frame: Frame;\n{}{ENTITY_ENTRIES}",
+        FrameInputs::WGSL.wgsl(),
+        horizon_shader_api::stages::SHADOW_HELPERS,
+    )
+}
+
+/// The shadow pass's entity pipeline: the entities' vertices and group 0, the frame at group 3.
+fn entity_pipeline(
+    device: &wgpu::Device,
+    entities: &wgpu::BindGroupLayout,
+    frame_layout: &wgpu::BindGroupLayout,
+) -> wgpu::RenderPipeline {
+    let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        label: Some("Native shader pack entity shadow"),
+        source: wgpu::ShaderSource::Wgsl(entity_source().into()),
+    });
+    let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] = Default::default();
+    groups[0] = Some(entities);
+    groups[GROUP as usize] = Some(frame_layout);
+    let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+        label: Some("Native shader pack entity shadow"),
+        bind_group_layouts: &groups,
+        ..Default::default()
+    });
+    let attributes =
+        wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x2, 2 => Uint32, 3 => Unorm8x4];
+    device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: Some("Native shader pack entity shadow"),
+        layout: Some(&layout),
+        vertex: wgpu::VertexState {
+            module: &module,
+            entry_point: Some("horizon_entity_shadow_vs"),
+            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,
+            })],
+        },
+        // Both sides, as the terrain: thin parts (ears, item quads) cast from either.
+        primitive: wgpu::PrimitiveState {
+            cull_mode: None,
+            ..Default::default()
+        },
+        depth_stencil: Some(wgpu::DepthStencilState {
+            format: wgpu::TextureFormat::Depth32Float,
+            depth_write_enabled: Some(true),
+            depth_compare: Some(wgpu::CompareFunction::LessEqual),
+            stencil: Default::default(),
+            bias: wgpu::DepthBiasState {
+                constant: 0,
+                slope_scale: 1.5,
+                clamp: 0.0,
+            },
+        }),
+        multisample: Default::default(),
+        fragment: Some(wgpu::FragmentState {
+            module: &module,
+            entry_point: Some("horizon_entity_shadow_fs"),
+            compilation_options: Default::default(),
+            targets: &[],
+        }),
+        multiview_mask: None,
+        cache: None,
+    })
+}
+
+/// `horizon_shadow_solid(layer)`: whether the sprite layer's id, out of `materials`
+/// (`(layer, id)`), is one of the pack's `solid` ones.
+fn shadow_solid(materials: &[(u32, u32)], solid: &[u32]) -> String {
+    let layers: Vec<String> = materials
+        .iter()
+        .filter(|(_, id)| solid.contains(id))
+        .map(|(layer, _)| format!("{layer}u"))
+        .collect();
+    let cases = if layers.is_empty() {
+        String::new()
+    } else {
+        format!("        case {}: {{ return true; }}\n", layers.join(", "))
+    };
+    format!(
+        "fn horizon_shadow_solid(layer: u32) -> bool {{\n    switch layer {{\n{cases}        \
+         default: {{ return false; }}\n    }}\n}}\n"
+    )
+}
+
+/// The shadow pass's shader: the frame, Horizon's terrain, and the entries, with the layers
+/// `solid` of `shadow_solid`.
+fn shader_source(solid: &str) -> String {
+    format!(
+        "{}@group({GROUP}) @binding(0) var<uniform> frame: Frame;\n{}\
+         // Horizon's terrain (terrain.wgsl)\n{}{solid}{ENTRIES}",
+        FrameInputs::WGSL.wgsl(),
+        horizon_shader_api::stages::SHADOW_HELPERS,
+        prefixed(
+            section(TERRAIN, "struct Globals {", "// Sky (SkyRenderer)"),
+            PREFIX
+        )
+    )
+}
+
+impl NativeShadow {
+    pub fn new(
+        device: &wgpu::Device,
+        shape: &TerrainShape<'_>,
+        frame: &super::native_post::NativeFrame,
+        solid_materials: &[u32],
+    ) -> Result<Self, String> {
+        let text = shader_source(&shadow_solid(shape.sprite_materials, solid_materials));
+        let module = naga::front::wgsl::parse_str(&text)
+            .map_err(|e| format!("shadow pass: {}", e.emit_to_string(&text)))?;
+        let constants = [
+            ("horizon_terrain_SPRITE_ARRAYS", shape.sprites[0]),
+            ("horizon_terrain_SPRITE_SPLIT", shape.sprites[1]),
+        ];
+        let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
+        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Native shader pack shadow"),
+            source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)),
+        });
+        let frame_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Native shader pack shadow frame"),
+            entries: &[wgpu::BindGroupLayoutEntry {
+                binding: 0,
+                visibility: wgpu::ShaderStages::VERTEX,
+                ty: wgpu::BindingType::Buffer {
+                    ty: wgpu::BufferBindingType::Uniform,
+                    has_dynamic_offset: false,
+                    min_binding_size: wgpu::BufferSize::new(size_of::<FrameInputs>() as u64),
+                },
+                count: None,
+            }],
+        });
+        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("Native shader pack shadow frame"),
+            layout: &frame_layout,
+            entries: &[wgpu::BindGroupEntry {
+                binding: 0,
+                resource: frame.buffer.as_entire_binding(),
+            }],
+        });
+        let layout = |flat: Option<&wgpu::BindGroupLayout>| {
+            let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] =
+                Default::default();
+            groups[0] = Some(shape.globals);
+            groups[1] = flat;
+            groups[GROUP as usize] = Some(&frame_layout);
+            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: Some("Native shader pack shadow"),
+                bind_group_layouts: &groups,
+                ..Default::default()
+            })
+        };
+        let instance_attributes = wgpu::vertex_attr_array![5=>Float32x4];
+        let vertices = wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<super::TerrainVertex>() as u64,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &super::TERRAIN_ATTRIBUTES,
+        };
+        let instances = wgpu::VertexBufferLayout {
+            array_stride: 16,
+            step_mode: wgpu::VertexStepMode::Instance,
+            attributes: &instance_attributes,
+        };
+        let color_target = [Some(wgpu::ColorTargetState {
+            format: SHADOW_COLOR,
+            blend: None,
+            write_mask: wgpu::ColorWrites::ALL,
+        })];
+        let pipeline = |layout: &wgpu::PipelineLayout,
+                        vertex: &str,
+                        buffers: &[Option<wgpu::VertexBufferLayout<'_>>],
+                        translucent: bool| {
+            let options = wgpu::PipelineCompilationOptions {
+                constants: &constants,
+                ..Default::default()
+            };
+            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: Some("Native shader pack shadow"),
+                layout: Some(layout),
+                vertex: wgpu::VertexState {
+                    module: &module,
+                    entry_point: Some(vertex),
+                    compilation_options: options.clone(),
+                    buffers,
+                },
+                // Both sides: the quads that face the light are drawn (`facing_runs`), and
+                // plants' crossed quads cast from either side.
+                primitive: wgpu::PrimitiveState {
+                    cull_mode: None,
+                    ..Default::default()
+                },
+                depth_stencil: Some(wgpu::DepthStencilState {
+                    format: wgpu::TextureFormat::Depth32Float,
+                    depth_write_enabled: Some(true),
+                    depth_compare: Some(wgpu::CompareFunction::LessEqual),
+                    stencil: Default::default(),
+                    bias: wgpu::DepthBiasState {
+                        constant: 0,
+                        slope_scale: 1.5,
+                        clamp: 0.0,
+                    },
+                }),
+                multisample: Default::default(),
+                fragment: Some(wgpu::FragmentState {
+                    module: &module,
+                    entry_point: Some(if translucent {
+                        "horizon_shadow_fs_translucent"
+                    } else {
+                        "horizon_shadow_fs"
+                    }),
+                    compilation_options: options,
+                    targets: if translucent { &color_target } else { &[] },
+                }),
+                multiview_mask: None,
+                cache: None,
+            })
+        };
+        let instanced = layout(None);
+        let solid = pipeline(
+            &instanced,
+            "horizon_shadow_vs",
+            &[Some(vertices.clone()), Some(instances.clone())],
+            false,
+        );
+        let translucent = pipeline(
+            &instanced,
+            "horizon_shadow_vs",
+            &[Some(vertices.clone()), Some(instances)],
+            true,
+        );
+        let flat_layout = shape.flat.map(|group| layout(Some(group)));
+        let flat_pipeline = |translucent| {
+            flat_layout.as_ref().map(|layout| {
+                pipeline(
+                    layout,
+                    "horizon_shadow_vs_flat",
+                    &[Some(vertices.clone())],
+                    translucent,
+                )
+            })
+        };
+        let flat = flat_pipeline(false);
+        let flat_translucent = flat_pipeline(true);
+        let entity = entity_pipeline(device, shape.entities, &frame_layout);
+        if let Some(e) = pollster::block_on(scope.pop()) {
+            return Err(format!("shadow pass: {e}"));
+        }
+        Ok(Self {
+            solid,
+            flat,
+            translucent,
+            flat_translucent,
+            entity,
+            group,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_shadow_shader_validates() {
+        for materials in [&[][..], &[(3, 7), (4, 8), (9, 7)][..]] {
+            let text = shader_source(&shadow_solid(materials, &[7]));
+            let module = naga::front::wgsl::parse_str(&text).unwrap();
+            naga::valid::Validator::new(
+                naga::valid::ValidationFlags::all(),
+                naga::valid::Capabilities::all(),
+            )
+            .validate(&module)
+            .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
+        }
+    }
+
+    #[test]
+    fn only_the_layers_of_solid_ids_lose_their_cutouts() {
+        let materials = [(3, 7), (4, 8), (9, 7)];
+        assert!(shadow_solid(&materials, &[7]).contains("case 3u, 9u: { return true; }"));
+        assert!(!shadow_solid(&materials, &[]).contains("case"));
+        assert!(!shadow_solid(&materials, &[5]).contains("case"));
+    }
+
+    #[test]
+    fn the_entity_shader_validates() {
+        let text = entity_source();
+        let module = naga::front::wgsl::parse_str(&text).unwrap();
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::all(),
+        )
+        .validate(&module)
+        .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
+    }
+
+    #[test]
+    fn what_the_camera_stands_on_is_inside_the_shadow_cameras_depth() {
+        let settings = Settings {
+            resolution: 2048,
+            distance: 128.0,
+            solid_materials: Vec::new(),
+        };
+        let shadow = camera(&settings);
+        let (view, projection) = super::super::pack_uniforms::shadow_camera(
+            glam::Vec3::new(0.3, 0.9, 0.0).normalize(),
+            glam::DVec3::new(-2064.5, 246.0, -4304.5),
+            &shadow,
+        );
+        // Up to the build height's span below a player flying high, as well as above them.
+        for y in [64.0, 0.0, -64.0, -200.0, -384.0] {
+            let clip = projection * view * glam::Vec4::new(0.0, y, 0.0, 1.0);
+            assert!(clip.is_finite(), "{clip}");
+            assert!((-1.0..=1.0).contains(&clip.z), "{clip}");
+        }
+    }
+
+    #[test]
+    fn the_centre_stays_near_the_player_on_both_sides_of_zero() {
+        let shadow = camera(&Settings {
+            resolution: 2048,
+            distance: 128.0,
+            solid_materials: Vec::new(),
+        });
+        let light = glam::Vec3::Y;
+        for x in [5.5, -5.5, -2064.5, 2064.5] {
+            let camera = glam::DVec3::new(x, 64.0, x);
+            let (view, _) = super::super::pack_uniforms::shadow_camera(light, camera, &shadow);
+            let centre = view.inverse().w_axis.truncate();
+            assert!(centre.x.abs() <= SNAP / 2.0, "{x}: {centre}");
+            assert!(centre.z.abs() <= SNAP / 2.0, "{x}: {centre}");
+        }
+    }
+
+    #[test]
+    fn the_distortion_brings_the_centre_texel_to_a_32nd_of_a_block() {
+        // 2048 texels over 256 blocks: an 8th of a block each, magnified 4 times.
+        assert!((distortion(128.0, 2048) - 0.75).abs() < 1e-6);
+        // Already that fine: no distortion.
+        assert_eq!(distortion(32.0, 2048), 0.0);
+        assert_eq!(distortion(10_000.0, 1024), 0.95);
+    }
+}

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

@@ -252,7 +252,7 @@ mod tests {
                 resource: globals_buffer.as_entire_binding(),
             }],
         });
-        let frame = NativeFrame::new(&device);
+        let frame = NativeFrame::new(&device, None, Vec::new(), Default::default(), None);
         queue.write_buffer(
             &frame.buffer,
             0,

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

@@ -620,6 +620,7 @@ impl Oit {
         depth: &wgpu::TextureView,
         draw: &dyn Fn(&mut wgpu::RenderPass<'_>, Stage),
         extras: &Extras<'_>,
+        mut timing: Option<&mut super::pack_timing::PassTiming>,
     ) {
         let Some(t) = &self.targets else { return };
         let attachment = |view, load| {
@@ -645,7 +646,7 @@ impl Oit {
         let water_mask = extras.water_mask.zip(t.terrain_depth.as_ref());
         let cloud_depth = extras.clouds.zip(t.cloud_depth.as_ref());
         if let Some((mask, _)) = water_mask {
-            self.execute_water_mask(encoder, t, color, depth, mask);
+            self.execute_water_mask(encoder, t, color, depth, mask, timing.as_deref_mut());
         }
         let terrain_depth = water_mask.map_or(depth, |(_, d)| &d.view);
         let [c0, c1] = &t.views.coefficients;
@@ -680,6 +681,7 @@ impl Oit {
             {
                 let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                     label: Some(label),
+                    timestamp_writes: timing.as_deref_mut().and_then(|t| t.writes(label)),
                     color_attachments: &first,
                     depth_stencil_attachment: read_only(terrain_depth),
                     ..Default::default()
@@ -692,6 +694,7 @@ impl Oit {
                 // the terrain's: the masks only hide water.
                 let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                     label: Some(label),
+                    timestamp_writes: timing.as_deref_mut().and_then(|t| t.writes("OIT features")),
                     color_attachments: &[attachment(
                         match stage {
                             Stage::DepthBounds => &t.views.bounds,
@@ -710,7 +713,7 @@ impl Oit {
                 features(&mut pass, stage);
             }
             if stage == Stage::DepthBounds {
-                self.execute_depth_bounds_cull(encoder, t, depth);
+                self.execute_depth_bounds_cull(encoder, t, depth, timing.as_deref_mut());
             }
             if let Some((clouds, cloud_depth)) = cloud_depth {
                 self.render_clouds(
@@ -720,16 +723,18 @@ impl Oit {
                     depth,
                     (label, group, &then),
                     (clouds, cloud_depth),
+                    timing.as_deref_mut(),
                 );
             }
             if stage == Stage::DepthBounds
                 && let Some((mask, _)) = water_mask
             {
-                self.execute_water_mask(encoder, t, color, depth, mask);
+                self.execute_water_mask(encoder, t, color, depth, mask, timing.as_deref_mut());
             }
         }
         let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("OIT composite"),
+            timestamp_writes: timing.and_then(|t| t.writes("OIT composite")),
             color_attachments: &[attachment(color, wgpu::LoadOp::Load)],
             depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
                 view: depth,
@@ -749,6 +754,7 @@ impl Oit {
     /// `CloudRenderer.renderOit` for one stage. The bounds stage first copies
     /// the world's depth (after the cull) and draws into it, so the later
     /// stages, which only read it, keep each pixel's nearest cloud face.
+    #[allow(clippy::too_many_arguments)]
     fn render_clouds(
         &self,
         encoder: &mut wgpu::CommandEncoder,
@@ -764,6 +770,7 @@ impl Oit {
             &dyn Fn(&mut wgpu::RenderPass<'_>, &wgpu::RenderPipeline),
             &Depth,
         ),
+        timing: Option<&mut super::pack_timing::PassTiming>,
     ) {
         if stage == Stage::DepthBounds {
             encoder.copy_texture_to_texture(
@@ -774,6 +781,7 @@ impl Oit {
         }
         let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some(label),
+            timestamp_writes: timing.and_then(|t| t.writes("OIT clouds")),
             color_attachments: targets,
             depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
                 view: &cloud_depth.view,
@@ -798,6 +806,7 @@ impl Oit {
         color: &wgpu::TextureView,
         depth: &wgpu::TextureView,
         mask: &dyn Fn(&mut wgpu::RenderPass<'_>),
+        timing: Option<&mut super::pack_timing::PassTiming>,
     ) {
         let Some(terrain) = &t.terrain_depth else {
             return;
@@ -810,6 +819,7 @@ impl Oit {
         // The mask pipeline writes depth only but has a colour target.
         let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("OIT water mask"),
+            timestamp_writes: timing.and_then(|t| t.writes("OIT water mask")),
             color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                 view: color,
                 resolve_target: None,
@@ -840,6 +850,7 @@ impl Oit {
         encoder: &mut wgpu::CommandEncoder,
         t: &Targets,
         depth: &wgpu::TextureView,
+        timing: Option<&mut super::pack_timing::PassTiming>,
     ) {
         encoder.copy_texture_to_texture(
             t.bounds.as_image_copy(),
@@ -852,6 +863,7 @@ impl Oit {
         );
         let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("OIT cull depth bounds"),
+            timestamp_writes: timing.and_then(|t| t.writes("OIT cull depth bounds")),
             color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                 view: &t.views.culled,
                 resolve_target: None,

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

@@ -217,7 +217,12 @@ impl Features {
                 &entity_module,
                 entities,
                 &entity_buffers,
-                kind("additive entities", "lightning", None, PLAIN),
+                kind(
+                    "additive entities",
+                    "lightning",
+                    Some(wgpu::Face::Back),
+                    PLAIN,
+                ),
             ),
             weather: set(
                 &entity_module,

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

@@ -3117,8 +3117,7 @@ impl PackPost {
 
     /// What the shadow camera draws of the terrain this frame, when the pack draws it.
     pub fn shadow_view(&self, frame: &super::Frame) -> Option<ShadowView> {
-        self.shadow_targets.as_ref()?;
-        if self.shadow_terrain.is_none() && self.shadow_water.is_none() {
+        if !self.has_shadow() {
             return None;
         }
         let shadow = &self.uniforms.shadow;
@@ -3139,6 +3138,12 @@ impl PackPost {
         self.terrain.is_some()
     }
 
+    /// Whether the pack's shadow pass draws terrain (`shadow_view`).
+    pub fn has_shadow(&self) -> bool {
+        self.shadow_targets.is_some()
+            && (self.shadow_terrain.is_some() || self.shadow_water.is_some())
+    }
+
     /// Whether the pack draws the sky (disc, sunset, stars, void) itself.
     /// What the world's background is when the pack draws the sky: colortex0's clear colour
     /// (`None`: the fog colour, its default).

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

@@ -1,5 +1,6 @@
-//! GPU time of each pass of a shader pack, of either kind: shown in the F3 overlay while it is
-//! open, and logged every `REPORT` timed frames with `HORIZON_SHADER_PACK_TIMING=1`. One frame
+//! GPU time of each pass of a shader pack, of either kind, and of Horizon's own passes: shown in
+//! the F3 overlay while it is open, and logged every `REPORT` timed frames with
+//! `HORIZON_SHADER_PACK_TIMING=1`. One frame
 //! at a time is timed, and the CPU never waits for it: its timestamps are resolved in a later
 //! frame, once the GPU has finished it (Metal resolves them without waiting for the passes that
 //! write them), then read back when mapped. The next frame after that is timed again.
@@ -139,6 +140,12 @@ impl PassTiming {
         Some(stamps(&self.queries, i))
     }
 
+    /// Timestamp writes for the compute pass `name`, in a timed frame.
+    pub fn compute_writes(&mut self, name: &str) -> Option<wgpu::ComputePassTimestampWrites<'_>> {
+        let i = self.push(name)?;
+        Some(compute_stamps(&self.queries, i))
+    }
+
     /// The index of the timed frame's next pass, `name`.
     fn push(&mut self, name: &str) -> Option<u32> {
         let i = self.names.len() as u32;
@@ -274,6 +281,15 @@ fn stamps(queries: &wgpu::QuerySet, i: u32) -> wgpu::RenderPassTimestampWrites<'
     }
 }
 
+/// The compute pass's twin of `stamps`.
+fn compute_stamps(queries: &wgpu::QuerySet, i: u32) -> wgpu::ComputePassTimestampWrites<'_> {
+    wgpu::ComputePassTimestampWrites {
+        query_set: queries,
+        beginning_of_pass_write_index: Some(2 * i),
+        end_of_pass_write_index: Some(2 * i + 1),
+    }
+}
+
 /// Each pass's time in milliseconds from its (beginning, end) timestamps, `None` for a pass
 /// the GPU left unstamped. Passes overlap on tiled GPUs (a pass begins before the one before it
 /// ends): a pass costs the time from the later of its beginning and the previous pass's end.

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

@@ -35,6 +35,33 @@ pub struct PackInputs {
     /// `heldItemId`, `heldItemId2` (item.properties, 5.3) and `heldBlockLightValue(2)`.
     pub held_items: [i32; 2],
     pub held_light: [i32; 2],
+    /// `isRightHanded` (the Main Hand option) and `is_on_ground`.
+    pub right_handed: bool,
+    pub on_ground: bool,
+    /// The dimension type's lowest block (`bedrockLevel`), build height (`heightLimit`),
+    /// logical height, sky light and ceiling.
+    pub min_y: i32,
+    pub height: i32,
+    pub logical_height: i32,
+    pub has_skylight: bool,
+    pub has_ceiling: bool,
+    /// `isElytraFlying`: the player is fall flying.
+    pub elytra_flying: bool,
+    /// `cloudHeight`, see [`cloud_height`].
+    pub cloud_height: f32,
+    /// The values native mods hand their packs (`frame.mods`, `native_shader_params`).
+    pub mod_params: [[f32; 4]; 8],
+}
+
+/// The `cloudHeight` uniform. Vanilla reads `visual/cloud_height` only while the cloud color
+/// has alpha (`LevelExtractor`); a dimension without clouds has no height, which the uniform
+/// reports as NaN. NaN is not vanilla's own value: packs map it to "no clouds".
+pub fn cloud_height(cloud_color_alpha: f32, height: f32) -> f32 {
+    if crate::clouds::has_color(cloud_color_alpha) {
+        height
+    } else {
+        f32::NAN
+    }
 }
 
 /// One uniform's value: up to 16 floats or 3 integers.
@@ -171,6 +198,15 @@ pub const NAMES: &[&str] = &[
     "playerLookVector",
     "playerBodyVector",
     "firstPersonCamera",
+    "isRightHanded",
+    "is_on_ground",
+    "bedrockLevel",
+    "heightLimit",
+    "logicalHeightLimit",
+    "hasSkylight",
+    "hasCeiling",
+    "isElytraFlying",
+    "cloudHeight",
 ];
 
 /// Values carried from frame to frame.
@@ -245,7 +281,7 @@ pub fn shadow_culling(frame: &Frame, shadow: &Shadow) -> Mat4 {
 
 /// How far toward the light the shadow projection starts, in blocks: part of the projection,
 /// not of `shadowModelView` (Iris's matrices, measured).
-const SHADOW_EYE: f32 = 100.0;
+pub const SHADOW_EYE: f32 = 100.0;
 
 /// The shadow camera as Iris places it (7.1; measured from the outside): its view (player
 /// space to shadow view space) and GL projection. The view undoes `sunPathRotation`, turns the
@@ -264,7 +300,12 @@ pub fn shadow_camera(light: Vec3, camera: DVec3, shadow: &Shadow) -> (Mat4, Mat4
         * DMat4::from_rotation_x(tilt);
     let step = f64::from(shadow.interval);
     let origin = if step > 0.0 {
-        DVec3::splat(step / 2.0) - camera % step
+        let remainder = if shadow.euclidean_snap {
+            camera.rem_euclid(DVec3::splat(step))
+        } else {
+            camera % step
+        };
+        DVec3::splat(step / 2.0) - remainder
     } else {
         DVec3::ZERO
     };
@@ -373,6 +414,13 @@ impl FrameUniforms {
                 "relativeEyePosition" => v3((frame.camera - frame.eye).as_vec3()),
                 "playerLookVector" | "playerBodyVector" => v3(look),
                 "firstPersonCamera" => Value::i(&[i32::from(frame.first_person)]),
+                "isRightHanded" => Value::i(&[i32::from(inputs.right_handed)]),
+                "is_on_ground" => Value::i(&[i32::from(inputs.on_ground)]),
+                "bedrockLevel" => Value::i(&[inputs.min_y]),
+                "heightLimit" => Value::i(&[inputs.height]),
+                "logicalHeightLimit" => Value::i(&[inputs.logical_height]),
+                "hasSkylight" => Value::i(&[i32::from(inputs.has_skylight)]),
+                "hasCeiling" => Value::i(&[i32::from(inputs.has_ceiling)]),
                 "eyeAltitude" => Value::f(&[frame.camera.y as f32]),
                 "upPosition" => v3(to_view(Vec3::new(0.0, 100.0, 0.0))),
                 "sunPosition" => v3(sun),
@@ -432,6 +480,8 @@ impl FrameUniforms {
                 "heldItemId2" => Value::i(&[inputs.held_items[1]]),
                 "heldBlockLightValue" => Value::i(&[inputs.held_light[0]]),
                 "heldBlockLightValue2" => Value::i(&[inputs.held_light[1]]),
+                "isElytraFlying" => Value::i(&[inputs.elytra_flying as i32]),
+                "cloudHeight" => Value::f(&[inputs.cloud_height]),
                 // renderStage is NONE outside gbuffers draws.
                 _ => Value::i(&[0]),
             }
@@ -526,6 +576,25 @@ mod tests {
         assert_eq!(out[60..64], [0; 4], "a value past the block is dropped");
     }
 
+    #[test]
+    fn cloud_height_needs_a_cloud_color() {
+        assert_eq!(cloud_height(0.8, 192.33), 192.33);
+        assert_eq!(cloud_height(0.8, 120.0), 120.0);
+        assert!(cloud_height(0.0, 192.33).is_nan());
+    }
+
+    #[test]
+    fn elytra_and_cloud_height_uniforms_are_written() {
+        assert!(NAMES.ends_with(&["isElytraFlying", "cloudHeight"]));
+        let mut out = vec![0u8; 16];
+        Value::i(&[1]).write("bool", &mut out, 0);
+        assert_eq!(i32::from_ne_bytes(out[0..4].try_into().unwrap()), 1);
+        Value::f(&[192.33]).write("float", &mut out, 4);
+        assert_eq!(f32::from_ne_bytes(out[4..8].try_into().unwrap()), 192.33);
+        Value::f(&[f32::NAN]).write("float", &mut out, 8);
+        assert!(f32::from_ne_bytes(out[8..12].try_into().unwrap()).is_nan());
+    }
+
     #[test]
     fn noon_is_straight_up_and_the_sun_sets_in_the_west() {
         assert!(body(0.0, 0.0).abs_diff_eq(Vec3::new(0.0, 100.0, 0.0), 1e-3));

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

@@ -0,0 +1,228 @@
+//! The frame's commands finished, submitted and presented on a thread of their own.
+//!
+//! wgpu records a pass's commands lazily: `CommandEncoder::finish` validates and
+//! encodes the whole frame (about 0.1 ms with the submit), work the window's thread
+//! would otherwise wait for before building the next frame. The renderer hands the
+//! frame's encoder to [`Queue::submit_later`] and goes on; every use of the queue
+//! ([`Deref`]) first waits for that frame to be submitted, so writes, copies and
+//! submissions keep the order they had on one thread.
+use std::ops::Deref;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Mutex, mpsc};
+
+/// Whether frames go to the submit thread, unless `HORIZON_SUBMIT_THREAD` says (`0` off, `1` on):
+/// on Linux, where it was measured faster (+32% FPS in a CPU-bound view on Vulkan, #5779). On
+/// macOS's Metal it stalled: offscreen at render distance 12, a tenth to a half of the frame rate
+/// with 20-180 ms p99 frames, against the same binary without it. Windows is not measured yet.
+pub fn wanted() -> bool {
+    match std::env::var("HORIZON_SUBMIT_THREAD").as_deref() {
+        Ok("0") => false,
+        Ok("1") => true,
+        _ => cfg!(target_os = "linux"),
+    }
+}
+
+/// Work to start right after a frame's submission (a readback's `map_async`).
+pub type AfterSubmit = Box<dyn FnOnce() + Send>;
+
+/// A frame for the submit thread: its commands and, in a window, the surface to present.
+pub struct Job {
+    pub encoder: wgpu::CommandEncoder,
+    pub surface: Option<wgpu::SurfaceTexture>,
+    pub after: Option<AfterSubmit>,
+}
+
+struct Thread {
+    jobs: Option<mpsc::Sender<Job>>,
+    handle: Option<std::thread::JoinHandle<()>>,
+}
+
+/// What the submit thread sent back, once it is taken in by [`Queue::wait`].
+struct Landing {
+    done: mpsc::Receiver<wgpu::SubmissionIndex>,
+    landed: Option<wgpu::SubmissionIndex>,
+}
+
+/// The device's queue, with frames submitted on the submit thread when it runs.
+pub struct Queue {
+    queue: wgpu::Queue,
+    thread: Option<Thread>,
+    /// A frame went to the submit thread and has not been waited for.
+    pending: AtomicBool,
+    landing: Mutex<Option<Landing>>,
+}
+
+impl Queue {
+    /// `threaded`: frames may go to a submit thread (the renderer asks [`wanted`]).
+    pub fn new(queue: wgpu::Queue, threaded: bool) -> Self {
+        let mut this = Self {
+            queue,
+            thread: None,
+            pending: AtomicBool::new(false),
+            landing: Mutex::new(None),
+        };
+        if !threaded {
+            return this;
+        }
+        let (jobs, job_rx) = mpsc::channel::<Job>();
+        let (done_tx, done) = mpsc::channel();
+        let queue = this.queue.clone();
+        let spawned = std::thread::Builder::new()
+            .name("Render submit".into())
+            .spawn(move || {
+                for job in job_rx {
+                    let commands = job.encoder.finish();
+                    let submission = queue.submit([commands]);
+                    if let Some(after) = job.after {
+                        after();
+                    }
+                    if let Some(surface) = job.surface {
+                        queue.present(surface);
+                    }
+                    if done_tx.send(submission).is_err() {
+                        break;
+                    }
+                }
+            });
+        match spawned {
+            Ok(handle) => {
+                this.thread = Some(Thread {
+                    jobs: Some(jobs),
+                    handle: Some(handle),
+                });
+                *this.lock() = Some(Landing { done, landed: None });
+            }
+            Err(e) => log::warn!("Horizon renderer: no submit thread ({e}); submitting in place"),
+        }
+        this
+    }
+    fn lock(&self) -> std::sync::MutexGuard<'_, Option<Landing>> {
+        self.landing
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+    }
+    /// Whether frames can go to the submit thread.
+    pub fn threaded(&self) -> bool {
+        self.thread.is_some()
+    }
+    /// Finish, submit and present the frame on the submit thread, then run its `after`;
+    /// given back, with nothing done, when there is none.
+    pub fn submit_later(&self, job: Job) -> Result<(), Box<Job>> {
+        let Some(jobs) = self.thread.as_ref().and_then(|t| t.jobs.as_ref()) else {
+            return Err(Box::new(job));
+        };
+        self.wait();
+        match jobs.send(job) {
+            Ok(()) => {
+                self.pending.store(true, Ordering::Release);
+                Ok(())
+            }
+            Err(mpsc::SendError(job)) => Err(Box::new(job)),
+        }
+    }
+    /// Wait until the frame on the submit thread is submitted and presented.
+    pub fn wait(&self) {
+        if !self.pending.load(Ordering::Acquire) {
+            return;
+        }
+        let mut landing = self.lock();
+        if !self.pending.load(Ordering::Acquire) {
+            return;
+        }
+        if let Some(l) = landing.as_mut() {
+            // A thread that died (a wgpu panic on it) panics here, as it would have in place.
+            let submission = l
+                .done
+                .recv()
+                .expect("Horizon renderer: the submit thread stopped");
+            l.landed = Some(submission);
+        }
+        self.pending.store(false, Ordering::Release);
+    }
+    /// The submission of the frame [`submit_later`](Self::submit_later) took, once it is
+    /// made; `None` if it was taken already.
+    pub fn landed(&self) -> Option<wgpu::SubmissionIndex> {
+        self.wait();
+        self.lock().as_mut().and_then(|l| l.landed.take())
+    }
+}
+
+impl Deref for Queue {
+    type Target = wgpu::Queue;
+    fn deref(&self) -> &wgpu::Queue {
+        self.wait();
+        &self.queue
+    }
+}
+
+impl Drop for Queue {
+    fn drop(&mut self) {
+        self.wait();
+        if let Some(thread) = &mut self.thread {
+            thread.jobs.take();
+            if let Some(handle) = thread.handle.take() {
+                let _ = handle.join();
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn device() -> Option<(wgpu::Device, wgpu::Queue)> {
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
+        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
+        pollster::block_on(adapter.request_device(&Default::default())).ok()
+    }
+
+    fn buffer(device: &wgpu::Device, usage: wgpu::BufferUsages) -> wgpu::Buffer {
+        device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: 4,
+            usage,
+            mapped_at_creation: false,
+        })
+    }
+
+    #[test]
+    fn writes_after_a_frame_on_the_thread_land_after_it() {
+        let Some((device, queue)) = device() else {
+            return;
+        };
+        let queue = Queue::new(queue, true);
+        assert!(queue.threaded());
+        use wgpu::BufferUsages as U;
+        let source = buffer(&device, U::COPY_SRC | U::COPY_DST);
+        let copy = buffer(&device, U::COPY_SRC | U::COPY_DST);
+        let read = buffer(&device, U::MAP_READ | U::COPY_DST);
+        queue.write_buffer(&source, 0, &[1, 2, 3, 4]);
+        for frame in 0..3u8 {
+            // The frame copies `source`; the next frame's write must not reach that copy.
+            let mut encoder = device.create_command_encoder(&Default::default());
+            encoder.copy_buffer_to_buffer(&source, 0, &copy, 0, 4);
+            let job = Job {
+                encoder,
+                surface: None,
+                after: None,
+            };
+            assert!(queue.submit_later(job).is_ok());
+            queue.write_buffer(&source, 0, &[frame + 10; 4]);
+            assert!(queue.landed().is_some(), "frame {frame} submitted");
+            let mut encoder = device.create_command_encoder(&Default::default());
+            encoder.copy_buffer_to_buffer(&copy, 0, &read, 0, 4);
+            queue.submit([encoder.finish()]);
+            read.slice(..)
+                .map_async(wgpu::MapMode::Read, |r| r.unwrap());
+            device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+            let expected = if frame == 0 {
+                [1, 2, 3, 4]
+            } else {
+                [frame + 9; 4]
+            };
+            assert_eq!(*read.slice(..).get_mapped_range().unwrap(), expected);
+            read.unmap();
+        }
+    }
+}

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

@@ -3,6 +3,10 @@ use crate::weather::{Time, Vertex};
 
 pub(super) struct Weather {
     pipeline: wgpu::RenderPipeline,
+    /// The layouts of groups 0 (the entities') and 1 (the fall clock), for a native pack's
+    /// weather pipeline.
+    pub entity_layout: wgpu::BindGroupLayout,
+    pub time_layout: wgpu::BindGroupLayout,
     group: wgpu::BindGroup,
     uniform: wgpu::Buffer,
     vertices: wgpu::Buffer,
@@ -84,6 +88,8 @@ impl Weather {
         });
         Self {
             pipeline,
+            entity_layout: entities.clone(),
+            time_layout: bindings,
             group,
             uniform,
             vertices: Self::buffer(device, 4),
@@ -138,11 +144,24 @@ impl Weather {
         pass.set_vertex_buffer(0, self.vertices.slice(..));
         pass.draw_indexed(0..self.count / 4 * 6, 0, 0..1);
     }
-    pub fn draw(&self, pass: &mut wgpu::RenderPass<'_>, entities: &wgpu::BindGroup) {
+    /// Draws the streaks, through a native pack's weather stage when `native` is given (its
+    /// pipeline and the pack's frame group).
+    pub fn draw(
+        &self,
+        pass: &mut wgpu::RenderPass<'_>,
+        entities: &wgpu::BindGroup,
+        native: Option<(&wgpu::RenderPipeline, &wgpu::BindGroup)>,
+    ) {
         if self.count == 0 {
             return;
         }
-        pass.set_pipeline(&self.pipeline);
+        match native {
+            Some((pipeline, frame)) => {
+                pass.set_pipeline(pipeline);
+                pass.set_bind_group(horizon_shader_api::stages::GROUP, frame, &[]);
+            }
+            None => pass.set_pipeline(&self.pipeline),
+        }
         pass.set_bind_group(0, entities, &[]);
         pass.set_bind_group(1, &self.group, &[]);
         pass.set_vertex_buffer(0, self.vertices.slice(..));
@@ -163,8 +182,156 @@ fn depth_stencil() -> wgpu::DepthStencilState {
     }
 }
 
+/// The entries around a native pack's `weather`: Horizon's weather vertex, then the texture
+/// as `fs_weather` reads it, handed to the pack with the light and the position.
+const NATIVE_ENTRIES: &str = "
+struct HorizonWeatherOut {
+    @builtin(position) clip: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+    @location(1) color: vec4<f32>,
+    @location(2) @interpolate(flat) rect: vec4<f32>,
+    @location(3) light: vec2<f32>,
+    @location(4) position: vec3<f32>,
+    @location(5) @interpolate(flat) snow: u32,
+}
+@vertex fn horizon_weather_vs(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
+    @location(2) rect: vec4<f32>, @location(3) animation: vec4<f32>,
+    @location(4) bases: vec4<u32>, @location(5) color: vec4<f32>,
+    @location(6) light: vec4<u32>, @location(7) snow: u32) -> HorizonWeatherOut {
+    let phase = horizon_entity_weather_phase(animation, bases, snow,
+        horizon_entity_weather_time.values);
+    let v = horizon_entity_entity_vertex(position, uv + phase, 0u, color, light, vec4(0.0));
+    var out: HorizonWeatherOut;
+    out.clip = v.clip;
+    out.uv = v.uv;
+    out.color = v.color;
+    out.rect = rect;
+    // entity_vertex's light: block in y, sky in x, 0..240.
+    out.light = min(vec2(f32(light.y), f32(light.x)) / 240.0, vec2(1.0));
+    out.position = position;
+    out.snow = snow;
+    return out;
+}
+@fragment fn horizon_weather_fs(in: HorizonWeatherOut) -> @location(0) vec4<f32> {
+    let texel = horizon_entity_weather_texel(in.uv, in.rect,
+        textureDimensions(horizon_entity_atlas));
+    let color = textureLoad(horizon_entity_atlas, texel, 0) * in.color;
+    if color.a < 0.1 { discard; }
+    return weather(WeatherInput(color, in.light, in.position, in.snow != 0u));
+}
+";
+
+/// The shader of a native pack's weather stage `source`.
+fn native_source(source: &str) -> String {
+    format!(
+        "{source}\n// Horizon's weather (entity.wgsl)\n{}{NATIVE_ENTRIES}",
+        super::wgsl_prefix::prefixed(&super::entity_shader(), "horizon_entity_")
+    )
+}
+
+/// A native pack's weather pipeline: its `stage` (with the option values `constants`), then
+/// entity.wgsl with every name prefixed, then the entries above. Group 0 is the entities',
+/// 1 the fall clock (`time_layout`), 3 the pack's frame.
+pub(super) fn native_pipeline(
+    device: &wgpu::Device,
+    format: wgpu::TextureFormat,
+    entities: &wgpu::BindGroupLayout,
+    time_layout: &wgpu::BindGroupLayout,
+    frame: &super::native_post::NativeFrame,
+    stage: &horizon_shader_api::check::CheckedStage,
+    constants: &[(String, f64)],
+) -> Result<wgpu::RenderPipeline, String> {
+    use horizon_shader_api::stages::GROUP;
+    let text = native_source(&stage.source);
+    let module = naga::front::wgsl::parse_str(&text)
+        .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))?;
+    let present = super::native_post::present_constants(&module, constants);
+    let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] = Default::default();
+    groups[0] = Some(entities);
+    groups[1] = Some(time_layout);
+    groups[GROUP as usize] = Some(&frame.layout);
+    let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+        label: Some("Native shader pack weather"),
+        bind_group_layouts: &groups,
+        ..Default::default()
+    });
+    let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
+    let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        label: Some(&stage.label),
+        source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)),
+    });
+    let options = wgpu::PipelineCompilationOptions {
+        constants: &present,
+        ..Default::default()
+    };
+    let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Float32x4,
+        3=>Float32x4,4=>Uint32x4,5=>Unorm8x4,6=>Uint8x4,7=>Uint32];
+    let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: Some("Native shader pack weather"),
+        layout: Some(&layout),
+        vertex: wgpu::VertexState {
+            module: &module,
+            entry_point: Some("horizon_weather_vs"),
+            compilation_options: options.clone(),
+            buffers: &[Some(wgpu::VertexBufferLayout {
+                array_stride: std::mem::size_of::<Vertex>() as u64,
+                step_mode: wgpu::VertexStepMode::Vertex,
+                attributes: &attributes,
+            })],
+        },
+        primitive: wgpu::PrimitiveState {
+            topology: wgpu::PrimitiveTopology::TriangleList,
+            ..Default::default()
+        },
+        depth_stencil: Some(depth_stencil()),
+        multisample: Default::default(),
+        fragment: Some(wgpu::FragmentState {
+            module: &module,
+            entry_point: Some("horizon_weather_fs"),
+            compilation_options: options,
+            targets: &[Some(wgpu::ColorTargetState {
+                format,
+                blend: Some(wgpu::BlendState {
+                    color: wgpu::BlendState::ALPHA_BLENDING.color,
+                    // The frame's alpha stays as the surfaces left it (entities mark it 0).
+                    alpha: wgpu::BlendComponent {
+                        src_factor: wgpu::BlendFactor::Zero,
+                        dst_factor: wgpu::BlendFactor::One,
+                        operation: wgpu::BlendOperation::Add,
+                    },
+                }),
+                write_mask: wgpu::ColorWrites::ALL,
+            })],
+        }),
+        multiview_mask: None,
+        cache: None,
+    });
+    if let Some(e) = pollster::block_on(scope.pop()) {
+        return Err(format!("{}: {e}", stage.file));
+    }
+    Ok(pipeline)
+}
+
 #[cfg(test)]
 mod tests {
+    use super::native_source;
+
+    #[test]
+    fn a_native_weather_stage_validates() {
+        use horizon_shader_api::stages::StageKind;
+        let source = StageKind::Weather.prelude()
+            + "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);
+        let module = naga::front::wgsl::parse_str(&text)
+            .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::all(),
+        )
+        .validate(&module)
+        .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
+    }
     use crate::weather::{Parameters, Time};
     use wgpu::util::DeviceExt;
 

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

@@ -437,14 +437,15 @@ impl Post {
         queue: &wgpu::Queue,
         encoder: &mut wgpu::CommandEncoder,
         screen: &wgpu::TextureView,
+        mut timing: Option<&mut super::pack_timing::PassTiming>,
     ) {
         let Some(target) = &self.target else { return };
         let Some(taa) = target.taa.as_ref().filter(|_| self.taa_previous.is_some()) else {
-            self.finish_with(encoder, screen, &target.group);
+            self.finish_with(encoder, screen, &target.group, timing.as_deref_mut());
             return;
         };
         let Some(res) = &self.taa_resources else {
-            self.finish_with(encoder, screen, &target.group);
+            self.finish_with(encoder, screen, &target.group, timing.as_deref_mut());
             return;
         };
         let i = (self.taa_frame % 2) as usize;
@@ -460,6 +461,7 @@ impl Post {
         })];
         let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("Horizon TAA"),
+            timestamp_writes: timing.as_deref_mut().and_then(|t| t.writes("TAA")),
             color_attachments: &attachments,
             ..Default::default()
         });
@@ -467,7 +469,7 @@ impl Post {
         pass.set_bind_group(0, &taa.resolve[i], &[]);
         pass.draw(0..3, 0..1);
         drop(pass);
-        self.finish_with(encoder, screen, &taa.show[i]);
+        self.finish_with(encoder, screen, &taa.show[i], timing);
     }
 
     /// Draw what `group` binds (`bind`) onto `screen`.
@@ -476,6 +478,7 @@ impl Post {
         encoder: &mut wgpu::CommandEncoder,
         screen: &wgpu::TextureView,
         group: &wgpu::BindGroup,
+        timing: Option<&mut super::pack_timing::PassTiming>,
     ) {
         let attachments = [Some(wgpu::RenderPassColorAttachment {
             view: screen,
@@ -488,6 +491,7 @@ impl Post {
         })];
         let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("Horizon post"),
+            timestamp_writes: timing.and_then(|t| t.writes("Post")),
             color_attachments: &attachments,
             ..Default::default()
         });

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

@@ -79,6 +79,47 @@ impl Preset {
     }
 }
 
+/// Entity occlusion strategy. The synchronous mode preserves the original
+/// same-frame CPU test; asynchronous results only hide a mesh when their
+/// camera, bounds and occluder evidence still match.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum EntityCullingMode {
+    #[default]
+    Off,
+    Synchronous,
+    Asynchronous,
+}
+impl EntityCullingMode {
+    pub const ALL: [EntityCullingMode; 3] = [
+        EntityCullingMode::Off,
+        EntityCullingMode::Synchronous,
+        EntityCullingMode::Asynchronous,
+    ];
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Off => "off",
+            Self::Synchronous => "sync",
+            Self::Asynchronous => "async",
+        }
+    }
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Off => "Off",
+            Self::Synchronous => "Synchronous",
+            Self::Asynchronous => "Asynchronous",
+        }
+    }
+    fn parse(s: &str) -> Self {
+        match s {
+            // Keep graphics files written before the mode selector readable.
+            "true" | "synchronous" | "sync" => Self::Synchronous,
+            "false" | "off" => Self::Off,
+            "asynchronous" | "async" => Self::Asynchronous,
+            _ => Self::default(),
+        }
+    }
+}
+
 /// How the swapchain presents frames.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum PresentMode {
@@ -246,6 +287,61 @@ impl FarDetail {
     }
 }
 
+/// What the section mesher does with leaf faces inside a canopy. Terrain
+/// geometry only: entities, particles and block entities are untouched.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum LeafCullingMode {
+    /// Every leaf face, as vanilla's fancy leaves draw them.
+    #[default]
+    Off,
+    /// Leaves surrounded on all six sides by leaves or full opaque cubes draw
+    /// in the opaque layer, so their cutouts no longer show the layers behind.
+    Solid,
+    /// Like `Solid`, but a leaf with one open side draws opaque too: the
+    /// exposed shell thins by a layer and the canopy looks chunkier.
+    SolidAggressive,
+    /// Drops the faces two leaves share. Faces toward air, cavities, partial
+    /// models, unknown neighbours and section boundaries stay.
+    Hollow,
+}
+impl LeafCullingMode {
+    pub const ALL: [LeafCullingMode; 4] = [
+        LeafCullingMode::Off,
+        LeafCullingMode::Solid,
+        LeafCullingMode::SolidAggressive,
+        LeafCullingMode::Hollow,
+    ];
+    pub fn name(self) -> &'static str {
+        match self {
+            LeafCullingMode::Off => "off",
+            LeafCullingMode::Solid => "solid",
+            LeafCullingMode::SolidAggressive => "solid_aggressive",
+            LeafCullingMode::Hollow => "hollow",
+        }
+    }
+    pub fn label(self) -> &'static str {
+        match self {
+            LeafCullingMode::Off => "Off",
+            LeafCullingMode::Solid => "Solid",
+            LeafCullingMode::SolidAggressive => "Solid Aggressive",
+            LeafCullingMode::Hollow => "Hollow",
+        }
+    }
+    /// Whether this mode draws interior leaf faces in the solid layer.
+    pub fn is_interior(self) -> bool {
+        matches!(
+            self,
+            LeafCullingMode::Solid | LeafCullingMode::SolidAggressive
+        )
+    }
+    fn parse(s: &str) -> Self {
+        Self::ALL
+            .into_iter()
+            .find(|mode| mode.name() == s)
+            .unwrap_or_default()
+    }
+}
+
 /// TAA upscaling: the world renders this much smaller than the resolution scale's size,
 /// and TAA builds the full-size picture from the jittered frames (FSR's and DLSS's ratios).
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
@@ -313,6 +409,8 @@ pub fn reduced_far_detail_suggested() -> bool {
 
 /// The name the options screen waits on to bind `Graphics::hdr_key`.
 pub const HDR_KEY: &str = "horizon.hdrSettings";
+/// The Screenshot Quality choices, times the game's resolution.
+pub const SCREENSHOT_QUALITIES: [u32; 4] = [1, 2, 4, 8];
 static HDR_OFFERED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
 /// Whether the display path offers HDR output (HDR10 or scRGB): set when the renderer
 /// opens its surface; the settings open HDR's screen only then.
@@ -323,6 +421,19 @@ pub fn hdr_offered() -> bool {
     HDR_OFFERED.load(std::sync::atomic::Ordering::Relaxed)
 }
 
+static TRANSLUCENT_BATCHING_OFFERED: std::sync::atomic::AtomicBool =
+    std::sync::atomic::AtomicBool::new(false);
+/// Whether the device can batch translucent quads (`Graphics::translucent_batching`): set when
+/// the renderer starts; not without indirect multi-draw or on OpenGL, which loops over a
+/// multi-draw's entries on the CPU, nor where vanilla frames draw flat (they read the section
+/// arena's translucent quads).
+pub fn offer_translucent_batching(on: bool) {
+    TRANSLUCENT_BATCHING_OFFERED.store(on, std::sync::atomic::Ordering::Relaxed);
+}
+pub fn translucent_batching_offered() -> bool {
+    TRANSLUCENT_BATCHING_OFFERED.load(std::sync::atomic::Ordering::Relaxed)
+}
+
 /// The farthest LOD Distance, in chunks, on integrated GPUs other than
 /// Apple's: they share the CPU's memory bandwidth, and past it far terrain
 /// costs them more frame time than it is worth.
@@ -346,6 +457,46 @@ impl Graphics {
     pub fn lod_distance_on(&self, info: &wgpu::AdapterInfo) -> u32 {
         lod_distance_capped(self.lod_distance, info)
     }
+    /// Whether the selected packs leave vanilla's block models in place.
+    /// Horizon's occlusion assumptions (entity and leaf culling) hold only
+    /// for those: a pack can replace an opaque cube's model or a leaf's.
+    pub fn vanilla_models(&self, resource_packs: &[String]) -> bool {
+        resource_packs.iter().all(|id| id == "vanilla")
+    }
+    /// The same check including packs overlaid by the connected server.
+    /// Their ids are namespaced as `server/...`, so an active server pack
+    /// disables model-dependent occlusion assumptions.
+    pub fn vanilla_models_with_server_packs<'a>(
+        &self,
+        resource_packs: impl IntoIterator<Item = &'a str>,
+        server_packs: impl IntoIterator<Item = &'a str>,
+    ) -> bool {
+        resource_packs
+            .into_iter()
+            .chain(server_packs)
+            .all(|id| id == "vanilla")
+    }
+    /// The leaf culling the mesher may apply. A pack that can replace leaf
+    /// models falls back to `Off`, which draws exactly vanilla's leaves.
+    pub fn leaf_culling_effective(&self, resource_packs: &[String]) -> LeafCullingMode {
+        if self.vanilla_models(resource_packs) {
+            self.leaf_culling
+        } else {
+            LeafCullingMode::Off
+        }
+    }
+    /// The effective mode when local and server resource packs are active.
+    pub fn leaf_culling_effective_with_server_packs<'a>(
+        &self,
+        resource_packs: impl IntoIterator<Item = &'a str>,
+        server_packs: impl IntoIterator<Item = &'a str>,
+    ) -> LeafCullingMode {
+        if self.vanilla_models_with_server_packs(resource_packs, server_packs) {
+            self.leaf_culling
+        } else {
+            LeafCullingMode::Off
+        }
+    }
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct Graphics {
@@ -356,16 +507,26 @@ pub struct Graphics {
     pub far_detail: FarDetail,
     /// Skip sections hidden behind closed ones (vanilla's occlusion graph).
     pub cave_culling: bool,
-    /// Skip drawing entities hidden behind opaque terrain.
-    pub entity_culling: bool,
+    /// Skip drawing entities hidden behind opaque terrain, synchronously or asynchronously.
+    pub entity_culling: EntityCullingMode,
+    /// Terrain leaf faces inside a canopy (see [`LeafCullingMode`]); `Off` draws
+    /// vanilla's fancy leaves. Ignored with a resource pack that may replace
+    /// the vanilla leaf models ([`Graphics::leaf_culling_effective`]).
+    pub leaf_culling: LeafCullingMode,
     /// Meshed sections uploaded per frame; 0 uploads all that are ready.
     pub chunk_updates: u32,
     /// Section mesh bytes uploaded per frame, in KiB; 0 is unlimited.
     pub upload_budget_kib: u32,
+    /// The block textures' video memory (their top mip level), in MiB; 0 leaves it to
+    /// Horizon (`sprites::DEFAULT_TEXTURE_BUDGET`). Applies when resources next load.
+    pub texture_budget_mib: u32,
     pub sky: bool,
     pub fog: bool,
     pub weather: bool,
     pub animated_textures: bool,
+    /// Dithers the small mip levels of cutouts from 64 texels up, so a high-resolution pack's
+    /// fine plants keep their coverage in the distance; off is vanilla's look.
+    pub dither_cutout_mips: bool,
     pub present_mode: PresentMode,
     pub pacing: Pacing,
     /// Chunk worker threads; 0 uses every core but one. Applies at the next start.
@@ -379,6 +540,8 @@ pub struct Graphics {
     pub taa: bool,
     /// TAA upscaling; anything but `Native` comes with `taa` on.
     pub upscaling: Upscaling,
+    /// F2 screenshots at this many times the game's resolution: 1, 2, 4 or 8.
+    pub screenshot_quality: u32,
     /// HDR output (HDR10, or scRGB), where the display path offers it.
     pub hdr: bool,
     /// HDR paper white (where SDR white sits), in nits; 0 is Auto: the desktop's SDR
@@ -405,6 +568,11 @@ pub struct Graphics {
     pub shadow_cache: bool,
     /// The graphics API (Windows only; see `GraphicsApi`).
     pub api: GraphicsApi,
+    /// Translucent quads in vertex buffers of their own (`gfx`'s translucent arena), so their
+    /// back-to-front draws go out in a few calls, for a little more video memory. Off by
+    /// default for now; read when a renderer is made (start, resource-pack reload), where it is
+    /// offered (`translucent_batching_offered`).
+    pub translucent_batching: bool,
     /// The shader pack picked in `shaderpacks/` (`shader_pack_list`); empty: none. Its key is
     /// not `shaderPack`, which versions before the clean-room rewrite saved and which stays
     /// ignored.
@@ -417,13 +585,16 @@ impl Default for Graphics {
             lod_distance: 0,
             far_detail: FarDetail::Full,
             cave_culling: true,
-            entity_culling: false,
+            entity_culling: EntityCullingMode::Off,
+            leaf_culling: LeafCullingMode::Off,
             chunk_updates: 0,
             upload_budget_kib: 0,
+            texture_budget_mib: 0,
             sky: true,
             fog: true,
             weather: true,
             animated_textures: true,
+            dither_cutout_mips: false,
             present_mode: PresentMode::Auto,
             pacing: Pacing::Efficient,
             workers: 0,
@@ -432,6 +603,7 @@ impl Default for Graphics {
             fxaa: false,
             taa: false,
             upscaling: Upscaling::Native,
+            screenshot_quality: 1,
             hdr: false,
             hdr_paper_white: 0,
             hdr_peak: 0,
@@ -441,6 +613,7 @@ impl Default for Graphics {
             battery: false,
             shadow_cache: false,
             api: GraphicsApi::Auto,
+            translucent_batching: false,
             shader_pack: String::new(),
         }
     }
@@ -482,13 +655,18 @@ impl Graphics {
                 }
                 "farDetail" => g.far_detail = FarDetail::parse(value),
                 "caveCulling" => g.cave_culling = flag(g.cave_culling),
-                "entityCulling" => g.entity_culling = flag(g.entity_culling),
+                "entityCulling" => g.entity_culling = EntityCullingMode::parse(value),
+                "leafCulling" => g.leaf_culling = LeafCullingMode::parse(value),
                 "chunkUpdates" => g.chunk_updates = number(g.chunk_updates).min(512),
                 "uploadBudgetKiB" => g.upload_budget_kib = number(g.upload_budget_kib).min(65536),
+                "textureBudgetMiB" => {
+                    g.texture_budget_mib = number(g.texture_budget_mib).min(16384);
+                }
                 "sky" => g.sky = flag(g.sky),
                 "fog" => g.fog = flag(g.fog),
                 "weather" => g.weather = flag(g.weather),
                 "animatedTextures" => g.animated_textures = flag(g.animated_textures),
+                "ditherCutoutMips" => g.dither_cutout_mips = flag(g.dither_cutout_mips),
                 "presentMode" => g.present_mode = PresentMode::parse(value),
                 "framePacing" => {
                     g.pacing = if value == "precise" {
@@ -502,6 +680,11 @@ impl Graphics {
                 "fxaa" => g.fxaa = flag(g.fxaa),
                 "taa" => g.taa = flag(g.taa),
                 "upscaling" => g.upscaling = Upscaling::parse(value),
+                "screenshotQuality" => {
+                    g.screenshot_quality = Some(number(0))
+                        .filter(|q| SCREENSHOT_QUALITIES.contains(q))
+                        .unwrap_or(1)
+                }
                 "hdr" => g.hdr = flag(g.hdr),
                 "hdrPaperWhite" => {
                     g.hdr_paper_white = match number(g.hdr_paper_white) {
@@ -522,6 +705,7 @@ impl Graphics {
                 "hdrKey" if value.starts_with("key.") => g.hdr_key = value.to_owned(),
                 "batteryMode" => g.battery = flag(g.battery),
                 "shadowCache" => g.shadow_cache = flag(g.shadow_cache),
+                "translucentBatching" => g.translucent_batching = flag(g.translucent_batching),
                 "graphicsApi" => g.api = GraphicsApi::from_name(value).unwrap_or_default(),
                 "pickedShaderPack" => g.shader_pack = value.to_owned(),
                 "overlay" => {
@@ -538,18 +722,21 @@ impl Graphics {
     }
     pub fn serialize(&self) -> String {
         format!(
-            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\n",
+            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nleafCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\ntextureBudgetMiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\nditherCutoutMips:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nscreenshotQuality:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\ntranslucentBatching:{}\n",
             self.preset.name(),
             self.lod_distance,
             self.far_detail.name(),
             bool_text(self.cave_culling),
-            bool_text(self.entity_culling),
+            self.entity_culling.name(),
+            self.leaf_culling.name(),
             self.chunk_updates,
             self.upload_budget_kib,
+            self.texture_budget_mib,
             bool_text(self.sky),
             bool_text(self.fog),
             bool_text(self.weather),
             bool_text(self.animated_textures),
+            bool_text(self.dither_cutout_mips),
             self.present_mode.name(),
             match self.pacing {
                 Pacing::Efficient => "efficient",
@@ -565,6 +752,7 @@ impl Graphics {
             bool_text(self.fxaa),
             bool_text(self.taa),
             self.upscaling.name(),
+            self.screenshot_quality,
             bool_text(self.hdr),
             self.hdr_paper_white,
             self.hdr_peak,
@@ -575,6 +763,7 @@ impl Graphics {
             bool_text(self.shadow_cache),
             self.api.name(),
             self.shader_pack,
+            bool_text(self.translucent_batching),
         )
     }
     /// Binds Horizon's graphics key `name` (`HDR_KEY`); false for another name.
@@ -695,13 +884,16 @@ mod tests {
             lod_distance: 256,
             far_detail: FarDetail::Reduced,
             cave_culling: false,
-            entity_culling: true,
+            entity_culling: EntityCullingMode::Synchronous,
+            leaf_culling: LeafCullingMode::SolidAggressive,
             chunk_updates: 12,
             upload_budget_kib: 4096,
+            texture_budget_mib: 1536,
             sky: false,
             fog: false,
             weather: false,
             animated_textures: false,
+            dither_cutout_mips: true,
             present_mode: PresentMode::Mailbox,
             pacing: Pacing::Precise,
             workers: 6,
@@ -710,6 +902,7 @@ mod tests {
             fxaa: true,
             taa: true,
             upscaling: Upscaling::Balanced,
+            screenshot_quality: 4,
             hdr: true,
             hdr_paper_white: 240,
             hdr_peak: 1400,
@@ -719,15 +912,46 @@ mod tests {
             battery: true,
             shadow_cache: true,
             api: GraphicsApi::Dx12,
+            translucent_batching: true,
             shader_pack: "Golden Hour".into(),
         };
         assert_eq!(Graphics::parse(&g.serialize()), g);
+        for mode in EntityCullingMode::ALL {
+            let graphics = Graphics {
+                entity_culling: mode,
+                ..Graphics::default()
+            };
+            assert_eq!(Graphics::parse(&graphics.serialize()), graphics);
+        }
+        assert_eq!(
+            Graphics::parse("entityCulling:true\n").entity_culling,
+            EntityCullingMode::Synchronous
+        );
+        assert_eq!(
+            Graphics::parse("entityCulling:false\n").entity_culling,
+            EntityCullingMode::Off
+        );
         assert_eq!(Graphics::parse(""), Graphics::default());
+        // Translucent Batching is opt-in for now: only the file turns it on.
+        assert!(!Graphics::default().translucent_batching);
         // 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);
         assert_eq!(Graphics::parse("hdrPaperWhite:0\n").hdr_paper_white, 0);
         assert_eq!(Graphics::parse("hdrPaperWhite:5\n").hdr_paper_white, 10);
+        // Only the button's choices.
+        assert_eq!(
+            Graphics::parse("screenshotQuality:8\n").screenshot_quality,
+            8
+        );
+        assert_eq!(
+            Graphics::parse("screenshotQuality:3\n").screenshot_quality,
+            1
+        );
+        assert_eq!(
+            Graphics::parse("screenshotQuality:16\n").screenshot_quality,
+            1
+        );
         // The old menus' Simple / Advanced choice is ignored, and so is the
         // shader pack older versions saved.
         assert_eq!(Graphics::parse("level:advanced\n"), Graphics::default());
@@ -736,11 +960,96 @@ mod tests {
             Graphics::default()
         );
         assert_eq!(
-            Graphics::parse("workers:abc\nsky:maybe\ncullLeaves:true\nentityCulling:maybe\n"),
+            Graphics::parse(
+                "workers:abc\nsky:maybe\ncullLeaves:true\nentityCulling:maybe\nleafCulling:maybe\n"
+            ),
             Graphics::default()
         );
     }
 
+    #[test]
+    fn leaf_culling_round_trips_its_stable_names() {
+        assert_eq!(Graphics::default().leaf_culling, LeafCullingMode::Off);
+        for mode in LeafCullingMode::ALL {
+            let g = Graphics {
+                leaf_culling: mode,
+                ..Graphics::default()
+            };
+            assert_eq!(Graphics::parse(&g.serialize()), g, "{mode:?}");
+            assert_eq!(
+                Graphics::parse(&format!("leafCulling:{}\n", mode.name())).leaf_culling,
+                mode
+            );
+        }
+        for text in [
+            "leafCulling:other\n",
+            "leafCulling:\n",
+            "leafCulling:SOLID\n",
+        ] {
+            assert_eq!(
+                Graphics::parse(text).leaf_culling,
+                LeafCullingMode::Off,
+                "{text:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn presets_keep_the_leaf_culling_choice() {
+        for mode in LeafCullingMode::ALL {
+            for preset in Preset::ALL {
+                let mut s = crate::settings::Settings::default();
+                s.horizon.leaf_culling = mode;
+                apply_preset(preset, &mut s);
+                assert_eq!(s.horizon.leaf_culling, mode, "{preset:?}");
+                assert_eq!(Graphics::parse(&s.horizon.serialize()), s.horizon);
+            }
+        }
+    }
+
+    #[test]
+    fn custom_packs_turn_leaf_culling_off() {
+        let g = Graphics {
+            leaf_culling: LeafCullingMode::Hollow,
+            ..Graphics::default()
+        };
+        assert!(g.vanilla_models(&["vanilla".into()]));
+        assert_eq!(
+            g.leaf_culling_effective(&["vanilla".into()]),
+            LeafCullingMode::Hollow
+        );
+        assert!(!g.vanilla_models(&["vanilla".into(), "My Pack".into()]));
+        assert_eq!(
+            g.leaf_culling_effective(&["vanilla".into(), "My Pack".into()]),
+            LeafCullingMode::Off
+        );
+        assert_eq!(g.leaf_culling_effective(&[]), LeafCullingMode::Hollow);
+    }
+
+    #[test]
+    fn server_pack_apply_disables_leaf_culling_and_removal_restores_it() {
+        let g = Graphics {
+            leaf_culling: LeafCullingMode::Solid,
+            ..Graphics::default()
+        };
+        let selected = ["vanilla"];
+        let applied_server_pack = ["server/0123456789abcdef/model-pack.zip"];
+
+        assert_eq!(
+            g.leaf_culling_effective_with_server_packs(selected, applied_server_pack),
+            LeafCullingMode::Off,
+            "an applied server pack can replace block models"
+        );
+        assert!(!g.vanilla_models_with_server_packs(selected, applied_server_pack));
+
+        assert_eq!(
+            g.leaf_culling_effective_with_server_packs(selected, []),
+            LeafCullingMode::Solid,
+            "removing the server pack restores the selected local mode"
+        );
+        assert!(g.vanilla_models_with_server_packs(selected, []));
+    }
+
     #[test]
     fn integrated_gpus_other_than_apple_cap_the_lod_distance() {
         let adapter = |name: &str, device_type| wgpu::AdapterInfo {

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

@@ -2,7 +2,10 @@
 //! they show, in what groups, with what description and cost, and their
 //! input. How they look comes from `graphics_style`.
 use crate::{
-    graphics::{FarDetail, GraphicsApi, Overlay, Pacing, PresentMode, Preset, Upscaling},
+    graphics::{
+        EntityCullingMode, FarDetail, GraphicsApi, LeafCullingMode, Overlay, Pacing, PresentMode,
+        Preset, Upscaling,
+    },
     graphics_style::{Cost, STYLE},
     hud::{HudAtlas, HudBatch},
     lang,
@@ -27,12 +30,14 @@ pub enum H {
     FarDetail,
     CaveCulling,
     EntityCulling,
+    LeafCulling,
     ChunkUpdates,
     UploadBudget,
     Sky,
     Fog,
     Weather,
     AnimatedTextures,
+    DitherCutoutMips,
     PresentMode,
     Pacing,
     Workers,
@@ -40,6 +45,7 @@ pub enum H {
     ResolutionScale,
     Antialiasing,
     Upscaling,
+    ScreenshotQuality,
     Hdr,
     /// Opens `Level::Hdr`.
     HdrSettings,
@@ -185,6 +191,12 @@ pub fn rows(level: Level) -> Vec<Row> {
                 Medium,
                 "How far away mobs and items are drawn, as a share of normal.",
             ),
+            h(
+                H::ChunkUpdates,
+                Low,
+                "Meshed sections uploaded per frame. Lower is smoother while loading.",
+            ),
+            Row::Header("Culling"),
             h(
                 H::CaveCulling,
                 Saves,
@@ -193,12 +205,12 @@ pub fn rows(level: Level) -> Vec<Row> {
             h(
                 H::EntityCulling,
                 None,
-                "Hides models behind opaque blocks. Entities update. Off with custom packs.",
+                "Hides models behind opaque blocks. Async checks off-thread; entities tick.",
             ),
             h(
-                H::ChunkUpdates,
-                Low,
-                "Meshed sections uploaded per frame. Lower is smoother while loading.",
+                H::LeafCulling,
+                Saves,
+                "Draws or drops leaf faces inside canopies. Off keeps vanilla's fancy leaves.",
             ),
             Row::Header("Quality"),
             v(
@@ -260,6 +272,11 @@ pub fn rows(level: Level) -> Vec<Row> {
                 Low,
                 "Animates water, lava, fire and other moving textures.",
             ),
+            h(
+                H::DitherCutoutMips,
+                Low,
+                "Keeps fine plants in high-res packs from fading far away.",
+            ),
             Row::Header("Display"),
             fov,
             fps,
@@ -279,6 +296,11 @@ pub fn rows(level: Level) -> Vec<Row> {
                 High,
                 "Renders the world smaller and rebuilds it with TAA. Faster, softer.",
             ),
+            h(
+                H::ScreenshotQuality,
+                None,
+                "F2 screenshots at this many times the game's resolution. Higher takes longer.",
+            ),
             h(
                 H::HdrSettings,
                 None,
@@ -434,6 +456,16 @@ fn description(item: Item, s: &Settings, text: &'static str) -> &'static str {
         (Item::Horizon(H::HdrPeak | H::HdrPaperWhite), Setup::Automatic | Setup::Changed) => {
             "Set up for your display. Leave on Auto unless it looks wrong."
         }
+        (Item::Horizon(H::LeafCulling), _) => match s.horizon.leaf_culling {
+            LeafCullingMode::Off => "Every leaf face. Vanilla's fancy leaves.",
+            LeafCullingMode::Solid => {
+                "Leaves fully inside a canopy draw solid: fewer see-through layers."
+            }
+            LeafCullingMode::SolidAggressive => {
+                "Leaves with one open side draw solid too: faster, chunkier edges."
+            }
+            LeafCullingMode::Hollow => "Drops faces between leaves: faster, but gaps look through.",
+        },
         _ => text,
     }
 }
@@ -503,7 +535,8 @@ impl H {
             },
             H::FarDetail => labelled("Far Detail", g.far_detail.label()),
             H::CaveCulling => labelled("Cave Culling", on_off(g.cave_culling)),
-            H::EntityCulling => labelled("Entity Culling", on_off(g.entity_culling)),
+            H::EntityCulling => labelled("Entity Culling", g.entity_culling.label()),
+            H::LeafCulling => labelled("Leaf Culling", g.leaf_culling.label()),
             H::ChunkUpdates => match g.chunk_updates {
                 0 => labelled("Chunk Updates", "Unlimited"),
                 n => labelled("Chunk Updates", lang::tr("%s per frame", &[&n])),
@@ -519,6 +552,7 @@ impl H {
             H::Fog => labelled("Fog", on_off(g.fog)),
             H::Weather => labelled("Weather", on_off(g.weather)),
             H::AnimatedTextures => labelled("Animated Textures", on_off(g.animated_textures)),
+            H::DitherCutoutMips => labelled("Distant Plant Dither", on_off(g.dither_cutout_mips)),
             H::PresentMode => labelled("Present Mode", g.present_mode.label()),
             H::Pacing => labelled(
                 "Frame Pacing",
@@ -544,6 +578,9 @@ impl H {
                 },
             ),
             H::Upscaling => labelled("Upscaling", g.upscaling.label()),
+            H::ScreenshotQuality => {
+                labelled("Screenshot Quality", format!("{}x", g.screenshot_quality))
+            }
             H::Hdr => labelled("HDR", on_off(g.hdr)),
             H::HdrSettings => Text::literal(lang::get("HDR Settings...")),
             H::HdrCalibrate => Text::literal(lang::get(match setup(s) {
@@ -632,11 +669,17 @@ impl H {
                 g.far_detail = step(&[FarDetail::Full, FarDetail::Reduced], g.far_detail, back)
             }
             H::CaveCulling => g.cave_culling = !g.cave_culling,
-            H::EntityCulling => g.entity_culling = !g.entity_culling,
+            H::EntityCulling => {
+                g.entity_culling = step(&EntityCullingMode::ALL, g.entity_culling, back)
+            }
+            H::LeafCulling => {
+                g.leaf_culling = step(&LeafCullingMode::ALL, g.leaf_culling, back);
+            }
             H::Sky => g.sky = !g.sky,
             H::Fog => g.fog = !g.fog,
             H::Weather => g.weather = !g.weather,
             H::AnimatedTextures => g.animated_textures = !g.animated_textures,
+            H::DitherCutoutMips => g.dither_cutout_mips = !g.dither_cutout_mips,
             H::PresentMode => g.present_mode = step(&PresentMode::ALL, g.present_mode, back),
             // Off, FXAA, TAA.
             H::Antialiasing => {
@@ -654,6 +697,13 @@ impl H {
                     (g.fxaa, g.taa) = (false, true);
                 }
             }
+            H::ScreenshotQuality => {
+                g.screenshot_quality = step(
+                    &crate::graphics::SCREENSHOT_QUALITIES,
+                    g.screenshot_quality,
+                    back,
+                )
+            }
             H::Hdr => g.hdr = !g.hdr,
             H::BatteryMode => g.battery = !g.battery,
             H::ShadowCache => g.shadow_cache = !g.shadow_cache,
@@ -712,11 +762,11 @@ impl Item {
         let g = &s.horizon;
         Some(match self {
             Item::Horizon(H::CaveCulling) => g.cave_culling,
-            Item::Horizon(H::EntityCulling) => g.entity_culling,
             Item::Horizon(H::Sky) => g.sky,
             Item::Horizon(H::Fog) => g.fog,
             Item::Horizon(H::Weather) => g.weather,
             Item::Horizon(H::AnimatedTextures) => g.animated_textures,
+            Item::Horizon(H::DitherCutoutMips) => g.dither_cutout_mips,
             Item::Horizon(H::Hdr) => g.hdr,
             Item::Horizon(H::BatteryMode) => g.battery,
             Item::Horizon(H::ShadowCache) => g.shadow_cache,
@@ -775,6 +825,7 @@ impl Item {
             Item::Horizon(
                 H::Preset
                     | H::Overlay
+                    | H::ScreenshotQuality
                     | H::Pacing
                     | H::PresentMode
                     | H::Workers
@@ -1743,6 +1794,21 @@ mod tests {
         assert_eq!(s.horizon.preset, Preset::Ultra);
     }
 
+    #[test]
+    fn screenshot_quality_cycles_1_2_4_8_and_keeps_the_preset() {
+        let mut s = Settings::default();
+        Item::Horizon(H::Preset).cycle(&mut s, false, [854, 480]);
+        let mut seen = Vec::new();
+        for _ in 0..4 {
+            Item::Horizon(H::ScreenshotQuality).cycle(&mut s, false, [854, 480]);
+            seen.push(s.horizon.screenshot_quality);
+        }
+        assert_eq!(seen, [2, 4, 8, 1]);
+        Item::Horizon(H::ScreenshotQuality).cycle(&mut s, true, [854, 480]);
+        assert_eq!(s.horizon.screenshot_quality, 8);
+        assert_eq!(s.horizon.preset, Preset::Performance);
+    }
+
     #[test]
     fn upload_budget_slider_steps() {
         let mut s = Settings::default();
@@ -1785,16 +1851,92 @@ mod tests {
     }
 
     #[test]
-    fn entity_culling_is_opt_in_and_toggles_from_advanced_graphics() {
+    fn leaf_culling_cycles_modes_in_the_advanced_culling_group() {
+        let mut s = Settings::default();
+        let item = Item::Horizon(H::LeafCulling);
+        assert_eq!(item.switch(&s), None);
+        assert_eq!(item.label(&s).plain(), "Leaf Culling: Off");
+        for label in ["Solid", "Solid Aggressive", "Hollow", "Off"] {
+            item.cycle(&mut s, false, [854, 480]);
+            assert_eq!(item.label(&s).plain(), format!("Leaf Culling: {label}"));
+            assert_eq!(
+                crate::graphics::Graphics::parse(&s.horizon.serialize()).leaf_culling,
+                s.horizon.leaf_culling
+            );
+        }
+        item.cycle(&mut s, true, [854, 480]);
+        assert_eq!(s.horizon.leaf_culling, LeafCullingMode::Hollow);
+
+        // The three culling settings share one group, below Rendering's chunk
+        // updates and above Quality.
+        let rows = rows(Level::Advanced);
+        let culling = rows
+            .iter()
+            .position(|row| matches!(row, Row::Header("Culling")))
+            .unwrap();
+        assert!(matches!(
+            rows.get(culling + 1),
+            Some(Row::Setting(setting)) if setting.item == Item::Horizon(H::CaveCulling)
+        ));
+        assert!(matches!(
+            rows.get(culling + 2),
+            Some(Row::Setting(setting)) if setting.item == Item::Horizon(H::EntityCulling)
+        ));
+        assert!(matches!(
+            rows.get(culling + 3),
+            Some(Row::Setting(setting)) if setting.item == item
+        ));
+        assert!(matches!(
+            rows.get(culling + 4),
+            Some(Row::Header("Quality"))
+        ));
+
+        // The description names what the picked mode does.
+        for mode in LeafCullingMode::ALL {
+            s.horizon.leaf_culling = mode;
+            let text = description(item, &s, "fallback");
+            assert_ne!(text, "fallback", "{mode:?}");
+            assert!(text.len() < 80, "{mode:?}: {text}");
+        }
+
+        // A click cycles it and leaves the preset, as the other quality
+        // settings do.
+        let mut ui = GraphicsUi::default();
+        let size = (480.0, 4000.0);
+        let (widgets, _, _) = ui.layout(Level::Advanced, &s, size.0, size.1);
+        let control = widgets
+            .iter()
+            .find(|w| matches!(w.target, Target::Item(i) if i == item))
+            .unwrap();
+        s.horizon.preset = Preset::Balanced;
+        s.horizon.leaf_culling = LeafCullingMode::Off;
+        assert_eq!(
+            ui.click(
+                Level::Advanced,
+                &mut s,
+                (control.x + 1.0, control.y + 1.0),
+                size,
+                [854, 480],
+                false,
+                false
+            ),
+            vec![Action::ButtonClick, Action::Changed]
+        );
+        assert_eq!(s.horizon.leaf_culling, LeafCullingMode::Solid);
+        assert_eq!(s.horizon.preset, Preset::Custom);
+    }
+
+    #[test]
+    fn entity_culling_modes_are_opt_in_and_cycle_from_advanced_graphics() {
         let mut s = Settings::default();
         let item = Item::Horizon(H::EntityCulling);
-        assert_eq!(item.switch(&s), Some(false));
+        assert_eq!(s.horizon.entity_culling, EntityCullingMode::Off);
         assert_eq!(item.label(&s).plain(), "Entity Culling: Off");
-        for enabled in [false, true] {
-            s.horizon.entity_culling = enabled;
+        for mode in EntityCullingMode::ALL {
+            s.horizon.entity_culling = mode;
             for preset in Preset::ALL {
                 crate::graphics::apply_preset(preset, &mut s);
-                assert_eq!(s.horizon.entity_culling, enabled);
+                assert_eq!(s.horizon.entity_culling, mode);
             }
         }
 
@@ -1806,7 +1948,11 @@ mod tests {
             .find(|w| matches!(w.target, Target::Item(i) if i == item))
             .unwrap();
         let point = (switch.x + 1.0, switch.y + 1.0);
-        for enabled in [false, true] {
+        for mode in [
+            EntityCullingMode::Off,
+            EntityCullingMode::Synchronous,
+            EntityCullingMode::Asynchronous,
+        ] {
             s.horizon.preset = Preset::Balanced;
             assert_eq!(
                 ui.click(
@@ -1820,10 +1966,10 @@ mod tests {
                 ),
                 vec![Action::ButtonClick, Action::Changed]
             );
-            assert_eq!(item.switch(&s), Some(enabled));
+            assert_eq!(s.horizon.entity_culling, mode);
             assert_eq!(s.horizon.preset, Preset::Custom);
         }
-        assert_eq!(item.label(&s).plain(), "Entity Culling: On");
+        assert_eq!(item.label(&s).plain(), "Entity Culling: Asynchronous");
     }
 
     #[test]

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

@@ -83,6 +83,8 @@ pub struct HudAtlas {
     /// A resource pack's own `core/text` shader for the GUI's text, translated;
     /// none draws the text natively.
     pub text_shader: Option<std::sync::Arc<horizon_shaders::CoreProgram>>,
+    /// The packs' OptiFine random entity textures, whose variants this atlas packs.
+    pub random_textures: horizon_optifine::random_textures::RandomTextures,
     white: Rect,
 }
 /// Atlas rows reserved for glyphs rasterized at run time.
@@ -479,6 +481,7 @@ impl HudAtlas {
             glint_armor: (vec![0; 4], 1, 1),
             white,
             text_shader: None,
+            random_textures: Default::default(),
         }
     }
     /// Shelf placements of `images` (tallest first) in the narrowest atlas
@@ -528,20 +531,33 @@ impl HudAtlas {
         for folder in folders {
             walk(&textures.join(folder), &mut files);
         }
-        // Content mods' equipment textures, which their equipment assets name as
-        // `<ns>:<path>`, and their mob effects' icons, `<ns>:mob_effect/<path>`.
+        // Content mods' entity textures: their equipment assets name them as
+        // `<ns>:<path>`, and native mods draw their block entities with them
+        // (`native_draw_quad`: `<ns>:entity/...`); and their mob effects'
+        // icons, `<ns>:mob_effect/<path>`.
         let namespaces = horizon_items::content_namespaces::namespaces(root);
-        for (folder, textures) in [("entity", "entity/equipment"), ("mob_effect", "mob_effect")] {
+        for folder in ["entity", "mob_effect"] {
             if folders.contains(&folder) {
                 for namespace in &namespaces {
                     walk(
-                        &root.join(format!("assets/{namespace}/textures/{textures}")),
+                        &root.join(format!("assets/{namespace}/textures/{folder}")),
                         &mut files,
                     );
                 }
             }
         }
         let assets = root.join("assets");
+        // A native mod's particle type names its textures `<ns>:particle/<path>`
+        // and needn't ship content, so every namespace's folder is packed.
+        if folders.contains(&"particle")
+            && let Ok(namespaces) = fs::read_dir(&assets)
+        {
+            for ns in namespaces.flatten() {
+                if ns.file_name() != "minecraft" {
+                    walk(&ns.path().join("textures/particle"), &mut files);
+                }
+            }
+        }
         // Content mods' GUI textures, for their screens: `<namespace>:gui/...`.
         if full && let Ok(namespaces) = fs::read_dir(&assets) {
             for ns in namespaces.flatten() {
@@ -554,17 +570,49 @@ impl HudAtlas {
             let s = p.to_string_lossy();
             !s.contains("title/background") && !s.contains("realms") && !s.contains("presets")
         });
+        // OptiFine random entity variants, under the names their scan gives them (those
+        // outside `textures/` are `<ns>:optifine/random/...`).
+        let random_textures = if folders.contains(&"entity") {
+            horizon_optifine::random_textures::RandomTextures::scan(root)
+        } else {
+            Default::default()
+        };
+        let mut named: HashMap<PathBuf, String> = HashMap::new();
+        for (file, name) in random_textures.files() {
+            named.insert(root.join(file), name.to_owned());
+        }
+        if !named.is_empty() {
+            // Those beside their texture are walked already.
+            let walked: HashSet<&PathBuf> = files.iter().collect();
+            let mut extra: Vec<PathBuf> = named
+                .keys()
+                .filter(|p| !walked.contains(p))
+                .cloned()
+                .collect();
+            extra.sort();
+            files.extend(extra);
+        }
         type Decoded = (PackedImage, Option<TextureFlags>, Option<(u32, u32)>, bool);
         let decode_one = |path: &PathBuf| -> Option<Decoded> {
-            let name = match path.strip_prefix(&textures) {
-                Ok(rel) => rel.with_extension("").to_string_lossy().replace('\\', "/"),
-                Err(_) => {
-                    let rel = path.strip_prefix(&assets).ok()?.with_extension("");
-                    let rel = rel.to_string_lossy().replace('\\', "/");
-                    let (namespace, rest) = rel.split_once("/textures/")?;
-                    format!("{namespace}:{rest}")
+            let name = if let Some(name) = named.get(path) {
+                name.clone()
+            } else {
+                match path.strip_prefix(&textures) {
+                    Ok(rel) => rel.with_extension("").to_string_lossy().replace('\\', "/"),
+                    Err(_) => {
+                        let rel = path.strip_prefix(&assets).ok()?.with_extension("");
+                        let rel = rel.to_string_lossy().replace('\\', "/");
+                        let (namespace, rest) = rel.split_once("/textures/")?;
+                        format!("{namespace}:{rest}")
+                    }
                 }
             };
+            // LabPBR's maps beside a texture are the world's (sprites.rs), not images to draw.
+            if let Some(base) = name.strip_suffix("_n").or_else(|| name.strip_suffix("_s"))
+                && textures.join(format!("{base}.png")).is_file()
+            {
+                return None;
+            }
             let image = decode(path)
                 .map_err(|e| log::warn!("skipped GUI texture {}: {e}", path.display()))
                 .ok()?;
@@ -758,6 +806,7 @@ impl HudAtlas {
             glint,
             glint_armor,
             text_shader: None,
+            random_textures,
             font,
             white,
         })
@@ -1604,6 +1653,9 @@ pub struct HudRenderer {
     atlas_view: wgpu::TextureView,
     /// The resource pack's text shader, when it has one that works.
     pack_text: Option<pack_text::PackText>,
+    /// Target pixels per window pixel: above 1 for a screenshot drawn larger than the
+    /// window (`Renderer::screenshot_quality`).
+    pub zoom: f32,
 }
 impl HudRenderer {
     pub fn new(
@@ -1833,6 +1885,7 @@ impl HudRenderer {
             format,
             atlas_view: view.clone(),
             pack_text: None,
+            zoom: 1.0,
         })
     }
     /// Draw the GUI's text with `shader` (`HudAtlas::text_shader`), or natively.
@@ -1968,14 +2021,14 @@ impl HudRenderer {
                 [
                     size[0] as f32,
                     size[1] as f32,
-                    batch.scale,
+                    batch.scale * self.zoom,
                     batch.glint_alpha,
                 ],
                 batch.end_portal,
             )),
         );
         if let Some(pack_text) = &self.pack_text {
-            pack_text.prepare(uploads, encoder, batch, size);
+            pack_text.prepare(uploads, encoder, batch, size, batch.scale * self.zoom);
         }
     }
     /// Draw the batch `prepare` staged.
@@ -1994,9 +2047,11 @@ impl HudRenderer {
             batch,
             size,
             0..batch.vertices.len() as u32,
+            None,
         );
     }
     /// Draw part of the prepared batch, preserving its blend/depth runs.
+    #[allow(clippy::too_many_arguments)]
     pub fn draw_range(
         &self,
         encoder: &mut wgpu::CommandEncoder,
@@ -2005,6 +2060,7 @@ impl HudRenderer {
         batch: &HudBatch,
         size: [u32; 2],
         vertices: std::ops::Range<u32>,
+        mut timing: Option<&mut crate::gfx::pack_timing::PassTiming>,
     ) {
         if vertices.is_empty() || size.contains(&0) {
             return;
@@ -2035,6 +2091,7 @@ impl HudRenderer {
             };
             let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                 label: Some("HUD"),
+                timestamp_writes: timing.as_deref_mut().and_then(|t| t.writes("HUD")),
                 color_attachments: &attachments,
                 depth_stencil_attachment: clip.map(|_| wgpu::RenderPassDepthStencilAttachment {
                     view: depth,
@@ -2048,7 +2105,8 @@ impl HudRenderer {
             });
             pass.set_bind_group(0, &self.group, &[]);
             pass.set_vertex_buffer(0, self.buffer.slice(..));
-            if let Some([x, y, w, h]) = clip {
+            if let Some(clip) = clip {
+                let [x, y, w, h] = clip.map(|v| (v as f32 * self.zoom) as u32);
                 let (x, y) = (x.min(size[0]), y.min(size[1]));
                 let (w, h) = (w.min(size[0] - x), h.min(size[1] - y));
                 if w == 0 || h == 0 {
@@ -2186,7 +2244,7 @@ mod tests {
         atlas.pixels[at..at + 4].try_into().unwrap()
     }
     #[test]
-    fn content_mod_equipment_textures_pack_under_their_namespace() {
+    fn content_mod_entity_textures_pack_under_their_namespace() {
         let root = std::env::temp_dir().join(format!("horizon-atlas-equip-{}", std::process::id()));
         let _ = fs::remove_dir_all(&root);
         let equipment = root.join("assets/gems/textures/entity/equipment/humanoid");
@@ -2206,10 +2264,17 @@ mod tests {
             br#"["gems"]"#,
         )
         .unwrap();
+        // A block entity's texture, for a native mod's renderer.
+        let machine = root.join("assets/gems/textures/entity/machine");
+        fs::create_dir_all(&machine).unwrap();
+        write_strip(&machine.join("cog.png"), 32, 32, &[[0, 0, 200, 255]], None);
         let atlas = HudAtlas::build(&root).unwrap();
         let rect = atlas.sprites["gems:entity/equipment/humanoid/ruby"];
         assert_eq!(texel_at(&atlas, rect, 0, 0), [200, 0, 0, 255]);
-        // Only equipment: the mods' other textures reach the atlas through atlas definitions.
+        let rect = atlas.sprites["gems:entity/machine/cog"];
+        assert_eq!(rect.texels((atlas.width, atlas.height)), (32, 32));
+        assert_eq!(texel_at(&atlas, rect, 0, 0), [0, 0, 200, 255]);
+        // Only entity textures: the mods' others reach the atlas through atlas definitions.
         assert!(!atlas.sprites.contains_key("gems:item/ruby"));
         fs::remove_dir_all(&root).unwrap();
     }

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

@@ -216,8 +216,9 @@ impl PackText {
         encoder: &mut wgpu::CommandEncoder,
         batch: &HudBatch,
         size: [u32; 2],
+        scale: f32,
     ) {
-        uploads.buffer(encoder, &self.uniform, 0, &uniforms(batch, size));
+        uploads.buffer(encoder, &self.uniform, 0, &uniforms(batch, size, scale));
     }
 
     /// Draw `range` (whole glyph quads) with the pack's shader; the caller sets its own
@@ -233,7 +234,8 @@ impl PackText {
 /// `GlintAlpha`, `GameTime`, `ScreenSize`), `Projection` (`GuiRenderer`'s orthographic GUI
 /// projection, 1000 to 11000 deep, in GL's depth range), `DynamicTransforms` (the GUI's model view
 /// moving 11000 back, colour modulator white) and an empty `Fog`.
-fn uniforms(batch: &HudBatch, size: [u32; 2]) -> Vec<u8> {
+/// `scale`: target pixels per GUI pixel (`batch.scale`, times `HudRenderer::zoom`).
+fn uniforms(batch: &HudBatch, size: [u32; 2], scale: f32) -> Vec<u8> {
     let mut data = vec![0f32; 256];
     let globals = 0;
     data[globals + 3] = batch.glint_alpha;
@@ -241,7 +243,7 @@ fn uniforms(batch: &HudBatch, size: [u32; 2]) -> Vec<u8> {
     data[globals + 8] = size[0] as f32;
     data[globals + 9] = size[1] as f32;
     // Matrix4f.setOrtho(0, width, height, 0, near, far) with the GUI's scale, columns.
-    let (w, h) = (size[0] as f32 / batch.scale, size[1] as f32 / batch.scale);
+    let (w, h) = (size[0] as f32 / scale, size[1] as f32 / scale);
     let (near, far) = (1000.0f32, 11000.0f32);
     let projection = 64;
     data[projection] = 2.0 / w;
@@ -287,7 +289,8 @@ mod tests {
     fn the_gui_projection_maps_gui_pixels_to_the_screen() {
         let mut batch = HudBatch::new([1920, 1080]);
         batch.scale = 4.0;
-        let data: Vec<f32> = bytemuck::cast_slice(&uniforms(&batch, [1920, 1080])).to_vec();
+        let data: Vec<f32> =
+            bytemuck::cast_slice(&uniforms(&batch, [1920, 1080], batch.scale)).to_vec();
         let column = |matrix: usize, c: usize| &data[matrix + 4 * c..matrix + 4 * c + 4];
         let apply = |matrix: usize, v: [f32; 4]| -> [f32; 4] {
             std::array::from_fn(|r| (0..4).map(|c| column(matrix, c)[r] * v[c]).sum())

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

@@ -18,9 +18,11 @@ pub mod camera;
 pub mod chat;
 pub mod chunk;
 pub mod chunk_map;
+pub mod cit;
 pub mod clouds;
 pub mod collisions;
 pub mod command_block;
+pub mod connected;
 pub mod containers;
 pub mod crash;
 pub mod datapack;

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

@@ -47,6 +47,9 @@ fn meshing_threads(cores: usize) -> usize {
 /// terrain starts one sample job at most this often and no detail: it would
 /// otherwise take the cores the near chunks and the frame need.
 const HELD_SAMPLE_STEP: std::time::Duration = std::time::Duration::from_millis(500);
+/// How long a tile whose sampling failed (`LodSampler::grid` gave no
+/// columns: a server refused or lost it) waits before it is asked again.
+const RETRY: std::time::Duration = std::time::Duration::from_secs(2);
 /// The coarsest tile level: `Plan` roots cover at most `MAX_CHUNKS` chunks
 /// around (a level-22 tile is 67 million blocks wide: the whole world).
 pub(crate) const MAX_LEVEL: u8 = 22;
@@ -494,7 +497,20 @@ struct Plan {
     /// selection is rebuilt, without sorting the whole set.
     by_level: [Vec<TileKey>; MAX_LEVEL as usize + 1],
     elevation: i32,
+    camera: [i32; 2],
+    /// The squared distance within which no coarser tile stands in for
+    /// missing detail (`stands_in`): the seam with the near chunks waits
+    /// for its own tiles instead of showing broad boxes beside them.
+    near: i64,
+    /// The squared distance within which planned tiles load before the
+    /// coarse backdrop (`wanted_tiles`).
+    first: i64,
 }
+/// Chunks past the render distance where only planned tiles are drawn (two
+/// past the last near chunk, `streaming::in_view_distance`), and where they
+/// load first.
+const SEAM_CHUNKS: i32 = 3;
+const FIRST_CHUNKS: i32 = 4;
 impl Plan {
     #[cfg(test)]
     fn new(camera: [i32; 2], detail: i32, distance: u32) -> Self {
@@ -518,6 +534,9 @@ impl Plan {
         let size = 16 << level;
         let mut result = Self {
             elevation,
+            camera,
+            near: i64::from((detail + SEAM_CHUNKS) * 16).pow(2),
+            first: i64::from((detail + FIRST_CHUNKS) * 16).pow(2),
             ..Self::default()
         };
         for z in (camera[1] - range).div_euclid(size)..=(camera[1] + range).div_euclid(size) {
@@ -589,7 +608,7 @@ impl Plan {
             if complete {
                 return true;
             }
-            if ready.contains_key(&key) {
+            if ready.contains_key(&key) && self.stands_in(key) {
                 // Its mesh is clipped around every selected finer tile.
                 out.push(key);
                 return true;
@@ -602,6 +621,26 @@ impl Plan {
             false
         }
     }
+    /// Whether a split tile may draw for its missing children: only away
+    /// from the near chunks, where its cells are small on screen.
+    fn stands_in(&self, key: TileKey) -> bool {
+        key.reach(self.camera) >= self.near
+    }
+    /// The coarse tile sampled to cover `leaf` while it loads: two levels
+    /// up (16 times fewer tiles, each as cheap as a leaf to sample), one
+    /// where that would reach the seam, none beside it.
+    fn backdrop(&self, leaf: TileKey) -> Option<TileKey> {
+        let mut backdrop = None;
+        let mut key = leaf;
+        for _ in 0..2 {
+            key = key.parent();
+            if !self.nodes.contains(&key) || !self.stands_in(key) {
+                break;
+            }
+            backdrop = Some(key);
+        }
+        backdrop
+    }
     /// Whether chunk column (x, z) is drawn by the tile planned there (ready;
     /// at level 0, also `filled`) rather than by a coarser ancestor standing
     /// in for it, or is past the far terrain.
@@ -625,6 +664,47 @@ impl Plan {
         self.split.contains(&key) || (ready.contains_key(&key) && (key.level > 0 || filled(key)))
     }
 }
+/// The tiles to sample, `Wanted`'s order best first. First the planned
+/// tiles at the seam with the near chunks, nearest first: coarse tiles
+/// there cost a far tile's work for broad boxes that fine tiles replace
+/// moments later. Then a coarse backdrop (`Plan::backdrop`) out to the
+/// horizon, then every other planned tile nearest first, each replacing its
+/// part of the backdrop: the horizon fills in early and sharpens from the
+/// player outward, whichever way they look.
+fn wanted_tiles(
+    plan: &Plan,
+    ready: &FxHashMap<TileKey, impl Sized>,
+    camera: [i32; 2],
+) -> impl Iterator<Item = Wanted> {
+    let wanted = |class, key: TileKey| Wanted {
+        class,
+        distance: i64::from(key.distance(camera)),
+        x: key.x,
+        z: key.z,
+        level: key.level,
+    };
+    let mut backdrop = FxHashSet::default();
+    let mut tiles: Vec<_> = plan
+        .nodes
+        .iter()
+        .filter(|key| !plan.split.contains(key) && !ready.contains_key(key))
+        .map(|&key| {
+            if let Some(coarse) = plan.backdrop(key)
+                && !ready.contains_key(&coarse)
+            {
+                backdrop.insert(coarse);
+            }
+            let first = key.reach(camera) < plan.first;
+            wanted(if first { SEAM } else { REST }, key)
+        })
+        .collect();
+    tiles.extend(backdrop.into_iter().map(|key| wanted(BACKDROP, key)));
+    tiles.into_iter()
+}
+/// `Wanted::class`es, best first.
+const SEAM: u8 = 0;
+const BACKDROP: u8 = 1;
+const REST: u8 = 2;
 /// Visited chunks' summaries (`Lod::saved`) and their reductions.
 type Saved = FxHashMap<(i32, i32), Arc<[Column; 256]>>;
 type Reduced = FxHashMap<(i32, i32), Arc<ReducedColumns>>;
@@ -791,9 +871,11 @@ impl Ord for MeshQueued {
             .then(other.order.cmp(&self.order))
     }
 }
-/// A tile the sampler should produce next, nearest first.
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+/// A tile the sampler should produce next: by `class`
+/// (`wanted_tiles`), then nearest first.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
 struct Wanted {
+    class: u8,
     distance: i64,
     x: i32,
     z: i32,
@@ -843,6 +925,8 @@ pub struct Lod {
     near_loading: bool,
     /// When `request_samples` last started a job while held.
     held_sample_at: std::time::Instant,
+    /// Tiles whose sampling failed, and when they may be asked again.
+    retry: FxHashMap<TileKey, std::time::Instant>,
     /// Each tile's samples, shared with mesh jobs in flight.
     ready: FxHashMap<TileKey, Arc<Vec<Column>>>,
     /// Fully covered subtrees, by tile.
@@ -1179,6 +1263,7 @@ impl Lod {
             sample_jobs: SAMPLE_JOBS.max(sampling_threads(cores) + 1),
             near_loading: false,
             held_sample_at: std::time::Instant::now(),
+            retry: FxHashMap::default(),
             ready: FxHashMap::default(),
             complete: FxHashMap::default(),
             active: FxHashSet::default(),
@@ -1411,14 +1496,15 @@ impl Lod {
         let present = self.ready.contains_key(&key);
         // Covered level-0 stand-ins complete their parent but are never drawn.
         let ready = present && !(key.level == 0 && self.covered.contains(&(key.x, key.z)));
-        // Mirrors `Plan::select`: a ready split tile is a complete
-        // stand-in even while its children are still incomplete, so no
-        // second fallback is drawn above it.
+        // Mirrors `Plan::select`: a ready split tile away from the seam is a
+        // complete stand-in even while its children are still incomplete,
+        // so no second fallback is drawn above it.
         let (complete, active) = if self.plan.split.contains(&key) {
             let children = key.children().into_iter().all(|child| {
                 !self.plan.nodes.contains(&child)
                     || self.complete.get(&child).copied().unwrap_or(false)
             });
+            let ready = ready && self.plan.stands_in(key);
             (children || ready, ready && !children)
         } else {
             (present, ready)
@@ -1609,7 +1695,16 @@ impl Lod {
     }
     fn finish_sample(&mut self, key: TileKey, samples: Vec<Column>) {
         self.pending.remove(&key);
-        if self.plan.nodes.contains(&key) && samples.len() == CELLS * CELLS {
+        if samples.len() != CELLS * CELLS {
+            let now = std::time::Instant::now();
+            if self.retry.len() > 4096 {
+                self.retry.retain(|_, at| *at > now);
+            }
+            self.retry.insert(key, now + RETRY);
+            return;
+        }
+        self.retry.remove(&key);
+        if self.plan.nodes.contains(&key) {
             let mut samples = samples;
             if let (Some(old), Some(mask)) = (self.ready.get(&key), self.detail_masks.get(&key)) {
                 for i in 0..256 {
@@ -2161,8 +2256,16 @@ impl Lod {
         if free == 0 {
             return;
         }
+        let now = std::time::Instant::now();
         if self.held() {
-            self.held_sample_at = std::time::Instant::now();
+            self.held_sample_at = now;
+        }
+        // A tile whose sampling failed waits out `RETRY`; once it has, the
+        // queue is rebuilt so the tile is asked again.
+        let retrying = self.retry.len();
+        self.retry.retain(|_, at| *at > now);
+        if self.retry.len() != retrying {
+            self.wanted_stale = true;
         }
         // The queue is rebuilt when the view moves a chunk, not scanned and
         // sorted on every frame.
@@ -2183,12 +2286,12 @@ impl Lod {
                 z: wanted.z,
                 level: wanted.level,
             };
-            // Final tiles only: a coarse tile under the near area is work
-            // that finer tiles replace moments later.
+            // Final tiles and the backdrop only (`wanted_tiles`).
             if self.pending.contains(&key)
                 || self.ready.contains_key(&key)
-                || self.plan.split.contains(&key)
+                || (self.plan.split.contains(&key) && wanted.class != BACKDROP)
                 || !self.plan.nodes.contains(&key)
+                || self.retry.contains_key(&key)
             {
                 continue;
             }
@@ -2203,17 +2306,19 @@ impl Lod {
     }
     fn rebuild_wanted(&mut self, camera: [i32; 2]) {
         self.wanted.clear();
-        for &key in &self.plan.nodes {
-            if self.plan.split.contains(&key) || self.ready.contains_key(&key) {
-                continue;
-            }
-            self.wanted.push(std::cmp::Reverse(Wanted {
-                distance: i64::from(key.distance(camera)),
-                x: key.x,
-                z: key.z,
-                level: key.level,
-            }));
-        }
+        // A failed tile waits out its retry delay (`retry`) before it is asked again.
+        let retry = &self.retry;
+        self.wanted.extend(
+            wanted_tiles(&self.plan, &self.ready, camera)
+                .filter(|w| {
+                    !retry.contains_key(&TileKey {
+                        x: w.x,
+                        z: w.z,
+                        level: w.level,
+                    })
+                })
+                .map(std::cmp::Reverse),
+        );
     }
 
     #[cfg(test)]
@@ -2607,14 +2712,14 @@ mod tests {
             (ox..ox + key.size()).contains(&(x * 16)) && (oz..oz + key.size()).contains(&(z * 16))
         };
         // 24 chunks out, now past the render distance: its planned tile was
-        // split before, so never sampled, and a root stands in for it.
+        // split before, so never sampled. The ready root reaches the seam, so
+        // it stands in for nothing: the column stays until its tile is in.
         let column = (24, 0);
         let mut selected = Vec::new();
         for &root in &after.roots {
             after.select(root, &ready, &mut selected);
         }
-        let drawn = selected.iter().filter(|key| contains(key, column));
-        assert_eq!(drawn.map(|key| key.level).min(), Some(6));
+        assert!(!selected.iter().any(|key| contains(key, column)));
         assert!(!after.replaces(column, &ready, |_| true));
         let planned = TileKey {
             x: 12,
@@ -3258,6 +3363,153 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn far_cells_past_render_distance_12_start_one_block_wide() {
+        // Leaves' cells: 1 block to 256 blocks out, 2 to 512 (Full); Reduced
+        // keeps 1 to the near terrain's edge and 2 to 256.
+        for (reduced, [one, two]) in [(false, [256, 512]), (true, [208, 256])] {
+            let plan = Plan::with_previous([8, 8], 12, 128, &Plan::default(), 0, reduced);
+            for key in plan.nodes.iter().filter(|key| !plan.split.contains(key)) {
+                let distance = key.distance([8, 8]);
+                if distance < one {
+                    assert_eq!(key.size() / 16, 1, "{key:?} reduced {reduced}");
+                } else if distance < two {
+                    assert!(key.size() / 16 <= 2, "{key:?} reduced {reduced}");
+                }
+            }
+        }
+    }
+    /// Loads a render distance 12 view one sample job at a time, in
+    /// `wanted_tiles`' order. Counts the jobs, and their density lattice
+    /// points (each job's cost), before every far column within two chunks
+    /// of the near terrain is drawn as finely as the plan wants it (one
+    /// block wide in Full): until then nothing is drawn there. And before
+    /// every far column is drawn, by its tile or a coarse stand-in: until
+    /// then the far terrain ends short of the horizon. Checks that no coarse
+    /// tile is ever drawn at the seam.
+    fn jobs_until_fine_seam(camera: [i32; 2], reduced: bool) -> ([(usize, i32); 2], usize) {
+        let (detail, distance) = (12, 128);
+        let center = (camera[0].div_euclid(16), camera[1].div_euclid(16));
+        let mut covered = FxHashSet::default();
+        for z in center.1 - detail..=center.1 + detail {
+            for x in center.0 - detail..=center.0 + detail {
+                if crate::streaming::in_view_distance(center, detail, x, z) {
+                    covered.insert((x, z));
+                }
+            }
+        }
+        let plan = Plan::with_previous(camera, detail, distance, &Plan::default(), 0, reduced);
+        let leaf = |x: i32, z: i32| {
+            (0..=MAX_LEVEL)
+                .map(|level| TileKey {
+                    x: x.div_euclid(16 << level),
+                    z: z.div_euclid(16 << level),
+                    level,
+                })
+                .find(|key| plan.nodes.contains(key) && !plan.split.contains(key))
+        };
+        let mut seam = Vec::new();
+        for z in (camera[1] - 256..camera[1] + 256).step_by(2) {
+            for x in (camera[0] - 256..camera[0] + 256).step_by(2) {
+                let chunk = (x.div_euclid(16), z.div_euclid(16));
+                let near = (-2..=2)
+                    .any(|dz| (-2..=2).any(|dx| covered.contains(&(chunk.0 + dx, chunk.1 + dz))));
+                if !covered.contains(&chunk) && near {
+                    seam.push((x, z, leaf(x, z).unwrap()));
+                }
+            }
+        }
+        let mut horizon = Vec::new();
+        for z in (camera[1] - 2048..camera[1] + 2048).step_by(64) {
+            for x in (camera[0] - 2048..camera[0] + 2048).step_by(64) {
+                if !covered.contains(&(x.div_euclid(16), z.div_euclid(16))) && leaf(x, z).is_some()
+                {
+                    horizon.push((x, z));
+                }
+            }
+        }
+        let mut ready: FxHashMap<TileKey, ()> = FxHashMap::default();
+        for key in &plan.nodes {
+            if key.level == 0 && covered.contains(&(key.x, key.z)) {
+                ready.insert(*key, ());
+            }
+        }
+        let leaves = plan
+            .nodes
+            .iter()
+            .filter(|k| !plan.split.contains(k))
+            .count();
+        let (mut cost, mut fine, mut reached) = (0, None, None);
+        for jobs in 0.. {
+            let mut selected = Vec::new();
+            for &root in &plan.roots {
+                plan.select(root, &ready, &mut selected);
+            }
+            let active: FxHashSet<_> = selected.into_iter().collect();
+            let drawn = |x: i32, z: i32, levels: u8| {
+                (0..=levels).any(|level| {
+                    active.contains(&TileKey {
+                        x: x.div_euclid(16 << level),
+                        z: z.div_euclid(16 << level),
+                        level,
+                    })
+                })
+            };
+            for &(x, z, leaf) in &seam {
+                assert!(drawn(x, z, leaf.level) || !drawn(x, z, MAX_LEVEL));
+            }
+            if fine.is_none() && seam.iter().all(|&(x, z, leaf)| drawn(x, z, leaf.level)) {
+                fine = Some((jobs, cost));
+            }
+            if reached.is_none() && horizon.iter().all(|&(x, z)| drawn(x, z, MAX_LEVEL)) {
+                reached = Some((jobs, cost));
+            }
+            if let (Some(fine), Some(reached)) = (fine, reached) {
+                return ([fine, reached], leaves);
+            }
+            let next = wanted_tiles(&plan, &ready, camera).min().unwrap();
+            let next = TileKey {
+                x: next.x,
+                z: next.z,
+                level: next.level,
+            };
+            // `lod_grid`'s density lattice: one point per max(stride, 4) blocks.
+            let stride = next.size() / 16;
+            let lattice = 16 * stride / stride.max(4) + 1;
+            cost += lattice * lattice;
+            ready.insert(next, ());
+        }
+        unreachable!()
+    }
+    #[test]
+    fn the_far_terrain_next_to_the_near_chunks_loads_first() {
+        // Measured: 270 to 301 jobs, all of them fine tiles (7500 to 8500
+        // lattice points). A coarse tile first costs up to 289 points; the
+        // order that filled a ring ahead first and refined broad tiles every
+        // other job took 54000 to 119000 for the seam in view alone.
+        for camera in [[8, 8], [40, -9], [-300, 517]] {
+            for reduced in [false, true] {
+                let ([(jobs, cost), _], _) = jobs_until_fine_seam(camera, reduced);
+                assert!(jobs < 320, "{jobs} jobs");
+                assert!(cost < 9000, "{cost} lattice points");
+            }
+        }
+    }
+    #[test]
+    fn a_coarse_backdrop_reaches_the_horizon_early() {
+        // Sampling only planned tiles, nearest first, reached the horizon
+        // with the last of ~3000 jobs in Full (500000 lattice points), ~1050
+        // in Reduced (200000): for minutes on a slow machine the far terrain
+        // ended in a hard edge. The backdrop adds ~230 coarse tiles (~80 in
+        // Reduced), about a tenth more work in all.
+        for camera in [[8, 8], [40, -9], [-300, 517]] {
+            for reduced in [false, true] {
+                let ([_, (jobs, cost)], leaves) = jobs_until_fine_seam(camera, reduced);
+                assert!(jobs < 1000 && jobs < leaves, "{jobs} jobs of {leaves}");
+                assert!(cost < 100_000, "{cost} lattice points");
+            }
+        }
+    }
     #[test]
     fn extra_sampling_threads_only_on_large_machines() {
         assert_eq!([1, 2, 4, 8, 11].map(sampling_threads), [1, 1, 1, 4, 5]);

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

@@ -160,7 +160,14 @@ impl Mesher {
                 for slot in &mut faces {
                     let Some(face) = matching.next() else { break };
                     *slot = Some(Style {
-                        layer: face.layer as u16 | if leaves { OPAQUE_LAYER } else { 0 },
+                        // As the mesher marks them: opaque leaves and faces over opaque
+                        // texels skip the cutout and draw in the opaque pass.
+                        layer: face.layer as u16
+                            | if leaves || face.opaque {
+                                OPAQUE_LAYER
+                            } else {
+                                0
+                            },
                         tint: if face.quad.tint_index >= 0 {
                             tint
                         } else {

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

@@ -59,6 +59,55 @@ pub fn set_game_home(home: PathBuf) {
     let _ = HOME.set(home);
 }
 
+/// `--player-dir DIR` (#4952), set once at start: one player's own files, when several games
+/// play in one game folder at the same time (the launcher's `play --account`).
+static PLAYER: std::sync::OnceLock<PathBuf> = std::sync::OnceLock::new();
+
+/// Makes [`player_dir`] return `dir` for the rest of the run (`--player-dir`), creating it.
+/// What is a player's own goes there: `options.txt` and the settings files beside it,
+/// `logs/`, `crash-reports/`, `horizon-player.txt`, `servers.dat`, `hotbar.nbt` and
+/// `screenshots/`. What the game folder's players share stays in it: saves, resource and
+/// shader packs, mods and their config, caches.
+pub fn set_player_dir(dir: PathBuf) {
+    let _ = fs::create_dir_all(&dir);
+    let _ = PLAYER.set(dir);
+}
+
+/// The folder of this player's own files: `--player-dir`, else the game folder (the working
+/// directory, where the launcher runs the game).
+pub fn player_dir() -> PathBuf {
+    PLAYER
+        .get()
+        .cloned()
+        .unwrap_or_else(|| std::env::current_dir().unwrap_or_default())
+}
+
+/// `--player-dir`, if given.
+pub fn player_dir_override() -> Option<&'static Path> {
+    PLAYER.get().map(PathBuf::as_path)
+}
+
+/// Where the files all players share live, for settings kept beside `options.txt` in
+/// `options_dir` (the enabled mods): that folder, unless `--player-dir` moved `options.txt`
+/// out of the game folder.
+pub fn shared_dir(options_dir: &Path) -> PathBuf {
+    shared_dir_of(PLAYER.get().map(PathBuf::as_path), options_dir, || {
+        std::env::current_dir().unwrap_or_default()
+    })
+}
+
+/// [`shared_dir`] for a given `--player-dir` and game folder.
+fn shared_dir_of(
+    player: Option<&Path>,
+    options_dir: &Path,
+    game_dir: impl FnOnce() -> PathBuf,
+) -> PathBuf {
+    match player {
+        Some(player) if player == options_dir => game_dir(),
+        _ => options_dir.to_path_buf(),
+    }
+}
+
 /// Where the launcher runs the game and keeps its saves: `--home`, else `HORIZON_HOME`, else
 /// `horizon` in the platform data folder (launcher/src/backend.rs `game_home`).
 pub fn game_home() -> PathBuf {
@@ -567,6 +616,20 @@ pub fn newest_crash_report(home: &Path) -> Option<PathBuf> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn a_player_dir_keeps_the_shared_files_in_the_game_folder() {
+        let (game, player) = (Path::new("/games/shared"), Path::new("/games/players/alex"));
+        // options.txt moved to the player's folder: the enabled mods stay the game folder's.
+        assert_eq!(shared_dir_of(Some(player), player, || game.into()), game);
+        // No --player-dir, or a splitscreen profile's own folder: beside options.txt as before.
+        assert_eq!(shared_dir_of(None, game, || unreachable!()), game);
+        let profile = Path::new("/games/shared/splitscreen/profiles/P2");
+        assert_eq!(
+            shared_dir_of(Some(player), profile, || unreachable!()),
+            profile
+        );
+    }
+
     #[test]
     fn a_warning_repeated_every_packet_is_counted_past_a_hundred_a_minute() {
         let (mut floods, start) = (Floods::default(), Instant::now());

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

@@ -172,6 +172,7 @@ impl MenuBlur {
         target: &wgpu::TextureView,
         size: [u32; 2],
         radius: f32,
+        mut timing: Option<&mut crate::gfx::pack_timing::PassTiming>,
     ) {
         self.ensure(device, size);
         encoder.copy_texture_to_texture(
@@ -224,6 +225,7 @@ impl MenuBlur {
             })];
             let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                 label: Some("Menu blur pass"),
+                timestamp_writes: timing.as_deref_mut().and_then(|t| t.writes("Menu blur")),
                 color_attachments: &attachments,
                 ..Default::default()
             });

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

@@ -4,6 +4,7 @@
 //! cardinal shading, tint sources, block offsets; see `lighting`). Fluids
 //! follow `FluidRenderer` (see `fluid`).
 mod fluid;
+mod leaf_culling;
 mod lighting;
 mod sides;
 use crate::{
@@ -11,6 +12,7 @@ use crate::{
     biome::Biomes,
     blocks::{BlockFacts, RenderShape},
     chunk::{Chunk, MIN_Y},
+    graphics::LeafCullingMode,
     models::catalog::BakedFace,
 };
 use horizon_core::{
@@ -231,6 +233,9 @@ pub struct SectionMesh {
     /// each frame by `block_entity_render` like vanilla's per-section
     /// `SectionCompiler.Results.blockEntities`.
     pub block_entities: Vec<([i32; 3], u32)>,
+    /// Blocks that give off light (world position, state id), for the colour of block light
+    /// Horizon's shader packs read (`gfx::block_light`).
+    pub lights: Vec<([i32; 3], u32)>,
     /// Sprite layers emitted while building this mesh. Kept distinct before
     /// upload so the renderer does not rescan every terrain vertex.
     pub sprite_layers: Vec<u16>,
@@ -248,6 +253,7 @@ impl Default for SectionMesh {
             translucent: Vec::new(),
             visibility: ALL_VISIBLE,
             block_entities: Vec::new(),
+            lights: Vec::new(),
             sprite_layers: Vec::new(),
             bounds: None,
             keep: false,
@@ -278,6 +284,7 @@ impl SectionMesh {
         self.solid.clear();
         self.translucent.clear();
         self.block_entities.clear();
+        self.lights.clear();
         self.sprite_layers.clear();
         self.sides = Sides::default();
         self.visibility = ALL_VISIBLE;
@@ -288,6 +295,7 @@ impl SectionMesh {
         self.solid.capacity() * std::mem::size_of::<TerrainVertex>()
             + self.translucent.capacity() * std::mem::size_of::<TerrainVertex>()
             + self.block_entities.capacity() * std::mem::size_of::<([i32; 3], u32)>()
+            + self.lights.capacity() * std::mem::size_of::<([i32; 3], u32)>()
             + self.sprite_layers.capacity() * std::mem::size_of::<u16>()
     }
     /// Sorts the solid quads by the side they face, for the renderer to
@@ -464,6 +472,9 @@ struct Info {
     overlay: bool,
     /// `LeavesBlock`: with opaque leaves the faces between two leaf blocks are skipped.
     leaves: bool,
+    /// A full opaque cube: `RenderShape::Model`, `can_occlude`, `solid_render`
+    /// and a full collision shape. The only block leaf culling treats as solid.
+    opaque_cube: bool,
     blocks_flow: bool,
     ice: bool,
     sturdy: u8,
@@ -641,6 +652,12 @@ impl MeshTables {
                 legacy_solid: s.legacy_solid,
                 overlay: s.has_class("HalfTransparentBlock") || s.has_class("LeavesBlock"),
                 leaves: s.has_class("LeavesBlock"),
+                opaque_cube: leaf_culling::opaque_cube(
+                    s.render_shape,
+                    s.can_occlude,
+                    s.solid_render,
+                    s.full_collision,
+                ),
                 blocks_flow: assets.blocks_fluid_flow.contains(&*s.name),
                 ice: s.has_class("IceBlock"),
                 sturdy: s.sturdy_full,
@@ -680,6 +697,14 @@ impl MeshTables {
             tint_sources: i.tint_count,
         })
     }
+    /// Whether `state` is a full opaque cube: the only block leaf culling
+    /// treats as a solid neighbour. Glass, fluids, slabs, stairs and models
+    /// that only partly fill their block are not.
+    pub fn opaque_cube(&self, state: BlockStateId) -> bool {
+        self.info
+            .get(state.0 as usize)
+            .is_some_and(|i| i.opaque_cube)
+    }
     /// `BlockTintSource.color(state)`: block-model colour without a level.
     /// `grass` is `GrassColor.getDefaultColor()` from the active pack's colormap.
     /// Untinted faces, blank sources and invalid tint indices return `None`.
@@ -854,14 +879,18 @@ impl Padded {
     }
 }
 /// Per-worker temporary arrays. They never hold resource-pack references or
-/// geometry still owned by the renderer, and total about 88 KiB per worker.
+/// geometry still owned by the renderer, and total about 150 KiB per worker
+/// (the leaf mask adds 8,000 cells, depths and a queue).
 #[derive(Default)]
 pub(crate) struct MeshScratch {
     padded: Padded,
     own: Option<Box<[u32; 4096]>>,
     visibility: Vec<usize>,
+    leaf: leaf_culling::LeafMask,
 }
 #[cfg(test)]
+mod leaf_culling_tests;
+#[cfg(test)]
 mod reuse_tests;
 /// Set on a terrain vertex's sprite layer when its texture alpha must be ignored.
 pub const OPAQUE_LAYER: u16 = 1 << 15;
@@ -1073,6 +1102,8 @@ pub struct Mesher<'a> {
     pub smooth_lighting: bool,
     /// The `cutoutLeaves` option (fancy graphics); off makes leaves opaque.
     pub cutout_leaves: bool,
+    /// What the worker does with leaf faces inside a canopy.
+    pub leaf_culling: LeafCullingMode,
 }
 impl Mesher<'_> {
     /// `region[dz][dx]` are the chunks around the meshed column (centre 1,1).
@@ -1102,6 +1133,11 @@ impl Mesher<'_> {
         let pad = &scratch.padded;
         out.visibility = visibility_reusing(pad, &self.tables.info, &mut scratch.visibility);
         let base_y = center.min_y() + sy * 16;
+        if self.leaf_culling.is_interior() {
+            scratch
+                .leaf
+                .prepare(self.leaf_culling, pad, &self.tables.info, region, base_y);
+        }
         let mut tints = Tints::new(
             region,
             self.biomes,
@@ -1124,6 +1160,10 @@ impl Mesher<'_> {
                         out.block_entities
                             .push(([center.x * 16 + x, base_y + y, center.z * 16 + z], id));
                     }
+                    if state.emission > 0 {
+                        out.lights
+                            .push(([center.x * 16 + x, base_y + y, center.z * 16 + z], id));
+                    }
                     if state.solid
                         && Direction::ALL.iter().all(|d| {
                             let [dx, dy, dz] = d.normal();
@@ -1162,13 +1202,21 @@ impl Mesher<'_> {
                         None => [x as f32, y as f32, z as f32],
                     };
                     let mut visible = [false; 6];
+                    let interior_leaf = state.leaves
+                        && self.leaf_culling.is_interior()
+                        && scratch.leaf.interior(self.leaf_culling, x, y, z);
                     for d in Direction::ALL {
                         let [dx, dy, dz] = d.normal();
                         let neighbor = pad.blocks[pi(x + dx, y + dy, z + dz)];
                         let other = &info[neighbor as usize];
                         // LeavesBlock.skipRendering with opaque leaves.
                         let opaque_leaves = !self.cutout_leaves && state.leaves && other.leaves;
+                        let hollow_leaf = self.leaf_culling == LeafCullingMode::Hollow
+                            && state.leaves
+                            && other.leaves
+                            && leaf_culling::in_section(x + dx, y + dy, z + dz);
                         visible[d as usize] = !opaque_leaves
+                            && !hollow_leaf
                             && self
                                 .visibility
                                 .should_render_face(
@@ -1193,6 +1241,7 @@ impl Mesher<'_> {
                                 face,
                                 ao,
                                 state,
+                                interior_leaf,
                             );
                         }
                     }
@@ -1231,6 +1280,7 @@ impl Mesher<'_> {
         face: &BakedFace,
         ao: bool,
         state: &Info,
+        interior_leaf: bool,
     ) {
         let q = &face.quad;
         // A quad's own light (a model's glowing part) may raise the tier; whether it
@@ -1265,6 +1315,17 @@ impl Mesher<'_> {
         } else {
             &mut out.solid
         };
+        // Opaque leaves (forceOpaque), quads over opaque texels and leaves a
+        // leaf-culling mode proved internal draw in the solid layer: no alpha
+        // cutout. All four vertices of the quad share the layer.
+        let layer = if face.opaque && !face.translucent
+            || !self.cutout_leaves && state.leaves
+            || interior_leaf
+        {
+            face.layer as u16 | OPAQUE_LAYER
+        } else {
+            face.layer as u16
+        };
         for i in 0..4 {
             let g = gray[i] as u32;
             let rgb = match tint {
@@ -1275,13 +1336,7 @@ impl Mesher<'_> {
             target.push(TerrainVertex::new(
                 [p[0] + origin[0], p[1] + origin[1], p[2] + origin[2]],
                 q.uv[i],
-                // Opaque leaves (forceOpaque) and quads over opaque texels draw in the
-                // solid layer: no alpha cutout (a dirt path's side skips its clear top row).
-                if face.opaque && !face.translucent || !self.cutout_leaves && state.leaves {
-                    face.layer as u16 | OPAQUE_LAYER
-                } else {
-                    face.layer as u16
-                },
+                layer,
                 emitting(pack_rgb(rgb), tier),
                 pack_coords(lighting::with_emission(coords[i], q.light_emission)),
             ));

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

@@ -0,0 +1,656 @@
+//! Leaf culling: decides which leaf faces a section may draw solid or drop.
+//!
+//! The mask is built on the mesh worker from the same padded block snapshot the
+//! rest of the mesher reads, so a decision never needs a chunk lookup on the
+//! render thread. It classifies each padded cell as a leaf, a full opaque cube,
+//! open (air, fluids, partial models, anything else) or unknown (a missing
+//! chunk, a Y outside the column, or the mask's outer shell). Only leaves can
+//! hide or solidify anything; unknown and open cells always expose a face.
+//!
+//! `Solid` performs an immediate 6-neighbour occlusion check, solidifying fully
+//! enclosed leaves into the opaque layer without cutout testing. `Solid
+//! Aggressive` runs a multi-source breadth-first search from leaves touching
+//! openings, solidifying leaves with a single open face to thin the canopy shell
+//! by one layer. `Hollow` directly drops faces shared between two leaves within
+//! the section, preserving boundaries and cavity faces.
+
+use super::{B, Info, P, Padded, pi};
+use crate::{blocks::RenderShape, chunk::Chunk, graphics::LeafCullingMode};
+
+/// A cell of the padded snapshot, as far as leaf culling cares.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum Cell {
+    /// Air, a fluid, a partial model, glass or any other non-occluding block.
+    Open,
+    /// `LeavesBlock`.
+    Leaf,
+    /// A full opaque cube (see [`opaque_cube`]).
+    Opaque,
+    /// Missing chunk, missing section or the mask's outer shell.
+    Unknown,
+}
+
+/// Whether a state is a full opaque cube: `RenderShape::Model`, `can_occlude`,
+/// `solid_render` and a full collision shape. Glass, fluids, slabs, stairs,
+/// chests and models that only partly fill their block are not.
+pub(super) fn opaque_cube(
+    shape: RenderShape,
+    can_occlude: bool,
+    solid_render: bool,
+    full_collision: bool,
+) -> bool {
+    shape == RenderShape::Model && can_occlude && solid_render && full_collision
+}
+
+const UNVISITED: u8 = u8::MAX;
+
+const STRIDE_X: isize = 1;
+const STRIDE_Z: isize = P as isize;
+const STRIDE_Y: isize = (P * P) as isize;
+
+const ADJACENT_STRIDES: [isize; 6] = [
+    STRIDE_X, -STRIDE_X, STRIDE_Z, -STRIDE_Z, STRIDE_Y, -STRIDE_Y,
+];
+
+/// Per-worker leaf mask and BFS scratch. The vectors keep their capacity
+/// between sections and modes; `Off` does no work at all.
+#[derive(Default)]
+pub(super) struct LeafMask {
+    cells: Vec<Cell>,
+    depth: Vec<u8>,
+    queue: Vec<u16>,
+    active: bool,
+}
+
+impl LeafMask {
+    /// Classify the padded snapshot and, for the interior modes, measure how
+    /// deep each leaf sits below the canopy surface.
+    pub(super) fn prepare(
+        &mut self,
+        mode: LeafCullingMode,
+        pad: &Padded,
+        info: &[Info],
+        region: &[[Option<&Chunk>; 3]; 3],
+        base_y: i32,
+    ) {
+        self.active = mode != LeafCullingMode::Off;
+        if !self.active {
+            return;
+        }
+        // Most sections hold no leaves at all; do not classify 8,000 cells to
+        // learn that. The centre is the only part this mesh can change.
+        let mut leaves = false;
+        'scan: for y in 0..16 {
+            for z in 0..16 {
+                for x in 0..16 {
+                    if info
+                        .get(pad.blocks[pi(x, y, z)] as usize)
+                        .is_some_and(|state| state.leaves)
+                    {
+                        leaves = true;
+                        break 'scan;
+                    }
+                }
+            }
+        }
+        if !leaves {
+            self.active = false;
+            return;
+        }
+        if self.cells.len() != P * P * P {
+            self.cells.resize(P * P * P, Cell::Open);
+        }
+        for y in -B..16 + B {
+            for z in -B..16 + B {
+                for x in -B..16 + B {
+                    let i = pi(x, y, z);
+                    self.cells[i] = if !known(region, base_y, x, y, z) {
+                        Cell::Unknown
+                    } else {
+                        match info.get(pad.blocks[i] as usize) {
+                            None => Cell::Unknown,
+                            Some(state) if state.leaves => Cell::Leaf,
+                            Some(state) if state.opaque_cube => Cell::Opaque,
+                            Some(_) => Cell::Open,
+                        }
+                    };
+                }
+            }
+        }
+        // Solid is a purely local six-neighbour test. Reserve the breadth-first
+        // search for Solid Aggressive, whose one-open-side rule needs to know
+        // whether a leaf is connected to the canopy surface through other
+        // leaves.
+        if mode == LeafCullingMode::SolidAggressive {
+            self.depths();
+        }
+    }
+
+    /// Multi-source BFS from leaves that touch an opening. Opaque neighbours do
+    /// not expose a leaf: a leaf fully enclosed by stone is interior too.
+    fn depths(&mut self) {
+        if self.depth.len() != self.cells.len() {
+            self.depth.resize(self.cells.len(), UNVISITED);
+        } else {
+            self.depth.fill(UNVISITED);
+        }
+        self.queue.clear();
+        for y in -B..16 + B {
+            for z in -B..16 + B {
+                for x in -B..16 + B {
+                    let i = pi(x, y, z);
+                    if self.cells[i] != Cell::Leaf {
+                        continue;
+                    }
+                    let touches_open = ADJACENT_STRIDES.iter().any(|&stride| {
+                        let j = (i as isize + stride) as usize;
+                        matches!(self.cells[j], Cell::Open | Cell::Unknown)
+                    });
+                    if touches_open {
+                        self.depth[i] = 0;
+                        self.queue.push(i as u16);
+                    }
+                }
+            }
+        }
+        let mut head = 0;
+        while head < self.queue.len() {
+            let i = self.queue[head] as usize;
+            head += 1;
+            let next_depth = self.depth[i].saturating_add(1);
+            for stride in ADJACENT_STRIDES {
+                let j = (i as isize + stride) as usize;
+                if self.cells[j] == Cell::Leaf && self.depth[j] == UNVISITED {
+                    self.depth[j] = next_depth;
+                    self.queue.push(j as u16);
+                }
+            }
+        }
+    }
+
+    /// Whether the leaf at `(x, y, z)` may draw in the opaque layer.
+    ///
+    /// `Solid` wants a leaf with no open neighbour, which is exactly depth 1 or
+    /// more. `Solid Aggressive` also takes the next layer of the shell: a leaf
+    /// with a single open side joins the opaque core, so the cutout shell is
+    /// one layer thinner. Unknown neighbours never qualify, however many sides
+    /// they leave open. A leaf the search never reached sits inside a closed
+    /// volume: interior for both.
+    pub(super) fn interior(&self, mode: LeafCullingMode, x: i32, y: i32, z: i32) -> bool {
+        if !self.active {
+            return false;
+        }
+        let aggressive = match mode {
+            LeafCullingMode::Solid => false,
+            LeafCullingMode::SolidAggressive => true,
+            _ => return false,
+        };
+        // A section boundary is not proof of a closed volume: the neighbouring
+        // section may not be drawn yet, and its data is not ours to assume.
+        if !(1..15).contains(&x) || !(1..15).contains(&y) || !(1..15).contains(&z) {
+            return false;
+        }
+        let i = pi(x, y, z);
+        if self.cells.get(i) != Some(&Cell::Leaf) {
+            return false;
+        }
+        if !aggressive {
+            return ADJACENT_STRIDES.iter().all(|&stride| {
+                let j = (i as isize + stride) as usize;
+                matches!(self.cells[j], Cell::Leaf | Cell::Opaque)
+            });
+        }
+        let depth = self.depth[i];
+        if depth == UNVISITED || depth >= 1 {
+            return true;
+        }
+        let mut open = 0;
+        for stride in ADJACENT_STRIDES {
+            let j = (i as isize + stride) as usize;
+            match self.cells[j] {
+                Cell::Unknown => return false,
+                Cell::Open => {
+                    open += 1;
+                    if open > 1 {
+                        return false;
+                    }
+                }
+                Cell::Leaf | Cell::Opaque => {}
+            }
+        }
+        open == 1
+    }
+}
+
+/// The cells this section's mesh owns. A face on this boundary belongs to the
+/// neighbouring section as much as to this one; leaf culling leaves it alone.
+#[inline]
+pub(super) fn in_section(x: i32, y: i32, z: i32) -> bool {
+    (0..16).contains(&x) && (0..16).contains(&y) && (0..16).contains(&z)
+}
+
+/// Whether the padded cell `(x, y, z)` has real block data. A missing chunk
+/// does not count: `Padded::fill` copies the centre's edge column into it, which
+/// would make a canopy look enclosed. A Y outside the column counts as unknown
+/// for the same reason. The mask's outer shell is unknown too, so nothing is
+/// inferred past the data the worker snapshotted.
+fn known(region: &[[Option<&Chunk>; 3]; 3], base_y: i32, x: i32, y: i32, z: i32) -> bool {
+    if x <= -B || x >= 16 + B - 1 || y <= -B || y >= 16 + B - 1 || z <= -B || z >= 16 + B - 1 {
+        return false;
+    }
+    let chunk = region[((z + 16) >> 4) as usize][((x + 16) >> 4) as usize];
+    chunk.is_some_and(|chunk| chunk.section_index(base_y + y).is_some())
+}
+
+#[cfg(test)]
+impl LeafMask {
+    /// Whether `Hollow` drops the face of the leaf at `(x, y, z)` toward `d`.
+    /// Only a known leaf on the other side counts: open cells, partial models,
+    /// missing neighbours and the mask's edge stay visible.
+    pub(super) fn hides_face(
+        &self,
+        mode: LeafCullingMode,
+        x: i32,
+        y: i32,
+        z: i32,
+        d: horizon_core::geometry::Direction,
+    ) -> bool {
+        if !self.active || mode != LeafCullingMode::Hollow {
+            return false;
+        }
+        let [dx, dy, dz] = d.normal();
+        let (nx, ny, nz) = (x + dx, y + dy, z + dz);
+        if !in_section(x, y, z) || !in_section(nx, ny, nz) {
+            return false;
+        }
+        let i = pi(x, y, z);
+        let ni = pi(nx, ny, nz);
+        self.cells.get(i) == Some(&Cell::Leaf) && self.cells.get(ni) == Some(&Cell::Leaf)
+    }
+
+    #[inline]
+    fn cell(&self, x: i32, y: i32, z: i32) -> Cell {
+        checked(x, y, z)
+            .and_then(|i| self.cells.get(i))
+            .copied()
+            .unwrap_or(Cell::Unknown)
+    }
+}
+
+#[cfg(test)]
+#[inline]
+fn checked(x: i32, y: i32, z: i32) -> Option<usize> {
+    if (-B..16 + B).contains(&x) && (-B..16 + B).contains(&y) && (-B..16 + B).contains(&z) {
+        Some(pi(x, y, z))
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+#[inline]
+fn unpi(i: usize) -> (i32, i32, i32) {
+    let x = (i % P) as i32 - B;
+    let z = (i / P % P) as i32 - B;
+    let y = (i / (P * P)) as i32 - B;
+    (x, y, z)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{blocks::RenderShape, graphics::LeafCullingMode};
+    use horizon_core::geometry::Direction;
+    use horizon_world::fluid::FluidState;
+    use std::time::Instant;
+
+    fn info(leaves: bool, opaque: bool) -> Info {
+        Info {
+            solid: opaque,
+            full: opaque,
+            permeable: false,
+            shade: 1.0,
+            emission: 0,
+            tier: 0,
+            emissive: false,
+            fluid: FluidState::EMPTY,
+            model: true,
+            block_entity: false,
+            tints: [super::super::Tint::None; 2],
+            tint_count: 0,
+            offset: None,
+            legacy_solid: false,
+            overlay: leaves,
+            leaves,
+            opaque_cube: opaque,
+            blocks_flow: false,
+            ice: false,
+            sturdy: 0,
+            face: [0; 6],
+            cover: [0.0; 6],
+        }
+    }
+
+    /// State 0 is air, 1 leaves, 2 a full opaque cube, 3 a partial model.
+    fn states() -> Vec<Info> {
+        vec![
+            info(false, false),
+            info(true, false),
+            info(false, true),
+            info(false, false),
+        ]
+    }
+
+    fn padded(fill: impl Fn(i32, i32, i32) -> u32) -> Padded {
+        Padded {
+            blocks: (0..P * P * P)
+                .map(|i| {
+                    let (x, y, z) = unpi(i);
+                    fill(x, y, z)
+                })
+                .collect(),
+            light: vec![0; P * P * P],
+        }
+    }
+
+    fn cube(pad: &mut Padded, min: i32, max: i32, state: u32) {
+        for y in min..=max {
+            for z in min..=max {
+                for x in min..=max {
+                    pad.blocks[pi(x, y, z)] = state;
+                }
+            }
+        }
+    }
+
+    fn loaded() -> Chunk {
+        Chunk::empty(0, 0)
+    }
+
+    fn region(chunk: &Chunk) -> [[Option<&Chunk>; 3]; 3] {
+        [[Some(chunk); 3]; 3]
+    }
+
+    fn built(mode: LeafCullingMode, pad: &Padded, states: &[Info], chunk: &Chunk) -> LeafMask {
+        let mut mask = LeafMask::default();
+        mask.prepare(mode, pad, states, &region(chunk), 0);
+        mask
+    }
+
+    #[test]
+    fn only_a_full_model_cube_is_opaque() {
+        let combinations = [
+            (RenderShape::Model, true, true, true),
+            (RenderShape::Model, true, true, false),
+            (RenderShape::Model, true, false, true),
+            (RenderShape::Model, false, true, true),
+            (RenderShape::Model, false, false, false),
+            (RenderShape::Invisible, true, true, true),
+            (RenderShape::Animated, true, true, true),
+        ];
+        let (shape, can_occlude, solid_render, full_collision) = combinations[0];
+        assert!(opaque_cube(
+            shape,
+            can_occlude,
+            solid_render,
+            full_collision
+        ));
+        for &(shape, can_occlude, solid_render, full_collision) in &combinations[1..] {
+            assert!(
+                !opaque_cube(shape, can_occlude, solid_render, full_collision),
+                "{shape:?} {can_occlude} {solid_render} {full_collision}"
+            );
+        }
+    }
+
+    #[test]
+    fn solid_marks_the_cell_inside_a_three_cube() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        cube(&mut pad, 7, 9, 1);
+        let chunk = loaded();
+        let solid = built(LeafCullingMode::Solid, &pad, &states, &chunk);
+        assert!(!solid.interior(LeafCullingMode::Solid, 7, 8, 8));
+        assert!(solid.interior(LeafCullingMode::Solid, 8, 8, 8));
+        assert!(!solid.interior(LeafCullingMode::Solid, 8, 9, 8));
+        // Aggressive also takes the six face-centre leaves, whose only open
+        // side faces out of the cube. Corners and edges keep their cutout.
+        let aggressive = built(LeafCullingMode::SolidAggressive, &pad, &states, &chunk);
+        assert!(aggressive.interior(LeafCullingMode::SolidAggressive, 8, 8, 8));
+        assert!(aggressive.interior(LeafCullingMode::SolidAggressive, 7, 8, 8));
+        assert!(aggressive.interior(LeafCullingMode::SolidAggressive, 8, 8, 9));
+        assert!(!aggressive.interior(LeafCullingMode::SolidAggressive, 7, 7, 8));
+        assert!(!aggressive.interior(LeafCullingMode::SolidAggressive, 7, 7, 7));
+    }
+
+    #[test]
+    fn aggressive_takes_the_next_shell_layer() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        cube(&mut pad, 6, 10, 1);
+        let chunk = loaded();
+        let solid = built(LeafCullingMode::Solid, &pad, &states, &chunk);
+        let aggressive = built(LeafCullingMode::SolidAggressive, &pad, &states, &chunk);
+        let surface = |v: i32| v == 6 || v == 10;
+        for [x, y, z] in [
+            [6, 8, 8],
+            [10, 8, 8],
+            [6, 6, 8],
+            [6, 6, 6],
+            [7, 8, 8],
+            [8, 8, 8],
+            [7, 7, 7],
+            [8, 8, 7],
+        ] {
+            let expected = !surface(x) && !surface(y) && !surface(z);
+            assert_eq!(
+                solid.interior(LeafCullingMode::Solid, x, y, z),
+                expected,
+                "solid {x} {y} {z}"
+            );
+            let open = [x, y, z].iter().filter(|v| surface(**v)).count();
+            let expected = open <= 1;
+            assert_eq!(
+                aggressive.interior(LeafCullingMode::SolidAggressive, x, y, z),
+                expected,
+                "aggressive {x} {y} {z}"
+            );
+        }
+    }
+
+    #[test]
+    fn hollow_hides_only_leaf_to_leaf_faces() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        cube(&mut pad, 7, 9, 1);
+        // Glass (3, a partial model), water and a slab are open: their leaves
+        // must keep the face.
+        pad.blocks[pi(10, 8, 8)] = 3;
+        let chunk = loaded();
+        let hollow = built(LeafCullingMode::Hollow, &pad, &states, &chunk);
+        for d in Direction::ALL {
+            assert!(
+                hollow.hides_face(LeafCullingMode::Hollow, 8, 8, 8, d),
+                "{d:?}"
+            );
+        }
+        assert!(!hollow.hides_face(LeafCullingMode::Hollow, 9, 8, 8, Direction::East));
+        assert!(!hollow.hides_face(LeafCullingMode::Hollow, 7, 8, 8, Direction::West));
+        // The other modes never hide a quad.
+        for mode in [
+            LeafCullingMode::Off,
+            LeafCullingMode::Solid,
+            LeafCullingMode::SolidAggressive,
+        ] {
+            let mask = built(mode, &pad, &states, &chunk);
+            assert!(!mask.hides_face(mode, 8, 8, 8, Direction::Up));
+        }
+    }
+
+    #[test]
+    fn a_cavity_keeps_its_faces_and_its_rim_visible() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        cube(&mut pad, 6, 10, 1);
+        pad.blocks[pi(8, 8, 8)] = 0;
+        let chunk = loaded();
+        let hollow = built(LeafCullingMode::Hollow, &pad, &states, &chunk);
+        assert!(!hollow.hides_face(LeafCullingMode::Hollow, 7, 8, 8, Direction::East));
+        assert!(!hollow.hides_face(LeafCullingMode::Hollow, 8, 8, 7, Direction::South));
+        let solid = built(LeafCullingMode::Solid, &pad, &states, &chunk);
+        assert!(!solid.interior(LeafCullingMode::Solid, 7, 8, 8));
+        assert!(!solid.interior(LeafCullingMode::Solid, 6, 8, 8));
+        // The corner away from the cavity is still two layers in.
+        assert!(solid.interior(LeafCullingMode::Solid, 9, 9, 9));
+    }
+
+    #[test]
+    fn an_opaque_neighbour_does_not_expose_a_leaf() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        for (dx, dy, dz) in [
+            (1, 0, 0),
+            (-1, 0, 0),
+            (0, 1, 0),
+            (0, -1, 0),
+            (0, 0, 1),
+            (0, 0, -1),
+        ] {
+            pad.blocks[pi(8 + dx, 8 + dy, 8 + dz)] = 2;
+        }
+        pad.blocks[pi(8, 8, 8)] = 1;
+        let chunk = loaded();
+        for mode in [LeafCullingMode::Solid, LeafCullingMode::SolidAggressive] {
+            let mask = built(mode, &pad, &states, &chunk);
+            assert!(mask.interior(mode, 8, 8, 8), "{mode:?}");
+        }
+        let hollow = built(LeafCullingMode::Hollow, &pad, &states, &chunk);
+        for d in Direction::ALL {
+            assert!(
+                !hollow.hides_face(LeafCullingMode::Hollow, 8, 8, 8, d),
+                "{d:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn a_leaf_inside_a_closed_volume_is_interior() {
+        let states = states();
+        // A leaf cube inside opaque rock: the search has no opening to start
+        // from, so every leaf stays unvisited and counts as interior.
+        let mut pad = padded(|_, _, _| 2);
+        cube(&mut pad, 7, 9, 1);
+        let chunk = loaded();
+        for mode in [LeafCullingMode::Solid, LeafCullingMode::SolidAggressive] {
+            let mask = built(mode, &pad, &states, &chunk);
+            if mode == LeafCullingMode::SolidAggressive {
+                assert_eq!(mask.depth[pi(8, 8, 8)], UNVISITED);
+            }
+            assert!(mask.interior(mode, 8, 8, 8), "{mode:?}");
+        }
+    }
+
+    #[test]
+    fn missing_chunks_and_sections_are_unknown() {
+        let states = states();
+        let pad = padded(|_, _, _| 1);
+        let chunk = loaded();
+        let mut around = [[Some(&chunk); 3]; 3];
+        around[1][2] = None; // east chunk
+        let mut mask = LeafMask::default();
+        mask.prepare(LeafCullingMode::Hollow, &pad, &states, &around, 0);
+        // The leaf at the edge keeps its face toward the missing chunk, even
+        // though `Padded::fill` copied the centre's edge leaf there.
+        assert!(!mask.hides_face(LeafCullingMode::Hollow, 15, 8, 8, Direction::East));
+        // A leaf one block inside is still between two known leaves.
+        assert!(mask.hides_face(LeafCullingMode::Hollow, 14, 8, 8, Direction::East));
+
+        // A section above the column is unknown too: the same leaf one
+        // section up has no data, so it can never be interior.
+        let short = Chunk::with_layout(0, 0, crate::chunk::ColumnLayout::new(0, 16).unwrap());
+        let mut mask = LeafMask::default();
+        mask.prepare(LeafCullingMode::Solid, &pad, &states, &region(&short), 16);
+        assert!(!mask.interior(LeafCullingMode::Solid, 8, 8, 8));
+
+        // The outer shell has no data beyond it.
+        let mut mask = LeafMask::default();
+        mask.prepare(LeafCullingMode::Hollow, &pad, &states, &region(&chunk), 0);
+        assert_eq!(mask.cell(-B, 0, 0), Cell::Unknown);
+        assert_eq!(mask.cell(16 + B - 1, 0, 0), Cell::Unknown);
+        assert_eq!(mask.cell(0, 0, 0), Cell::Leaf);
+
+        // A section boundary is never enclosed, even with every chunk loaded:
+        // the neighbouring section may not have been meshed yet.
+        let mut mask = LeafMask::default();
+        mask.prepare(LeafCullingMode::Solid, &pad, &states, &region(&chunk), 0);
+        assert!(!mask.interior(LeafCullingMode::Solid, 15, 8, 8));
+        assert!(mask.interior(LeafCullingMode::Solid, 14, 8, 8));
+    }
+
+    #[test]
+    fn off_does_no_work_and_hides_nothing() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        cube(&mut pad, 7, 9, 1);
+        let chunk = loaded();
+        let mut mask = LeafMask::default();
+        mask.prepare(LeafCullingMode::Off, &pad, &states, &region(&chunk), 0);
+        assert!(!mask.active);
+        assert!(mask.cells.is_empty());
+        assert!(!mask.interior(LeafCullingMode::Off, 8, 8, 8));
+        assert!(!mask.hides_face(LeafCullingMode::Off, 8, 8, 8, Direction::Up));
+    }
+
+    #[test]
+    fn a_reused_mask_reclassifies_every_cell() {
+        let states = states();
+        let chunk = loaded();
+        let mut mask = LeafMask::default();
+        let mut leaves = padded(|_, _, _| 0);
+        cube(&mut leaves, 7, 9, 1);
+        mask.prepare(
+            LeafCullingMode::Hollow,
+            &leaves,
+            &states,
+            &region(&chunk),
+            0,
+        );
+        assert_eq!(mask.cell(8, 8, 8), Cell::Leaf);
+        let mut other = padded(|_, _, _| 0);
+        cube(&mut other, 10, 12, 1);
+        mask.prepare(LeafCullingMode::Hollow, &other, &states, &region(&chunk), 0);
+        assert_eq!(mask.cell(8, 8, 8), Cell::Open);
+        assert_eq!(mask.cell(11, 11, 11), Cell::Leaf);
+    }
+
+    #[test]
+    #[ignore = "microbenchmark; run with --ignored --nocapture"]
+    fn mask_build_benchmark() {
+        let states = states();
+        let mut pad = padded(|x, y, z| {
+            // Alternating leaf slabs make the search visit most of the volume.
+            if (x / 2 + y / 2 + z / 2) % 3 == 0 {
+                1
+            } else {
+                0
+            }
+        });
+        cube(&mut pad, 6, 10, 1);
+        let chunk = loaded();
+        let region = region(&chunk);
+        let iterations = 1000;
+        for mode in [LeafCullingMode::Solid, LeafCullingMode::SolidAggressive] {
+            let mut mask = LeafMask::default();
+            let started = Instant::now();
+            for _ in 0..iterations {
+                mask.prepare(mode, &pad, &states, &region, 0);
+            }
+            let per = started.elapsed() / iterations;
+            println!("leaf mask {mode:?}: {per:?} per section ({iterations} iterations)");
+            assert!(mask.active);
+            if mode == LeafCullingMode::SolidAggressive {
+                assert_ne!(mask.depth[pi(8, 8, 8)], UNVISITED);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,293 @@
+//! Leaf culling through the real mesher: face counts, the opaque layer and the
+//! conservative cases (cavities, partial neighbours, missing chunks, column
+//! ends). Needs prepared resources, like the other mesher geometry tests.
+use super::*;
+use crate::{
+    assets::{Assets, RenderAssets},
+    biome::Biomes,
+    blocks::BlockFacts,
+    chunk::{Chunk, ColumnLayout},
+    graphics::LeafCullingMode,
+    models,
+};
+
+struct Fixture {
+    assets: Assets,
+    biomes: Biomes,
+    render: RenderAssets,
+    visibility: horizon_world::block_render::FaceVisibility,
+    tables: MeshTables,
+}
+
+fn fixture() -> Fixture {
+    let root = std::env::var_os("HORIZON_MESH_TEST_RESOURCES")
+        .map(std::path::PathBuf::from)
+        .unwrap_or_else(|| {
+            std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+                .join("../../.local/horizon-client/26.3")
+        });
+    let assets = Assets::load(&root).unwrap();
+    let facts = BlockFacts::load(&root, assets.registry).unwrap();
+    let biomes = Biomes::load(&root).unwrap();
+    let render = assets.reload(&root).unwrap();
+    let visibility = models::load_visibility(&root, assets.registry).unwrap();
+    let tables = MeshTables::new(&assets, &render, &facts, visibility.clone()).unwrap();
+    Fixture {
+        assets,
+        biomes,
+        render,
+        visibility,
+        tables,
+    }
+}
+
+fn state(f: &Fixture, name: &str) -> u32 {
+    f.assets.registry.default_state(name).unwrap().0
+}
+
+fn leaves_cube(chunk: &mut Chunk, min: i32, max: i32, y: i32, state: u32) {
+    for z in min..=max {
+        for x in min..=max {
+            chunk.set(x, y, z, state);
+        }
+    }
+}
+
+fn leaf_cube(f: &Fixture, min: i32, max: i32, base: i32, name: &str) -> Chunk {
+    let mut chunk = Chunk::empty(0, 0);
+    let state = state(f, name);
+    for y in base..base + (max - min + 1) {
+        leaves_cube(&mut chunk, min, max, y, state);
+    }
+    chunk
+}
+
+fn mesh(
+    f: &Fixture,
+    _chunk: &Chunk,
+    region: [[Option<&Chunk>; 3]; 3],
+    sy: i32,
+    mode: LeafCullingMode,
+) -> SectionMesh {
+    let mut mesher = Mesher {
+        nether_shading: false,
+        shader_pack_lighting: false,
+        assets: &f.assets,
+        render: &f.render,
+        tables: &f.tables,
+        biomes: &f.biomes,
+        visibility: f.visibility.clone(),
+        zoom: BiomeZoom::new(0),
+        blend_radius: 0,
+        smooth_lighting: false,
+        cutout_leaves: true,
+        leaf_culling: mode,
+    };
+    mesher.mesh(&region, sy)
+}
+
+fn around(chunk: &Chunk) -> [[Option<&Chunk>; 3]; 3] {
+    [[Some(chunk); 3]; 3]
+}
+
+/// (opaque, cutout) leaf quads, rejecting a quad whose four vertices disagree.
+fn quads(mesh: &SectionMesh) -> (usize, usize) {
+    let mut opaque = 0;
+    let mut cutout = 0;
+    for quad in mesh.solid.as_chunks::<4>().0 {
+        let flags = quad
+            .iter()
+            .map(|v| v.layer & OPAQUE_LAYER != 0)
+            .collect::<Vec<_>>();
+        assert!(
+            flags.iter().all(|flag| *flag == flags[0]),
+            "a quad mixed opaque and cutout vertices: {flags:?}"
+        );
+        if flags[0] {
+            opaque += 1;
+        } else {
+            cutout += 1;
+        }
+    }
+    assert_eq!(mesh.solid.len() % 4, 0);
+    (opaque, cutout)
+}
+
+const BASE: i32 = MIN_Y + 4;
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn off_draws_every_fancy_leaf_face() {
+    let f = fixture();
+    let chunk = leaf_cube(&f, 6, 8, BASE, "minecraft:oak_leaves");
+    let mesh = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Off);
+    // 27 blocks, six quads each: vanilla's fancy leaves keep the inside.
+    assert_eq!(quads(&mesh), (0, 162));
+    assert_eq!(mesh.translucent.len(), 0);
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn solid_draws_the_fully_enclosed_leaf_opaque() {
+    let f = fixture();
+    let chunk = leaf_cube(&f, 6, 8, BASE, "minecraft:oak_leaves");
+    let solid = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Solid);
+    // Only the centre has all six sides covered: its six quads go opaque.
+    assert_eq!(quads(&solid), (6, 156));
+
+    let aggressive = mesh(
+        &f,
+        &chunk,
+        around(&chunk),
+        0,
+        LeafCullingMode::SolidAggressive,
+    );
+    // Aggressive also takes the six face-centre leaves: seven blocks opaque.
+    assert_eq!(quads(&aggressive), (42, 120));
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn aggressive_solidifies_the_next_shell_layer_of_a_five_cube() {
+    let f = fixture();
+    let chunk = leaf_cube(&f, 5, 9, BASE, "minecraft:oak_leaves");
+    let solid = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Solid);
+    // The 3x3x3 inside the surface: 27 blocks, six quads each.
+    assert_eq!(quads(&solid), (162, 588));
+    let aggressive = mesh(
+        &f,
+        &chunk,
+        around(&chunk),
+        0,
+        LeafCullingMode::SolidAggressive,
+    );
+    // The 3x3x3 inside plus the 3x3 face centre of each of the six sides.
+    assert_eq!(quads(&aggressive), (486, 264));
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn hollow_drops_only_the_faces_two_leaves_share() {
+    let f = fixture();
+    let chunk = leaf_cube(&f, 6, 8, BASE, "minecraft:oak_leaves");
+    let hollow = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Hollow);
+    // 162 quads minus the 54 shared pairs' 108 faces: the 3x3x3 shell.
+    assert_eq!(quads(&hollow), (0, 54));
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn mixed_species_count_as_one_leaf_volume() {
+    let f = fixture();
+    let oak = state(&f, "minecraft:oak_leaves");
+    let birch = state(&f, "minecraft:birch_leaves");
+    let mut chunk = Chunk::empty(0, 0);
+    for y in BASE..BASE + 3 {
+        for z in 6..=8 {
+            for x in 6..=8 {
+                chunk.set(x, y, z, if (x + y + z) % 2 == 0 { oak } else { birch });
+            }
+        }
+    }
+    let solid = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Solid);
+    assert_eq!(quads(&solid), (6, 156));
+    let hollow = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Hollow);
+    assert_eq!(quads(&hollow), (0, 54));
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn a_cavity_keeps_its_six_faces_and_its_rim_stays_cutout() {
+    let f = fixture();
+    let mut chunk = leaf_cube(&f, 5, 9, BASE, "minecraft:oak_leaves");
+    chunk.set(7, BASE + 2, 7, 0);
+    let hollow = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Hollow);
+    // Five-cube shell (150) plus the six faces around the one-block cavity.
+    assert_eq!(quads(&hollow), (0, 156));
+    let solid = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Solid);
+    // The six leaves around the cavity are exposed, so they stay cutout; the
+    // other 20 inner leaves draw solid. The cavity block itself has no quads.
+    assert_eq!(quads(&solid), (120, 624));
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn section_boundary_faces_stay_with_a_loaded_neighbour() {
+    let f = fixture();
+    let leaf = state(&f, "minecraft:oak_leaves");
+    let chunk = leaf_cube(&f, 12, 15, BASE, "minecraft:oak_leaves");
+    // A loaded east chunk whose x=0 column continues the canopy.
+    let mut east = Chunk::empty(1, 0);
+    for y in BASE..BASE + 4 {
+        for z in 12..=15 {
+            east.set(0, y, z, leaf);
+        }
+    }
+    let mut region = around(&chunk);
+    region[1][2] = Some(&east);
+    let joined = mesh(&f, &chunk, region, 0, LeafCullingMode::Hollow);
+    let mut region = around(&chunk);
+    region[1][2] = None;
+    let missing = mesh(&f, &chunk, region, 0, LeafCullingMode::Hollow);
+    // The east faces of the x=15 leaves are on the section boundary: a loaded
+    // neighbour does not let Hollow drop them, and a missing one does not
+    // change the mesh either.
+    assert_eq!(joined.solid.len(), missing.solid.len());
+    let off = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Off);
+    assert!(joined.solid.len() < off.solid.len());
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn the_top_of_a_one_section_column_stays_visible() {
+    let f = fixture();
+    let leaf = state(&f, "minecraft:oak_leaves");
+    let layout = ColumnLayout::new(0, 16).unwrap();
+    let mut chunk = Chunk::with_layout(0, 0, layout);
+    for y in 13..16 {
+        leaves_cube(&mut chunk, 5, 7, y, leaf);
+    }
+    let hollow = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Hollow);
+    let solid = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Solid);
+    // y=15 is the column's top: the faces toward y=16 are unknown, so they
+    // stay, and the y=15 leaves are not enclosed.
+    assert!(!hollow.solid.is_empty());
+    assert!(solid.solid.iter().any(|v| v.pos[1] == 16.0));
+    assert!(
+        solid
+            .solid
+            .iter()
+            .filter(|v| v.pos[1] == 16.0)
+            .all(|v| v.layer & OPAQUE_LAYER == 0)
+    );
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn a_world_without_leaves_meshes_identically_in_every_mode() {
+    let f = fixture();
+    let mut chunk = Chunk::empty(0, 0);
+    for y in BASE..BASE + 3 {
+        leaves_cube(&mut chunk, 6, 8, y, state(&f, "minecraft:stone"));
+    }
+    let off = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Off);
+    for mode in LeafCullingMode::ALL {
+        let other = mesh(&f, &chunk, around(&chunk), 0, mode);
+        assert_eq!(off.solid.len(), other.solid.len(), "{mode:?}");
+        assert_eq!(off.translucent.len(), other.translucent.len(), "{mode:?}");
+        for (a, b) in off.solid.iter().zip(&other.solid) {
+            assert_eq!(
+                (a.pos, a.uv, a.layer, a.light, a.color),
+                (b.pos, b.uv, b.layer, b.light, b.color),
+                "{mode:?}"
+            );
+        }
+        for (a, b) in off.translucent.iter().zip(&other.translucent) {
+            assert_eq!(
+                (a.pos, a.uv, a.layer, a.light, a.color),
+                (b.pos, b.uv, b.layer, b.light, b.color),
+                "{mode:?}"
+            );
+        }
+    }
+}

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

@@ -81,6 +81,7 @@ fn a_shader_pack_lights_the_faces_itself() {
             blend_radius: 0,
             smooth_lighting: false,
             cutout_leaves: true,
+            leaf_culling: LeafCullingMode::Off,
         };
         let mut colours: Vec<u32> = mesher
             .mesh(&region, 0)
@@ -156,6 +157,7 @@ fn reused_mesh_matches_fresh_geometry_across_sections_and_resource_reload() {
             blend_radius: 2,
             smooth_lighting: reload == 0,
             cutout_leaves: reload == 0,
+            leaf_culling: LeafCullingMode::Off,
         };
         for (case, (center, east)) in [
             (&empty, None),

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

@@ -13,9 +13,10 @@
 //!
 //! The buckets lie one after another in the mesh, in an order chosen so that
 //! the buckets an eye can see are usually one or two runs of quads: one draw
-//! each. Inside a bucket quads keep their model order, so coplanar quads
-//! facing one way (an overlay on its base) still draw in that order.
-use super::TerrainVertex;
+//! each. Coplanar quads facing one way keep their model order, so an overlay
+//! on its base still draws in that order. Solid cutout quads are otherwise
+//! ordered from the outside toward the section interior to reduce overdraw.
+use super::{OPAQUE_LAYER, TerrainVertex};
 
 /// The buckets in mesh order: +X, +Z, other, +Y, -Z, -X, -Y. Seen from
 /// above (+Y, the commonest case), each pair of horizontal sides with a
@@ -138,11 +139,14 @@ fn bucket(quad: &[TerrainVertex; 4]) -> usize {
     OTHER
 }
 
-/// Reorders `solid`'s quads by bucket, keeping their order inside each.
+/// Reorders `solid`'s quads by bucket. Solid cutout quads are also ordered
+/// front to back within each axis-facing bucket; stable sorting preserves the
+/// mesher's order for coplanar overlays.
 pub fn sort(solid: &mut Vec<TerrainVertex>) -> Sides {
     let (quads, rest) = solid.as_chunks::<4>();
     debug_assert!(rest.is_empty(), "solid vertices come in quads");
     let buckets: Vec<u8> = quads.iter().map(|q| bucket(q) as u8).collect();
+    let has_cutout = quads.iter().any(|q| q[0].layer & OPAQUE_LAYER == 0);
     let mut counts = [0u32; 7];
     let mut planes = [0f32; 7];
     for (quad, &b) in quads.iter().zip(&buckets) {
@@ -163,7 +167,7 @@ pub fn sort(solid: &mut Vec<TerrainVertex>) -> Sides {
         total += count;
         *end = total;
     }
-    if counts.iter().filter(|&&c| c > 0).count() > 1 {
+    if has_cutout || counts.iter().filter(|&&c| c > 0).count() > 1 {
         let mut next: [u32; 7] = std::array::from_fn(|b| ends[b] - counts[b]);
         let mut sorted = vec![quads[0]; quads.len()];
         for (quad, &b) in quads.iter().zip(&buckets) {
@@ -171,6 +175,25 @@ pub fn sort(solid: &mut Vec<TerrainVertex>) -> Sides {
             sorted[*slot as usize] = *quad;
             *slot += 1;
         }
+        if has_cutout {
+            let mut start = 0;
+            for (i, bucket) in BUCKETS.iter().enumerate() {
+                let end = ends[i] as usize;
+                let slice = &mut sorted[start..end];
+                if let Bucket::Side(axis, positive) = *bucket {
+                    slice.sort_by(|a, b| {
+                        let a = a[0].pos[axis];
+                        let b = b[0].pos[axis];
+                        if positive {
+                            b.total_cmp(&a)
+                        } else {
+                            a.total_cmp(&b)
+                        }
+                    });
+                }
+                start = end;
+            }
+        }
         *solid = sorted.into_flattened();
     }
     Sides { ends, planes }
@@ -368,4 +391,46 @@ mod tests {
             before.iter().map(|v| v.layer).collect::<Vec<_>>()
         );
     }
+
+    #[test]
+    fn front_to_back_sort_orders_positive_faces_and_keeps_ties_stable() {
+        let mut solid: Vec<_> = [(1.0, 10), (3.0, 30), (3.0, 31)]
+            .into_iter()
+            .flat_map(|(x, layer)| {
+                quad(
+                    [[x, 0.0, 0.0], [x, 1.0, 0.0], [x, 1.0, 1.0], [x, 0.0, 1.0]],
+                    layer,
+                )
+            })
+            .collect();
+        sort(&mut solid);
+        let layers: Vec<u16> = solid
+            .as_chunks::<4>()
+            .0
+            .iter()
+            .map(|q| q[0].layer)
+            .collect();
+        assert_eq!(layers, [30, 31, 10]);
+    }
+
+    #[test]
+    fn front_to_back_sort_orders_negative_faces_toward_the_eye() {
+        let mut solid: Vec<_> = [(3.0, 30), (1.0, 10), (2.0, 20)]
+            .into_iter()
+            .flat_map(|(x, layer)| {
+                quad(
+                    [[x, 0.0, 0.0], [x, 0.0, 1.0], [x, 1.0, 1.0], [x, 1.0, 0.0]],
+                    layer,
+                )
+            })
+            .collect();
+        sort(&mut solid);
+        let layers: Vec<u16> = solid
+            .as_chunks::<4>()
+            .0
+            .iter()
+            .map(|q| q[0].layer)
+            .collect();
+        assert_eq!(layers, [10, 20, 30]);
+    }
 }

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

@@ -88,6 +88,7 @@ fn info(solid: bool) -> Info {
         legacy_solid: false,
         overlay: false,
         leaves: false,
+        opaque_cube: solid,
         blocks_flow: false,
         ice: false,
         sturdy: 0,

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

@@ -38,6 +38,21 @@ pub struct Settings {
     pub alpha_cutoff_bias: f32,
     pub has_transparent: bool,
     pub item: bool,
+    /// Whether a high-resolution cutout's small levels are dithered ([`dither_cutout_levels`]).
+    pub dither_cutouts: bool,
+}
+
+/// The `ditherCutoutMips` setting, for textures loaded from now on.
+static DITHER_CUTOUTS: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+
+/// Sets `ditherCutoutMips`; true if that changes it, when the textures must load again.
+pub fn set_dither_cutouts(on: bool) -> bool {
+    DITHER_CUTOUTS.swap(on, std::sync::atomic::Ordering::Relaxed) != on
+}
+
+/// The `ditherCutoutMips` setting.
+pub fn dither_cutouts() -> bool {
+    DITHER_CUTOUTS.load(std::sync::atomic::Ordering::Relaxed)
 }
 
 /// A square or rectangular RGBA8 image, rows top to bottom.
@@ -362,5 +377,113 @@ fn generate_native(mut base: Image, levels: u32, settings: Settings) -> Vec<Imag
         }
         out.push(data);
     }
+    if settings.dither_cutouts && cutout && out[0].width >= DITHERED_CUTOUT_SIZE {
+        dither_cutout_levels(&mut out);
+    }
     out
 }
+
+/// From this size a cutout texture's mips can be dithered ([`dither_cutout_levels`]).
+const DITHERED_CUTOUT_SIZE: u32 = 64;
+/// A high-resolution cutout's detail is finer than its small mips: grass blades a few
+/// texels wide at 2048 average to about the same alpha everywhere at 64, and no scale of
+/// that alpha can keep the coverage, so the alpha test passes the whole quad or none of it.
+/// Each level below the base takes the base's mean alpha through an ordered dither instead:
+/// its texels are in or out, about as many in as the base has.
+fn dither_cutout_levels(levels: &mut [Image]) {
+    const BAYER: [[f32; 4]; 4] = [
+        [0.0, 8.0, 2.0, 10.0],
+        [12.0, 4.0, 14.0, 6.0],
+        [3.0, 11.0, 1.0, 9.0],
+        [15.0, 7.0, 13.0, 5.0],
+    ];
+    let (mut w, mut h) = (levels[0].width as usize, levels[0].height as usize);
+    let mut alpha: Vec<f32> = levels[0]
+        .pixels
+        .iter()
+        .map(|p| f32::from(p[3]) / 255.0)
+        .collect();
+    for level in &mut levels[1..] {
+        let (nw, nh) = (level.width as usize, level.height as usize);
+        let mut next = vec![0.0; nw * nh];
+        for y in 0..nh {
+            for x in 0..nw {
+                let at = |dx: usize, dy: usize| {
+                    alpha[(y * 2 + dy).min(h - 1) * w + (x * 2 + dx).min(w - 1)]
+                };
+                let mean = (at(0, 0) + at(1, 0) + at(0, 1) + at(1, 1)) / 4.0;
+                next[y * nw + x] = mean;
+                let threshold = (BAYER[y % 4][x % 4] + 0.5) / 16.0;
+                level.pixels[y * nw + x][3] = if mean > threshold { 255 } else { 0 };
+            }
+        }
+        alpha = next;
+        (w, h) = (nw, nh);
+    }
+}
+
+#[cfg(test)]
+mod dither_tests {
+    use super::*;
+    #[test]
+    fn the_dither_only_runs_when_asked_for_and_from_its_size() {
+        let cutout = |side: u32| Image {
+            width: side,
+            height: side,
+            pixels: (0..side * side)
+                .map(|i| {
+                    [
+                        90,
+                        140,
+                        40,
+                        if (i % side).is_multiple_of(4) { 255 } else { 0 },
+                    ]
+                })
+                .collect(),
+        };
+        let settings = |dither_cutouts| Settings {
+            has_transparent: true,
+            dither_cutouts,
+            ..Settings::default()
+        };
+        assert_ne!(
+            generate(cutout(128), 4, settings(false)),
+            generate(cutout(128), 4, settings(true))
+        );
+        assert_eq!(
+            generate(cutout(32), 4, settings(false)),
+            generate(cutout(32), 4, settings(true))
+        );
+    }
+    #[test]
+    fn a_high_resolution_cutouts_fine_detail_keeps_its_coverage_in_small_mips() {
+        // Blades one texel wide, one column in four: too fine for the mips to hold.
+        let side = 128u32;
+        let pixels = (0..side * side)
+            .map(|i| {
+                [
+                    90,
+                    140,
+                    40,
+                    if (i % side).is_multiple_of(4) { 255 } else { 0 },
+                ]
+            })
+            .collect();
+        let base = Image {
+            width: side,
+            height: side,
+            pixels,
+        };
+        let settings = Settings {
+            has_transparent: true,
+            dither_cutouts: true,
+            ..Settings::default()
+        };
+        let mips = generate(base, 4, settings);
+        for level in &mips[3..] {
+            let passing = level.pixels.iter().filter(|p| p[3] >= 128).count() as f32;
+            let coverage = passing / level.pixels.len() as f32;
+            assert!((0.15..0.35).contains(&coverage), "{coverage}");
+        }
+    }
+}

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

@@ -1236,6 +1236,9 @@ pub enum Page {
     NativeMod(usize),
     /// Horizon's shader packs, either kind (`shader_pack_list`).
     ShaderPacks,
+    /// The options of `s.shader_packs[.0]`, a Horizon pack: its `[[pages]]` entry `.1`, the
+    /// first the one the button opens.
+    NativePackOptions(usize, u8),
     /// The picked `shaders/` pack's options (`shader_options`), one of its screens at a time.
     ShaderOptions,
     /// Horizon's graphics settings (`graphics_ui`).
@@ -1261,6 +1264,8 @@ pub enum Page {
     Online,
     /// Splitscreen: the profile another player joins as (`split_profiles`).
     SplitProfiles,
+    /// Splitscreen: enable joining on this computer.
+    SplitSetup,
 }
 #[derive(Clone, Debug, PartialEq)]
 enum Act {
@@ -1282,6 +1287,12 @@ enum Act {
     OpenShaderPackFolder,
     /// Open the picked pack's Shader Options page.
     ShaderOptions,
+    /// Open the options page of the Horizon pack `s.shader_packs[.0]`.
+    NativePackOptions(usize),
+    /// Option `.1` of that pack: its next value.
+    NativePackOption(usize, usize),
+    /// Every option of that pack back to its default.
+    NativePackReset(usize),
     /// Shader Options: the next value of an option, a screen of the pack, the next profile,
     /// every option back to its default.
     ShaderOption(String),
@@ -1411,6 +1422,9 @@ pub enum Event {
     OpenShaderOptions,
     /// The Shader Options page closed with changes: save them and load the pack again.
     ShaderOptions,
+    /// The options of `shader_packs[.0]`, a Horizon pack, changed: save them (the pack reloads
+    /// with them).
+    NativePackOptions(usize),
     /// Native mod `.0`'s page opened: the game asks the mod for its labels
     /// again (they were made with the list, maybe in another language).
     NativeSettings(usize),
@@ -1514,6 +1528,8 @@ pub struct OptionsUi {
     /// The list's rows as last laid out: each row's top and bottom (GUI
     /// pixels), for the narration's row under the mouse.
     row_bands: Vec<[f32; 2]>,
+    /// Other local players are joined: leave before turning splitscreen off.
+    pub split_joined: bool,
 }
 impl Default for OptionsUi {
     fn default() -> Self {
@@ -1559,6 +1575,7 @@ impl Default for OptionsUi {
             framebuffer: [1280, 720],
             split_guest: false,
             row_bands: Vec::new(),
+            split_joined: false,
         }
     }
 }
@@ -1622,23 +1639,18 @@ fn horizon_page_tooltip(page: Page) -> Option<&'static str> {
         Page::SplitProfiles => "horizon.pages.split_profiles.tooltip",
         Page::ShaderPacks => "horizon.pages.shader_packs.tooltip",
         Page::Mods => "horizon.pages.mods.tooltip",
+        Page::SplitSetup => "horizon.pages.split_setup.tooltip",
         _ => return None,
     })
 }
 /// The open screen of the picked pack: its title, then its items two to a row (one when the
 /// pack asks for a single column).
-fn shader_option_rows(s: &Settings) -> Vec<Row> {
-    let Some(options) = &s.shader_options else {
-        return vec![Row::Header("horizon.shader_options.loading")];
-    };
-    let columns = options
-        .screens
-        .screen(options.screen())
-        .map_or(2, |(_, c)| c);
-    let blank = || Widget {
+/// A list's slot with nothing in it: text takes no clicks.
+fn blank_slot(w: f32) -> Widget {
+    Widget {
         x: 0.0,
         y: 0.0,
-        w: 150.0,
+        w,
         h: 20.0,
         kind: WKind::Text {
             text: Text::literal(""),
@@ -1647,7 +1659,55 @@ fn shader_option_rows(s: &Settings) -> Vec<Row> {
         },
         list: false,
         row: 0,
+    }
+}
+/// Page `at` of the options of the Horizon pack `s.shader_packs[i]`: the pack's own layout,
+/// else every option two a row.
+fn native_pack_option_rows(s: &Settings, i: usize, at: u8) -> Vec<Row> {
+    use horizon_shader_api::PageItem;
+    let Some(pack) = s.shader_packs.get(i) else {
+        return Vec::new();
     };
+    let count = pack.options.len().min(pack.values.len());
+    let (columns, items) = match pack.pages.get(usize::from(at)) {
+        Some(page) => (usize::from(page.columns), page.items.clone()),
+        None => (2, (0..count).map(PageItem::Option).collect()),
+    };
+    let width = if columns == 1 { 310.0 } else { 150.0 };
+    let widget = |item: &PageItem| match *item {
+        PageItem::Option(o) if o < count => {
+            let option = &pack.options[o];
+            let value = crate::shader_pack_list::show_value(&option.kind, pack.values[o]);
+            let label = Text::literal(format!("{}: {value}", option.name));
+            button(0.0, 0.0, width, label, Act::NativePackOption(i, o))
+        }
+        PageItem::Page(p) if p < pack.pages.len() => {
+            let label = Text::literal(format!("{}...", pack.pages[p].name));
+            let page = Page::NativePackOptions(i, p as u8);
+            button(0.0, 0.0, width, label, Act::Push(page))
+        }
+        _ => blank_slot(width),
+    };
+    let mut rows = Vec::new();
+    if at == 0 {
+        rows.push(Row::Note(pack.title.clone()));
+    }
+    rows.extend(
+        items
+            .chunks(columns)
+            .map(|row| Row::Buttons(widget(&row[0]), row.get(1).map(widget))),
+    );
+    rows
+}
+fn shader_option_rows(s: &Settings) -> Vec<Row> {
+    let Some(options) = &s.shader_options else {
+        return vec![Row::Header("horizon.shader_options.loading")];
+    };
+    let columns = options
+        .screens
+        .screen(options.screen())
+        .map_or(2, |(_, c)| c);
+    let blank = || blank_slot(150.0);
     let width = if columns == 1 { 310.0 } else { 150.0 };
     let widget = |item: &horizon_shaders::ScreenItem| -> Option<Widget> {
         use horizon_shaders::ScreenItem;
@@ -1712,6 +1772,26 @@ enum Row {
 /// A widget's tooltip (`setTooltip`), unwrapped: drawn while hovered, and
 /// its narration's hint.
 fn tooltip_text(s: &Settings, wd: &Widget) -> Option<Text> {
+    let pack_text = match &wd.kind {
+        WKind::Button {
+            act: Act::NativePackOption(pack, option),
+            ..
+        } => Some(&s.shader_packs.get(*pack)?.options.get(*option)?.description),
+        WKind::Button {
+            act: Act::Push(Page::NativePackOptions(pack, at)),
+            ..
+        } => Some(
+            &s.shader_packs
+                .get(*pack)?
+                .pages
+                .get(usize::from(*at))?
+                .description,
+        ),
+        _ => None,
+    };
+    if let Some(text) = pack_text {
+        return (!text.is_empty()).then(|| Text::literal(text));
+    }
     let WKind::Button { act, .. } = &wd.kind else {
         let WKind::Slider { opt, .. } = &wd.kind else {
             return None;
@@ -2055,6 +2135,14 @@ impl OptionsUi {
             _ => None,
         }
     }
+    /// The name of a Horizon pack's options page past its first, as the page's title.
+    fn pack_page_title(s: &Settings, page: Page) -> Option<Text> {
+        let Page::NativePackOptions(pack, at @ 1..) = page else {
+            return None;
+        };
+        let page = s.shader_packs.get(pack)?.pages.get(usize::from(at))?;
+        Some(Text::literal(&page.name))
+    }
     fn title(page: Page) -> &'static str {
         match page {
             Page::Main => "options.title",
@@ -2073,7 +2161,7 @@ impl OptionsUi {
             Page::Mods => "horizon.pages.mods",
             Page::NativeMod(_) => "Mod Settings",
             Page::ShaderPacks => "horizon.pages.shader_packs",
-            Page::ShaderOptions => "horizon.pages.shader_options",
+            Page::ShaderOptions | Page::NativePackOptions(..) => "horizon.pages.shader_options",
             Page::Graphics | Page::GraphicsAdvanced | Page::GraphicsHdr | Page::HdrCalibration => {
                 "options.videoTitle"
             }
@@ -2084,6 +2172,7 @@ impl OptionsUi {
             Page::Horizon => "horizon.pages.settings",
             Page::Agent => "horizon.pages.agent",
             Page::SplitProfiles => "horizon.pages.split_profiles",
+            Page::SplitSetup => "horizon.pages.split_setup",
         }
     }
     fn scrollbar_x(&self, width: f32) -> f32 {
@@ -2173,6 +2262,14 @@ impl OptionsUi {
 
     fn list_rows(&self, s: &Settings) -> Vec<Row> {
         match self.page() {
+            Page::SplitSetup => vec![Row::Buttons(
+                if self.split_guest || self.split_joined {
+                    inactive(self.extra_button(s, crate::extras::Item::Splitscreen))
+                } else {
+                    self.extra_button(s, crate::extras::Item::Splitscreen)
+                },
+                None,
+            )],
             Page::Extras => {
                 // Each section's switches two to a row, as vanilla's
                 // OptionsList.addSmall lays out an options screen.
@@ -2239,6 +2336,17 @@ impl OptionsUi {
                         open("horizon.pages.open.extras", Page::Extras),
                         Some(open("horizon.pages.open.mods", Page::Mods)),
                     ),
+                    Row::Buttons(
+                        open(
+                            "horizon.pages.open.split_setup",
+                            if self.split_guest {
+                                Page::SplitProfiles
+                            } else {
+                                Page::SplitSetup
+                            },
+                        ),
+                        None,
+                    ),
                     // No AI hides the AI Agent page and everything AI.
                     Row::Buttons(
                         self.extra_button(s, crate::extras::Item::DiscordPresence),
@@ -2502,13 +2610,19 @@ impl OptionsUi {
                 if s.shader_packs.is_empty() {
                     return vec![Row::Header("horizon.shader_packs.empty")];
                 }
-                let options = s.shader_packs.iter().any(|p| {
-                    p.file == s.horizon.shader_pack
-                        && p.kind == crate::shader_pack_list::Kind::Classic
-                });
-                let options = options.then(|| {
+                let picked = s
+                    .shader_packs
+                    .iter()
+                    .position(|p| p.file == s.horizon.shader_pack);
+                let options = picked.and_then(|i| {
+                    let pack = &s.shader_packs[i];
+                    let act = match pack.kind {
+                        crate::shader_pack_list::Kind::Classic => Act::ShaderOptions,
+                        _ if pack.options.is_empty() => return None,
+                        crate::shader_pack_list::Kind::Horizon => Act::NativePackOptions(i),
+                    };
                     let label = tr("horizon.shader_options.open");
-                    Row::Buttons(button(0.0, 0.0, 310.0, label, Act::ShaderOptions), None)
+                    Some(Row::Buttons(button(0.0, 0.0, 310.0, label, act), None))
                 });
                 options
                     .into_iter()
@@ -2526,6 +2640,7 @@ impl OptionsUi {
                     .collect()
             }
             Page::ShaderOptions => shader_option_rows(s),
+            Page::NativePackOptions(i, at) => native_pack_option_rows(s, i, at),
             _ => {
                 let _ = s;
                 Vec::new()
@@ -2977,7 +3092,8 @@ impl OptionsUi {
                     w,
                     h: 9.0,
                     kind: WKind::Text {
-                        text: tr(Self::title(page)),
+                        text: Self::pack_page_title(s, page)
+                            .unwrap_or_else(|| tr(Self::title(page))),
                         color: u32::MAX,
                         centered: true,
                     },
@@ -3062,6 +3178,9 @@ impl OptionsUi {
                     Page::Mods => Some(("horizon.mods.open_folder", Act::OpenModFolder)),
                     Page::ShaderPacks => Some(("pack.openFolder", Act::OpenShaderPackFolder)),
                     Page::ShaderOptions => Some(("controls.reset", Act::ShaderReset)),
+                    Page::NativePackOptions(i, _) => {
+                        Some(("controls.reset", Act::NativePackReset(i)))
+                    }
                     _ => None,
                 };
                 if let Some((label, act)) = folder {
@@ -3722,6 +3841,25 @@ impl OptionsUi {
                 options.cycle(&name, true);
                 events.push(Event::ButtonClick);
             }
+            let native = widgets.iter().find_map(|wd| match wd.kind {
+                WKind::Button {
+                    active: true,
+                    act: Act::NativePackOption(pack, option),
+                    ..
+                } if ui::hovered((x, y), wd.x, wd.y, wd.w, wd.h)
+                    && !(wd.list && (y < top || y >= bottom)) =>
+                {
+                    Some((pack, option))
+                }
+                _ => None,
+            });
+            if let Some((pack, option)) = native
+                && let Some(entry) = s.shader_packs.get_mut(pack)
+                && entry.step_option(option, true, false)
+            {
+                events.push(Event::ButtonClick);
+                events.push(Event::NativePackOptions(pack));
+            }
             return events;
         }
         if ui::scrollbar_thumb(top, bottom, content, self.scroll).is_some()
@@ -3838,6 +3976,22 @@ impl OptionsUi {
                                 options.reset();
                             }
                         }
+                        Act::NativePackOptions(i) => {
+                            self.push(Page::NativePackOptions(i, 0));
+                        }
+                        Act::NativePackOption(pack, option) => {
+                            if let Some(entry) = s.shader_packs.get_mut(pack)
+                                && entry.step_option(option, false, self.shift)
+                            {
+                                events.push(Event::NativePackOptions(pack));
+                            }
+                        }
+                        Act::NativePackReset(pack) => {
+                            if let Some(entry) = s.shader_packs.get_mut(pack) {
+                                entry.reset_options();
+                                events.push(Event::NativePackOptions(pack));
+                            }
+                        }
                         Act::Credits => events.push(Event::Credits),
                         Act::CopyAgentDetails => events.push(Event::CopyAgentDetails),
                         Act::None => {}
@@ -4745,6 +4899,22 @@ impl OptionsUi {
                                 options.reset();
                             }
                         }
+                        Act::NativePackOptions(i) => {
+                            self.push(Page::NativePackOptions(i, 0));
+                        }
+                        Act::NativePackOption(pack, option) => {
+                            if let Some(entry) = s.shader_packs.get_mut(pack)
+                                && entry.step_option(option, false, shift)
+                            {
+                                events.push(Event::NativePackOptions(pack));
+                            }
+                        }
+                        Act::NativePackReset(pack) => {
+                            if let Some(entry) = s.shader_packs.get_mut(pack) {
+                                entry.reset_options();
+                                events.push(Event::NativePackOptions(pack));
+                            }
+                        }
                         Act::Credits => events.push(Event::Credits),
                         Act::CopyAgentDetails => events.push(Event::CopyAgentDetails),
                         Act::None => {}
@@ -5032,6 +5202,82 @@ mod tests {
         HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")).unwrap()
     }
 
+    #[test]
+    fn a_horizon_packs_options_step_both_ways_from_the_picked_packs_button() {
+        let atlas = atlas();
+        let size = (960.0, 540.0);
+        let mut s = Settings::default();
+        s.horizon.shader_pack = "p".into();
+        s.shader_packs = vec![crate::shader_pack_list::Entry {
+            file: "p".into(),
+            title: "P".into(),
+            kind: crate::shader_pack_list::Kind::Horizon,
+            options: vec![horizon_shader_api::PackOption {
+                id: "a".into(),
+                name: "A".into(),
+                description: String::new(),
+                kind: horizon_shader_api::OptionKind::Float {
+                    default: 1.0,
+                    min: 0.0,
+                    max: 2.0,
+                    step: 0.5,
+                },
+            }],
+            values: vec![1.0],
+            pages: vec![
+                horizon_shader_api::OptionPage {
+                    id: "main".into(),
+                    name: "P".into(),
+                    description: String::new(),
+                    columns: 2,
+                    items: vec![horizon_shader_api::PageItem::Page(1)],
+                },
+                horizon_shader_api::OptionPage {
+                    id: "more".into(),
+                    name: "More".into(),
+                    description: String::new(),
+                    columns: 1,
+                    items: vec![horizon_shader_api::PageItem::Option(0)],
+                },
+            ],
+        }];
+        let mut ui = OptionsUi::default();
+        ui.show(Page::ShaderPacks);
+        let find = |ui: &mut OptionsUi, s: &Settings, want: &Act| {
+            let (widgets, ..) = ui.layout(s, size.0, size.1);
+            let w = widgets
+                .into_iter()
+                .find(|w| matches!(&w.kind, WKind::Button { act, .. } if act == want))
+                .expect("button");
+            (w.x + w.w / 2.0, w.y + w.h / 2.0)
+        };
+        let (x, y) = find(&mut ui, &s, &Act::NativePackOptions(0));
+        ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false);
+        assert_eq!(ui.page(), Page::NativePackOptions(0, 0));
+        // The option is on the pack's second page, behind a button on its first.
+        let (x, y) = find(&mut ui, &s, &Act::Push(Page::NativePackOptions(0, 1)));
+        ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false);
+        assert_eq!(ui.page(), Page::NativePackOptions(0, 1));
+        let (x, y) = find(&mut ui, &s, &Act::NativePackOption(0, 0));
+        let events = ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false);
+        assert!(events.contains(&Event::NativePackOptions(0)));
+        assert_eq!(s.shader_packs[0].values, [1.5]);
+        ui.click(&mut s, &atlas, x, y, size, [854, 480], false, true);
+        ui.click(&mut s, &atlas, x, y, size, [854, 480], false, true);
+        assert_eq!(s.shader_packs[0].values, [0.5]);
+        // Shift-click: the option's default.
+        ui.shift = true;
+        ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false);
+        ui.shift = false;
+        assert_eq!(s.shader_packs[0].values, [1.0]);
+        ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false);
+        let (x, y) = find(&mut ui, &s, &Act::NativePackReset(0));
+        ui.click(&mut s, &atlas, x, y, size, [854, 480], false, false);
+        assert_eq!(s.shader_packs[0].values, [1.0]);
+        ui.back(&mut s);
+        assert_eq!(ui.page(), Page::NativePackOptions(0, 0));
+    }
+
     #[test]
     fn resource_reload_error_blocks_options_until_dismissed() {
         use winit::keyboard::KeyCode;
@@ -6568,6 +6814,7 @@ mod tests {
                 Page::Controller,
                 Page::Extras,
                 Page::Mods,
+                Page::SplitSetup,
                 Page::Agent,
             ]
         );

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

@@ -47,6 +47,9 @@ pub struct ParticleOptions {
     /// `GeyserParticleOptions.waterBlocks` and `GeyserBaseParticleOptions`'
     /// `waterBlocks` and `burstImpulseBase` (0 where the type has none).
     pub geyser: Option<(i32, f32)>,
+    /// A native mod's own particle type, by its namespaced name (`mymod:spark`):
+    /// `SimpleParticleType` plus the provider `particles/<name>.json` names.
+    pub mod_particle: Option<String>,
 }
 impl ParticleOptions {
     pub fn simple(ty: ParticleType) -> Self {
@@ -59,6 +62,15 @@ impl ParticleOptions {
             trail: None,
             item: None,
             geyser: None,
+            mod_particle: None,
+        }
+    }
+    /// A native mod's `SimpleParticleType`: the sprite set of
+    /// `assets/<namespace>/particles/<path>.json`, drawn as a plain billboard.
+    pub fn named(name: impl Into<String>) -> Self {
+        Self {
+            mod_particle: Some(name.into()),
+            ..Self::simple(ParticleType::Smoke)
         }
     }
     /// `GeyserParticleOptions(type, waterBlocks)`.
@@ -1055,6 +1067,8 @@ pub struct ParticleEngine {
     /// it on the translucent layer (a texel with 0 < alpha < 255).
     atlas: HashMap<String, (Rect, bool)>,
     sets: HashMap<ParticleType, u32>,
+    /// A native mod's sprite sets, by namespaced particle name.
+    mod_sets: HashMap<String, u32>,
     set_sprites: Vec<Vec<u32>>,
     /// `TrackingEmitter`s: particle type, entity feet position, width, height, ticks left.
     emitters: Vec<(ParticleOptions, [f64; 3], f64, f64, u32)>,
@@ -1092,6 +1106,7 @@ impl ParticleEngine {
             rects: Vec::new(),
             atlas: HashMap::new(),
             sets: HashMap::new(),
+            mod_sets: HashMap::new(),
             set_sprites: Vec::new(),
             emitters: Vec::new(),
             starters: Vec::new(),
@@ -1123,12 +1138,24 @@ impl ParticleEngine {
             .map(|name| self.atlas.get(name).map(|&(rect, _)| rect))
             .collect();
         self.sets.clear();
+        self.mod_sets.clear();
         self.set_sprites.clear();
         self.item_sprites.clear();
         self.load_sprites(root);
     }
-    /// The sprite sets of every `particles/*.json` under `root`.
+    /// The sprite sets of every `particles/*.json` under `root`: vanilla's own
+    /// and a native mod's (`assets/<namespace>/particles/<name>.json`).
     fn load_sprites(&mut self, root: &Path) {
+        let assets = root.join("assets");
+        if let Ok(namespaces) = std::fs::read_dir(&assets) {
+            for namespace in namespaces.flatten() {
+                let ns = namespace.file_name().to_string_lossy().into_owned();
+                if ns == "minecraft" || !namespace.path().is_dir() {
+                    continue;
+                }
+                self.load_mod_sprites(&ns, &namespace.path().join("particles"));
+            }
+        }
         let dir = root.join("assets/minecraft/particles");
         for &ty in ParticleType::ALL {
             let Ok(bytes) = std::fs::read(dir.join(format!("{}.json", ty.name()))) else {
@@ -1154,6 +1181,56 @@ impl ParticleEngine {
             }
         }
     }
+    /// A namespace's particle JSONs that vanilla has no type for: each becomes
+    /// one sprite set under `<ns>:<file name>`.
+    fn load_mod_sprites(&mut self, ns: &str, dir: &Path) {
+        let Ok(files) = std::fs::read_dir(dir) else {
+            return;
+        };
+        for file in files.flatten() {
+            let path = file.path();
+            if path.extension().is_none_or(|e| e != "json") {
+                continue;
+            }
+            let Some(stem) = path.file_stem().map(|s| s.to_string_lossy().into_owned()) else {
+                continue;
+            };
+            let key = format!("{ns}:{stem}");
+            if ParticleType::from_name(&key).is_some() {
+                continue;
+            }
+            let Ok(bytes) = std::fs::read(&path) else {
+                continue;
+            };
+            let Ok(json) = serde_json::from_slice::<serde_json::Value>(&bytes) else {
+                continue;
+            };
+            let sprites: Vec<u32> = json["textures"]
+                .as_array()
+                .map(|a| {
+                    a.iter()
+                        .filter_map(|t| t.as_str())
+                        .map(|t| {
+                            // A texture is `<ns>:<path>` (bare means
+                            // `minecraft:`), and the atlas names a sprite
+                            // `<ns>:particle/<path>` — `minecraft`'s own
+                            // without its namespace.
+                            let name = match t.split_once(':') {
+                                Some(("minecraft", path)) => format!("particle/{path}"),
+                                Some((ns, path)) => format!("{ns}:particle/{path}"),
+                                None => format!("particle/{t}"),
+                            };
+                            self.intern(&name)
+                        })
+                        .collect()
+                })
+                .unwrap_or_default();
+            if !sprites.is_empty() {
+                self.mod_sets.insert(key, self.set_sprites.len() as u32);
+                self.set_sprites.push(sprites);
+            }
+        }
+    }
     fn intern(&mut self, name: &str) -> u32 {
         if let Some(i) = self.names.iter().position(|n| n == name) {
             return i as u32;
@@ -1626,6 +1703,23 @@ impl ParticleEngine {
     ) -> Option<Particle> {
         use ParticleType as T;
         let ty = o.ty;
+        // A native mod's SimpleParticleType: vanilla's TextureSheetParticle with
+        // the sprite set its particles/<name>.json names, no tint, 20..40 ticks.
+        if let Some(name) = &o.mod_particle {
+            let set = *self.mod_sets.get(name)?;
+            let mut r = LegacyRandom::new(seed);
+            let mut q = Particle::moving(&mut r, ParticleType::Smoke, p, v);
+            q.ty = ParticleType::Smoke;
+            q.gravity = 0.0;
+            q.rgba = [1.0; 4];
+            q.lifetime = 20 + r.next_int_bound(20).unwrap_or(0);
+            q.set = Some(set);
+            let sprites = &self.set_sprites[set as usize];
+            q.sprite = Sprite::Index(
+                sprites[r.next_int_bound(sprites.len() as i32).unwrap_or(0) as usize],
+            );
+            return Some(q);
+        }
         let set = self.set_of(ty);
         let mut local = LegacyRandom::new(seed);
         let r = &mut local;
@@ -4222,6 +4316,48 @@ const CREEPER: [[f64; 2]; 12] = [
 mod tests {
     use super::*;
 
+    #[test]
+    fn a_mod_particles_json_becomes_its_sprite_set() {
+        let dir =
+            std::env::temp_dir().join(format!("horizon-mod-particles-{}", std::process::id()));
+        let particles = dir.join("assets/mymod/particles");
+        std::fs::create_dir_all(&particles).unwrap();
+        std::fs::write(
+            particles.join("spark.json"),
+            br#"{"textures":["mymod:spark/1","mymod:spark/2"]}"#,
+        )
+        .unwrap();
+        assert!(particles.join("spark.json").exists());
+        let mut engine = ParticleEngine::new(&dir, &HashMap::new(), &HashSet::new());
+        let set = *engine
+            .mod_sets
+            .get("mymod:spark")
+            .expect("the set is loaded");
+        assert_eq!(engine.set_sprites[set as usize].len(), 2);
+        // The named option spawns a billboard from that set, not a vanilla type.
+        let made = engine
+            .make(
+                &ParticleOptions::named("mymod:spark"),
+                [0.0; 3],
+                [0.0; 3],
+                7,
+            )
+            .expect("a mod particle is made");
+        assert_eq!(made.set, Some(set));
+        // A name no pack knows draws nothing, like a missing vanilla sprite set.
+        assert!(
+            engine
+                .make(
+                    &ParticleOptions::named("mymod:missing"),
+                    [0.0; 3],
+                    [0.0; 3],
+                    7
+                )
+                .is_none()
+        );
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
     #[test]
     fn egg_teleport_unpacks_offsets_and_preserves_seeded_draw_order() {
         let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());

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

@@ -1024,6 +1024,7 @@ impl PostEffects {
         size: [u32; 2],
         depth: Option<&wgpu::TextureView>,
         req: &Request,
+        mut timing: Option<&mut crate::gfx::pack_timing::PassTiming>,
     ) -> bool {
         self.use_root(req.root);
         let mut applied = Vec::new();
@@ -1099,6 +1100,7 @@ impl PostEffects {
             (&work.1, size),
             0.0,
             format,
+            timing.as_deref_mut(),
         );
         self.staging = Some(staging);
         for id in &applied {
@@ -1113,6 +1115,7 @@ impl PostEffects {
                 depth,
                 req.menu_blur_radius,
                 format,
+                timing.as_deref_mut(),
             );
             self.chains.insert(id.clone(), Some(chain));
         }
@@ -1126,6 +1129,7 @@ impl PostEffects {
             (target, size),
             0.0,
             format,
+            timing,
         );
         self.blit = Some(blit);
         self.work = Some(work);
@@ -1144,6 +1148,7 @@ impl PostEffects {
         main_depth: Option<&wgpu::TextureView>,
         menu_radius: f32,
         format: wgpu::TextureFormat,
+        mut timing: Option<&mut crate::gfx::pack_timing::PassTiming>,
     ) {
         for pass in &mut chain.passes {
             if let Some(translated) = &mut pass.translated {
@@ -1203,6 +1208,7 @@ impl PostEffects {
             {
                 encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                     label: Some("Post effect depth clear"),
+                    timestamp_writes: timing.as_deref_mut().and_then(|t| t.writes("Post clear")),
                     color_attachments: &[],
                     depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
                         view,
@@ -1221,6 +1227,7 @@ impl PostEffects {
                 let c = t.clear.map(f64::from);
                 encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                     label: Some("Post effect target clear"),
+                    timestamp_writes: timing.as_deref_mut().and_then(|t| t.writes("Post clear")),
                     color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                         view: &chain.textures[i - 1].1,
                         resolve_target: None,
@@ -1274,6 +1281,7 @@ impl PostEffects {
                     &inputs,
                     (view(pass.output), sizes[pass.output]),
                     format,
+                    timing.as_deref_mut(),
                 );
                 continue;
             }
@@ -1287,6 +1295,7 @@ impl PostEffects {
                 (view(pass.output), sizes[pass.output]),
                 menu_radius,
                 format,
+                timing.as_deref_mut(),
             );
         }
     }
@@ -1303,6 +1312,7 @@ impl PostEffects {
         inputs: &[(&wgpu::TextureView, [u32; 2])],
         output: (&wgpu::TextureView, [u32; 2]),
         format: wgpu::TextureFormat,
+        timing: Option<&mut crate::gfx::pack_timing::PassTiming>,
     ) {
         let Some(pipeline) = translated.pipelines.get(&format) else {
             return;
@@ -1353,6 +1363,7 @@ impl PostEffects {
         });
         let mut rp = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("Post effect pass"),
+            timestamp_writes: timing.and_then(|t| t.writes("Post effect")),
             color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                 view: output.0,
                 resolve_target: None,
@@ -1381,6 +1392,7 @@ impl PostEffects {
         output: (&wgpu::TextureView, [u32; 2]),
         menu_radius: f32,
         format: wgpu::TextureFormat,
+        timing: Option<&mut crate::gfx::pack_timing::PassTiming>,
     ) {
         // SamplerInfo: OutSize, then each input's size.
         let info = [
@@ -1441,6 +1453,7 @@ impl PostEffects {
         });
         let mut rp = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("Post effect pass"),
+            timestamp_writes: timing.and_then(|t| t.writes("Post effect")),
             color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                 view: output.0,
                 resolve_target: None,
@@ -1715,6 +1728,7 @@ mod tests {
                 menu_blur_radius: 5.0,
                 globals: Globals::default(),
             },
+            None,
         );
         let buffer = crate::gfx::copy_frame(device, &mut encoder, &frame, [8, 4]);
         queue.submit([encoder.finish()]);
@@ -1845,6 +1859,7 @@ mod tests {
                 menu_blur_radius: 0.0,
                 globals: Globals::default(),
             },
+            None,
         ));
         let buffer = crate::gfx::copy_frame(device, &mut encoder, &frame, [8, 4]);
         queue.submit([encoder.finish()]);

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

@@ -332,6 +332,7 @@ impl Settings {
             .parent()
             .map(crate::graphics::Graphics::load)
             .unwrap_or_default();
+        crate::mipmap::set_dither_cutouts(horizon.dither_cutout_mips);
         let controller = path
             .parent()
             .map(crate::gamepad::PadSettings::load)
@@ -340,9 +341,10 @@ impl Settings {
             .parent()
             .map(crate::extras::Extras::load)
             .unwrap_or_default();
+        // The enabled mods are the game folder's, shared by its players (`--player-dir`).
         let mods = path
             .parent()
-            .map(crate::mod_list::ModList::load)
+            .map(|dir| crate::mod_list::ModList::load(&crate::logging::shared_dir(dir)))
             .unwrap_or_default();
         let settings = match fs::read(path) {
             Ok(bytes) => Self {
@@ -649,7 +651,7 @@ impl Settings {
             self.horizon.save(dir);
             self.controller.save(dir);
             self.extras.save(dir);
-            self.mods.save(dir);
+            self.mods.save(&crate::logging::shared_dir(dir));
         }
     }
     /// Volume of a sound source (master excluded).

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

@@ -2,7 +2,9 @@
 //! Settings > Shader Packs lists them: Horizon's own (docs/shaders.md) and those in the
 //! `shaders/` format, side by side.
 
-use std::path::Path;
+use std::path::{Path, PathBuf};
+
+use horizon_shader_api::{OptionKind, OptionPage, PackOption};
 
 pub const DIR: &str = "shaderpacks";
 
@@ -14,13 +16,48 @@ pub enum Kind {
     Classic,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct Entry {
     /// The folder's or file's name in `shaderpacks`: what the pick saves.
     pub file: String,
     /// The pack's own name for Horizon's packs, else `file`.
     pub title: String,
     pub kind: Kind,
+    /// A Horizon pack's `[[options]]`, and the value of each the player set (`values_path`).
+    pub options: Vec<PackOption>,
+    pub values: Vec<f64>,
+    /// Its options page's `[[pages]]`; empty for one page of every option.
+    pub pages: Vec<OptionPage>,
+}
+
+impl Entry {
+    /// Saves the player's option values, for the pack in the folder `dir`.
+    pub fn save_values(&self, dir: &Path) {
+        let path = dir.join(&self.file);
+        if let Err(e) = save_values(&path, &self.options, &self.values) {
+            log::warn!("shader pack options of {}: {e}", self.file);
+        }
+    }
+
+    /// The option `i` one value on (`back`: one before), or at its default (`reset`). Whether
+    /// the pack has that option.
+    pub fn step_option(&mut self, i: usize, back: bool, reset: bool) -> bool {
+        let (Some(o), Some(v)) = (self.options.get(i), self.values.get_mut(i)) else {
+            return false;
+        };
+        *v = if reset {
+            o.kind.default_constant()
+        } else {
+            step_value(&o.kind, *v, back)
+        };
+        true
+    }
+
+    /// Every option back to its default.
+    pub fn reset_options(&mut self) {
+        let defaults = self.options.iter().map(|o| o.kind.default_constant());
+        self.values = defaults.collect();
+    }
 }
 
 /// The packs in `dir`, Horizon's first, each kind by title. A missing folder has none.
@@ -53,11 +90,18 @@ fn entry(path: &Path) -> Option<Entry> {
                 .ok()
                 .map(|p| p.manifest)
         };
-        let title = manifest.map_or_else(|| file.clone(), |m| m.name);
+        let (title, options, pages) = manifest.map_or_else(
+            || (file.clone(), Vec::new(), Vec::new()),
+            |m| (m.name, m.options, m.pages),
+        );
+        let values = load_values(path, &options);
         return Some(Entry {
             file,
             title,
             kind: Kind::Horizon,
+            options,
+            values,
+            pages,
         });
     }
     let zip = path.is_file()
@@ -68,9 +112,128 @@ fn entry(path: &Path) -> Option<Entry> {
         title: file.clone(),
         file,
         kind: Kind::Classic,
+        options: Vec::new(),
+        values: Vec::new(),
+        pages: Vec::new(),
     })
 }
 
+/// Where the option values of the Horizon pack at `pack` are kept: `<pack>.txt` beside it,
+/// one `id=value` a line.
+pub fn values_path(pack: &Path) -> PathBuf {
+    let mut path = pack.as_os_str().to_owned();
+    path.push(".txt");
+    PathBuf::from(path)
+}
+
+/// The value of each of `options` saved for the pack at `pack`, else its default; a value
+/// out of the option's range is brought into it.
+pub fn load_values(pack: &Path, options: &[PackOption]) -> Vec<f64> {
+    let text = std::fs::read_to_string(values_path(pack)).unwrap_or_default();
+    let saved: std::collections::HashMap<&str, f64> = text
+        .lines()
+        .filter_map(|l| l.split_once('='))
+        .filter_map(|(k, v)| Some((k.trim(), v.trim().parse().ok()?)))
+        .collect();
+    options
+        .iter()
+        .map(|o| {
+            saved
+                .get(o.id.as_str())
+                .map_or_else(|| o.kind.default_constant(), |&v| clamp(&o.kind, v))
+        })
+        .collect()
+}
+
+/// Saves `values` of `options`; values at their defaults are left out, and with none left
+/// the file goes.
+fn save_values(pack: &Path, options: &[PackOption], values: &[f64]) -> std::io::Result<()> {
+    let text: String = options
+        .iter()
+        .zip(values)
+        .filter(|(o, v)| o.kind.default_constant() != **v)
+        .map(|(o, v)| format!("{}={v}\n", o.id))
+        .collect();
+    let path = values_path(pack);
+    if text.is_empty() {
+        match std::fs::remove_file(&path) {
+            Err(e) if e.kind() != std::io::ErrorKind::NotFound => Err(e),
+            _ => Ok(()),
+        }
+    } else {
+        std::fs::write(path, text)
+    }
+}
+
+fn clamp(kind: &OptionKind, v: f64) -> f64 {
+    match kind {
+        OptionKind::Bool { .. } => f64::from(u8::from(v != 0.0)),
+        OptionKind::Float { min, max, .. } => v.clamp(f64::from(*min), f64::from(*max)),
+        OptionKind::Int { min, max, .. } => v.round().clamp(f64::from(*min), f64::from(*max)),
+        OptionKind::Choice { values, .. } => v.round().clamp(0.0, values.len() as f64 - 1.0),
+    }
+}
+
+/// The option's next value (`back`: the one before), wrapping around at the ends.
+fn step_value(kind: &OptionKind, v: f64, back: bool) -> f64 {
+    let dir = if back { -1.0 } else { 1.0 };
+    match kind {
+        OptionKind::Bool { .. } => f64::from(u8::from(v == 0.0)),
+        OptionKind::Float { min, max, step, .. } => {
+            let (min, max, step) = (f64::from(*min), f64::from(*max), f64::from(*step));
+            if !back && v >= max - step * 0.01 {
+                min
+            } else if back && v <= min + step * 0.01 {
+                max
+            } else {
+                // On the grid of steps from the minimum, so float error never piles up.
+                let n = ((v - min) / step).round() + dir;
+                (min + n * step).clamp(min, max)
+            }
+        }
+        OptionKind::Int { min, max, .. } => {
+            let (min, max) = (f64::from(*min), f64::from(*max));
+            let n = v.round() + dir;
+            if n > max {
+                min
+            } else if n < min {
+                max
+            } else {
+                n
+            }
+        }
+        OptionKind::Choice { values, .. } => {
+            let n = values.len() as f64;
+            (v.round() + dir).rem_euclid(n)
+        }
+    }
+}
+
+/// The value as the settings page shows it.
+pub fn show_value(kind: &OptionKind, v: f64) -> String {
+    match kind {
+        OptionKind::Bool { .. } => crate::lang::get(if v != 0.0 {
+            "options.on"
+        } else {
+            "options.off"
+        }),
+        OptionKind::Float { step, .. } => {
+            let digits = if *step >= 1.0 {
+                0
+            } else if *step >= 0.1 {
+                1
+            } else {
+                2
+            };
+            format!("{v:.digits$}")
+        }
+        OptionKind::Int { .. } => format!("{v:.0}"),
+        OptionKind::Choice { values, .. } => {
+            values.get(v.round() as usize).cloned().unwrap_or_default()
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -106,4 +269,59 @@ mod tests {
         assert!(scan(&d.join("missing")).is_empty());
         std::fs::remove_dir_all(d).unwrap();
     }
+
+    fn option(id: &str, kind: OptionKind) -> PackOption {
+        PackOption {
+            id: id.into(),
+            name: id.into(),
+            description: String::new(),
+            kind,
+        }
+    }
+
+    #[test]
+    fn values_step_wrap_and_round_trip() {
+        let float = OptionKind::Float {
+            default: 1.0,
+            min: 0.0,
+            max: 2.0,
+            step: 0.5,
+        };
+        assert_eq!(step_value(&float, 1.0, false), 1.5);
+        assert_eq!(step_value(&float, 2.0, false), 0.0);
+        assert_eq!(step_value(&float, 0.0, true), 2.0);
+        assert_eq!(show_value(&float, 1.5), "1.5");
+        let choice = OptionKind::Choice {
+            values: vec!["a".into(), "b".into(), "c".into()],
+            default: 0,
+        };
+        assert_eq!(step_value(&choice, 2.0, false), 0.0);
+        assert_eq!(step_value(&choice, 0.0, true), 2.0);
+        assert_eq!(show_value(&choice, 1.0), "b");
+        let int = OptionKind::Int {
+            default: 0,
+            min: -1,
+            max: 1,
+        };
+        assert_eq!(step_value(&int, 1.0, false), -1.0);
+        let on = OptionKind::Bool { default: true };
+        assert_eq!(step_value(&on, 1.0, false), 0.0);
+
+        let dir =
+            std::env::temp_dir().join(format!("horizon-shader-values-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let pack = dir.join("p.hshader");
+        let options = [option("a", float), option("b", choice)];
+        // Only what differs from the defaults is written; out of range comes back clamped.
+        save_values(&pack, &options, &[1.0, 2.0]).unwrap();
+        let text = std::fs::read_to_string(values_path(&pack)).unwrap();
+        assert_eq!(text, "b=2\n");
+        std::fs::write(values_path(&pack), "a=9\nb=1\nzzz=4\n").unwrap();
+        assert_eq!(load_values(&pack, &options), [2.0, 1.0]);
+        save_values(&pack, &options, &[1.0, 0.0]).unwrap();
+        assert!(!values_path(&pack).exists());
+        assert_eq!(load_values(&pack, &options), [1.0, 0.0]);
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
 }

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

@@ -158,6 +158,12 @@ pub fn profile_skin_url_nbt(profile: &horizon_world::nbt::Tag) -> Option<String>
     unpack(&value, Signature::Unsigned, &TEXTURE_URIS).skin
 }
 
+/// `ResolvableProfile.skinPatch().body()` of a skull's `profile` NBT: the
+/// `texture` id that replaces its skin.
+pub fn profile_texture_nbt(profile: &horizon_world::nbt::Tag) -> Option<String> {
+    nbt_text(profile.get("texture"))
+}
+
 /// The profile's uuid as u128: `id` as an int array (block entity NBT) or a
 /// uuid string (older and component forms). Used for `DefaultPlayerSkin.get`
 /// when a head's skin is not downloaded yet.
@@ -467,6 +473,11 @@ pub fn head_skin(
     downloads: &mut Downloader,
     atlas: impl Fn(&str) -> bool,
 ) -> String {
+    if let Some(texture) = profile.get("texture").and_then(|t| t.as_str())
+        && let Some(sprite) = patch_skin(texture, downloads, &atlas)
+    {
+        return sprite;
+    }
     let p = parse_profile(profile);
     let property = p.textures.or_else(|| {
         let key = p.dynamic.as_ref()?;
@@ -495,6 +506,68 @@ pub fn head_skin(
     crate::tab_list::default_skin(p.id).to_owned()
 }
 
+/// `PlayerSkin.Patch.apply` for a head: the sprite of a profile's `texture`
+/// override (`ClientAsset.ResourceTexture`, a resource pack's
+/// `<namespace>:textures/<path>.png`), which replaces the downloaded or
+/// default skin. Vanilla textures are in the atlas already; another
+/// namespace's loads into a skin slot, and `None` answers until it is there
+/// (or when the packs lack it).
+pub fn patch_skin(
+    texture: &str,
+    downloads: &mut Downloader,
+    atlas: impl Fn(&str) -> bool,
+) -> Option<String> {
+    let (namespace, path) = texture.split_once(':').unwrap_or(("minecraft", texture));
+    if !valid_texture_id(namespace, path) {
+        return None;
+    }
+    if namespace == "minecraft" && atlas(path) {
+        return Some(path.to_owned());
+    }
+    let location = format!("patch/{namespace}/{path}");
+    if atlas(&location) {
+        downloads.drawn(&location);
+        return Some(location);
+    }
+    downloads.resource(&location, namespace, path);
+    None
+}
+
+/// `Identifier`'s characters (`isValidNamespace`, `isValidPath`), and no
+/// `.`, `..` or empty segment (`FileUtil.decomposePath`, as the packs read
+/// it): a server's `texture` never names a file outside the packs.
+fn valid_texture_id(namespace: &str, path: &str) -> bool {
+    let segment = |s: &str| !s.is_empty() && s != "." && s != "..";
+    !namespace.is_empty()
+        && namespace
+            .chars()
+            .all(|c| matches!(c, 'a'..='z' | '0'..='9' | '_' | '-' | '.'))
+        && path
+            .chars()
+            .all(|c| matches!(c, 'a'..='z' | '0'..='9' | '_' | '-' | '.' | '/'))
+        && segment(namespace)
+        && path.split('/').all(segment)
+}
+
+/// A `width`x`height` RGBA image as the 64x64 skin it maps onto: each texel
+/// the nearest of the image's at the same normalised UV.
+fn resample_64(width: u32, height: u32, rgba: &[u8]) -> Option<Vec<u8>> {
+    let (w, h) = (width as usize, height as usize);
+    if w == 0 || h == 0 || rgba.len() < w * h * 4 {
+        return None;
+    }
+    let mut out = vec![0u8; 64 * 64 * 4];
+    for y in 0..64 {
+        for x in 0..64 {
+            let (sx, sy) = (x * w / 64, y * h / 64);
+            let s = (sy * w + sx) * 4;
+            let d = (y * 64 + x) * 4;
+            out[d..d + 4].copy_from_slice(&rgba[s..s + 4]);
+        }
+    }
+    Some(out)
+}
+
 /// `MinecraftProfileTexture.getHash`: the base name of the URL's path.
 pub fn texture_hash(url: &str) -> Option<String> {
     let rest = url.split_once("://")?.1;
@@ -732,6 +805,10 @@ pub struct Downloader {
     image_order: std::collections::VecDeque<String>,
     /// Skins and capes drawn from the atlas since `take_drawn`.
     drawn: std::collections::HashSet<String>,
+    /// The resource packs' root, where a profile's `texture` patch is read.
+    resource_root: std::path::PathBuf,
+    /// How each `patch/` texture of the resource packs loaded, by location.
+    resources: std::collections::HashMap<String, Download>,
 }
 /// `images` is bounded only so a long session on a busy server does not grow
 /// without end; the disk cache holds everything it drops.
@@ -749,8 +826,48 @@ impl Downloader {
             images: Default::default(),
             image_order: Default::default(),
             drawn: Default::default(),
+            resource_root: Default::default(),
+            resources: Default::default(),
         }
     }
+    /// The resource packs changed (or were first loaded) at `root`: patch
+    /// textures load again from there.
+    pub fn set_resource_root(&mut self, root: std::path::PathBuf) {
+        for location in std::mem::take(&mut self.resources).into_keys() {
+            self.images.remove(&location);
+            self.image_order.retain(|l| *l != location);
+        }
+        self.resource_root = root;
+    }
+    /// `ClientAsset.ResourceTexture`: loads `<namespace>:textures/<path>.png`
+    /// from the resource packs into a skin slot as `location`, once. A
+    /// texture of another size is sampled as the model's normalised UVs would
+    /// sample it (nearest texel) into the 64x64 slot.
+    fn resource(&mut self, location: &str, namespace: &str, path: &str) {
+        match self.resources.get(location) {
+            Some(Download::Failed) => return,
+            Some(_) => {
+                self.again(location);
+                return;
+            }
+            None => {}
+        }
+        let file = self
+            .resource_root
+            .join(format!("assets/{namespace}/textures/{path}.png"));
+        let image = std::fs::read(file)
+            .ok()
+            .and_then(|b| crate::hud::decode_bytes(&b).ok())
+            .and_then(|(w, h, rgba)| resample_64(w, h, &rgba));
+        let state = match image {
+            Some(rgba) => {
+                self.queue(location.to_owned(), rgba);
+                Download::Ready
+            }
+            None => Download::Failed,
+        };
+        self.resources.insert(location.to_owned(), state);
+    }
     /// How the download of `url` stands, starting it the first time.
     pub fn state(&mut self, kind: Kind, url: &str) -> Download {
         while let Ok((key, image)) = self.done.try_recv() {
@@ -824,6 +941,15 @@ impl Downloader {
         if self.queued.contains(location) {
             return true;
         }
+        if location.starts_with("patch/") {
+            let Some(image) = self.images.get(location).cloned() else {
+                // Dropped from memory: read from the packs again.
+                self.resources.remove(location);
+                return false;
+            };
+            self.queue(location.to_owned(), image);
+            return true;
+        }
         let (digest, process): (_, fn(u32, u32, &[u8]) -> Option<Vec<u8>>) =
             if let Some(digest) = location.strip_prefix("skins/") {
                 (digest, process_legacy_skin)
@@ -960,6 +1086,21 @@ pub fn sha1(data: &[u8]) -> [u8; 20] {
 
 #[cfg(test)]
 mod tests {
+    /// A profile's `texture` names a pack texture, never a file outside the
+    /// packs: bad characters and `..` segments draw nothing.
+    #[test]
+    fn a_texture_patch_stays_inside_the_packs() {
+        use super::valid_texture_id;
+        assert!(valid_texture_id("ethereal", "entity/plush_blank"));
+        assert!(valid_texture_id("minecraft", "entity/player/wide/steve"));
+        assert!(!valid_texture_id("ethereal", "../../../secret"));
+        assert!(!valid_texture_id("..", "entity/x"));
+        assert!(!valid_texture_id("ethereal", "entity//x"));
+        assert!(!valid_texture_id("Ethereal", "entity/x"));
+        assert!(!valid_texture_id("ethereal", "entity\\x"));
+        assert!(!valid_texture_id("", "entity/x"));
+    }
+
     /// A pack reload swaps the atlas: its skin slots are blank, so a forgotten
     /// table holds nothing and hands out slots from the start again, even for
     /// skins drawn in the last frame.

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

@@ -25,6 +25,9 @@ pub const UI: usize = 10;
 /// sources: `clamp((int) sqrt(255), 2, 8)` streaming, the rest static.
 pub const STATIC_CHANNELS: usize = 247;
 pub const STREAMING_CHANNELS: usize = 8;
+/// Static channels only sounds played to the listener (no position) may take
+/// while the `uiSoundReserve` extra is on.
+pub const HEARD_RESERVE: usize = 16;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum PlayResult {
@@ -65,6 +68,9 @@ pub enum Ticking {
     /// `RidingEntitySoundInstance` for the player riding a happy ghast
     /// (`underwater_sound` false) or a nautilus (true).
     RidingEntity { entity: u32, underwater_sound: bool },
+    /// A native mod's music layer (`MusicLayers`), whose volume its owner
+    /// sets each tick.
+    MusicLayer,
 }
 /// What a minecart's sound instances read about it.
 #[derive(Clone, Copy, Debug)]
@@ -230,6 +236,25 @@ impl SoundInstance {
             true,
         )
     }
+    /// A native mod's music layer: a looping, unattenuated track on the music
+    /// source that starts silent (`MusicLayers` fades it in).
+    pub fn for_music_layer(id: &str, random: LegacyRandom) -> Self {
+        let mut s = Self::new(
+            id,
+            MUSIC,
+            0.0,
+            1.0,
+            random,
+            true,
+            0,
+            Attenuation::None,
+            [0.0; 3],
+            true,
+        );
+        s.can_start_silent = true;
+        s.ticking = Ticking::MusicLayer;
+        s
+    }
     /// `SimpleSoundInstance.forJukeboxSong`.
     pub fn for_jukebox_song(id: &str, at: [f64; 3], random: LegacyRandom) -> Self {
         Self::new(
@@ -519,7 +544,7 @@ impl SoundInstance {
     /// `TickableSoundInstance.tick`.
     pub fn tick(&mut self, ctx: &TickContext) {
         match &mut self.ticking {
-            Ticking::No => {}
+            Ticking::No | Ticking::MusicLayer => {}
             Ticking::BiomeLoop { fade, direction } => {
                 let stop = *fade < 0;
                 *fade += *direction;
@@ -792,6 +817,9 @@ pub struct SoundEngine {
     pub source_volumes: [f32; 11],
     /// A `SoundEventListener` is registered.
     pub listening: bool,
+    /// Static channels positional sounds leave free for the ones played to the
+    /// listener: 0 as vanilla, `HEARD_RESERVE` with the `uiSoundReserve` extra.
+    pub listener_reserve: usize,
     pub notifications: Vec<Notification>,
 }
 fn handle_channel(h: &Handle) -> Option<ChannelId> {
@@ -819,6 +847,7 @@ impl SoundEngine {
             limits: [STATIC_CHANNELS, STREAMING_CHANNELS],
             source_volumes: [1.0; 11],
             listening: false,
+            listener_reserve: 0,
             notifications: Vec::new(),
         }
     }
@@ -1100,7 +1129,15 @@ impl SoundEngine {
         let looping = instance.looping && instance.delay <= 0;
         let streaming = sound.stream;
         let pool = usize::from(streaming);
-        let channel = if self.used[pool] >= self.limits[pool] {
+        // With the `uiSoundReserve` extra, sounds out in the world leave a few static channels free, so a flood of
+        // them (a crater's worth of blocks breaking) can't stop the ones played to the listener.
+        let positional = !instance.relative && instance.attenuation != Attenuation::None;
+        let reserved = if positional && !streaming {
+            self.listener_reserve
+        } else {
+            0
+        };
+        let channel = if self.used[pool] + reserved >= self.limits[pool] {
             None
         } else {
             backend.create(streaming)
@@ -1549,4 +1586,47 @@ mod tests {
         assert_eq!(s.volume, 0.0);
         assert!(!s.stopped);
     }
+    #[test]
+    fn world_sounds_leave_channels_for_the_listener_only_with_the_extra() {
+        use test_backend::Null;
+        let mut registry = SoundRegistry::default();
+        registry.add_file(
+            "minecraft",
+            br#"{"block.stone.break": {"sounds": ["dig/stone1"]},
+                 "ui.button.click": {"sounds": ["random/click"]}}"#,
+            &|_, _| true,
+        );
+        let random = || LegacyRandom::new(0);
+        let block = |i: usize| {
+            let at = [i as f64, 64.0, 0.0];
+            let source = crate::settings::sound_source("minecraft:block.stone.break");
+            SoundInstance::at(
+                "minecraft:block.stone.break",
+                source,
+                1.0,
+                1.0,
+                random(),
+                at,
+            )
+        };
+        let click = || SoundInstance::for_ui("minecraft:ui.button.click", 1.0, 0.25, random());
+        for reserve in [0, HEARD_RESERVE] {
+            let mut engine = SoundEngine::new(registry.clone());
+            engine.listener_reserve = reserve;
+            let mut backend = Null::default();
+            // Positional sounds take the static channels the reserve leaves; then their plays fail.
+            let started = (0..STATIC_CHANNELS)
+                .filter(|&i| {
+                    engine.play_new(block(i), false, &mut backend).1 == PlayResult::Started
+                })
+                .count();
+            assert_eq!(started, STATIC_CHANNELS - reserve);
+            let heard = engine.play_new(click(), false, &mut backend).1;
+            assert_eq!(
+                heard == PlayResult::Started,
+                reserve > 0,
+                "reserve {reserve}"
+            );
+        }
+    }
 }

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

@@ -25,6 +25,30 @@ const ROWS: [&[u32]; MAX_PLAYERS - 4] = [
     &[4, 4, 4, 4],
 ];
 
+/// Where a window is.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Placement {
+    /// A normal window: its corner on the desktop and its size in pixels (`None`: a new one,
+    /// where the system opens it).
+    Free(Option<([i32; 2], [u32; 2])>),
+    /// Borderless over the monitor of this name.
+    Fill(String),
+}
+
+/// How far window `number` opens right and down of the centre, in logical pixels: Window 2
+/// centred, each next one a step further, as systems cascade new windows (back to the centre
+/// after six), so new windows never open exactly on one another.
+pub fn cascade(number: u8) -> f64 {
+    f64::from(number.saturating_sub(2) % 6) * 32.0
+}
+
+/// A window: its number (1 is the game's own) and where it is.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Window {
+    pub number: u8,
+    pub placement: Placement,
+}
+
 /// `order` made a whole order of `n` players: those it names (once, if there are), then the
 /// others, P1 first.
 pub fn ordered(order: &[usize], n: usize) -> Vec<usize> {

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

@@ -85,18 +85,93 @@ pub struct Sprites {
     /// Each layer's frames at the texture's own resolution (square), and the
     /// frame shown first.
     native: Vec<(u32, Arc<Vec<Vec<u8>>>, usize)>,
-    /// Still textures by their pixels and mip settings: mods copy vanilla's
-    /// textures under their own names, and one layer serves them all (the
-    /// GPU's array may hold as few as 2048).
-    still: std::collections::HashMap<(Vec<u8>, u32, [u32; 2], [bool; 4]), u32>,
+    /// Each layer's LabPBR maps (`_n` normals, `_s` specular) beside its texture: their first
+    /// frame at their own resolution (square).
+    pbr: Vec<[Option<(u32, Vec<u8>)>; 2]>,
+    /// The layers' normal and specular maps at `pbr_size`, layer after layer, set by
+    /// [`Sprites::finish`]: empty when no texture has either.
+    pub normals: Vec<u8>,
+    pub specular: Vec<u8>,
+    pub pbr_size: u32,
+    /// Still textures by their pixels, their LabPBR maps and mip settings: mods copy vanilla's
+    /// textures under their own names, and one layer serves them all (the GPU's array may
+    /// hold as few as 2048).
+    still: std::collections::HashMap<(Vec<u8>, u64, u32, [u32; 2], [bool; 4]), u32>,
     /// Decoded textures kept on disk between launches ([`Sprites::with_disk_cache`]).
     disk: Option<crate::sprite_cache::SpriteCache>,
 }
 /// Edge length of vanilla's block textures: the smallest array layer.
 pub const SPRITE_SIZE: u32 = 16;
-/// Largest sprite array (all layers of the top mip level): resource packs
-/// with bigger textures are sampled down to fit.
-const MAX_ARRAY_BYTES: u64 = 256 << 20;
+/// The largest sprite array (all layers of the top mip level) when the settings leave it to
+/// Horizon: resource packs with bigger textures are sampled down to fit.
+pub const DEFAULT_TEXTURE_BUDGET: u64 = 256 << 20;
+/// The budget in bytes the next resource load keeps to (`set_texture_budget`).
+static TEXTURE_BUDGET: std::sync::atomic::AtomicU64 =
+    std::sync::atomic::AtomicU64::new(DEFAULT_TEXTURE_BUDGET);
+/// The block textures' budget from the `textureBudgetMiB` setting (0 for the default), for
+/// resources loaded from now on.
+pub fn set_texture_budget(mib: u32) {
+    let bytes = match mib {
+        0 => DEFAULT_TEXTURE_BUDGET,
+        mib => u64::from(mib) << 20,
+    };
+    TEXTURE_BUDGET.store(bytes, std::sync::atomic::Ordering::Relaxed);
+}
+/// Whether resource loads read the resource packs' LabPBR maps (`set_labpbr_maps`).
+static LABPBR_MAPS: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+/// Whether resource loads from now on read the resource packs' LabPBR maps beside their block
+/// textures. Only a native shader pack's material stage reads them, so without one they cost
+/// neither loading time nor video memory.
+pub fn set_labpbr_maps(on: bool) {
+    LABPBR_MAPS.store(on, std::sync::atomic::Ordering::Relaxed);
+}
+/// Whether resource loads read the LabPBR maps (`set_labpbr_maps`).
+pub fn labpbr_maps() -> bool {
+    LABPBR_MAPS.load(std::sync::atomic::Ordering::Relaxed)
+}
+/// Largest array of each LabPBR map, which only a native shader pack reads.
+const MAX_MAP_BYTES: u64 = DEFAULT_TEXTURE_BUDGET / 4;
+/// Fewer layers than any game has (vanilla's are about 1300): what a map is kept at while
+/// loading assumes at least these many share the array.
+const LAYERS_AT_LEAST: u64 = 1024;
+/// A layer's normal map where its texture has none: flat, unoccluded, at full height.
+pub const FLAT_NORMAL: [u8; 4] = [128, 128, 255, 255];
+/// A layer's specular map where its texture has none: rough, not metal, not glowing.
+pub const NO_SPECULAR: [u8; 4] = [0, 0, 0, 0];
+/// The largest power-of-two side from `start` down (at least `SPRITE_SIZE`) at which `layers`
+/// square RGBA layers take at most `bytes`.
+fn side_within(start: u32, layers: u64, bytes: u64) -> u32 {
+    let mut size = start.max(SPRITE_SIZE).next_power_of_two();
+    while size > SPRITE_SIZE && layers * u64::from(size) * u64::from(size) * 4 > bytes {
+        size /= 2;
+    }
+    size
+}
+/// A LabPBR map's square `frame` of `side` averaged down by whole powers of two to at most
+/// `max`, channel by channel: they are data, not colour.
+fn shrink_map(frame: Vec<u8>, side: u32, max: u32) -> (u32, Vec<u8>) {
+    if side <= max || !side.is_power_of_two() || !max.is_power_of_two() {
+        return (side, frame);
+    }
+    let (out_side, f, side) = (max as usize, (side / max) as usize, side as usize);
+    let mut out = Vec::with_capacity(out_side * out_side * 4);
+    for y in 0..out_side {
+        for x in 0..out_side {
+            let mut sum = [0u32; 4];
+            for dy in 0..f {
+                let row = ((y * f + dy) * side + x * f) * 4;
+                for texel in frame[row..row + f * 4].as_chunks::<4>().0 {
+                    for (s, &v) in sum.iter_mut().zip(texel) {
+                        *s += u32::from(v);
+                    }
+                }
+            }
+            let n = (f * f) as u32;
+            out.extend(sum.map(|s| ((s + n / 2) / n) as u8));
+        }
+    }
+    (max, out)
+}
 /// Nearest-resample a square RGBA frame to another square size.
 pub(crate) fn resample(frame: &[u8], from: u32, to: u32) -> Vec<u8> {
     if from == to {
@@ -156,7 +231,7 @@ impl Sprites {
     }
     /// Lay every layer out at one size: the largest texture's (resource packs
     /// may ship 32x, 64x... textures, like vanilla's stitched atlas), rounded
-    /// up to a power of two and limited to [`MAX_ARRAY_BYTES`]. Smaller
+    /// up to a power of two and limited to the texture budget (`set_texture_budget`). Smaller
     /// textures are scaled up by whole pixels, so UVs stay per layer.
     pub fn finish(&mut self) {
         self.lay_out(true);
@@ -170,13 +245,18 @@ impl Sprites {
         let layers = self.native.len().max(1) as u64;
         let largest = self.native.iter().map(|n| n.0).max().unwrap_or(SPRITE_SIZE);
         self.minimum_size = self.native.iter().map(|n| n.0).min().unwrap_or(SPRITE_SIZE);
-        let mut size = largest.max(SPRITE_SIZE).next_power_of_two();
-        while size > SPRITE_SIZE && layers * u64::from(size * size) * 4 > MAX_ARRAY_BYTES {
-            size /= 2;
+        let budget = TEXTURE_BUDGET.load(std::sync::atomic::Ordering::Relaxed);
+        let size = side_within(largest, layers, budget);
+        if pixels {
+            log::info!(
+                "Horizon: block sprites: {layers} layers at {size} px (largest {largest} px, budget {} MiB)",
+                budget >> 20
+            );
         }
         if !pixels {
             self.pixels = Vec::new();
             self.animations = Vec::new();
+            self.pbr = Vec::new();
             self.size = size;
             return;
         }
@@ -192,6 +272,30 @@ impl Sprites {
             animation.frames = resized[animation.layer as usize].clone();
         }
         self.size = size;
+        self.normals.clear();
+        self.specular.clear();
+        let largest_map = self.pbr.iter().flatten().flatten().map(|m| m.0).max();
+        self.pbr_size = largest_map.map_or(SPRITE_SIZE, |l| {
+            side_within(l.min(size), layers, MAX_MAP_BYTES)
+        });
+        if largest_map.is_some() {
+            let pbr_size = self.pbr_size;
+            log::info!("Horizon: LabPBR maps at {pbr_size} px, {layers} layers");
+            for maps in std::mem::take(&mut self.pbr) {
+                for (map, (out, none)) in maps.into_iter().zip([
+                    (&mut self.normals, FLAT_NORMAL),
+                    (&mut self.specular, NO_SPECULAR),
+                ]) {
+                    match map {
+                        Some((from, pixels)) => {
+                            let (from, pixels) = shrink_map(pixels, from, pbr_size);
+                            out.extend(resample(&pixels, from, pbr_size));
+                        }
+                        None => out.extend(none.repeat((pbr_size * pbr_size) as usize)),
+                    }
+                }
+            }
+        }
     }
     /// The layer of a texture, added on first use. A texture that is missing
     /// or does not load (a resource pack's filter or a broken file) becomes
@@ -222,6 +326,7 @@ impl Sprites {
                     .collect();
                 let layer = u32::try_from(self.native.len())?;
                 self.opaque.push(true);
+                self.pbr.push([None, None]);
                 self.translucent.push(false);
                 self.mips.push(crate::mipmap::Settings::default());
                 self.layers.insert(name.to_owned(), layer);
@@ -242,12 +347,28 @@ impl Sprites {
                 decoded
             }
         };
-        self.register(name, decoded)
+        self.register(root, name, decoded)
+    }
+    /// The layer of a texture outside `textures/` (an OptiFine pack's connected-texture tile),
+    /// named by its resource path and added on first use. Unlike [`Sprites::insert`], a texture
+    /// that does not load is an error: the caller drops what needed it. Such files bypass the
+    /// disk cache, whose fingerprint covers only `textures/`.
+    pub fn insert_file(&mut self, root: &Path, resource: &str) -> Result<u32> {
+        if let Some(layer) = self.layers.get(resource) {
+            return Ok(*layer);
+        }
+        let decoded = Self::decode_file(&root.join(resource), resource)?;
+        self.register(root, resource, decoded)
     }
     /// Read and decode one texture and its `.mcmeta`.
     fn decode(root: &Path, name: &str) -> Result<crate::sprite_cache::Decoded> {
         let (namespace, path) = name.split_once(':').ok_or("invalid sprite identifier")?;
-        let path = root.join(format!("assets/{namespace}/textures/{path}.png"));
+        Self::decode_file(
+            &root.join(format!("assets/{namespace}/textures/{path}.png")),
+            name,
+        )
+    }
+    fn decode_file(path: &Path, name: &str) -> Result<crate::sprite_cache::Decoded> {
         let metadata = match fs::read_to_string(path.with_extension("png.mcmeta")) {
             Ok(text) => Some(serde_json::from_str::<
                 BTreeMap<String, Box<serde_json::value::RawValue>>,
@@ -263,40 +384,19 @@ impl Sprites {
             .as_deref()
             .map(AnimationMetadata::from_json)
             .transpose()?;
-        let mut decoder = png::Decoder::new(BufReader::new(File::open(path)?));
-        decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
-        let mut reader = decoder.read_info()?;
-        let mut bytes = vec![
-            0;
-            reader
-                .output_buffer_size()
-                .ok_or("sprite exceeds decoder limits")?
-        ];
-        let info = reader.next_frame(&mut bytes)?;
+        let (png_width, png_height, pixels) = read_rgba(path)?;
         let (width, height) = if let Some(animation) = &animation {
             let [width, height] =
-                animation.frame_size(i32::try_from(info.width)?, i32::try_from(info.height)?);
+                animation.frame_size(i32::try_from(png_width)?, i32::try_from(png_height)?);
             (u32::try_from(width)?, u32::try_from(height)?)
         } else {
-            (info.width, info.height)
+            (png_width, png_height)
         };
-        if width == 0 || height == 0 || info.width % width != 0 || info.height % height != 0 {
+        if width == 0 || height == 0 || png_width % width != 0 || png_height % height != 0 {
             return Err(format!("sprite {name} has invalid frame dimensions").into());
         }
-        let channels = info.color_type.samples();
-        let mut pixels = Vec::with_capacity(info.width as usize * info.height as usize * 4);
-        for pixel in bytes[..info.buffer_size()].chunks_exact(channels) {
-            let rgba = match info.color_type {
-                png::ColorType::Rgba => [pixel[0], pixel[1], pixel[2], pixel[3]],
-                png::ColorType::Rgb => [pixel[0], pixel[1], pixel[2], 255],
-                png::ColorType::Grayscale => [pixel[0], pixel[0], pixel[0], 255],
-                png::ColorType::GrayscaleAlpha => [pixel[0], pixel[0], pixel[0], pixel[1]],
-                _ => return Err("unsupported expanded sprite format".into()),
-            };
-            pixels.extend(rgba);
-        }
-        let columns = info.width / width;
-        let count = columns * (info.height / height);
+        let columns = png_width / width;
+        let count = columns * (png_height / height);
         // Layers are square; a frame of another shape is nearest-resampled to
         // its longer side so UVs (normalized per layer) are unchanged.
         let side = width.max(height);
@@ -309,7 +409,7 @@ impl Sprites {
                 let source_row = y + row * height / side;
                 for column in 0..side {
                     let offset =
-                        ((source_row * info.width + x + column * width / side) * 4) as usize;
+                        ((source_row * png_width + x + column * width / side) * 4) as usize;
                     frame.extend_from_slice(&pixels[offset..offset + 4]);
                 }
             }
@@ -339,7 +439,12 @@ impl Sprites {
         })
     }
     /// Give a decoded texture its layer (or the one an identical still has).
-    fn register(&mut self, name: &str, decoded: crate::sprite_cache::Decoded) -> Result<u32> {
+    fn register(
+        &mut self,
+        root: &Path,
+        name: &str,
+        decoded: crate::sprite_cache::Decoded,
+    ) -> Result<u32> {
         let crate::sprite_cache::Decoded {
             side,
             frames,
@@ -356,6 +461,13 @@ impl Sprites {
             .transpose()?;
         let count = frames.len() as u32;
         let layer = u32::try_from(self.native.len())?;
+        let pbr = match name.split_once(':') {
+            Some((namespace, path)) if labpbr_maps() => {
+                let path = root.join(format!("assets/{namespace}/textures/{path}.png"));
+                ["_n", "_s"].map(|suffix| pbr_map(&path, suffix, count))
+            }
+            _ => [None, None],
+        };
         let settings = crate::mipmap::Settings {
             native_size: side,
             strategy,
@@ -364,10 +476,15 @@ impl Sprites {
             item: name
                 .split_once(':')
                 .is_some_and(|(_, p)| p.starts_with("item/")),
+            dither_cutouts: crate::mipmap::dither_cutouts(),
         };
         let still = (animation.is_none() && frames.len() == 1).then(|| {
+            use std::hash::{Hash, Hasher};
+            let mut maps = std::collections::hash_map::DefaultHasher::new();
+            pbr.hash(&mut maps);
             (
                 frames[0].clone(),
+                maps.finish(),
                 side,
                 [
                     settings.strategy as u32,
@@ -401,12 +518,66 @@ impl Sprites {
         self.mips.push(settings);
         self.opaque.push(opaque);
         self.translucent.push(translucent);
+        self.pbr.push(pbr);
         self.layers.insert(name.to_owned(), layer);
         self.native.push((side, frames, initial));
         Ok(layer)
     }
 }
 
+/// A PNG's width, height and pixels as RGBA.
+fn read_rgba(path: &Path) -> Result<(u32, u32, Vec<u8>)> {
+    let mut decoder = png::Decoder::new(BufReader::new(File::open(path)?));
+    decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
+    let mut reader = decoder.read_info()?;
+    let mut bytes = vec![
+        0;
+        reader
+            .output_buffer_size()
+            .ok_or("sprite exceeds decoder limits")?
+    ];
+    let info = reader.next_frame(&mut bytes)?;
+    let channels = info.color_type.samples();
+    let mut pixels = Vec::with_capacity(info.width as usize * info.height as usize * 4);
+    for pixel in bytes[..info.buffer_size()].chunks_exact(channels) {
+        let rgba = match info.color_type {
+            png::ColorType::Rgba => [pixel[0], pixel[1], pixel[2], pixel[3]],
+            png::ColorType::Rgb => [pixel[0], pixel[1], pixel[2], 255],
+            png::ColorType::Grayscale => [pixel[0], pixel[0], pixel[0], 255],
+            png::ColorType::GrayscaleAlpha => [pixel[0], pixel[0], pixel[0], pixel[1]],
+            _ => return Err("unsupported expanded sprite format".into()),
+        };
+        pixels.extend(rgba);
+    }
+    Ok((info.width, info.height, pixels))
+}
+
+/// The LabPBR map with `suffix` beside the texture at `path`, whose frames lie in a column of
+/// `count`: its first frame, square, no larger than the maps' array allows any game's
+/// textures (a 512x pack's maps would otherwise fill the memory while loading).
+fn pbr_map(path: &Path, suffix: &str, count: u32) -> Option<(u32, Vec<u8>)> {
+    let stem = path.file_stem()?.to_str()?;
+    let map = path.with_file_name(format!("{stem}{suffix}.png"));
+    let (map_width, map_height, pixels) = read_rgba(&map).ok()?;
+    let (w, h) = (map_width, map_height / count.max(1));
+    if w == 0 || h == 0 {
+        return None;
+    }
+    let side = w.max(h);
+    let mut frame = Vec::with_capacity((side * side * 4) as usize);
+    for row in 0..side {
+        for column in 0..side {
+            let offset = (((row * h / side) * map_width + column * w / side) * 4) as usize;
+            frame.extend_from_slice(&pixels[offset..offset + 4]);
+        }
+    }
+    Some(shrink_map(
+        frame,
+        side,
+        side_within(side, LAYERS_AT_LEAST, MAX_MAP_BYTES),
+    ))
+}
+
 /// SpriteContents: the `.mcmeta` `texture` section (TextureMetadataSection's
 /// mipmap strategy and alpha cutoff bias).
 fn texture_section(
@@ -452,6 +623,54 @@ pub(crate) fn sprite_mipmap_limit(requested: u32, size: u32, minimum: u32, avail
 mod tests {
     use super::*;
     #[test]
+    fn the_texture_budget_picks_the_largest_side_that_fits() {
+        // 1300 layers: vanilla's count, about.
+        assert_eq!(side_within(512, 1300, DEFAULT_TEXTURE_BUDGET), 128);
+        assert_eq!(side_within(512, 1300, 1536 << 20), 512);
+        assert_eq!(side_within(64, 1300, 1536 << 20), 64);
+        // Never under vanilla's size, whatever the budget.
+        assert_eq!(side_within(512, 1300, 1), SPRITE_SIZE);
+    }
+    #[test]
+    fn a_labpbr_map_shrinks_by_plain_means_and_a_layer_without_one_gets_the_default() {
+        // Alpha is data here: it does not weigh the other channels.
+        let frame = [
+            [200, 100, 0, 255],
+            [0, 0, 0, 0],
+            [200, 100, 0, 255],
+            [0, 0, 0, 0],
+        ]
+        .concat();
+        assert_eq!(shrink_map(frame, 2, 1), (1, vec![100, 50, 0, 128]));
+        let mut sprites = Sprites {
+            native: vec![
+                (SPRITE_SIZE, Arc::new(vec![vec![0; 16 * 16 * 4]]), 0),
+                (SPRITE_SIZE, Arc::new(vec![vec![0; 16 * 16 * 4]]), 0),
+            ],
+            pbr: vec![
+                [Some((16, [9, 8, 7, 6].repeat(16 * 16))), None],
+                [None, None],
+            ],
+            ..Default::default()
+        };
+        sprites.finish();
+        assert_eq!(sprites.pbr_size, 16);
+        assert_eq!(sprites.normals[..4], [9, 8, 7, 6]);
+        assert_eq!(sprites.normals[16 * 16 * 4..][..4], FLAT_NORMAL);
+        assert_eq!(sprites.specular[..4], NO_SPECULAR);
+        assert_eq!(sprites.specular.len(), 2 * 16 * 16 * 4);
+    }
+    #[test]
+    fn textures_without_labpbr_maps_keep_none() {
+        let mut sprites = Sprites {
+            native: vec![(SPRITE_SIZE, Arc::new(vec![vec![0; 16 * 16 * 4]]), 0)],
+            pbr: vec![[None, None]],
+            ..Default::default()
+        };
+        sprites.finish();
+        assert!(sprites.normals.is_empty() && sprites.specular.is_empty());
+    }
+    #[test]
     fn mipmap_option_keeps_real_16px_reductions() {
         for levels in 0..=4 {
             assert_eq!(sprite_mipmap_limit(levels, 32, 16, 6), levels + 1);
@@ -459,6 +678,33 @@ mod tests {
         }
     }
     #[test]
+    fn files_outside_textures_load_by_path() {
+        let root = std::env::temp_dir().join(format!("horizon-sprite-file-{}", std::process::id()));
+        let tile = "assets/minecraft/optifine/ctm/glass/0.png";
+        fs::create_dir_all(root.join(tile).parent().unwrap()).unwrap();
+        let mut encoder = png::Encoder::new(File::create(root.join(tile)).unwrap(), 16, 16);
+        encoder.set_color(png::ColorType::Rgba);
+        encoder.set_depth(png::BitDepth::Eight);
+        let pixels: Vec<u8> = (0..256).flat_map(|i| [i as u8, 0, 0, 128]).collect();
+        encoder
+            .write_header()
+            .unwrap()
+            .write_image_data(&pixels)
+            .unwrap();
+        let mut sprites = Sprites::default();
+        let layer = sprites.insert_file(&root, tile).unwrap();
+        assert_eq!(sprites.insert_file(&root, tile).unwrap(), layer);
+        assert!(sprites.translucent[layer as usize]);
+        // A missing tile is an error, not the missing texture.
+        assert!(
+            sprites
+                .insert_file(&root, "assets/minecraft/optifine/ctm/glass/1.png")
+                .is_err()
+        );
+        assert_eq!(sprites.count(), 1);
+        fs::remove_dir_all(&root).unwrap();
+    }
+    #[test]
     fn identical_still_textures_share_a_layer() {
         let root =
             std::env::temp_dir().join(format!("horizon-sprite-share-{}", std::process::id()));

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

@@ -6,6 +6,7 @@ use crate::fast_hash::{FxHashMap, FxHashSet};
 use crate::section_mask::SectionMask;
 use crate::{
     chunk::Chunk,
+    graphics::LeafCullingMode,
     light::{LightChanges, LightTables, apply_lighting, apply_relighting, light_chunk},
     mesher::{MeshScratch, MeshTables, Mesher, Region, SectionMesh, borrow},
     world::World,
@@ -149,6 +150,8 @@ pub trait LodSampler: Send {
     fn reduced_column(&mut self, x: i32, z: i32, _width: i32) -> crate::lod::Column {
         self.column(x, z)
     }
+    /// `side` x `side` columns from (`x`, `z`), `stride` blocks apart; none
+    /// when sampling failed and should be tried again later.
     fn grid(&mut self, x: i32, z: i32, stride: i32, side: usize) -> Vec<crate::lod::Column> {
         let mut columns = Vec::with_capacity(side * side);
         for dz in 0..side {
@@ -202,6 +205,7 @@ struct MeshSettings {
     blend_radius: i32,
     smooth_lighting: bool,
     cutout_leaves: bool,
+    leaf_culling: LeafCullingMode,
 }
 enum Job {
     Generate(i32, i32),
@@ -215,6 +219,8 @@ enum Job {
     /// Proto chunks checked out to be saved (`ChunkGenerator::save_protos`),
     /// off the main thread like vanilla's IOWorker.
     Save(Vec<((i32, i32), Proto)>),
+    /// A proto chunk checked out for its light view (`light_region`).
+    LightView(i32, i32, Proto),
     /// Meshes the renderer is done with (`Streaming::free`): their memory
     /// is given back here, not in the frame.
     Free(Vec<((i32, i32, i32), SectionMesh)>),
@@ -235,6 +241,8 @@ pub enum Done {
     Lit(i32, i32, Vec<crate::chunk::Light>, u64),
     Meshed(i32, i32, i32, SectionMesh, u64),
     Saved(Vec<((i32, i32), Proto)>),
+    /// A proto chunk back from `Job::LightView`, with its view.
+    LightView(i32, i32, Proto, Option<Chunk>),
 }
 struct Queued {
     priority: i64,
@@ -279,6 +287,8 @@ struct Shared {
     /// Workers that have freed their buffers ([`IDLE_RELEASE`]) and taken no
     /// job since: the last of them gives the freed memory back to the OS.
     released: AtomicUsize,
+    /// The workers that started.
+    workers: AtomicUsize,
 }
 #[derive(Default)]
 struct MeshPool {
@@ -352,7 +362,6 @@ pub struct Streaming {
     /// Columns generated and saved as they were left behind: new when they
     /// next arrive, though read from the save (`World::loaded_chunks`).
     dropped_new: FxHashSet<(i32, i32)>,
-    light_view: Arc<dyn Fn(&Proto) -> Option<Chunk> + Send + Sync>,
     non_air_sections: Arc<dyn Fn(&Proto) -> Option<SectionMask> + Send + Sync>,
     threads: Vec<thread::JoinHandle<()>>,
     order: u64,
@@ -377,6 +386,8 @@ pub struct Streaming {
     decorating_finals: HashSet<(i32, i32)>,
     /// Save jobs in flight.
     saving: usize,
+    /// Proto chunks checked out to a worker for their light view.
+    viewing: FxHashSet<(i32, i32)>,
     /// Vanilla's decoration order around the player, and the centre and
     /// radius it was last ranked for.
     decoration_order: DecorationOrder,
@@ -429,6 +440,8 @@ pub struct Streaming {
     /// The `ao` and `cutoutLeaves` options.
     pub smooth_lighting: bool,
     pub cutout_leaves: bool,
+    /// What the mesher does with leaf faces inside a canopy (`LeafCullingMode`).
+    pub leaf_culling: LeafCullingMode,
     /// Incremental relighting of block edits on lit chunks (see `light::relight`).
     light_tables: Arc<LightTables>,
     /// Applied edits by sequence, replayed onto light jobs snapshotted before them.
@@ -618,8 +631,8 @@ impl Streaming {
             done: Mailbox::default(),
             meshes: Mutex::new(MeshPool::default()),
             released: AtomicUsize::new(0),
+            workers: AtomicUsize::new(0),
         });
-        let workers = threads.max(1);
         let light_tables = context.light.clone();
         let saves: Arc<dyn Saves> = generator.clone();
         let threads = (0..threads.max(1))
@@ -673,7 +686,7 @@ impl Streaming {
                                         // runs short: once every worker has freed its own,
                                         // hand them back.
                                         if shared.released.fetch_add(1, Ordering::Relaxed) + 1
-                                            == workers
+                                            == shared.workers.load(Ordering::Relaxed)
                                         {
                                             // No worker needs retained mesh capacity now.
                                             // Drop it outside the pool lock before asking
@@ -732,6 +745,10 @@ impl Streaming {
                                     generator.save_protos(&refs);
                                     Done::Saved(protos)
                                 }
+                                Job::LightView(x, z, proto) => {
+                                    let view = generator.light_view(&proto);
+                                    Done::LightView(x, z, proto, view)
+                                }
                                 Job::Free(meshes) => {
                                     for (_, mesh) in meshes {
                                         let rejected = shared.meshes.lock().unwrap().put(mesh);
@@ -759,6 +776,7 @@ impl Streaming {
                                         blend_radius: settings.blend_radius,
                                         smooth_lighting: settings.smooth_lighting,
                                         cutout_leaves: settings.cutout_leaves,
+                                        leaf_culling: settings.leaf_culling,
                                         assets: &context.assets,
                                         render: &context.render,
                                         tables: &context.tables,
@@ -780,20 +798,22 @@ impl Streaming {
                             shared.done.send(done);
                         }
                     })
-                    .expect("spawn worker")
             })
-            .collect();
-        let light_view = {
-            let generator = generator.clone();
-            Arc::new(move |p: &Proto| generator.light_view(p))
-        };
+            // A thread the system refuses (a container's process limit reached) leaves the pool a
+            // worker short: a server that panicked here went down with its players' moves unsaved.
+            .filter_map(|spawned| {
+                spawned
+                    .inspect_err(|e| log::error!("Horizon: chunk worker not started: {e}"))
+                    .ok()
+            })
+            .collect::<Vec<_>>();
+        shared.workers.store(threads.len(), Ordering::Relaxed);
         let non_air_sections = {
             let generator = generator.clone();
             Arc::new(move |p: &Proto| generator.non_air_sections(p))
         };
         Self {
             shared,
-            light_view,
             non_air_sections,
             threads,
             order: 0,
@@ -808,6 +828,7 @@ impl Streaming {
             decorating: 0,
             decorating_finals: HashSet::new(),
             saving: 0,
+            viewing: Default::default(),
             decoration_order: DecorationOrder::default(),
             order_area: None,
             queue_basis: Default::default(),
@@ -837,6 +858,7 @@ impl Streaming {
             biome_blend: 2,
             smooth_lighting: true,
             cutout_leaves: true,
+            leaf_culling: LeafCullingMode::Off,
             light_tables,
             light_log: Vec::new(),
             light_edit_sequence: 0,
@@ -1092,28 +1114,42 @@ impl Streaming {
     /// The 3x3 a light job reads: the finished columns, and for a neighbour
     /// that will not finish (past the area), its decorated proto chunk, as
     /// vanilla lights its last FULL ring against neighbours at FEATURES.
+    /// A proto neighbour without its view yet is checked out to a worker,
+    /// which builds the view off the server thread (`Job::LightView`); the
+    /// region is asked for again once it is back.
     fn light_region(&mut self, world: &World, x: i32, z: i32) -> Option<Box<Region>> {
         let mut region: Region = Default::default();
+        let mut complete = true;
         for dz in 0..3 {
             for dx in 0..3 {
                 let n = (x + dx as i32 - 1, z + dz as i32 - 1);
-                region[dz][dx] = Some(match world.chunks.get(&n) {
-                    Some(chunk) => chunk.clone(),
+                region[dz][dx] = match world.chunks.get(&n) {
+                    Some(chunk) => Some(chunk.clone()),
                     None if !self.in_range(n.0, n.1, 1) && self.decorated.contains(&n) => {
                         if let Some(view) = self.light_views.get(&n) {
-                            view.clone()
+                            Some(view.clone())
                         } else {
-                            let proto = self.protos.get(&n)?.as_ref()?;
-                            let view = Arc::new((self.light_view)(proto)?);
-                            self.light_views.insert(n, view.clone());
-                            view
+                            let proto = self.protos.get_mut(&n)?.take()?;
+                            self.viewing.insert(n);
+                            self.submit(Some((x, z)), 0, Job::LightView(n.0, n.1, proto));
+                            complete = false;
+                            None
                         }
                     }
                     None => return None,
-                });
+                };
             }
         }
-        Some(Box::new(region))
+        complete.then(|| Box::new(region))
+    }
+    /// A proto chunk back from its light view: the view waits in
+    /// `light_views` for the light jobs that asked for it.
+    fn receive_light_view(&mut self, x: i32, z: i32, proto: Proto, view: Option<Chunk>) {
+        self.viewing.remove(&(x, z));
+        self.protos.insert((x, z), Some(proto));
+        if let Some(view) = view {
+            self.light_views.insert((x, z), Arc::new(view));
+        }
     }
     /// Whether `light_region` would find all nine columns: the same walk
     /// without building the snapshot, so the scheduler can rank the ready
@@ -1201,6 +1237,7 @@ impl Streaming {
     pub fn busy(&self) -> bool {
         !(self.generating.is_empty()
             && self.decorating == 0
+            && self.viewing.is_empty()
             && self.finishing.is_empty()
             && self.lighting.is_empty()
             && self.meshing.is_empty()
@@ -1264,6 +1301,7 @@ impl Streaming {
                 }
                 Done::Generated(chunk) => self.receive_generated(chunk, world),
                 Done::Saved(protos) => self.receive_saved(protos),
+                Done::LightView(x, z, proto, view) => self.receive_light_view(x, z, proto, view),
                 Done::Lit(x, z, sections, seq) => {
                     if self.lighting.get(&(x, z)) != Some(&seq) {
                         continue;
@@ -1680,6 +1718,7 @@ impl Streaming {
                             blend_radius: self.biome_blend,
                             smooth_lighting: self.smooth_lighting,
                             cutout_leaves: self.cutout_leaves,
+                            leaf_culling: self.leaf_culling,
                         },
                     ),
                 );
@@ -1822,7 +1861,11 @@ impl Streaming {
             return;
         }
         let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
-        while self.decorating > 0 || !self.finishing.is_empty() || self.saving > 0 {
+        while self.decorating > 0
+            || !self.finishing.is_empty()
+            || self.saving > 0
+            || !self.viewing.is_empty()
+        {
             let left = deadline.saturating_duration_since(std::time::Instant::now());
             match self.shared.done.recv_timeout(left) {
                 Some(Done::Decorated(x, z, region, finals, writes)) => {
@@ -1830,6 +1873,9 @@ impl Streaming {
                 }
                 Some(Done::Generated(chunk)) => self.receive_generated(chunk, world),
                 Some(Done::Saved(protos)) => self.receive_saved(protos),
+                Some(Done::LightView(x, z, proto, view)) => {
+                    self.receive_light_view(x, z, proto, view)
+                }
                 Some(other) => self.deferred.push(other),
                 None => {
                     log::warn!("Horizon: chunk generation did not finish before saving");
@@ -1860,13 +1906,18 @@ impl Streaming {
                 }
                 Done::Generated(chunk) => self.receive_generated(chunk, world),
                 Done::Saved(protos) => self.receive_saved(protos),
+                Done::LightView(x, z, proto, view) => self.receive_light_view(x, z, proto, view),
                 other => self.deferred.push(other),
             }
             if started.elapsed() >= std::time::Duration::from_millis(2) {
                 return false;
             }
         }
-        if self.decorating > 0 || !self.finishing.is_empty() || self.saving > 0 {
+        if self.decorating > 0
+            || !self.finishing.is_empty()
+            || self.saving > 0
+            || !self.viewing.is_empty()
+        {
             return false;
         }
         let written: Vec<_> = self.written.drain().collect();
@@ -1940,7 +1991,11 @@ impl Streaming {
                 counts[1] += 1;
             } else {
                 counts[2] += 1;
-                if self.light_region(world, key.0, key.1).is_some() {
+                if self.light_region(world, key.0, key.1).is_some()
+                    || (-1..=1).any(|dz| {
+                        (-1..=1).any(|dx| self.viewing.contains(&(key.0 + dx, key.1 + dz)))
+                    })
+                {
                     world.dirty_light.insert(key);
                 }
             }
@@ -2325,6 +2380,7 @@ mod tests {
         mesh.solid.resize(64, bytemuck::Zeroable::zeroed());
         mesh.translucent.resize(16, bytemuck::Zeroable::zeroed());
         mesh.block_entities.push(([1, 2, 3], 7));
+        mesh.lights.push(([1, 2, 3], 7));
         mesh.visibility = 0;
         mesh.sides = crate::mesher::Sides::unsorted(16);
         let capacities = mesh.capacity_bytes();
@@ -2341,6 +2397,7 @@ mod tests {
         assert!(reused.solid.is_empty());
         assert!(reused.translucent.is_empty());
         assert!(reused.block_entities.is_empty());
+        assert!(reused.lights.is_empty());
         assert_eq!(reused.visibility, crate::mesher::ALL_VISIBLE);
         assert_eq!(reused.sides, crate::mesher::Sides::default());
         assert_eq!(pool.bytes, 0);

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

@@ -92,19 +92,29 @@ fn sprite_level(uv: vec2<f32>, layer: u32, lod: f32) -> vec4<f32> {
 }
 // texture_sampling.glsl's sampleNearest: the sprite's texels stay square pixels, blending only
 // across the one screen pixel where two meet, so a linear (and anisotropic) sampler keeps them crisp.
+// `tiled`: a distant tile's face takes its sprite again per block, so its gradients span many
+// sprites while `uv` stays inside one (see `tile_uv` below).
 fn sample_nearest(uv: vec2<f32>, layer: u32, pixel: vec2<f32>, du: vec2<f32>, dv: vec2<f32>,
-                  texel_screen: vec2<f32>) -> vec4<f32> {
+                  texel_screen: vec2<f32>, tiled: bool) -> vec4<f32> {
     let texel_coords = uv / pixel;
     let center = round(texel_coords) - 0.5;
     var offset = texel_coords - center;
     offset = (offset - 0.5) * pixel / max(texel_screen, vec2(1e-12)) + 0.5;
     offset = clamp(offset, vec2(0.0), vec2(1.0));
-    return sprite_grad((center + offset) * pixel, layer, du, dv);
+    let at = (center + offset) * pixel;
+    if tiled {
+        // An anisotropic sampler lays its taps along those gradients, past the sprite's edge,
+        // where the clamped sampler reads that edge texel again: long streaks on the far tiles.
+        // Asking for the level the gradients give takes the one tap an anisotropy of 1 would.
+        let level = max(length(du), length(dv)) / min(pixel.x, pixel.y);
+        return sprite_level(at, layer, max(0.0, log2(level)));
+    }
+    return sprite_grad(at, layer, du, dv);
 }
 // sampleRGSS: four rotated-grid samples of the two nearest mip levels, faded in as the texels
 // shrink below two screen pixels, over sample_nearest.
 fn sample_rgss(uv: vec2<f32>, layer: u32, pixel: vec2<f32>, du: vec2<f32>, dv: vec2<f32>,
-               texel_screen: vec2<f32>) -> vec4<f32> {
+               texel_screen: vec2<f32>, tiled: bool) -> vec4<f32> {
     let max_texel = max(texel_screen.x, texel_screen.y);
     let min_pixel = min(pixel.x, pixel.y);
     let blend = smoothstep(min_pixel, min_pixel * 2.0, max_texel);
@@ -124,7 +134,7 @@ fn sample_rgss(uv: vec2<f32>, layer: u32, pixel: vec2<f32>, du: vec2<f32>, dv: v
         sum_high += sprite_level(p, layer, low + 1.0);
     }
     let rgss = mix(sum_low * 0.25, sum_high * 0.25, mip_blend);
-    return mix(sample_nearest(uv, layer, pixel, du, dv, texel_screen), rgss, blend);
+    return mix(sample_nearest(uv, layer, pixel, du, dv, texel_screen, tiled), rgss, blend);
 }
 // Distant terrain tiles (lod/mesh.rs) count their UVs in blocks past 1: each block takes the
 // sprite again, as separate faces would under the clamped sampler. Sprite UVs in [0, 1] stay.
@@ -137,12 +147,15 @@ fn sprite(tiled: vec2<f32>, layer: u32) -> vec4<f32> {
     let du = dpdx(tiled);
     let dv = dpdy(tiled);
     let uv = tile_uv(tiled);
+    // The wrap shifts a face's UVs by whole blocks, so half of one tells a tile's face from a
+    // block's (whose UVs stay inside its sprite).
+    let tiled_face = any(tiled - uv >= vec2(0.5));
     let pixel = vec2(1.0 / globals.filtering.y);
     let texel_screen = sqrt(du * du + dv * dv);
     if u32(globals.filtering.x) == 1u {
-        return sample_rgss(uv, layer, pixel, du, dv, texel_screen);
+        return sample_rgss(uv, layer, pixel, du, dv, texel_screen, tiled_face);
     }
-    return sample_nearest(uv, layer, pixel, du, dv, texel_screen);
+    return sample_nearest(uv, layer, pixel, du, dv, texel_screen, tiled_face);
 }
 
 struct TerrainOut {
@@ -295,6 +308,56 @@ fn fade_code(w: f32) -> u32 {
     return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
         origin.w);
 }
+// Solid terrain draws in two passes from the same draws: first the quads with no
+// cutout that are not fading, through `fs_opaque`, which never discards, so a tiled
+// GPU (Apple's) keeps hiding the pixels behind them; then the rest through
+// `fs_solid`. One discard anywhere in a pipeline's shader turned that hiding off for
+// all the terrain it drew. A quad the pass leaves out is decided before any of the
+// vertex's work and lies outside the clip volume: it makes no pixel.
+fn opaque_quad(layer: u32, w: f32) -> bool {
+    return (layer & 0x8000u) != 0u && fade_code(w) == 0u;
+}
+fn left_out() -> TerrainOut {
+    var out: TerrainOut;
+    out.clip = vec4(2.0, 2.0, 2.0, 1.0);
+    return out;
+}
+@vertex fn vs_terrain_opaque(
+    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
+    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>,
+    @location(5) origin: vec4<f32>) -> TerrainOut {
+    if !opaque_quad(layer, origin.w) { return left_out(); }
+    return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
+        origin.w);
+}
+@vertex fn vs_terrain_cutout(
+    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
+    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>,
+    @location(5) origin: vec4<f32>) -> TerrainOut {
+    if opaque_quad(layer, origin.w) { return left_out(); }
+    return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
+        origin.w);
+}
+@vertex fn vs_terrain_flat_opaque(
+    @builtin(vertex_index) vertex: u32,
+    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
+    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>
+) -> TerrainOut {
+    let origin = slot_origins[block_slots[vertex >> 8u]];
+    if !opaque_quad(layer, origin.w) { return left_out(); }
+    return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
+        origin.w);
+}
+@vertex fn vs_terrain_flat_cutout(
+    @builtin(vertex_index) vertex: u32,
+    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
+    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>
+) -> TerrainOut {
+    let origin = slot_origins[block_slots[vertex >> 8u]];
+    if opaque_quad(layer, origin.w) { return left_out(); }
+    return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
+        origin.w);
+}
 fn terrain_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f32>,
     light: vec2<u32>, origin: vec3<f32>, w: f32) -> TerrainOut {
     let pos = position + origin;
@@ -344,6 +407,13 @@ fn brightness(c: vec3<f32>) -> f32 {
 @fragment fn fs_solid(in: TerrainOut) -> @location(0) vec4<f32> {
     return solid_color(in);
 }
+// `fs_solid` for the opaque pass (`opaque_quad`): no fade, no cutout, no discard.
+@fragment fn fs_opaque(in: TerrainOut) -> @location(0) vec4<f32> {
+    let texel = sprite(in.uv, in.layer & 0x7fffu);
+    var color = texel * in.color;
+    color = mix(globals.fog_color * vec4(1.0, 1.0, 1.0, color.a), color, in.visibility);
+    return solid_finish(in, texel, color);
+}
 // The water mirror (gfx.rs's reflection pass): what lies below the water plane
 // (`fog_ends.w`, camera-relative) would show above it in the mirror, so it is cut away.
 @fragment fn fs_solid_mirror(in: TerrainOut) -> @location(0) vec4<f32> {
@@ -360,6 +430,10 @@ fn solid_color(in: TerrainOut) -> vec4<f32> {
     // terrain.fsh: the fade-in mixes toward the fog colour.
     color = mix(globals.fog_color * vec4(1.0, 1.0, 1.0, color.a), color, in.visibility);
     if color.a < 0.5 && (in.layer & 0x8000u) == 0u { discard; }
+    return solid_finish(in, texel, color);
+}
+// The rest of a solid pixel's colour once it is kept: emission and fog.
+fn solid_finish(in: TerrainOut, texel: vec4<f32>, color: vec4<f32>) -> vec4<f32> {
     // Below 0.75, alpha tells HDR output (hdr.wgsl) a light source's pixel may
     // shine, and at which tier (mesher::hdr_tier): 0.525 at the lowest, 0 at the
     // brightest. Only pixels as bright as their sprite's threshold may: its
@@ -517,6 +591,11 @@ fn sky_along_ray(d: vec3<f32>) -> vec3<f32> {
 @fragment fn fs_sky(in: SkyOut) -> @location(0) vec4<f32> {
     return vec4(sky_along_ray(view_ray(in.ndc)), 1.0);
 }
+// The first-person hand's depth clear inside the world pass: `vs_sky`'s triangle lies at the
+// far plane, written over the whole depth target with no colour.
+@fragment fn fs_depth_reset(in: SkyOut) -> @location(0) vec4<f32> {
+    return vec4(0.0);
+}
 @fragment fn fs_dark_disc(in: SkyOut) -> @location(0) vec4<f32> {
     let d = view_ray(in.ndc);
     let dist = disc_distance(d, -4.0);

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

@@ -98,6 +98,25 @@ thread_local! {
     static TARGETS: RefCell<(Vec<Target>, Vec<Target>, u64)> = const { RefCell::new((Vec::new(), Vec::new(), 0)) };
 }
 
+/// Splitscreen: one player's buttons and focus targets, kept aside while another player's game
+/// runs on this thread ([`take`] and [`put`] around each turn).
+#[derive(Default)]
+pub struct Saved(
+    (Vec<Widget>, Vec<Widget>, u64),
+    (Vec<Target>, Vec<Target>, u64),
+);
+
+/// This thread's buttons and targets, leaving none.
+pub fn take() -> Saved {
+    Saved(WIDGETS.take(), TARGETS.take())
+}
+
+/// Bring back what [`take`] kept.
+pub fn put(saved: Saved) {
+    WIDGETS.set(saved.0);
+    TARGETS.set(saved.1);
+}
+
 /// An interactive rectangle (GUI pixels) a controller can focus and click.
 pub fn target(rect: [f32; 4]) {
     target_as(rect, Kind::Button);

crates/horizon-client/Cargo.toml

@@ -36,6 +36,7 @@ horizon-narrator = { path = "../horizon-narrator" }
 # Horizon mods: sandboxed WebAssembly components, off unless installed and turned on (docs/mods.md).
 # Their runtime is the `mods` feature.
 horizon-mods = { path = "../horizon-mods", default-features = false, features = ["index"] }
+horizon-optifine = { path = "../horizon-optifine" }
 wgpu = { version = "30.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "metal", "wgsl", "naga-ir"] }
 winit = "0.30.13"
 pollster = "0.4"
@@ -83,6 +84,13 @@ open = { version = "5.4.5", features = ["shellexecute-on-windows"] }
 # on the PATH.
 wgpu = { version = "30.0.1", default-features = false, features = ["dx12"] }
 
+[target.'cfg(target_os = "macos")'.dependencies]
+# Splitscreen: a window filling a monitor goes over its menu bar (game/split/windows.rs
+# `above_menu_bar`); all already in the tree through winit and wgpu.
+objc2 = "0.6"
+objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSApplication", "NSResponder", "NSWindow", "NSScreen"] }
+objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSString"] }
+
 [target.'cfg(not(target_os = "macos"))'.dependencies]
 # OpenGL (WGL on Windows, EGL on Linux), the last fallback, for GPUs with no Vulkan or
 # DirectX 12 driver (`graphicsApi`, graphics.rs).

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

@@ -34,6 +34,8 @@
   "horizon.pages.extras": "Horizon Extras",
   "horizon.pages.settings": "Horizon Settings",
   "horizon.pages.agent": "AI Agent",
+  "horizon.pages.split_settings": "Splitscreen Settings",
+  "horizon.pages.split_setup": "Splitscreen",
   "horizon.pages.split_profiles": "Who's playing?",
   "horizon.pages.settings.tooltip": "Horizon's own settings: graphics, controllers, extras and mods.",
   "horizon.pages.graphics.tooltip": "Graphics, simply: each setting says what it costs.",
@@ -41,6 +43,7 @@
   "horizon.pages.controller.tooltip": "Controllers: their buttons, sticks, vibration and menu navigation.",
   "horizon.pages.extras.tooltip": "Optional additions, all off by default: the game stays vanilla until you turn one on.",
   "horizon.pages.agent.tooltip": "Let your own AI agent play: horizon-ctl and MCP clients on this computer.",
+  "horizon.pages.split_setup.tooltip": "Players on this computer: controllers can join your world.",
   "horizon.pages.split_profiles.tooltip": "Who plays: a profile kept in this game folder.",
   "horizon.pages.shader_packs.tooltip": "Shader packs from the shaderpacks folder: Horizon's own and those in the shaders/ format. One runs at a time.",
   "horizon.pages.mods.tooltip": "Mods made for Horizon, from the horizon-mods folder. Each runs in a sandbox and stays off until you turn it on.",
@@ -48,6 +51,7 @@
   "horizon.pages.open.graphics_advanced": "Advanced Graphics...",
   "horizon.pages.open.shader_packs": "Shader Packs...",
   "horizon.pages.open.controller": "Controller Settings...",
+  "horizon.pages.open.split_setup": "Splitscreen...",
   "horizon.pages.open.extras": "Extras...",
   "horizon.pages.open.mods": "Mods...",
   "horizon.pages.open.agent": "AI Agent...",

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

@@ -203,5 +203,11 @@
   "horizon.multiplayer.not_signed_in": "Este servidor está en modo en línea. Inicia sesión con tu cuenta de Microsoft en el launcher de Horizon para unirte.",
   "horizon.multiplayer.invalid_address": "Dirección de servidor no válida: %s",
   "horizon.multiplayer.connected_friend_direct": "Conectado directamente con tu amigo…",
-  "horizon.multiplayer.connected_friend_relay": "Conectado con tu amigo a través del relé…"
+  "horizon.multiplayer.connected_friend_relay": "Conectado con tu amigo a través del relé…",
+  "horizon.pages.shader_options": "Opciones de sombreadores",
+  "horizon.pages.split_profiles": "¿Quién juega?",
+  "horizon.pages.split_profiles.tooltip": "Quién juega: un perfil guardado en esta carpeta del juego.",
+  "horizon.shader_options.open": "Opciones de sombreadores…",
+  "horizon.shader_options.profile": "Perfil",
+  "horizon.shader_options.loading": "Leyendo las opciones del paquete de sombreadores…"
 }

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

@@ -18,5 +18,11 @@
   "horizon.multiplayer.not_signed_in": "Ten serwer działa w trybie online. Zaloguj się kontem Microsoft w launcherze Horizon, aby dołączyć.",
   "horizon.multiplayer.invalid_address": "Nieprawidłowy adres serwera: %s",
   "horizon.multiplayer.connected_friend_direct": "Połączono bezpośrednio ze znajomym…",
-  "horizon.multiplayer.connected_friend_relay": "Połączono ze znajomym przez przekaźnik…"
+  "horizon.multiplayer.connected_friend_relay": "Połączono ze znajomym przez przekaźnik…",
+  "horizon.pages.shader_options": "Ustawienia shaderów",
+  "horizon.pages.split_profiles": "Kto gra?",
+  "horizon.pages.split_profiles.tooltip": "Kto gra: profil przechowywany w tym folderze gry.",
+  "horizon.shader_options.open": "Ustawienia shaderów…",
+  "horizon.shader_options.profile": "Profil",
+  "horizon.shader_options.loading": "Wczytywanie ustawień paczki shaderów…"
 }

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

@@ -202,5 +202,11 @@
   "horizon.multiplayer.not_signed_in": "Этот сервер работает в онлайн-режиме. Войдите с помощью аккаунта Microsoft в лаунчере Horizon, чтобы присоединиться.",
   "horizon.multiplayer.invalid_address": "Недействительный адрес сервера: %s",
   "horizon.multiplayer.connected_friend_direct": "Установлено прямое соединение с другом…",
-  "horizon.multiplayer.connected_friend_relay": "Соединение с другом через релей…"
+  "horizon.multiplayer.connected_friend_relay": "Соединение с другом через релей…",
+  "horizon.pages.shader_options": "Настройки шейдеров",
+  "horizon.pages.split_profiles": "Кто играет?",
+  "horizon.pages.split_profiles.tooltip": "Кто играет: профиль, хранимый в этой папке игры.",
+  "horizon.shader_options.open": "Настройки шейдеров…",
+  "horizon.shader_options.profile": "Профиль",
+  "horizon.shader_options.loading": "Чтение настроек набора шейдеров…"
 }

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

@@ -196,5 +196,11 @@
   "Threads that generate, light and mesh chunks. Next start.": "Parçaları oluşturan, aydınlatan ve ağ verilerini hazırlayan iş parçacıklarının sayısı. Değişiklikler sonraki başlatmada uygulanır.",
   "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Önce Vulkan kullanılır. Çalışmazsa Windows'ta DirectX 12, Linux'ta OpenGL denenir. Değişiklikler sonraki başlatmada uygulanır.",
   "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Her karede GPU'ya gönderilen ağ verisi miktarı. Daha düşük değerler yükleme sırasında daha akıcı bir deneyim sağlar.",
-  "Frame rate and frame times over the game, with a graph.": "Oyun ekranında FPS değerini ve kare sürelerini grafikle birlikte gösterir."
+  "Frame rate and frame times over the game, with a graph.": "Oyun ekranında FPS değerini ve kare sürelerini grafikle birlikte gösterir.",
+  "horizon.pages.shader_options": "Gölgelendirici Seçenekleri",
+  "horizon.pages.split_profiles": "Kim oynuyor?",
+  "horizon.pages.split_profiles.tooltip": "Kim oynuyor: bu oyun klasöründe tutulan bir profil.",
+  "horizon.shader_options.open": "Gölgelendirici Seçenekleri…",
+  "horizon.shader_options.profile": "Profil",
+  "horizon.shader_options.loading": "Gölgelendirici paketinin seçenekleri okunuyor…"
 }

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

@@ -18,5 +18,11 @@
   "horizon.multiplayer.not_signed_in": "Цей сервер працює в онлайн-режимі. Увійдіть за допомогою акаунта Microsoft у лаунчері Horizon, щоб приєднатися.",
   "horizon.multiplayer.invalid_address": "Недійсна адреса сервера: %s",
   "horizon.multiplayer.connected_friend_direct": "Пряме з'єднання з другом встановлено…",
-  "horizon.multiplayer.connected_friend_relay": "З'єднання з другом через ретранслятор…"
+  "horizon.multiplayer.connected_friend_relay": "З'єднання з другом через ретранслятор…",
+  "horizon.pages.shader_options": "Налаштування шейдерів",
+  "horizon.pages.split_profiles": "Хто грає?",
+  "horizon.pages.split_profiles.tooltip": "Хто грає: профіль, що зберігається в цій теці гри.",
+  "horizon.shader_options.open": "Налаштування шейдерів…",
+  "horizon.shader_options.profile": "Профіль",
+  "horizon.shader_options.loading": "Читання налаштувань набору шейдерів…"
 }

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

@@ -203,5 +203,11 @@
   "horizon.multiplayer.not_signed_in": "该服务器为在线模式服务器。请先在 Horizon 启动器中登录 Microsoft 账户再加入。",
   "horizon.multiplayer.invalid_address": "无效的服务器地址：%s",
   "horizon.multiplayer.connected_friend_direct": "已直连好友的世界…",
-  "horizon.multiplayer.connected_friend_relay": "已通过中继连接好友的世界…"
+  "horizon.multiplayer.connected_friend_relay": "已通过中继连接好友的世界…",
+  "horizon.pages.shader_options": "光影选项",
+  "horizon.pages.split_profiles": "谁在玩？",
+  "horizon.pages.split_profiles.tooltip": "谁在玩：保存在此游戏文件夹中的一份档案。",
+  "horizon.shader_options.open": "光影选项…",
+  "horizon.shader_options.profile": "档案",
+  "horizon.shader_options.loading": "正在读取光影包的选项…"
 }

crates/horizon-client/build.rs

@@ -5,6 +5,15 @@ fn main() {
     let dir = std::env::var("CARGO_MANIFEST_DIR").unwrap_or_default();
     let ico = format!("{dir}/../../packaging/icons/horizon.ico");
     println!("cargo:rerun-if-changed={ico}");
+    // The game's main thread gets 8 MB of stack on Windows as on macOS and Linux (Windows gives 1
+    // MB): splitscreen builds a joining player's `Game`, ~67 KB, deep in the event loop.
+    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
+        let arg = match std::env::var("CARGO_CFG_TARGET_ENV").as_deref() {
+            Ok("msvc") => "/STACK:8388608",
+            _ => "-Wl,--stack,8388608",
+        };
+        println!("cargo:rustc-link-arg-bin=horizon-client={arg}");
+    }
     #[cfg(windows)]
     if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
         let mut resource = winresource::WindowsResource::new();

crates/horizon-client/examples/chunk_load_bench.rs

@@ -17,6 +17,7 @@ use horizon_client::{
     biome::Biomes,
     blocks::BlockFacts,
     chunk::HEIGHT,
+    graphics::LeafCullingMode,
     light::LightTables,
     mesher::{MeshTables, Mesher, Region, borrow},
     models,
@@ -139,6 +140,7 @@ fn main() -> Result<(), Error> {
             blend_radius: 2,
             smooth_lighting: true,
             cutout_leaves: true,
+            leaf_culling: LeafCullingMode::Off,
             assets: &context.assets,
             render: &context.render,
             tables: &context.tables,

crates/horizon-client/examples/mod_port_probe.rs

@@ -133,7 +133,7 @@ fn main() -> Result<()> {
                 .collect();
             let descriptor = BlockState {
                 name: name.clone(),
-                properties,
+                properties: properties.into(),
             };
             let Some(id) = registry.id(&descriptor) else {
                 states.insert(key.clone(), Value::Null);

crates/horizon-client/examples/probe/entity_death_loot_fixture.rs

@@ -291,6 +291,8 @@ pub fn main() -> horizon_client::Result<()> {
             for d in items {
                 let _ = match d {
                     drops::Drop::Item(s) => writeln!(out, "{}", line(&s)),
+                    // The fixture's mobs keep no whole stacks.
+                    drops::Drop::Stack(s) => writeln!(out, "drop {} {}", s.item, s.count),
                     drops::Drop::CarriedBlock(state) => {
                         let stacks = enderman::carried_block_drops(
                             &block_items,

crates/horizon-client/examples/probe/hud_fixture/kinds.rs

@@ -328,5 +328,5 @@ fn chat(c: &Value, h: i32, atlas: &HudAtlas) -> Vec<GuiDraw> {
     if let Some(n) = c["scroll"].as_i64() {
         chat.scroll_by(n as i32, focused);
     }
-    chat.layout(h, c["now"].as_u64().unwrap_or(0), focused)
+    chat.layout(h, c["now"].as_f64().unwrap_or(0.0) as f32, focused)
 }

crates/horizon-client/examples/probe/mob_ai_probe.rs

@@ -179,7 +179,7 @@ fn state(registry: &BlockRegistry, text: &str) -> BlockStateId {
     registry
         .resolve(&BlockState {
             name: name.to_owned(),
-            properties,
+            properties: properties.into(),
         })
         .unwrap_or_else(|e| panic!("{text}: {e}"))
 }
@@ -1182,6 +1182,7 @@ pub fn main() -> horizon_client::Result<()> {
                     thundering: s.thunder,
                     nether: false,
                     block_tags: &items.block_tags,
+                    landing: &motion.landing,
                     biomes: &biomes,
                     mob_griefing: true,
                     universal_anger: false,
@@ -1315,7 +1316,7 @@ pub fn main() -> horizon_client::Result<()> {
                     continue;
                 }
                 if let Some(Some((name, volume, pitch))) =
-                    horizon_client::mobs::ai::feed_animal(&mut mobs[i], &mut level_random)
+                    horizon_client::mobs::ai::feed_animal(&mut mobs[i], &mut level_random, None)
                 {
                     events.push(MobEvent::Sound(name, [0.0; 3], volume, pitch));
                 }