Merge main and fold in the launcher file-room move

main's native_mods now installs the mods' content (#11083): the prebuilt export writes it into
DIR/native-content as an install does, and unpack (now in native_mods/source.rs) reads the
bundle's source files. cli.rs and native_mods.rs are over 3000 lines and may not grow, so this
branch also carries the pure move of #13996 (screenshots and multiplayer to cli/media.rs,
warn_conflicts to native_mods/conflicts.rs).

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

.github/workflows/ci.yml

@@ -80,24 +80,21 @@ jobs:
           rustup toolchain install stable --profile minimal --component rustfmt --component clippy
           rustup default stable
           echo "WGPU_BACKEND=dx12" >> "$GITHUB_ENV"
-      # On a pull request, the next three checks compare with HEAD^1: the main that GitHub's merge commit puts the pull
-      # request on. pull_request.base.sha is main at the pull request's last push and falls behind, so main's own
-      # changes since then would count as the pull request's (#13874).
       # docs/layers.md: a crate depends only on its own layer or a lower one; today's exceptions only shrink.
       - name: Crates follow the layers
         env:
-          BASE: ${{ github.event_name == 'pull_request' && 'HEAD^1' || '' }}
-        run: python3 tools/check_layers.py ${BASE:+--base "$BASE"}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+        run: python3 tools/check_layers.py ${BASE_SHA:+--base "$BASE_SHA"}
       # docs/layers.md#built-in-addresses: every built-in outside address in the Horizon layer's home; the rest only shrinks.
       - name: Built-in addresses stay in their home
         env:
-          BASE: ${{ github.event_name == 'pull_request' && 'HEAD^1' || '' }}
-        run: python3 tools/check_addresses.py ${BASE:+--base "$BASE"}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+        run: python3 tools/check_addresses.py ${BASE_SHA:+--base "$BASE_SHA"}
       # docs/layers.md#file-size: a Rust file over 3000 lines may not grow (pull requests; main has no base to compare).
       - name: Big files don't grow
         env:
-          BASE: ${{ github.event_name == 'pull_request' && 'HEAD^1' || '' }}
-        run: python3 tools/check_file_size.py ${BASE:+--base "$BASE"}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+        run: python3 tools/check_file_size.py ${BASE_SHA:+--base "$BASE_SHA"}
       - name: Test offline research tooling
         run: python -m unittest discover -s tests -v
       - name: Install Rust toolchain and the ALSA and udev headers the client links against

.github/workflows/launcher.yml

@@ -201,9 +201,6 @@ jobs:
       - name: Verify Windows executable architecture
         if: runner.os == 'Windows'
         run: python ../tools/check_pe_arch.py "${{ matrix.pe_arch }}" "$BIN/${{ matrix.binary }}"
-      - name: Unrelated DLLs cannot intercept launcher or setup startup
-        if: runner.os == 'Windows'
-        run: python ../tools/test_launcher_dll_search.py "$BIN/${{ matrix.binary }}"
       - name: The version is the release's
         run: |
           out=$("$BIN/${{ matrix.binary }}" --version)

CONTRIBUTING.md

@@ -13,14 +13,6 @@ else (videos, Discord and other community material) lives elsewhere.
 suggest something. A pull request for a roadmap item carries its `roadmap:<id>` label; ideas go to the suggestion
 queue (the hub, or `/suggest` on Discord) rather than to issues, which are for bugs.
 
-**Mod-related pull requests go to [arismoko/horizon](https://github.com/arismoko/horizon)**, the fork that carries the
-mod API and reviews and merges that work. That covers the mod API, native hooks and events for mods, native mods,
-content mods (`.hmod`), mixins, wasm mods, `cargo horizon-mod`, `horizon-mods`, mod builds and the registry, and
-their docs ([mods](docs/mods.md), [native mods](docs/native-mods.md)). Open the pull request there from your usual
-branch. Mod-related pull requests opened here are closed with a pointer to it. Engine extension points that Horizon's
-own crates register (the [layer split](docs/layers.md)), resource and shader pack formats, and gameplay fixes stay
-here.
-
 ## Build it
 
 - **Prerequisites:** Rust (stable), Python 3.10+, JDK 25, and on Linux the ALSA and udev headers

Cargo.lock

@@ -1418,7 +1418,6 @@ dependencies = [
 name = "horizon-chat-filter"
 version = "0.1.0"
 dependencies = [
- "horizon-server-files",
  "serde",
  "serde_json",
  "toml",
@@ -1449,6 +1448,7 @@ dependencies = [
  "horizon-core",
  "horizon-cosmetics",
  "horizon-dualsense",
+ "horizon-friends",
  "horizon-hdr",
  "horizon-hooks",
  "horizon-items",
@@ -1528,6 +1528,8 @@ dependencies = [
  "horizon-client-render",
  "horizon-command",
  "horizon-core",
+ "horizon-cosmetics",
+ "horizon-friends",
  "horizon-hdr",
  "horizon-hooks",
  "horizon-items",
@@ -1585,12 +1587,12 @@ dependencies = [
  "horizon-core",
  "horizon-cosmetics",
  "horizon-hdr",
- "horizon-hooks",
  "horizon-items",
  "horizon-narrator",
  "horizon-optifine",
  "horizon-polytone",
  "horizon-protocol",
+ "horizon-render-pipeline",
  "horizon-shader-api",
  "horizon-shaders",
  "horizon-system",
@@ -1666,7 +1668,6 @@ dependencies = [
  "getrandom 0.3.4",
  "hkdf",
  "horizon-addresses",
- "horizon-platform",
  "if-addrs",
  "serde",
  "serde_json",
@@ -1792,7 +1793,6 @@ dependencies = [
 name = "horizon-official"
 version = "0.1.0"
 dependencies = [
- "horizon-friends",
  "horizon-game",
  "horizon-heartbeat",
  "horizon-platform",
@@ -1814,13 +1814,8 @@ dependencies = [
 name = "horizon-platform"
 version = "0.1.0"
 dependencies = [
- "horizon-core",
  "horizon-hooks",
- "horizon-prepare",
- "horizon-protocol",
- "horizon-server-files",
  "horizon-system",
- "horizon-world",
 ]
 
 [[package]]
@@ -1891,6 +1886,10 @@ dependencies = [
  "ring",
 ]
 
+[[package]]
+name = "horizon-render-pipeline"
+version = "0.1.0"
+
 [[package]]
 name = "horizon-server"
 version = "0.1.0"
@@ -1902,9 +1901,11 @@ dependencies = [
  "horizon-anticheat",
  "horizon-bench",
  "horizon-chat-filter",
+ "horizon-core",
  "horizon-mcp",
- "horizon-platform",
  "horizon-release-sign",
+ "horizon-server-files",
+ "horizon-world",
  "libc",
  "p12-keystore",
  "png",
@@ -1953,6 +1954,7 @@ version = "0.1.0"
 dependencies = [
  "half",
  "horizon-core",
+ "horizon-render-pipeline",
  "naga",
  "png",
  "zip",

Cargo.toml

@@ -43,6 +43,7 @@ members = [
     "crates/cargo-horizon-mod",
     "crates/horizon-port-pack",
     "crates/horizon-shaders",
+    "crates/horizon-render-pipeline",
     "crates/horizon-optifine",
     "crates/horizon-polytone",
     "crates/horizon-shader-api",

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

@@ -80,8 +80,8 @@ pub fn main(args: &[String]) -> Result<(), String> {
             };
             let author = flag(rest, "--author").ok_or(USAGE)?;
             let (base, _) = registry::load(Path::new(base)).map_err(lines)?;
-            let (head, revoked) = registry::load(Path::new(head)).map_err(lines)?;
-            let review = registry::review_with_revoked(&base, &head, &revoked, author);
+            let (head, _) = registry::load(Path::new(head)).map_err(lines)?;
+            let review = registry::review(&base, &head, author);
             if rest.iter().any(|a| a == "--json") {
                 let json = serde_json::json!({"errors": review.errors, "notes": review.notes});
                 println!("{json}");

crates/horizon-assets/src/animation.rs

@@ -26,23 +26,18 @@ pub struct AnimationMetadata {
 pub enum ClipMode {
     /// `day_time`: frame 0 at time 0, the last at the cycle's end, then again.
     DayTime { cycle: i64 },
-    /// `screen_time`: the ticks the open screen has been open, over the cycle, held on the last
-    /// frame once it has run (it doesn't loop, measured on the real mod).
-    ScreenTime { cycle: i64 },
     /// `weather`: frame 0 in clear weather, 1 in rain, 2 in a storm (the rain and thunder levels
     /// added up), at most the last.
     Weather,
     /// A Polytone expression: its value's fraction is how far through the animation it is.
     Expression(String),
-    /// `game_time`, `season`: not driven; the animation runs on ticks.
+    /// `game_time`, `screen_time`, `season`: not driven yet; the animation runs on ticks.
     Unsupported(String),
 }
 
 /// The values [`ClipMode`]s read this frame.
 pub struct ModeInputs<'a> {
     pub day_time: i64,
-    /// The ticks the open screen has been open (0 without one).
-    pub screen_time: i64,
     /// The rain level plus the thunder level, 0 to 2.
     pub weather: f32,
     /// An expression's value this frame, by its source.
@@ -121,8 +116,7 @@ impl AnimationMetadata {
                     match mode.as_str() {
                         "day_time" => ClipMode::DayTime { cycle },
                         "weather" => ClipMode::Weather,
-                        "screen_time" => ClipMode::ScreenTime { cycle },
-                        "game_time" | "season" => ClipMode::Unsupported(mode),
+                        "game_time" | "screen_time" | "season" => ClipMode::Unsupported(mode),
                         _ => ClipMode::Expression(mode),
                     }
                 }),
@@ -245,9 +239,6 @@ impl AnimationClip {
     pub fn sample_mode(&self, inputs: &ModeInputs) -> Option<AnimationSample> {
         let fraction = match self.mode.as_ref()? {
             ClipMode::DayTime { cycle } => day_fraction(inputs.day_time, *cycle),
-            ClipMode::ScreenTime { cycle } => {
-                (inputs.screen_time.max(0) as f64 / *cycle as f64).min(1.0 - f64::EPSILON)
-            }
             ClipMode::Weather => {
                 let last = self.sequence.len() - 1;
                 let index = (inputs.weather.max(0.0) as usize).min(last);
@@ -297,7 +288,6 @@ mod mode_tests {
         let expression = move |_: &str| Some(value);
         clip.sample_mode(&ModeInputs {
             day_time,
-            screen_time: day_time,
             weather,
             expression: &expression,
         })
@@ -312,13 +302,6 @@ mod mode_tests {
             .map(|t| frame(&day, t, 0.0, 0.0))
             .into();
         assert_eq!(frames, [0, 1, 2, 3, 1]);
-        // 26.3-6.8.6, four frames over 200 ticks: 40 ticks open show the first, and from ten
-        // seconds on the last, even after 27 (it doesn't loop).
-        let screen = clip(r#"{"frametime": 1, "mode": "screen_time", "time_cycle_duration": 200}"#);
-        let frames: Vec<u32> = [0, 40, 200, 360, 540]
-            .map(|t| frame(&screen, t, 0.0, 0.0))
-            .into();
-        assert_eq!(frames, [0, 0, 3, 3, 3]);
         let value = clip(r#"{"frametime": 1, "mode": "0.6"}"#);
         assert_eq!(frame(&value, 0, 0.0, 0.6), 2);
         assert_eq!(frame(&value, 0, 0.0, 2.0), 0);
@@ -338,7 +321,6 @@ mod mode_tests {
             clip(r#"{"frametime": 1}"#)
                 .sample_mode(&ModeInputs {
                     day_time: 0,
-                    screen_time: 0,
                     weather: 0.0,
                     expression: &|_| None
                 })
@@ -348,7 +330,6 @@ mod mode_tests {
             clip(r#"{"frametime": 1, "mode": "season"}"#)
                 .sample_mode(&ModeInputs {
                     day_time: 0,
-                    screen_time: 0,
                     weather: 0.0,
                     expression: &|_| None
                 })

crates/horizon-chat-filter/Cargo.toml

@@ -7,8 +7,6 @@ rust-version.workspace = true
 description = "The dedicated server's chat filter: its [chat_filter] settings, the slur list's matcher and the mutes, with no game state (docs/chat-filter.md)"
 
 [dependencies]
-# The moderation durations, shared with `/tempban`.
-horizon-server-files = { path = "../horizon-server-files" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 toml = "1.1"

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

@@ -10,9 +10,6 @@ use std::path::{Path, PathBuf};
 
 mod normalise;
 
-pub use horizon_server_files::duration::{
-    DurationUnit, duration_parts, duration_text, now_millis, parse_duration,
-};
 pub use normalise::{Run, Text};
 
 /// The list built into the game, used when `words_file` is empty.
@@ -477,6 +474,61 @@ pub fn append_log(path: &Path, line: &str) -> std::io::Result<()> {
     writeln!(f, "{line}")
 }
 
+/// `/tempmute`'s duration in milliseconds: a positive whole number and a unit, `s`, `m`, `h`, `d` or
+/// `w` (`10m`, `2h`, `1d`).
+pub fn parse_duration(text: &str) -> Option<i64> {
+    let unit = match text.chars().last()? {
+        's' => 1_000,
+        'm' => MINUTE,
+        'h' => 60 * MINUTE,
+        'd' => 24 * 60 * MINUTE,
+        'w' => 7 * 24 * 60 * MINUTE,
+        _ => return None,
+    };
+    let count: i64 = text[..text.len() - 1].parse().ok()?;
+    (count > 0).then(|| count.checked_mul(unit)).flatten()
+}
+
+/// The unit used when presenting a moderation duration to a player.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DurationUnit {
+    Minute,
+    Hour,
+    Day,
+}
+
+/// A duration's rounded count and unit, shared by logs and translated replies.
+pub fn duration_parts(millis: i64) -> (i64, DurationUnit) {
+    let (unit, kind) = if millis <= 60 * MINUTE {
+        (MINUTE, DurationUnit::Minute)
+    } else if millis <= 48 * 60 * MINUTE {
+        (60 * MINUTE, DurationUnit::Hour)
+    } else {
+        (24 * 60 * MINUTE, DurationUnit::Day)
+    };
+    (
+        millis.div_euclid(unit) + i64::from(millis.rem_euclid(unit) > 0),
+        kind,
+    )
+}
+
+/// `millis` for logs, rounded up: minutes up to an hour, hours up to two days, then days.
+pub fn duration_text(millis: i64) -> String {
+    let (count, unit) = duration_parts(millis);
+    let unit = match unit {
+        DurationUnit::Minute => "minute",
+        DurationUnit::Hour => "hour",
+        DurationUnit::Day => "day",
+    };
+    format!("{count} {unit}{}", if count == 1 { "" } else { "s" })
+}
+
+pub fn now_millis() -> i64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_or(0, |d| d.as_millis() as i64)
+}
+
 /// `YYYY-MM-DDTHH:MM:SSZ` for epoch milliseconds.
 pub fn utc(millis: i64) -> String {
     let secs = millis.div_euclid(1000);

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

@@ -74,70 +74,11 @@ pub trait ResourceSource {
         vec!["minecraft".into()]
     }
 }
-/// The bundled file a language reads, and whether it drops `ß`: a regional variant reads its
-/// language's file (Swiss German writes "ss" for "ß", as vanilla's de_ch does).
-fn bundled_code(code: &str) -> (&str, bool) {
-    match code {
-        "ko" => ("ko_kr", false),
-        "hr" => ("hr_hr", false),
-        "de_at" => ("de_de", false),
-        "de_ch" => ("de_de", true),
-        "fr_ca" | "fr_ch" => ("fr_fr", false),
-        "es_ar" | "es_cl" | "es_ec" | "es_mx" | "es_uy" | "es_ve" => ("es_es", false),
-        code => (code, false),
-    }
-}
-
-/// Lang files crates above the engine ship (`horizon_hooks::lang`), each a list of
-/// (code, JSON) pairs. The game's entry installs them once, before any language loads.
-static CRATE_FILES: std::sync::OnceLock<&'static [&'static [(&'static str, &'static str)]]> =
-    std::sync::OnceLock::new();
-
-/// Installs the crates' lang files (`horizon_hooks::lang::engine::all()`). Only the first call
-/// counts.
-pub fn install_crate_files(files: &'static [&'static [(&'static str, &'static str)]]) {
-    let _ = CRATE_FILES.set(files);
-}
-
-/// The crates' entries for language `code` (through [`bundled_code`]'s variants) that the
-/// engine's own `horizon` file for it doesn't have: on a key both have, the engine wins.
-fn read_crate_files(files: &[&[(&str, &str)]], code: &str, map: &mut HashMap<String, String>) {
-    if files.is_empty() {
-        return;
-    }
-    let (file, swiss) = bundled_code(code);
-    let mut own = HashMap::new();
-    if let Some(bytes) = Bundled.read(&format!("assets/horizon/lang/{code}.json")) {
-        read_lang_file(&bytes, &mut own);
-    }
-    for (c, json) in files.iter().flat_map(|f| f.iter()) {
-        if *c != file {
-            continue;
-        }
-        let mut theirs = HashMap::new();
-        if swiss {
-            read_lang_file(json.replace('ß', "ss").as_bytes(), &mut theirs);
-        } else {
-            read_lang_file(json.as_bytes(), &mut theirs);
-        }
-        for (key, value) in theirs {
-            if !own.contains_key(&key) {
-                map.insert(key, value);
-            }
-        }
-    }
-}
-
 /// Horizon's own strings, compiled in so they need no prepared resources.
 struct Bundled;
 impl ResourceSource for Bundled {
     fn read(&self, path: &str) -> Option<Vec<u8>> {
-        let code = path
-            .strip_prefix("assets/horizon/lang/")?
-            .strip_suffix(".json")?;
-        let (file, swiss) = bundled_code(code);
-        let path = format!("assets/horizon/lang/{file}.json");
-        let body = match path.as_str() {
+        let body = match path {
             "assets/horizon/lang/en_us.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/en_us.json")
             }
@@ -162,10 +103,10 @@ impl ResourceSource for Bundled {
             "assets/horizon/lang/tr_tr.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/tr_tr.json")
             }
-            "assets/horizon/lang/ko_kr.json" => {
+            "assets/horizon/lang/ko_kr.json" | "assets/horizon/lang/ko.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/ko_kr.json")
             }
-            "assets/horizon/lang/hr_hr.json" => {
+            "assets/horizon/lang/hr_hr.json" | "assets/horizon/lang/hr.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/hr_hr.json")
             }
             "assets/horizon/lang/pt_pt.json" => {
@@ -390,20 +331,30 @@ impl ResourceSource for Bundled {
             "assets/horizon/lang/vec_it.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/vec_it.json")
             }
-            "assets/horizon/lang/de_de.json" => {
+            "assets/horizon/lang/de_de.json" | "assets/horizon/lang/de_at.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/de_de.json")
             }
-            "assets/horizon/lang/fr_fr.json" => {
+            // Swiss German writes "ss" for "ß", as vanilla's de_ch does.
+            "assets/horizon/lang/de_ch.json" => {
+                let de = include_str!("../../horizon-client/assets/horizon/lang/de_de.json");
+                return Some(de.replace('ß', "ss").into_bytes());
+            }
+            "assets/horizon/lang/fr_fr.json"
+            | "assets/horizon/lang/fr_ca.json"
+            | "assets/horizon/lang/fr_ch.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/fr_fr.json")
             }
-            "assets/horizon/lang/es_es.json" => {
+            "assets/horizon/lang/es_es.json"
+            | "assets/horizon/lang/es_ar.json"
+            | "assets/horizon/lang/es_cl.json"
+            | "assets/horizon/lang/es_ec.json"
+            | "assets/horizon/lang/es_mx.json"
+            | "assets/horizon/lang/es_uy.json"
+            | "assets/horizon/lang/es_ve.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/es_es.json")
             }
             _ => return None,
         };
-        if swiss {
-            return Some(body.replace('ß', "ss").into_bytes());
-        }
         Some(body.as_bytes().to_vec())
     }
     fn namespaces(&self) -> Vec<String> {
@@ -487,16 +438,6 @@ impl Language {
     /// from every namespace and every source in priority order (later sources
     /// override).
     pub fn load(sources: &[&dyn ResourceSource], code: &str) -> Self {
-        let crate_files = CRATE_FILES.get().copied().unwrap_or_default();
-        Self::load_with(sources, code, crate_files)
-    }
-
-    /// [`Language::load`] with these crates' lang files.
-    fn load_with(
-        sources: &[&dyn ResourceSource],
-        code: &str,
-        crate_files: &[&[(&str, &str)]],
-    ) -> Self {
         let mut map = HashMap::new();
         let mut codes = vec![DEFAULT];
         if code != DEFAULT {
@@ -512,14 +453,12 @@ impl Language {
             sources.iter().flat_map(|s| s.namespaces()).collect();
         for c in codes {
             for namespace in &namespaces {
-                for (i, source) in sources.iter().enumerate() {
-                    if let Some(bytes) = source.read(&format!("assets/{namespace}/lang/{c}.json")) {
-                        read_lang_file(&bytes, &mut map);
-                    }
-                    // The crates' text right after the engine's own (`Bundled`, the first source).
-                    if i == 0 && namespace == "horizon" {
-                        read_crate_files(crate_files, c, &mut map);
-                    }
+                for source in sources {
+                    let Some(bytes) = source.read(&format!("assets/{namespace}/lang/{c}.json"))
+                    else {
+                        continue;
+                    };
+                    read_lang_file(&bytes, &mut map);
                 }
             }
         }
@@ -749,43 +688,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn a_crates_text_loads_after_the_engines_and_before_packs() {
-        static CRATE: &[(&str, &str)] = &[
-            (
-                "en_us",
-                r#"{"test.crate.hello": "Hello", "horizon.osk.close": "Shut", "test.crate.packed": "Crate"}"#,
-            ),
-            (
-                "de_de",
-                r#"{"test.crate.hello": "Grüß dich", "horizon.osk.close": "Zu"}"#,
-            ),
-            ("fr_fr", r#"{"test.crate.hello": "Bonjour"}"#),
-        ];
-        let pack = Mem(HashMap::from([(
-            "assets/horizon/lang/en_us.json".to_owned(),
-            br#"{"test.crate.packed": "Pack"}"#.to_vec(),
-        )]));
-        let load = |code| Language::load_with(&[&pack], code, &[CRATE]);
-        let en = load("en_us");
-        assert_eq!(en.get("test.crate.hello"), Some("Hello"));
-        // The engine's own file wins on a key both have; a pack wins over both.
-        assert_eq!(en.get("horizon.osk.close"), Some("Close"));
-        assert_eq!(en.get("test.crate.packed"), Some("Pack"));
-        let de = load("de_de");
-        assert_eq!(de.get("test.crate.hello"), Some("Grüß dich"));
-        assert_eq!(de.get("horizon.osk.close"), Some("Schließen"));
-        // Regional variants read their language's file, as the engine's do.
-        assert_eq!(load("de_ch").get("test.crate.hello"), Some("Grüss dich"));
-        assert_eq!(load("fr_ca").get("test.crate.hello"), Some("Bonjour"));
-        // A language the crate lacks falls back to its English.
-        assert_eq!(load("pl_pl").get("test.crate.hello"), Some("Hello"));
-        // Without crate files, nothing changes.
-        let plain = Language::load_with(&[&pack], "de_de", &[]);
-        assert_eq!(plain.get("test.crate.hello"), None);
-        assert_eq!(plain.len() + 1, de.len());
-    }
-
     #[test]
     fn a_scoped_language_is_the_calling_threads_and_reports_what_it_lacks() {
         let empty = Mem(HashMap::new());
@@ -837,20 +739,6 @@ mod tests {
         std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
             .join("../horizon-client/assets/horizon/lang")
     }
-    /// The crates whose own lang files the game loads (`crates/<name>/assets/lang`,
-    /// registered through `horizon_hooks::lang`), with that folder.
-    fn crate_lang_dirs() -> Vec<(String, std::path::PathBuf)> {
-        let crates = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
-        let mut dirs: Vec<_> = std::fs::read_dir(&crates)
-            .unwrap()
-            .flatten()
-            .map(|e| (e.file_name().into_string().unwrap(), e.path()))
-            .map(|(name, path)| (name, path.join("assets/lang")))
-            .filter(|(_, dir)| dir.join("en_us.json").is_file())
-            .collect();
-        dirs.sort();
-        dirs
-    }
     /// The keys of a flat bundled file in file order, duplicates included (a map
     /// would keep only the last of two equal keys). One `"key": "value"` per line.
     fn file_keys(body: &str) -> Vec<String> {
@@ -888,33 +776,11 @@ mod tests {
 
     #[test]
     fn bundled_files_are_served_and_have_no_stale_or_repeated_keys() {
-        let engine = check_lang_dir(&bundled_dir(), true);
-        assert!(
-            engine.1 >= 7,
-            "found {} bundled lang files in {}",
-            engine.1,
-            bundled_dir().display()
-        );
-        // A crate's files pass the same checks. Its keys are its own: on a key the engine's
-        // files also have, the engine's text would win and hide the crate's.
-        for (name, dir) in crate_lang_dirs() {
-            let (en, _) = check_lang_dir(&dir, false);
-            for key in en.keys() {
-                assert!(
-                    !engine.0.contains_key(key),
-                    "{name}: {key} is also the engine's"
-                );
-            }
-        }
-    }
-
-    /// The checks every lang folder passes: flat maps, no repeated key, no key en_us lacks, the
-    /// same placeholders as English, no empty text. Its en_us and how many files it has.
-    fn check_lang_dir(dir: &std::path::Path, bundled: bool) -> (HashMap<String, String>, usize) {
+        let dir = bundled_dir();
         let en_body = std::fs::read_to_string(dir.join("en_us.json")).unwrap();
         let en: HashMap<String, String> = serde_json::from_str(&en_body).unwrap();
         let mut seen = 0;
-        for entry in std::fs::read_dir(dir).unwrap().flatten() {
+        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
             let name = entry.file_name().into_string().unwrap();
             let Some(code) = name.strip_suffix(".json") else {
                 continue;
@@ -923,7 +789,7 @@ mod tests {
             // A file that Bundled::read does not name is never loaded.
             let path = format!("assets/horizon/lang/{name}");
             assert!(
-                !bundled || Bundled.read(&path).is_some(),
+                Bundled.read(&path).is_some(),
                 "{name} is not served by Bundled"
             );
             let body = std::fs::read_to_string(entry.path()).unwrap();
@@ -949,7 +815,11 @@ mod tests {
                 assert!(!value.trim().is_empty(), "{code}: {key} is empty");
             }
         }
-        (en, seen)
+        assert!(
+            seen >= 7,
+            "found {seen} bundled lang files in {}",
+            dir.display()
+        );
     }
 
     #[test]
@@ -964,10 +834,10 @@ mod tests {
                 }
             }
         }
-        let english = |dir: &std::path::Path| -> HashMap<String, String> {
-            serde_json::from_str(&std::fs::read_to_string(dir.join("en_us.json")).unwrap()).unwrap()
-        };
-        let mut en = english(&bundled_dir());
+        let en: HashMap<String, String> = serde_json::from_str(
+            &std::fs::read_to_string(bundled_dir().join("en_us.json")).unwrap(),
+        )
+        .unwrap();
         let crates = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
         let mut files = Vec::new();
         for krate in [
@@ -977,11 +847,6 @@ mod tests {
         ] {
             rust_files(&crates.join(krate).join("src"), &mut files);
         }
-        // A crate that ships lang files names its keys in its own sources.
-        for (name, dir) in crate_lang_dirs() {
-            en.extend(english(&dir));
-            rust_files(&crates.join(name).join("src"), &mut files);
-        }
         assert!(files.len() > 100, "found only {} sources", files.len());
         let mut found = 0;
         for file in files {

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

@@ -670,39 +670,6 @@ pub fn with_horizon_icon(
     attributes
 }
 
-/// The screen a window is on: its size in physical pixels, its refresh rate where the OS gives
-/// it, and its scale. For `horizon-ctl status` and the performance statistics' `system.display`.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Display {
-    pub width: u32,
-    pub height: u32,
-    pub refresh_hz: Option<u32>,
-    pub scale: f64,
-}
-
-/// The screen `window` is on, else the primary one, else the only one: right after the window
-/// is made, Wayland doesn't say yet which screen it is on.
-pub fn monitor(window: &winit::window::Window) -> Option<winit::monitor::MonitorHandle> {
-    let only = || {
-        let mut all = window.available_monitors();
-        all.next().filter(|_| all.next().is_none())
-    };
-    window
-        .current_monitor()
-        .or_else(|| window.primary_monitor())
-        .or_else(only)
-}
-
-/// [`monitor`]'s size, refresh rate and scale.
-pub fn display(window: &winit::window::Window) -> Option<Display> {
-    monitor(window).map(|m| Display {
-        width: m.size().width,
-        height: m.size().height,
-        refresh_hz: m.refresh_rate_millihertz().map(|r| r.div_ceil(1000)),
-        scale: m.scale_factor(),
-    })
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

crates/horizon-client-lib/Cargo.toml

@@ -18,6 +18,8 @@ horizon-client-core = { path = "../horizon-client-core" }
 horizon-client-input = { path = "../horizon-client-input" }
 horizon-client-render = { path = "../horizon-client-render" }
 horizon-command = { path = "../horizon-command" }
+# Emotes pose the player model (`Mob::emote`, `mobs::anim::setup`).
+horizon-cosmetics = { path = "../horizon-cosmetics" }
 horizon-items = { path = "../horizon-items" }
 horizon-core = { path = "../horizon-core" }
 # Extension points for the crates above the engine (docs/layers.md, "How a Horizon crate plugs in").
@@ -42,6 +44,8 @@ horizon-chat-filter = { path = "../horizon-chat-filter" }
 horizon-shaders = { path = "../horizon-shaders" }
 # Horizon's own shader packs: the format, the stages and the check (docs/shaders.md).
 horizon-shader-api = { path = "../horizon-shader-api" }
+# Play with Friends: invite codes and their tunnel; the `friends` feature.
+horizon-friends = { path = "../horizon-friends", optional = true }
 # The narrator (GameNarrator): text-to-speech of chat, system messages and screens.
 horizon-narrator = { path = "../horizon-narrator" }
 # Horizon mods: sandboxed WebAssembly components, off unless installed and turned on (docs/mods.md).
@@ -109,17 +113,16 @@ objc2-foundation = { version = "0.3", default-features = false, features = ["std
 wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }
 
 [features]
-default = ["audio", "controllers", "horizon-extras"]
+default = ["audio", "controllers", "discord", "friends"]
 # Sound output. Without it (and `controllers`) the program links neither libasound nor libudev on
 # Linux: the server build (`--no-default-features`, released as horizon-engine; docs/server.md).
 audio = ["horizon-client-render/audio"]
 # Controllers: gilrs, and the DualSense's own output. Without it only `horizon-ctl pad`'s virtual pad.
 controllers = ["dep:gilrs", "horizon-client-input/controllers"]
-# Horizon's own parts (docs/forking.md, docs/layers.md): the features below, and the official
-# server in the list (`official_servers`).
-horizon-extras = ["discord"]
 # "Playing Horizon" on the player's Discord profile (`discord_presence`).
 discord = []
+# Play with Friends, joining side (`net.rs`): without it no invite code joins.
+friends = ["dep:horizon-friends"]
 # Records the call sites of mob random draws (`mob_ai_probe` traces).
 rng-trace = ["horizon-core/rng-trace"]
 # Compatibility with earlier experiment commands: main already uses mimalloc.

crates/horizon-client-render/Cargo.toml

@@ -7,8 +7,6 @@ rust-version.workspace = true
 description = "The client's world data, rendering and screens: chunks, meshing, light, streaming, the renderer, the HUD, menus and settings; no gameplay"
 
 [dependencies]
-# The settings stores of the crates above the engine (docs/layers.md, "Platform registries").
-horizon-hooks = { path = "../horizon-hooks" }
 horizon-cosmetics = { path = "../horizon-cosmetics" }
 # The GUI atlas's pixels, kept compressed once uploaded (hud.rs `pack_pixels`).
 lz4_flex = { version = "0.14", default-features = false, features = ["std", "safe-encode", "safe-decode", "checked-decode"] }
@@ -26,6 +24,7 @@ horizon-narrator = { path = "../horizon-narrator" }
 horizon-optifine = { path = "../horizon-optifine" }
 horizon-polytone = { path = "../horizon-polytone" }
 horizon-protocol = { path = "../horizon-protocol" }
+horizon-render-pipeline = { path = "../horizon-render-pipeline" }
 horizon-shader-api = { path = "../horizon-shader-api" }
 horizon-shaders = { path = "../horizon-shaders" }
 horizon-system = { path = "../horizon-system" }
@@ -76,10 +75,6 @@ wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }
 audio = ["dep:cpal"]
 # Helpers horizon-client's tests build their fixtures with.
 test-support = []
-# horizon-client's `horizon-extras`: asking the device for hardware ray tracing on request
-# (`gfx/ray_query.rs`, `HORIZON_RAY_TRACING=1`). Without it the device is requested as without
-# the variable.
-horizon-extras = []
 
 [lints]
 workspace = true

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

@@ -382,8 +382,8 @@ impl RenderAssets {
         };
         // After the connected tiles: a tile identical to a block shares its layer, and the
         // overlays skip shared layers.
-        if draws && let Some(suffix) = crate::pack_hooks::formats().emissive_suffix(root) {
-            emissive = crate::native_emissive::load_overlays(root, &suffix, &mut sprites);
+        if draws {
+            emissive = crate::native_emissive::load_optifine(root, &mut sprites);
         }
         sprites.save_disk_cache();
         if draws {

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

@@ -233,11 +233,11 @@ pub fn texture_path(root: &Path, texture: &str, directory: &str) -> PathBuf {
     }
     let (namespace, path) = texture.split_once(':').unwrap_or(("minecraft", texture));
     let rel = format!("assets/{namespace}/{directory}/{path}.png");
-    // No `.`, `..` or empty segment, and no `\` (a separator on Windows, where `..\..` climbs).
-    let stays = rel
-        .split('/')
-        .all(|segment| !matches!(segment, "" | "." | "..") && !segment.contains('\\'));
-    root.join(if stays { &rel } else { NOWHERE })
+    root.join(if horizon_optifine::paths::valid(&rel) {
+        &rel
+    } else {
+        NOWHERE
+    })
 }
 
 /// `SpriteSourceList.list`: every sprite id of the atlas and its origin.

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

@@ -16,45 +16,6 @@ use crate::{
 #[path = "chat_tests.rs"]
 mod tests;
 
-/// `FilterMask.applyWithFormatting` over a player message's signed content, as
-/// the packet's mask `(type, bit set)`: as it is when passed through, none when
-/// fully filtered, and when partly filtered each masked UTF-16 unit becomes a
-/// `#` in `FILTERED_STYLE` (dark grey, hover "chat.filtered").
-pub fn filtered_message(
-    content: &str,
-    (kind, bits): &(i32, Vec<i64>),
-) -> Option<serde_json::Value> {
-    match kind {
-        1 => return None,
-        2 => {}
-        _ => return Some(serde_json::Value::from(content)),
-    }
-    let masked = |i: usize| {
-        bits.get(i / 64)
-            .is_some_and(|w| (*w as u64 >> (i % 64)) & 1 != 0)
-    };
-    let units: Vec<u16> = content.encode_utf16().collect();
-    let mut parts = Vec::new();
-    let mut start = 0;
-    while start < units.len() {
-        let filtered = masked(start);
-        let end = (start..units.len())
-            .find(|&i| masked(i) != filtered)
-            .unwrap_or(units.len());
-        parts.push(if filtered {
-            serde_json::json!({
-                "text": "#".repeat(end - start),
-                "color": "dark_gray",
-                "hover_event": {"action": "show_text", "value": {"translate": "chat.filtered"}},
-            })
-        } else {
-            serde_json::Value::from(String::from_utf16_lossy(&units[start..end]))
-        });
-        start = end;
-    }
-    Some(serde_json::json!({"text": "", "extra": parts}))
-}
-
 /// `CommandHistory.PERSISTED_COMMANDS_FILE_NAME` and its size cap.
 const COMMAND_HISTORY_FILE: &str = "command_history.txt";
 const MAX_PERSISTED_COMMAND_HISTORY: usize = 50;

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

@@ -1026,43 +1026,3 @@ fn a_compact_repeat_keeps_the_scrolled_view_still() {
     says(&mut chat, "new");
     assert_eq!(chat.scroll, 6);
 }
-
-/// `FilterMask.applyWithFormatting`: a pass-through mask keeps the message, a
-/// fully filtered one hides it, and a partial one turns each masked UTF-16 unit
-/// into a dark grey `#` whose hover reads `chat.filtered`.
-#[test]
-fn a_server_filter_mask_hides_or_masks_the_message() {
-    let text = |v: &serde_json::Value| crate::component::to_text(v, &mut |s| Text::literal(s));
-    let shown = |content: &str, mask: (i32, Vec<i64>)| {
-        filtered_message(content, &mask).map(|v| text(&v).plain())
-    };
-    assert_eq!(shown("hello", (0, vec![])), Some("hello".to_owned()));
-    assert_eq!(shown("hello", (1, vec![])), None);
-    assert_eq!(shown("hello", (2, vec![0b0110])), Some("h##lo".to_owned()));
-    assert_eq!(
-        shown("hello", (2, vec![0b1_0001])),
-        Some("#ell#".to_owned())
-    );
-    // An emoji is two UTF-16 units, so two bits and two `#`.
-    assert_eq!(
-        shown("a\u{1F600}b", (2, vec![0b0110])),
-        Some("a##b".to_owned())
-    );
-    // Bit 65 is in the second word.
-    let long = "x".repeat(70);
-    let mut expected = long.clone();
-    expected.replace_range(65..66, "#");
-    assert_eq!(shown(&long, (2, vec![0, 0b10])), Some(expected));
-    let masked = text(&filtered_message("hello", &(2, vec![0b0110])).unwrap());
-    let hash = masked.spans.iter().find(|s| s.text == "##").unwrap();
-    assert_eq!(hash.style.color, Some(text::DARK_GRAY));
-    let hover = hash.style.hover.as_ref().unwrap();
-    assert_eq!(hover.spans[0].text, "chat.filtered");
-    assert!(
-        masked
-            .spans
-            .iter()
-            .filter(|s| s.text != "##")
-            .all(|s| s.style.color.is_none())
-    );
-}

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

@@ -121,8 +121,8 @@ impl CommandBlock {
             condition_met: flag("conditionMet", false),
         }
     }
-    /// `CommandBlockEntity.saveAdditional`. The last output is the component
-    /// itself (`ComponentSerialization.CODEC`), styles and click events kept.
+    /// `CommandBlockEntity.saveAdditional`. The last output is written as a
+    /// plain string component.
     pub fn save(&self) -> Vec<(&'static str, Tag)> {
         let mut out = vec![
             ("Command", Tag::String(self.command.as_str().into())),
@@ -135,7 +135,7 @@ impl CommandBlock {
         if self.track_output
             && let Some(last) = &self.last_output
         {
-            out.push(("LastOutput", scoreboard::component_tag(&last.component())));
+            out.push(("LastOutput", Tag::String(last.plain().as_str().into())));
         }
         out.push((
             "UpdateLastExecution",

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

@@ -43,11 +43,6 @@ pub fn enter_native_mod(call: NativeModCall) -> NativeModGuard {
     }
 }
 
-/// The native mod call this thread is currently inside, if any.
-pub fn current_native_mod() -> Option<NativeModCall> {
-    IN_NATIVE_MOD.with(Cell::get)
-}
-
 /// Puts back the call that `enter_native_mod` found.
 #[must_use]
 pub struct NativeModGuard {

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

@@ -1,34 +1,27 @@
-//! Custom sky layers: skyboxes a pack draws over the vanilla sky, in a format vanilla doesn't read
-//! (OptiFine's), which the platform's pack formats fill ([`crate::pack_hooks`]). The layers'
-//! textures are read once with the pack; each frame the game asks for the layers to draw, their
-//! brightness and rotation ([`SkyLayers::draws`]), and `gfx::custom_sky` draws them over the
-//! vanilla sky. A pack without layers keeps the vanilla sky.
+//! OptiFine custom skies (`horizon_optifine::sky`) as the game draws them: a pack's layers with
+//! their decoded textures, read once with the pack, and each frame's choice of layers, their
+//! brightness and rotation ([`CustomSky::draws`]), which `gfx::custom_sky` draws over the
+//! vanilla sky. A pack without `optifine/sky` gives an empty [`CustomSky`] and the sky stays
+//! vanilla.
 
 use std::path::Path;
-use std::sync::Arc;
 
-use glam::Mat4;
+use glam::{Mat4, Vec3};
+use horizon_optifine::sky::{Blend, Conditions, Skies, SkyLayer, Transition};
 
-/// A layer's texture, RGBA8: the skybox's six faces in a 3x2 grid, bottom, top and south in the
-/// top row, west, north and east below (`gfx::custom_sky`'s faces).
+/// A layer's texture, RGBA8.
 pub struct Image {
     pub width: u32,
     pub height: u32,
     pub rgba: Vec<u8>,
 }
 
-/// How a layer mixes with what is drawn below it.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Blend {
-    Add,
-    Subtract,
-    Multiply,
-    Dodge,
-    Burn,
-    Screen,
-    Replace,
-    Overlay,
-    Alpha,
+/// The pack's layers, by world, with one texture per layer (`images[i]` for the `i`th layer
+/// over all worlds, in `worlds` order).
+#[derive(Default)]
+pub struct CustomSky {
+    worlds: Vec<(i32, Vec<SkyLayer>)>,
+    pub images: Vec<Image>,
 }
 
 /// One layer of a frame: which texture, with which blend, how bright and turned how.
@@ -41,44 +34,62 @@ pub struct Draw {
     pub rotation: Mat4,
 }
 
-/// The weather of a frame: thunder is a storm's rain, so it is only `Thunder`.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Weather {
-    Clear,
-    Rain,
-    Thunder,
-}
-
-/// What a frame's layers may depend on.
-#[derive(Clone, Copy, Debug)]
-pub struct Conditions<'a> {
-    /// Ticks of the day, counting the days.
-    pub day_time: i64,
-    pub weather: Weather,
-    /// The biome at the camera, namespaced.
-    pub biome: &'a str,
-    /// The camera's block height.
-    pub y: i32,
-}
-
 /// The eased brightness of each layer, kept by the game between frames.
 #[derive(Default)]
 pub struct State {
-    /// The world the layers were last drawn for.
-    pub world: Option<i32>,
-    /// Each layer's eased visibility, 0 to 1.
-    pub eased: Vec<f32>,
+    world: Option<i32>,
+    eased: Vec<Transition>,
 }
 
-/// A pack's custom sky layers, by world (`0` the Overworld, `1` the End).
-pub trait SkyLayers: Send + Sync {
-    /// Every layer's texture: [`Draw::image`] indexes it.
-    fn images(&self) -> &[Image];
-    /// Whether `world` has layers.
-    fn has(&self, world: i32) -> bool;
-    /// This frame's layers of `world` into `out` (cleared first), in drawing order, eased by
-    /// `seconds` since the last frame. `sun_turns` is the sun's angle over 360° (`0` at noon).
-    fn draws(
+/// Textures past this many texels in all are left out (a skybox is a few megapixels at most).
+const TEXEL_BUDGET: u64 = 64 << 20;
+
+impl CustomSky {
+    /// The custom skies of the overlay at `root`. A layer whose texture does not decode is
+    /// dropped with a warning.
+    pub fn load(root: &Path) -> Self {
+        let skies = Skies::scan(root);
+        let mut out = Self::default();
+        let mut texels = 0u64;
+        for (world, sky) in skies.worlds {
+            let mut layers = Vec::new();
+            for layer in sky.layers {
+                match crate::hud::decode(&root.join(&layer.source)) {
+                    Ok((width, height, rgba))
+                        if texels + u64::from(width) * u64::from(height) <= TEXEL_BUDGET =>
+                    {
+                        texels += u64::from(width) * u64::from(height);
+                        out.images.push(Image {
+                            width,
+                            height,
+                            rgba,
+                        });
+                        layers.push(layer);
+                    }
+                    Ok(_) => log::warn!("{}: past the custom sky's texture budget", layer.source),
+                    Err(e) => log::warn!("{}: {e:#}", layer.source),
+                }
+            }
+            if !layers.is_empty() {
+                out.worlds.push((world, layers));
+            }
+        }
+        out
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.worlds.is_empty()
+    }
+
+    /// Whether `world` has layers (`0` the Overworld, `1` the End).
+    pub fn has(&self, world: i32) -> bool {
+        self.worlds.iter().any(|(w, _)| *w == world)
+    }
+
+    /// This frame's layers of `world` into `out` (cleared first), in drawing order: those whose
+    /// conditions hold, eased over their `transition` by `seconds` since the last frame, at the
+    /// brightness of their fade times. `sun_turns` is the sun's angle over 360° (`0` at noon).
+    pub fn draws(
         &self,
         world: i32,
         conditions: &Conditions,
@@ -86,30 +97,147 @@ pub trait SkyLayers: Send + Sync {
         seconds: f32,
         state: &mut State,
         out: &mut Vec<Draw>,
-    );
-}
-
-/// No layers: the vanilla sky.
-struct NoLayers;
-
-impl SkyLayers for NoLayers {
-    fn images(&self) -> &[Image] {
-        &[]
-    }
-
-    fn has(&self, _: i32) -> bool {
-        false
-    }
-
-    fn draws(&self, _: i32, _: &Conditions, _: f32, _: f32, s: &mut State, out: &mut Vec<Draw>) {
+    ) {
         out.clear();
-        s.world = None;
+        let mut first = 0;
+        let mut found = None;
+        for (w, layers) in &self.worlds {
+            if *w == world {
+                found = Some(layers);
+                break;
+            }
+            first += layers.len();
+        }
+        let Some(layers) = found else {
+            state.world = None;
+            return;
+        };
+        // A new world (or pack) starts each layer where its conditions put it: no fade in.
+        let snap = state.world != Some(world) || state.eased.len() != layers.len();
+        if snap {
+            state.world = Some(world);
+            state.eased.clear();
+            state.eased.resize(layers.len(), Transition::default());
+        }
+        for (i, (layer, eased)) in layers.iter().zip(&mut state.eased).enumerate() {
+            let target = if layer.shows(conditions) { 1.0 } else { 0.0 };
+            let shown = if snap {
+                eased.value = target;
+                target
+            } else {
+                eased.step(target, seconds, layer.transition)
+            };
+            let brightness = shown * layer.brightness(conditions.day_time);
+            if brightness <= 0.0 {
+                continue;
+            }
+            let turns = layer.turns(conditions.day_time, sun_turns);
+            let rotation = if turns == 0.0 {
+                Mat4::IDENTITY
+            } else {
+                Mat4::from_axis_angle(Vec3::from_array(layer.axis), turns * std::f32::consts::TAU)
+            };
+            out.push(Draw {
+                image: (first + i) as u16,
+                blend: layer.blend,
+                brightness,
+                rotation,
+            });
+        }
     }
 }
 
-/// The custom sky layers of the overlay at `root`, from the installed pack formats.
-pub fn load(root: &Path) -> Arc<dyn SkyLayers> {
-    crate::pack_hooks::formats()
-        .custom_sky(root)
-        .unwrap_or_else(|| Arc::new(NoLayers))
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_optifine::sky::Now;
+
+    fn pack(files: &[(&str, &str)]) -> (std::path::PathBuf, CustomSky) {
+        let root = std::env::temp_dir().join(format!(
+            "horizon-custom-sky-{}-{}",
+            std::process::id(),
+            files.len()
+        ));
+        let _ = std::fs::remove_dir_all(&root);
+        let dir = root.join("assets/minecraft/optifine/sky/world0");
+        std::fs::create_dir_all(&dir).unwrap();
+        let png = {
+            let mut bytes = Vec::new();
+            let mut encoder = png::Encoder::new(&mut bytes, 6, 4);
+            encoder.set_color(png::ColorType::Rgba);
+            encoder.set_depth(png::BitDepth::Eight);
+            let mut writer = encoder.write_header().unwrap();
+            writer
+                .write_image_data(&[255, 0, 0, 255].repeat(24))
+                .unwrap();
+            writer.finish().unwrap();
+            bytes
+        };
+        for (name, text) in files {
+            std::fs::write(dir.join(format!("{name}.properties")), text).unwrap();
+            std::fs::write(dir.join(format!("{name}.png")), &png).unwrap();
+        }
+        let sky = CustomSky::load(&root);
+        (root, sky)
+    }
+
+    fn noon(biome: &str) -> Conditions<'_> {
+        Conditions {
+            day_time: 6000,
+            weather: Now::Clear,
+            biome,
+            y: 64,
+        }
+    }
+
+    #[test]
+    fn layers_ease_in_at_a_biome_border_but_not_on_arrival() {
+        let (root, sky) = pack(&[
+            ("sky1", "biomes=desert\ntransition=2"),
+            ("sky2", "blend=alpha\nrotate=false"),
+        ]);
+        let _ = std::fs::remove_dir_all(root);
+        assert!(sky.has(0) && !sky.has(1));
+        assert_eq!(sky.images[0].width, 6);
+        let (mut state, mut out) = (State::default(), Vec::new());
+        sky.draws(
+            0,
+            &noon("minecraft:desert"),
+            0.0,
+            0.05,
+            &mut state,
+            &mut out,
+        );
+        assert_eq!(
+            out.iter().map(|d| d.brightness).collect::<Vec<_>>(),
+            [1.0, 1.0]
+        );
+        // Out of the desert: the first layer fades over its two seconds.
+        sky.draws(0, &noon("minecraft:plains"), 0.0, 0.5, &mut state, &mut out);
+        assert_eq!(out[0].brightness, 0.75);
+        assert_eq!(out[1].blend, Blend::Alpha);
+        sky.draws(0, &noon("minecraft:plains"), 0.0, 2.0, &mut state, &mut out);
+        assert_eq!(out.len(), 1, "a dark layer is not drawn");
+        assert_eq!(out[0].image, 1);
+        // Into the End, which has no layers, and back: no fade.
+        sky.draws(1, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
+        assert!(out.is_empty());
+        sky.draws(0, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
+        assert_eq!(out.len(), 2);
+    }
+
+    #[test]
+    fn a_layer_turns_west_like_the_sun() {
+        let (root, sky) = pack(&[("sky1", "")]);
+        let _ = std::fs::remove_dir_all(root);
+        let (mut state, mut out) = (State::default(), Vec::new());
+        // A quarter turn after noon (sunset): the skybox's zenith has gone down to the west.
+        let c = Conditions {
+            day_time: 12000,
+            ..noon("minecraft:plains")
+        };
+        sky.draws(0, &c, 0.25, 0.0, &mut state, &mut out);
+        let up = out[0].rotation.transform_vector3(Vec3::Y);
+        assert!((up - Vec3::NEG_X).length() < 1e-5, "{up}");
+    }
 }

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

@@ -305,9 +305,6 @@ pub(crate) struct Colormap {
     /// (`temperature`, `downfall`, `biome_id`) blend: Polytone 6.8.6's water by `biome_id`
     /// fades over a biome edge.
     pub(crate) biome_blend: bool,
-    /// Its axes read nothing that changes up a column of one biome (no `o.y`): a section of
-    /// one biome can sample it once per column.
-    pub(crate) column: bool,
     width: u32,
     height: u32,
     rgba: Vec<u8>,
@@ -326,18 +323,6 @@ enum Axis {
 }
 
 impl Axis {
-    /// Whether the axis reads only what stays the same up a column of one biome.
-    fn column(&self) -> bool {
-        use horizon_polytone::expr::Root;
-        let flat = |root: Root, name: &str| match root {
-            Root::Object => matches!(name, "x" | "z" | "biome" | "temperature" | "downfall"),
-            Root::Random => name == "noise",
-            _ => false,
-        };
-        match self {
-            Self::Expr(program) | Self::BiomeId(_, program) => program.reads_only(&flat),
-        }
-    }
     fn value(&self, host: &mut dyn horizon_polytone::expr::Host) -> Option<f64> {
         match self {
             Self::Expr(program) => Some(program.eval(host).ok()?.num()),
@@ -388,23 +373,6 @@ fn biome_id_mapper(pack_root: &Path, json: &Json) -> HashMap<String, f64> {
 }
 
 impl Colormap {
-    /// One colour wherever it samples (a `biome_colors` flat colour, RGB).
-    pub(crate) fn flat(rgb: u32) -> Self {
-        let zero = || Axis::Expr(horizon_polytone::expr::Program::compile("0").expect("a number"));
-        let [_, r, g, b] = rgb.to_be_bytes();
-        Self {
-            x: zero(),
-            y: zero(),
-            triangular: false,
-            rounds: true,
-            biome_blend: false,
-            column: true,
-            width: 1,
-            height: 1,
-            rgba: vec![r, g, b, 255],
-        }
-    }
-
     /// `assets/<namespace>/polytone/colormaps/<path>.png` and its optional `.json` (without
     /// one, the axes are the biome's temperature and downfall).
     pub(crate) fn load(pack_root: &Path, id: &str) -> Option<Self> {
@@ -456,11 +424,9 @@ impl Colormap {
             axis("x_axis", "o.temperature")?,
             axis("y_axis", "o.downfall")?,
         );
-        let column = [&x, &y].iter().all(|axis| axis.column());
         Some(Self {
             x,
             y,
-            column,
             biome_blend: json["biome_blend"].as_bool().unwrap_or(by_biome),
             triangular: json["triangular"].as_bool() == Some(true),
             rounds: json["rounds"].as_bool() != Some(false),

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

@@ -482,16 +482,13 @@ impl Extras {
         true
     }
     /// Written only once something differs from the defaults, so a vanilla
-    /// setup gains no file. The settings stores of this file follow these lines
-    /// (`horizon_hooks::settings`).
+    /// setup gains no file.
     pub fn save(&self, dir: &Path) {
         let path = dir.join(FILE);
-        let mut text = self.serialize();
-        let stores_default = horizon_hooks::settings::engine::append(FILE, &mut text);
-        if *self == Self::default() && stores_default && !path.exists() {
+        if *self == Self::default() && !path.exists() {
             return;
         }
-        let _ = fs::write(path, text);
+        let _ = fs::write(path, self.serialize());
     }
 }
 

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

@@ -1,6 +1,5 @@
 //! The Horizon Extras page, on the settings shell (`settings_shell`): which rows it has and what
-//! pressing them does. Each one's value and what it does stay in `extras::Item`; the sections crates
-//! add (`horizon_hooks::pages::Place::Extras`) keep theirs.
+//! pressing them does. Each one's value and what it does stay in `extras::Item`.
 use crate::{
     extras::{self, Item},
     lang,
@@ -8,7 +7,6 @@ use crate::{
     settings::Settings,
     settings_shell::{self as shell, Binding, Group, Output, Row, Screen, Sheet, Value},
 };
-use horizon_hooks::pages::{self as added, Act, Label};
 
 const TITLE: &str = "horizon.pages.extras";
 const ABOUT: &str = "horizon.pages.extras.tooltip";
@@ -33,125 +31,6 @@ pub(crate) enum ExtraRow {
     /// It isn't installed: where to get it. A note, not a button: Options > Mods already has the
     /// one way into the Mods page (`every_setting_and_page_is_reached_from_one_place`).
     ZoomInstall,
-    /// Row `.1` of the section registered page `.0` adds (`Place::Extras`).
-    Added(usize, usize),
-}
-
-#[cfg(test)]
-thread_local! {
-    /// A test's own pages, instead of the game's registered ones: each test runs on its thread.
-    static TEST_PAGES: std::cell::Cell<Option<&'static [&'static dyn added::Page]>> =
-        const { std::cell::Cell::new(None) };
-}
-
-/// The pages crates registered, all places.
-fn pages() -> &'static [&'static dyn added::Page] {
-    #[cfg(test)]
-    if let Some(pages) = TEST_PAGES.get() {
-        return pages;
-    }
-    added::engine::all()
-}
-
-/// The sections of this page, by their index among the registered pages.
-fn sections() -> impl Iterator<Item = (usize, &'static dyn added::Page)> {
-    let pages = pages().iter().copied().enumerate();
-    pages.filter(|(_, page)| page.place() == added::Place::Extras)
-}
-
-fn label_text(label: Label) -> String {
-    match label {
-        Label::Key(key) => lang::get(key),
-        Label::Value(text) => text,
-    }
-}
-
-/// The page's group named `name`, made at the end if it has none.
-fn group_named<'a>(
-    groups: &'a mut Vec<Group<ExtraRow>>,
-    name: &'static str,
-) -> &'a mut Group<ExtraRow> {
-    let at = groups.iter().position(|group| group.name == name);
-    let at = at.unwrap_or_else(|| {
-        groups.push(Group {
-            name,
-            rows: Vec::new(),
-        });
-        groups.len() - 1
-    });
-    &mut groups[at]
-}
-
-/// The sections' rows, in the groups their titles and headings name.
-fn add_sections(groups: &mut Vec<Group<ExtraRow>>) {
-    for (page, section) in sections() {
-        let mut rows = Vec::new();
-        section.rows(&mut rows);
-        let mut name = section.title();
-        for (r, row) in rows.into_iter().enumerate() {
-            let id = ExtraRow::Added(page, r);
-            let row = match row {
-                added::Row::Heading(key) => {
-                    name = key;
-                    continue;
-                }
-                added::Row::Note(text) => Row::new(id, text, Value::Note).live(false),
-                added::Row::Toggle { label, on } => {
-                    Row::new(id, lang::get(label), Value::Switch(on))
-                }
-                added::Row::Cycle { label, value } => {
-                    Row::new(id, lang::get(label), Value::Choice(label_text(value)))
-                }
-                added::Row::Slider { label, value, text } => {
-                    let position = value.clamp(0.0, 1.0);
-                    let text = label_text(text);
-                    let value = Value::Slider {
-                        position,
-                        steps: None,
-                        text,
-                    };
-                    Row::new(id, lang::get(label), value)
-                }
-                added::Row::Button {
-                    label,
-                    active: true,
-                    ..
-                } => Row::new(id, lang::get(label), Value::Press),
-                added::Row::Key { label, key } => {
-                    let key = crate::keybinds::display_name(&key).plain();
-                    Row::new(id, lang::get(label), Value::Read(key))
-                }
-                // A row kind newer than this engine.
-                _ => continue,
-            };
-            let row = match section.tooltip(r) {
-                Some(about) => row.about(label_text(about)),
-                None => row,
-            };
-            group_named(groups, name).rows.push(row);
-        }
-    }
-}
-
-/// Row `r` of registered page `page` was acted on: the options screen saves when it closes.
-fn act(page: usize, r: usize, act: Act) -> Vec<Output> {
-    let Some(section) = pages().get(page) else {
-        return Vec::new();
-    };
-    section.act(r, act);
-    vec![Output::Event(Event::Changed)]
-}
-
-/// Whether row `r` of registered page `page` steps (a switch or a cycle).
-fn steps(page: usize, r: usize) -> bool {
-    let mut rows = Vec::new();
-    if let Some(section) = pages().get(page) {
-        section.rows(&mut rows);
-    }
-    matches!(
-        rows.get(r),
-        Some(added::Row::Toggle { .. } | added::Row::Cycle { .. })
-    )
 }
 
 fn item_row(item: Item, s: &Settings) -> Row<ExtraRow> {
@@ -206,14 +85,9 @@ impl Screen for ExtrasScreen {
     fn note_lines(&self) -> usize {
         NOTE_LINES
     }
-    /// The rows read the extras, the mods, whether cosmetics are offered and the sections' rows.
+    /// The rows read the extras, the mods and whether cosmetics are offered.
     fn stamp(&self, s: &Settings) -> u64 {
-        let mut added = Vec::new();
-        for (_, section) in sections() {
-            section.rows(&mut added);
-        }
-        let cosmetics = horizon_cosmetics::enabled();
-        shell::stamp_of(&(&s.extras, &s.mods, cosmetics, added))
+        shell::stamp_of(&(&s.extras, &s.mods, horizon_cosmetics::enabled()))
     }
     fn sheets(&self, s: &Settings) -> Vec<Sheet<(), ExtraRow>> {
         let mut groups = vec![Group {
@@ -233,7 +107,6 @@ impl Screen for ExtrasScreen {
                 }
             }
         }
-        add_sections(&mut groups);
         vec![Sheet::new((), lang::get(TITLE), lang::get(ABOUT), groups)]
     }
     fn press(&mut self, s: &mut Settings, row: ExtraRow, back: bool) -> Vec<Output> {
@@ -252,29 +125,16 @@ impl Screen for ExtrasScreen {
                 Output::Event(Event::NativeSettings(i)),
             ],
             ExtraRow::ZoomInstall => Vec::new(),
-            ExtraRow::Added(page, r) => {
-                act(page, r, if back { Act::PressBack } else { Act::Press })
-            }
-        }
-    }
-    fn slide(&mut self, _s: &mut Settings, row: ExtraRow, position: f32) {
-        if let ExtraRow::Added(page, r) = row {
-            act(page, r, Act::Slide(position));
         }
     }
     /// With the wheel extra on, the wheel over an item changes it, without a click; the mod's rows
     /// let the list scroll.
     fn wheel_step(&mut self, s: &mut Settings, row: ExtraRow, back: bool) -> Option<Vec<Output>> {
-        match row {
-            ExtraRow::Item(item) => {
-                item.cycle(&mut s.extras, back);
-                Some(vec![Output::Event(Event::Changed)])
-            }
-            ExtraRow::Added(page, r) if steps(page, r) => {
-                Some(act(page, r, if back { Act::PressBack } else { Act::Press }))
-            }
-            _ => None,
-        }
+        let ExtraRow::Item(item) = row else {
+            return None;
+        };
+        item.cycle(&mut s.extras, back);
+        Some(vec![Output::Event(Event::Changed)])
     }
 }
 
@@ -432,146 +292,4 @@ mod tests {
         shell.key(&mut s, K::ArrowDown, None, false, size);
         assert_eq!(shell.focused_row(), Some(first));
     }
-
-    /// A section with a switch in the page's Multiplayer group, then a heading of its own with a
-    /// number that steps either way, a note and a volume.
-    struct Section {
-        on: std::sync::Mutex<bool>,
-        step: std::sync::Mutex<i32>,
-        volume: std::sync::Mutex<f32>,
-    }
-    impl added::Page for Section {
-        fn id(&self) -> &'static str {
-            "test.section"
-        }
-        fn title(&self) -> &'static str {
-            "horizon.extras.header.multiplayer"
-        }
-        fn place(&self) -> added::Place {
-            added::Place::Extras
-        }
-        fn rows(&self, rows: &mut Vec<added::Row>) {
-            rows.push(added::Row::Toggle {
-                label: "test.section.switch",
-                on: *self.on.lock().unwrap(),
-            });
-            rows.push(added::Row::Heading("test.section.heading"));
-            rows.push(added::Row::Cycle {
-                label: "test.section.step",
-                value: Label::Value(self.step.lock().unwrap().to_string()),
-            });
-            rows.push(added::Row::Note("a note".into()));
-            rows.push(added::Row::Slider {
-                label: "test.section.volume",
-                value: *self.volume.lock().unwrap(),
-                text: Label::Value(String::new()),
-            });
-        }
-        fn act(&self, row: usize, act: Act) {
-            match (row, act) {
-                (0, Act::Press | Act::PressBack) => {
-                    let mut on = self.on.lock().unwrap();
-                    *on = !*on;
-                }
-                (2, Act::Press) => *self.step.lock().unwrap() += 1,
-                (2, Act::PressBack) => *self.step.lock().unwrap() -= 1,
-                (4, Act::Slide(v)) => *self.volume.lock().unwrap() = v,
-                _ => {}
-            }
-        }
-    }
-
-    /// A page for Horizon Settings: never on Extras.
-    struct Elsewhere;
-    impl added::Page for Elsewhere {
-        fn id(&self) -> &'static str {
-            "test.elsewhere"
-        }
-        fn title(&self) -> &'static str {
-            "test.elsewhere"
-        }
-        fn place(&self) -> added::Place {
-            added::Place::HorizonSettings
-        }
-        fn rows(&self, rows: &mut Vec<added::Row>) {
-            rows.push(added::Row::button("test.elsewhere.button"));
-        }
-        fn act(&self, _: usize, _: Act) {}
-    }
-
-    fn with_section() -> &'static Section {
-        let section: &'static Section = Box::leak(Box::new(Section {
-            on: false.into(),
-            step: 0.into(),
-            volume: 0.5.into(),
-        }));
-        let pages: &'static [&'static dyn added::Page] = Box::leak(Box::new([
-            &Elsewhere as &dyn added::Page,
-            section as &dyn added::Page,
-        ]));
-        TEST_PAGES.set(Some(pages));
-        section
-    }
-
-    /// The section's first row joins the page's own Multiplayer group, after its rows; its heading
-    /// starts a group after the page's; a page for elsewhere adds nothing.
-    #[test]
-    fn a_section_joins_the_group_its_title_names_and_heads_its_own() {
-        with_section();
-        let s = Settings::default();
-        let sheets = ExtrasScreen.sheets(&s);
-        let groups = &sheets[0].groups;
-        let ids = |name: &str| -> Vec<ExtraRow> {
-            let group = groups.iter().find(|g| g.name == name).unwrap();
-            group.rows.iter().map(|r| r.id).collect()
-        };
-        let multiplayer = ids("horizon.extras.header.multiplayer");
-        assert_eq!(multiplayer.last(), Some(&ExtraRow::Added(1, 0)));
-        assert_eq!(groups.last().unwrap().name, "test.section.heading");
-        let own = [
-            ExtraRow::Added(1, 2),
-            ExtraRow::Added(1, 3),
-            ExtraRow::Added(1, 4),
-        ];
-        assert_eq!(ids("test.section.heading"), own);
-        let all = rows_of(&s);
-        assert!(!all.iter().any(|r| matches!(r.id, ExtraRow::Added(0, _))));
-    }
-
-    /// A click flips the switch, a Shift click steps the number back, the wheel steps it, and the
-    /// note takes no click; the rows show what the section holds after each.
-    #[test]
-    fn a_sections_rows_act_on_it() {
-        let section = with_section();
-        let mut s = Settings::default();
-        let mut shell = Shell::<ExtrasScreen>::default();
-        let switch = ExtraRow::Added(1, 0);
-        let at = shell.point_at(&s, SIZE, switch);
-        assert!(
-            !shell
-                .click(&mut s, at, SIZE, false, false, false)
-                .is_empty()
-        );
-        assert!(*section.on.lock().unwrap());
-        let value = |s: &Settings, id| rows_of(s).into_iter().find(|r| r.id == id).unwrap().value;
-        assert_eq!(value(&s, switch), Value::Switch(true));
-        let step = ExtraRow::Added(1, 2);
-        let mut screen = ExtrasScreen;
-        screen.press(&mut s, step, true);
-        assert_eq!(value(&s, step), Value::Choice("-1".into()));
-        assert!(screen.wheel_step(&mut s, step, false).is_some());
-        assert_eq!(*section.step.lock().unwrap(), 0);
-        assert_eq!(
-            screen.wheel_step(&mut s, ExtraRow::Added(1, 3), false),
-            None
-        );
-        let note = shell.point_at(&s, SIZE, ExtraRow::Added(1, 3));
-        assert!(
-            shell
-                .click(&mut s, note, SIZE, false, false, false)
-                .is_empty()
-        );
-        screen.slide(&mut s, ExtraRow::Added(1, 4), 0.25);
-        assert_eq!(*section.volume.lock().unwrap(), 0.25);
-    }
 }

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

@@ -231,8 +231,8 @@ pub struct FogInputs<'a> {
     /// `GameRenderer.nightVisionScale` while Night Vision is on without
     /// Darkness, else 0 (`FogRenderer.computeFogColor`'s brightenFactor).
     pub night_vision: f32,
-    /// The packs' `environment` fog settings (Polytone's).
-    pub environment: crate::pack_palette::Environment,
+    /// The packs' Polytone `environment` fog settings.
+    pub environment: horizon_polytone::colors::Environment,
 }
 
 /// `FogRenderer.setupFog` + `computeFogColor`.
@@ -581,7 +581,7 @@ mod tests {
         let tables = FogTables {
             water_fog_end: vec![1.0],
         };
-        let environment = crate::pack_palette::Environment {
+        let environment = horizon_polytone::colors::Environment {
             powder_snow_fog: Some(0xFF0000),
             blindness_fog_distance: 40.0,
             water_fog_brightening: 0.0,
@@ -613,7 +613,7 @@ mod tests {
     }
     fn inputs_with<'a>(
         input: &FogInputs<'a>,
-        environment: crate::pack_palette::Environment,
+        environment: horizon_polytone::colors::Environment,
     ) -> FogInputs<'a> {
         FogInputs {
             environment,

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

@@ -179,7 +179,7 @@ fn packed_wanted() -> bool {
     std::env::var("HORIZON_PACKED_QUADS").as_deref() != Ok("0")
 }
 
-pub(crate) mod animate;
+mod animate;
 mod arena;
 pub mod capture;
 pub mod compositor;
@@ -239,7 +239,6 @@ mod reuse;
 mod stars;
 mod surface_setup;
 use surface_setup::{AdapterChoice, AdapterFailure, open_adapter, pick_adapter, set_up_surface};
-mod off_page;
 pub mod submit;
 mod sunrise_fan;
 mod timing;
@@ -251,7 +250,6 @@ mod wgsl_prefix;
 mod world_post;
 pub mod world_primitives;
 mod world_warp;
-use off_page::move_off_page;
 
 /// A section's instance: its camera-relative origin and, in `w`, the step of
 /// its fixed-point UVs (`terrain.wgsl`'s `terrain_uv`).
@@ -728,6 +726,62 @@ impl Part {
         }
     }
 }
+/// `Renderer::compact_arena`'s and `shrink_translucent`'s moves: what the meshes
+/// hold on `page` of `arena` (`part`) goes to its other pages in video memory,
+/// until the next range would pass `budget` bytes (it keeps what is left; the
+/// first range moves whatever its size, so none keeps the page closed), the
+/// copies into `encoder`, the ranges' flat draw ids (`flat`) and, in the
+/// section arena, GPU culling's records (`records`) along. False when the other
+/// pages have no room left.
+fn move_off_page<'a>(
+    arena: &mut arena::Arena,
+    encoder: &mut wgpu::CommandEncoder,
+    mut flat: Option<(&mut flat::Flat, &wgpu::Device, &mut upload::Uploads)>,
+    mut records: Option<&mut gpu_culling::Records>,
+    meshes: impl Iterator<Item = &'a mut SectionGpu>,
+    page: u32,
+    part: Part,
+    budget: &mut u64,
+) -> bool {
+    debug_assert!(
+        records.is_none() || matches!(part, Part::Section { .. }),
+        "records follow the section arena's ranges"
+    );
+    let mut moved = false;
+    for s in meshes {
+        // Nothing of a mesh here: split, one without solid quads (its (0, 0) is no
+        // range of page 0); in the other arenas, one without translucent quads.
+        let Some((_, start, vertices)) = part.of(s).filter(|r| r.0 == page) else {
+            continue;
+        };
+        let bytes = vertices * arena.stride();
+        if moved && bytes > *budget {
+            break;
+        }
+        let Some(to) = arena.alloc_moved(vertices) else {
+            return false;
+        };
+        arena.copy(encoder, (page, start), to, vertices);
+        arena.release(page, start, vertices);
+        if let (Some((flat, device, uploads)), Some(id)) = (&mut flat, s.flat_id) {
+            let key = match part {
+                Part::Translucent => to.0 + flat::TRANSLUCENT_KEYS,
+                _ => to.0,
+            };
+            flat.place(device, encoder, uploads, id, key, to.1, vertices);
+        }
+        part.set(s, to);
+        // Its solid quads start the range in either layout.
+        if let (Part::Section { .. }, Some(records), Some(id)) =
+            (part, records.as_deref_mut(), s.gpu_id)
+        {
+            records.relocate(id, to.0, u64::from(s.solid_base()));
+        }
+        *budget = budget.saturating_sub(bytes);
+        moved = true;
+    }
+    true
+}
 /// Starts moving a page of a large arena far larger than its ranges in use
 /// (`Arena::oversized`) into a new page of the size they get (`Arena::open_page`),
 /// for `Renderer::shrink_translucent`: the page closes and `move_off_page` empties
@@ -1275,7 +1329,7 @@ pub struct Renderer {
     celestial_buffer: wgpu::Buffer,
     end_sky: end_sky::EndSky,
     stars: stars::Stars,
-    /// Custom sky layers (`crate::custom_sky`), and the frame's from the game.
+    /// OptiFine custom sky layers (`crate::custom_sky`), and the frame's from the game.
     custom_sky: custom_sky::CustomSky,
     custom_sky_draws: Vec<crate::custom_sky::Draw>,
     /// The glowing entities' outline (`LevelRenderer.entityOutlineTarget`).
@@ -1476,8 +1530,6 @@ pub struct Renderer {
     output_caps: output::OutputCapabilities,
     /// An output that failed to apply, not tried again until something it needs changes.
     output_rejected: Option<output_apply::Rejected>,
-    /// Since when Auto keeps HDR on through the display's loss of its report.
-    auto_off_since: Option<std::time::Instant>,
     /// The output applied (`update_output`), with the frame every pipeline that draws it
     /// targets: the swapchain's 8-bit format, or `Rgba16Unorm` when the renderer was made with
     /// HDR output on and Smooth Gradients and the device draws and blends into it, or
@@ -4195,13 +4247,16 @@ impl Renderer {
             CRUMBLING_BLEND,
             false,
         );
-        // RenderPipelines.ENTITY_SHADOW: translucent, back-face culled, depth test without writes.
-        // The quads lie exactly on the block tops like vanilla's, facing +Y so looking up from
-        // below culls them, but terrain and shadows are separate draw paths, so their fp32 depth
-        // interpolations disagree by a few dozen ulps of the fragment depth and the shadow's rim
-        // z-fights with the block top (speckle that re-rolls as the camera drifts a subpixel). A
-        // constant bias of 128 ulps covers that spread at any resolution while staying far below
-        // the 0.001 a model's feet sit higher, so shadows never bleed onto the feet.
+        // RenderPipelines.ENTITY_SHADOW: translucent, back-face culled, depth
+        // test without writes. The quads lie exactly on the block tops like
+        // vanilla's, facing +Y so looking up from below culls them, but
+        // terrain and shadows are separate draw paths, so their fp32 depth
+        // interpolations disagree by a few dozen ulps of the fragment depth
+        // and the shadow's rim z-fights with the block top (speckle that
+        // re-rolls as the camera drifts a subpixel). A constant bias of 128
+        // ulps covers that spread at any resolution while staying far below
+        // the 0.001 a model's feet sit higher, so shadows never bleed onto
+        // the feet.
         let shadow_blob_pipeline = entity_pipeline_with(
             "Entity shadows",
             Some(wgpu::Face::Back),
@@ -5300,7 +5355,6 @@ impl Renderer {
             emission_stats,
             output_caps,
             output_rejected: None,
-            auto_off_since: None,
             // Nothing is presented as HDR yet: `update_output` applies the settings.
             output: output::resolve_output(settings, output_caps, display, frame, false),
             frame_kept_logged: false,
@@ -5463,11 +5517,11 @@ impl Renderer {
             ))
         });
     }
-    /// The pack's custom sky layer textures (`crate::custom_sky::load`).
-    pub fn set_custom_sky(&mut self, pack: &dyn crate::custom_sky::SkyLayers) {
+    /// The pack's OptiFine custom sky layer textures (`crate::custom_sky::CustomSky::load`).
+    pub fn set_custom_sky(&mut self, pack: &crate::custom_sky::CustomSky) {
         self.custom_sky.set_pack(&self.device, &self.queue, pack);
     }
-    /// The custom sky layers the next frame draws (`SkyLayers::draws`): the game refills it each
+    /// The custom sky layers the next frame draws (`CustomSky::draws`): the game refills it each
     /// frame, empty when the world's sky has none.
     pub fn custom_sky_draws(&mut self) -> &mut Vec<crate::custom_sky::Draw> {
         &mut self.custom_sky_draws
@@ -7040,6 +7094,11 @@ impl Renderer {
             horizon_hdr::set_metadata(&self.device, surface, hdr.declared_peak(), hdr.black);
         }
     }
+    /// The swapchain's configuration: `config` (what every pipeline draws in), or
+    /// HDR10 or scRGB while HDR output is on.
+    fn surface_config(&self) -> wgpu::SurfaceConfiguration {
+        output_apply::surface_config(&self.config, self.hdr.as_ref().map(|hdr| hdr.output))
+    }
     /// This renderer's output as applied, with what its destination offers and reports.
     pub fn output(&self) -> &output::EffectiveOutput {
         &self.output
@@ -7095,7 +7154,7 @@ impl Renderer {
             settings,
             request,
             self.caps_for(settings),
-            output_apply::graced(self.auto_off_since, self.reading, &self.output),
+            self.reading,
             self.config.format,
         )
     }
@@ -8295,12 +8354,8 @@ impl Renderer {
             t.begin(&self.device, &self.queue);
         }
         if self.animated_textures {
-            self.hud.animate(
-                &mut self.uploads,
-                &mut encoder,
-                frame.ticks,
-                &self.animations,
-            );
+            self.hud
+                .animate_sprites(&mut self.uploads, &mut encoder, frame.ticks);
         }
         self.update_lightmap(
             &mut encoder,
@@ -9238,11 +9293,13 @@ impl Renderer {
         }
         // Near water and distant water share one back-to-front draw order.
         if self.translucent_draws.len() > section_translucent {
-            // Distant water goes after the near chunks', and replaced tiles' after all: each is a
-            // hair behind the one before, so depth leaves it only where that one has none. Back to
-            // front together, a far tile's water under a near chunk's (one fading in, or brought
-            // into view by a longer render distance) blended twice and looked opaque. The cost: far
-            // water just behind near water shows no surface of its own there.
+            // Distant water goes after the near chunks', and replaced tiles'
+            // after all: each is a hair behind the one before, so depth leaves
+            // it only where that one has none. Back to front together, a far
+            // tile's water under a near chunk's (one fading in, or brought
+            // into view by a longer render distance) blended twice and looked
+            // opaque. The cost: far water just behind near water shows no
+            // surface of its own there.
             let tier = |instance: usize| match instance.checked_sub(visible.len()) {
                 None => 0,
                 Some(tile) if visible_lods[tile].old => 2,
@@ -10062,11 +10119,7 @@ impl Renderer {
         let pack_reads_world = pack_post || native_post;
         laps.lap("r_uploads");
         // Phase 2 of occlusion culling draws over the depth, and a shader pack or TAA reads it.
-        // Post effects (a resource pack's chains, `use_depth_buffer`) read the world's depth
-        // after the world pass, as `GameRenderer.render` hands them the main target's.
-        let post_reads_depth = !frame.title && !frame.post_effects.effects.is_empty();
         let keep_depth = pack_reads_world
-            || post_reads_depth
             || (taa && self.world_post.taa)
             || oit_on
             || native_render::render_needs().world_depth
@@ -13664,7 +13717,6 @@ mod tests {
             Some(Reported {
                 paper_white: 240,
                 peak: 998,
-                peak_guessed: true,
             })
         );
         assert_eq!(
@@ -13672,7 +13724,6 @@ mod tests {
             Some(Reported {
                 paper_white: 480,
                 peak: 480,
-                peak_guessed: true,
             })
         );
         // White above the calibrated peak (a Samsung QD-OLED's 380, the slider at 456).
@@ -13681,7 +13732,6 @@ mod tests {
             Some(Reported {
                 paper_white: 456,
                 peak: 456,
-                peak_guessed: true,
             })
         );
         assert_eq!(os_reported(&info(Some(1000.0), None)), None);
@@ -15372,9 +15422,11 @@ fn log_os_reported(reported: Option<crate::graphics::Reported>) {
         None => "Horizon renderer: the system doesn't report the display's luminance".into(),
     });
 }
-/// What the OS reports in absolute nits, HDR output's scale (Windows: DXGI's SDR white level,
-/// the brightness slider's, as Paper White, and its `MaxLuminance`, mostly the display's EDID
-/// guess, as Peak Brightness), kept within the settings' ranges. The player's values win.
+/// What the OS reports in absolute nits (Windows: DXGI's `MaxLuminance` and the SDR
+/// white level the brightness slider sets), which is HDR output's scale there: SDR
+/// white is Paper White, the display's peak is Peak Brightness. Both are kept within
+/// the settings' ranges. The OS's figures often come from the display's EDID and may
+/// run optimistic; the player's own value always wins.
 fn os_reported(info: &wgpu::DisplayHdrInfo) -> Option<crate::graphics::Reported> {
     let luminance = info.luminance?;
     let usable = |n: f32| n.is_finite() && n > 0.0;
@@ -15386,7 +15438,6 @@ fn os_reported(info: &wgpu::DisplayHdrInfo) -> Option<crate::graphics::Reported>
         // Windows' SDR brightness slider can set white above the reported peak (480 against
         // a calibrated 380): the highlights then stay at white instead of dropping below it.
         peak: (peak.round() as u32).clamp(200, 10_000).max(paper_white),
-        peak_guessed: true,
     })
 }
 
@@ -15422,7 +15473,6 @@ fn reported(l: horizon_hdr::wayland::Luminances) -> crate::graphics::Reported {
     crate::graphics::Reported {
         paper_white: 203,
         peak: peak.clamp(200, 10_000),
-        peak_guessed: false,
     }
 }
 
@@ -15671,11 +15721,11 @@ mod shadow_caster_tests {
     #[test]
     fn the_shadow_pass_draws_terrain_outside_the_pack_s_planes() {
         let kept = |near: Option<f32>, far: Option<f32>, y: f64, min: [f32; 3], depth: bool| {
-            let shadow = horizon_shaders::Shadow {
+            let shadow = horizon_render_pipeline::Shadow {
                 distance: 128.0,
                 near,
                 far,
-                ..horizon_shaders::Shadow::default()
+                ..horizon_render_pipeline::Shadow::default()
             };
             let camera = DVec3::new(13.5, y + 1.62, -13.5);
             let view = pack_post::ShadowView {

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

@@ -64,7 +64,7 @@ enum Writer {
     },
 }
 
-pub(crate) struct SpriteAnimator {
+pub(super) struct SpriteAnimator {
     sprites: Vec<Sprite>,
     groups: Vec<Group>,
     writer: Writer,
@@ -86,9 +86,6 @@ struct AnimationModes {
     day_time: i64,
     weather: f32,
     values: std::collections::HashMap<String, f64>,
-    /// The open screen (an identity the game picks) and the ticks it has been open.
-    screen: Option<u64>,
-    screen_time: i64,
 }
 
 impl AnimationModes {
@@ -119,15 +116,8 @@ impl super::Renderer {
         day_time: i64,
         [rain, thunder]: [f32; 2],
         frame: Option<&crate::environment::Frame>,
-        screen: Option<u64>,
     ) {
         let modes = &mut self.animations.modes;
-        // `screen_time`: a tick more while the same screen stays open, from 0 on a new one.
-        modes.screen_time = match (screen, modes.screen) {
-            (Some(open), Some(was)) if open == was => modes.screen_time + 1,
-            _ => 0,
-        };
-        modes.screen = screen;
         modes.day_time = day_time;
         modes.weather = rain + thunder;
         modes.values.clear();
@@ -143,16 +133,6 @@ impl super::Renderer {
 }
 
 impl SpriteAnimator {
-    /// What the modes read this frame, for the GUI atlas's sprites (their expressions aren't
-    /// compiled: those run on ticks).
-    pub(crate) fn mode_inputs(&self) -> horizon_assets::animation::ModeInputs<'static> {
-        horizon_assets::animation::ModeInputs {
-            day_time: self.modes.day_time,
-            screen_time: self.modes.screen_time,
-            weather: self.modes.weather,
-            expression: &|_| None,
-        }
-    }
     /// `textures` are the sprite arrays, `split` layers each, `size` pixels
     /// wide; `animations` hold their frames at that size. `compute`: whether
     /// the device says it runs compute shaders writing storage textures.
@@ -381,7 +361,6 @@ impl SpriteAnimator {
         let expression = |source: &str| values.get(source).copied();
         let inputs = horizon_assets::animation::ModeInputs {
             day_time: self.modes.day_time,
-            screen_time: self.modes.screen_time,
             weather: self.modes.weather,
             expression: &expression,
         };

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

@@ -1,11 +1,12 @@
-//! Custom sky layers (`crate::custom_sky`) on the GPU: one texture per layer, kept with the renderer (its pack),
+//! OptiFine custom sky layers on the GPU: one texture per layer, kept with the renderer (its pack),
 //! a static skybox mesh of the 3x2 grid's six faces, and one pipeline per blend mode. A frame
 //! uploads one small uniform per drawn layer ([`crate::custom_sky::Draw`]) and draws 36 vertices
 //! each, after the vanilla sky's disc and sunrise and before the sun, moon and stars.
 use glam::Mat4;
+use horizon_optifine::sky::{Blend, Face};
 use wgpu::util::DeviceExt;
 
-use crate::custom_sky::{Blend, Draw, SkyLayers};
+use crate::custom_sky::{CustomSky as Pack, Draw};
 
 /// The blend modes in the shader's `mode` order (custom_sky.wgsl).
 const MODES: [Blend; 9] = [
@@ -84,76 +85,6 @@ fn blend(mode: Blend) -> wgpu::BlendComponent {
     }
 }
 
-/// A face of the skybox, as the 3x2 grid of its texture holds them: `Bottom`, `Top`, `South` in
-/// the top row, `West`, `North`, `East` below.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum Face {
-    Bottom,
-    Top,
-    South,
-    West,
-    North,
-    East,
-}
-
-impl Face {
-    const ALL: [Self; 6] = [
-        Self::Bottom,
-        Self::Top,
-        Self::South,
-        Self::West,
-        Self::North,
-        Self::East,
-    ];
-
-    /// The face's cell of the texture, `[u0, v0, u1, v1]` in 0..1.
-    fn cell(self) -> [f32; 4] {
-        let (col, row) = match self {
-            Self::Bottom => (0, 0),
-            Self::Top => (1, 0),
-            Self::South => (2, 0),
-            Self::West => (0, 1),
-            Self::North => (1, 1),
-            Self::East => (2, 1),
-        };
-        let (u, v) = (col as f32 / 3.0, row as f32 / 2.0);
-        [u, v, u + 1.0 / 3.0, v + 0.5]
-    }
-
-    /// The face's corners (on the unit cube around the camera; x east, y up, z south) in the
-    /// order of its cell's `(u0, v0)`, `(u1, v0)`, `(u1, v1)`, `(u0, v1)`. The side faces are
-    /// seen from inside with up at the top of their cell; the top face has north at the bottom of
-    /// its cell, the bottom face north at the top (the template's `N` marks).
-    fn corners(self) -> [[f32; 3]; 4] {
-        match self {
-            // Seen looking north: west on the left.
-            Self::North => [
-                [-1., 1., -1.],
-                [1., 1., -1.],
-                [1., -1., -1.],
-                [-1., -1., -1.],
-            ],
-            Self::South => [[1., 1., 1.], [-1., 1., 1.], [-1., -1., 1.], [1., -1., 1.]],
-            Self::East => [[1., 1., -1.], [1., 1., 1.], [1., -1., 1.], [1., -1., -1.]],
-            Self::West => [
-                [-1., 1., 1.],
-                [-1., 1., -1.],
-                [-1., -1., -1.],
-                [-1., -1., 1.],
-            ],
-            // Looking up with north toward the cell's bottom edge: east on the right.
-            Self::Top => [[-1., 1., 1.], [1., 1., 1.], [1., 1., -1.], [-1., 1., -1.]],
-            // Looking down with north toward the cell's top edge: east on the right.
-            Self::Bottom => [
-                [-1., -1., -1.],
-                [1., -1., -1.],
-                [1., -1., 1.],
-                [-1., -1., 1.],
-            ],
-        }
-    }
-}
-
 /// The skybox's 36 vertices: two triangles per face, each corner with its cell's UV.
 fn mesh() -> Vec<Vertex> {
     let mut out = Vec::with_capacity(36);
@@ -325,15 +256,10 @@ impl CustomSky {
     }
 
     /// The pack's layer textures, replacing any before.
-    pub(super) fn set_pack(
-        &mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        pack: &dyn SkyLayers,
-    ) {
+    pub(super) fn set_pack(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, pack: &Pack) {
         let limit = device.limits().max_texture_dimension_2d;
         self.groups = pack
-            .images()
+            .images
             .iter()
             .map(|image| {
                 // Too large for this GPU: a 1x1 transparent texel, so the layer draws nothing.
@@ -487,38 +413,6 @@ impl CustomSky {
 mod tests {
     use super::*;
 
-    #[test]
-    fn the_grid_holds_each_face_once_and_faces_point_out() {
-        let mut cells: Vec<_> = Face::ALL
-            .iter()
-            .map(|f| f.cell().map(|x| (x * 6.0) as i32))
-            .collect();
-        cells.dedup();
-        assert_eq!(cells.len(), 6);
-        assert_eq!(Face::East.cell(), [2.0 / 3.0, 0.5, 1.0, 1.0]);
-        for face in Face::ALL {
-            let c = face.corners();
-            let sub = |a: [f32; 3], b: [f32; 3]| [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-            let (a, b) = (sub(c[1], c[0]), sub(c[3], c[0]));
-            let n = [
-                a[1] * b[2] - a[2] * b[1],
-                a[2] * b[0] - a[0] * b[2],
-                a[0] * b[1] - a[1] * b[0],
-            ];
-            let centre: [f32; 3] =
-                std::array::from_fn(|i| c.iter().map(|p| p[i]).sum::<f32>() / 4.0);
-            // Seen from inside, u runs right and v down, so u x v points away from the camera.
-            let dot: f32 = (0..3).map(|i| n[i] * centre[i]).sum();
-            assert!(dot > 0.0, "{face:?} is mirrored");
-        }
-        // The top cell's bottom edge (v1) is north: its corners 2 and 3 have z = -1.
-        assert_eq!(Face::Top.corners()[2][2], -1.0);
-        assert_eq!(Face::Top.corners()[3][2], -1.0);
-        // The bottom cell's top edge (v0) is north.
-        assert_eq!(Face::Bottom.corners()[0][2], -1.0);
-        assert_eq!(Face::Bottom.corners()[1][2], -1.0);
-    }
-
     /// What a blend leaves a sky texel of `dst` with when the shader outputs `src`
     /// (custom_sky.wgsl) for a layer texel `t` at brightness `b`, per channel.
     fn mix(mode: Blend, dst: f32, t: f32, a: f32, b: f32) -> f32 {

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

@@ -6,7 +6,7 @@ struct Layer {
     // Projection * view (camera-relative) * the layer's rotation.
     clip_from_sky: mat4x4<f32>,
     brightness: f32,
-    // crate::custom_sky::Blend, in gfx/custom_sky.rs's MODES order.
+    // horizon_optifine::sky::Blend, in gfx/custom_sky.rs's MODES order.
     mode: u32,
     pad: vec2<u32>,
     hdr_settings: vec4<f32>,

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

@@ -185,7 +185,7 @@ pub struct Hdr {
     /// The display's black level, in nits: shadows are lifted onto it (`hdr.wgsl`).
     pub black: f32,
     pub tiers: [Tier; 4],
-    /// The HUD and menus' brightness, as a share of paper white: above 1 brighter than it.
+    /// The HUD and menus' brightness, as a share of paper white (0.25..=1).
     pub ui: f32,
     /// Which pixels of a light source shine (`Masks`).
     pub masks: Masks,
@@ -956,7 +956,7 @@ impl Hdr {
             f32::from(u8::from(pq)),
         ]);
         params[5] = self.black.clamp(0.0, paper);
-        params[6] = self.ui;
+        params[6] = self.ui.clamp(0.25, 1.0);
         params[7] = if self.lighting {
             scene_gain(self.peak, self.paper_white)
         } else {
@@ -1906,11 +1906,9 @@ struct ReferenceParams { peak: f32, scene: f32, world: f32, debug: f32, share: v
             // Covered: the HUD as drawn, at UI Brightness.
             (2.0, 0.3, 1.0, 1.0, 0.3),
             (2.0, 0.3, 1.0, 0.5, 0.3 * 0.5f32.powf(1.0 / 2.2)),
-            // UI Brightness above paper white: brighter than drawn.
-            (2.0, 0.3, 1.0, 2.0, 0.3 * 2f32.powf(1.0 / 2.2)),
             // Added over the world (the text highlight), which it doesn't hide.
             (0.6, 0.8, 0.0, 1.0, 0.8),
-            // At or below white, at paper white: the HUD's picture as drawn.
+            // At or below white, at 100%: the HUD's picture as drawn.
             (0.7, 0.45, 0.5, 1.0, 0.45),
         ] {
             hdr.ui = ui;
@@ -1930,50 +1928,6 @@ struct ReferenceParams { peak: f32, scene: f32, world: f32, debug: f32, share: v
         }
     }
 
-    /// On the frame without the HUD's layer, the HUD at UI Brightness reaches its nits, and
-    /// above the peak stops there, as on the layered frame.
-    #[test]
-    fn the_hud_at_ui_brightness_stops_at_the_peak() {
-        let Some((device, queue)) = gpu() else {
-            return;
-        };
-        let mut hdr = Hdr::with_debug(&device, &queue, F::Rgba8Unorm, Output::ScRgb, false, None);
-        (hdr.paper_white, hdr.peak) = (200.0, 300.0);
-        let target = device.create_texture(&wgpu::TextureDescriptor {
-            label: None,
-            size: wgpu::Extent3d {
-                width: 1,
-                height: 1,
-                depth_or_array_layers: 1,
-            },
-            mip_level_count: 1,
-            sample_count: 1,
-            dimension: wgpu::TextureDimension::D2,
-            format: Output::ScRgb.format(),
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
-            view_formats: &[],
-        });
-        // UI Brightness (a share of paper white) and the white HUD's nits.
-        for (ui, want) in [(0.5, 100.0), (1.25, 250.0), (2.0, 300.0)] {
-            hdr.ui = ui;
-            let frame = hdr.frame(&device, [1, 1]);
-            let mut encoder = device.create_command_encoder(&Default::default());
-            fill(&mut encoder, &frame, [0.2, 0.2, 0.2, 1.0]);
-            hdr.keep_world(&mut encoder, None);
-            // Opaque white HUD over the world: alpha 1 is full coverage.
-            fill(&mut encoder, &frame, [1.0; 4]);
-            hdr.begin(&queue, true);
-            hdr.present(&queue, &mut encoder, &target, true, None);
-            let got = texel(&device, &queue, encoder, &target);
-            for c in &got[..3] {
-                assert!(
-                    (c * 80.0 - want).abs() < 0.5,
-                    "UI {ui}: {got:?}, not {want} nits"
-                );
-            }
-        }
-    }
-
     #[test]
     fn the_menu_blur_keeps_the_light_it_blurs() {
         let Some((device, queue)) = gpu() else {

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

@@ -338,7 +338,7 @@ pub struct NativeFrame {
     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>,
+    shadow_camera: Option<horizon_render_pipeline::Shadow>,
     /// Whether the pack's material reads `reflection` (`NativePack::new`): else no mirror
     /// is drawn and `has_reflection` stays 0.
     pub reflects: bool,
@@ -1497,7 +1497,7 @@ pub fn frame_inputs(
     size: [u32; 2],
     seconds: f32,
     index: u32,
-    shadow: Option<&horizon_shaders::Shadow>,
+    shadow: Option<&horizon_render_pipeline::Shadow>,
 ) -> FrameInputs {
     let aspect = size[0] as f32 / size[1].max(1) as f32;
     let view = crate::camera::view_matrix(frame.yaw, frame.pitch);

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

@@ -6,8 +6,8 @@
 //! draw lists (`ShadowView`) serve both; the map's texels are distorted toward the camera as the
 //! prelude's `shadow_position` undoes.
 
+use horizon_render_pipeline::Shadow;
 use horizon_shader_api::{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};

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

@@ -1,59 +0,0 @@
-//! `move_off_page`, moved out of `gfx.rs` unchanged.
-use super::*;
-
-/// `Renderer::compact_arena`'s and `shrink_translucent`'s moves: what the meshes
-/// hold on `page` of `arena` (`part`) goes to its other pages in video memory,
-/// until the next range would pass `budget` bytes (it keeps what is left; the
-/// first range moves whatever its size, so none keeps the page closed), the
-/// copies into `encoder`, the ranges' flat draw ids (`flat`) and, in the
-/// section arena, GPU culling's records (`records`) along. False when the other
-/// pages have no room left.
-pub(super) fn move_off_page<'a>(
-    arena: &mut arena::Arena,
-    encoder: &mut wgpu::CommandEncoder,
-    mut flat: Option<(&mut flat::Flat, &wgpu::Device, &mut upload::Uploads)>,
-    mut records: Option<&mut gpu_culling::Records>,
-    meshes: impl Iterator<Item = &'a mut SectionGpu>,
-    page: u32,
-    part: Part,
-    budget: &mut u64,
-) -> bool {
-    debug_assert!(
-        records.is_none() || matches!(part, Part::Section { .. }),
-        "records follow the section arena's ranges"
-    );
-    let mut moved = false;
-    for s in meshes {
-        // Nothing of a mesh here: split, one without solid quads (its (0, 0) is no
-        // range of page 0); in the other arenas, one without translucent quads.
-        let Some((_, start, vertices)) = part.of(s).filter(|r| r.0 == page) else {
-            continue;
-        };
-        let bytes = vertices * arena.stride();
-        if moved && bytes > *budget {
-            break;
-        }
-        let Some(to) = arena.alloc_moved(vertices) else {
-            return false;
-        };
-        arena.copy(encoder, (page, start), to, vertices);
-        arena.release(page, start, vertices);
-        if let (Some((flat, device, uploads)), Some(id)) = (&mut flat, s.flat_id) {
-            let key = match part {
-                Part::Translucent => to.0 + flat::TRANSLUCENT_KEYS,
-                _ => to.0,
-            };
-            flat.place(device, encoder, uploads, id, key, to.1, vertices);
-        }
-        part.set(s, to);
-        // Its solid quads start the range in either layout.
-        if let (Part::Section { .. }, Some(records), Some(id)) =
-            (part, records.as_deref_mut(), s.gpu_id)
-        {
-            records.relocate(id, to.0, u64::from(s.solid_base()));
-        }
-        *budget = budget.saturating_sub(bytes);
-        moved = true;
-    }
-    true
-}

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

@@ -142,7 +142,7 @@ pub struct EffectiveOutput {
     /// Paper white, peak and black level in nits, as HDR output's last pass and its
     /// metadata take them, while it is on.
     pub(crate) nits: [f32; 3],
-    /// The HUD and menus' brightness, as a share of paper white: their nits over its.
+    /// The HUD and menus' brightness, as a share of paper white.
     pub(crate) ui_brightness: f32,
 }
 impl Default for EffectiveOutput {
@@ -271,8 +271,7 @@ pub(crate) fn resolve_output(
             settings.peak_nits(reading.luminance) as f32,
             settings.black_level_nits(),
         ],
-        ui_brightness: settings.ui_nits(reading.luminance) as f32
-            / settings.paper_white_nits(reading.luminance) as f32,
+        ui_brightness: settings.hdr_ui_brightness as f32 / 100.0,
     }
 }
 
@@ -300,7 +299,6 @@ pub(crate) mod tests {
                 luminance: Some(Reported {
                     paper_white: 400,
                     peak: 1000,
-                    peak_guessed: false,
                 }),
                 hdr: system,
             },
@@ -568,39 +566,6 @@ pub(crate) mod tests {
         );
     }
 
-    /// UI Brightness reaches HDR output as its nits over paper white's: 1 on Auto, whatever
-    /// paper white is; a value set by hand holds its nits, Paper White on Auto or set by hand.
-    #[test]
-    fn ui_brightness_is_its_nits_over_paper_whites() {
-        let (caps, reading) = window(Some(Output::Pq), Some(true));
-        let share = |paper_white, ui_nits, reading| {
-            let settings = Graphics {
-                hdr: HdrMode::On,
-                hdr_paper_white: paper_white,
-                hdr_ui_nits: ui_nits,
-                ..Graphics::default()
-            };
-            let frame = resolve_frame(
-                &settings,
-                FrameRequest::default(),
-                caps,
-                reading,
-                Bgra8Unorm,
-            );
-            resolve_output(&settings, caps, reading, frame, true).ui_brightness
-        };
-        // Auto: the report's 400 nits, 203 without one, or the player's 250.
-        let unreported = DisplayReading::default();
-        for (paper_white, reading) in [(0, reading), (0, unreported), (250, reading)] {
-            assert_eq!(share(paper_white, 0, reading), 1.0);
-        }
-        assert_eq!(share(0, 100, reading), 0.25);
-        assert_eq!(share(0, 480, reading), 1.2);
-        assert_eq!(share(0, 406, unreported), 2.0);
-        assert_eq!(share(250, 100, reading), 0.4);
-        assert_eq!(share(250, 480, reading), 1.92);
-    }
-
     /// Two renderers' states, a window's and an offscreen one's, made and changed in turn:
     /// neither's offer or report shows in the other's snapshot, and the offscreen one
     /// stopping its watch (HDR Off) leaves the window's report alone.
@@ -651,7 +616,6 @@ pub(crate) mod tests {
         window_reading.luminance = Some(Reported {
             paper_white: 300,
             peak: 800,
-            peak_guessed: false,
         });
         assert_eq!(window_output(window_reading).nits[..2], [300.0, 800.0]);
         assert_eq!(

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

@@ -3,12 +3,9 @@
 //! changes only values (the luminance, the UI brightness, what the display reports) updates
 //! them in place. Another encoding or frame is built and the swapchain configured for it before
 //! the snapshot says so. One that fails is never published as active, and is not tried again
-//! until the request, the capabilities or the surface change. Auto keeps HDR on through a
-//! moment's loss of the display's report ([`auto_grace`]).
+//! until the request, the capabilities or the surface change.
 use super::{DisplayReading, DisplayWatch, Renderer, hdr, output};
-use crate::graphics::HdrMode;
 use output::{EffectiveOutput, OutputCapabilities};
-use std::time::{Duration, Instant};
 
 /// What an output's resources are made for: the encoding presented and the frame.
 type Key = (Option<hdr::Output>, output::FrameConfiguration);
@@ -104,98 +101,6 @@ pub(super) fn surface_config(
     config
 }
 
-/// How long Auto keeps HDR on once the display stops reporting it. A fixed window that
-/// coalesces the report's churn as a display wakes or the window moves to another one; not a
-/// measured sleep/wake time.
-const AUTO_OFF_DELAY: Duration = Duration::from_millis(500);
-
-/// The display's report `update_output` resolves Auto with at `now`. While Auto presents HDR
-/// and the surface still offers that encoding, a report that turns false or unknown starts
-/// the timer `since`, once, and HDR stays on at the values last applied until it has held
-/// for [`AUTO_OFF_DELAY`]; a positive report before then clears it. Off and On, a changed
-/// offer, and entering HDR take `raw` at once.
-fn auto_grace(
-    now: Instant,
-    mode: HdrMode,
-    offered: Option<hdr::Output>,
-    raw: DisplayReading,
-    applied: &EffectiveOutput,
-    since: &mut Option<Instant>,
-) -> DisplayReading {
-    let lost = mode == HdrMode::Auto
-        && applied.encoding.is_some()
-        && offered == applied.encoding
-        && raw.hdr != Some(true);
-    if !lost {
-        if since.take().is_some() && raw.hdr == Some(true) {
-            log::info!("Horizon renderer: the display reports HDR again; HDR stays on");
-        }
-    } else if since.is_none() {
-        log::info!(
-            "Horizon renderer: the display stopped reporting HDR; Auto keeps it on for {} ms",
-            AUTO_OFF_DELAY.as_millis()
-        );
-        *since = Some(now);
-    } else if grace_over(*since, now) {
-        *since = None;
-    }
-    graced(*since, raw, applied)
-}
-
-fn grace_over(since: Option<Instant>, now: Instant) -> bool {
-    since.is_some_and(|since| now.saturating_duration_since(since) >= AUTO_OFF_DELAY)
-}
-
-/// What the display reports as the output takes it: during Auto's grace (`since`), HDR at the
-/// luminance `applied` was resolved with; `raw` otherwise.
-pub(super) fn graced(
-    since: Option<Instant>,
-    raw: DisplayReading,
-    applied: &EffectiveOutput,
-) -> DisplayReading {
-    match since {
-        Some(_) => DisplayReading {
-            luminance: applied.reported,
-            hdr: Some(true),
-        },
-        None => raw,
-    }
-}
-
-/// Whether the output resolves again at `now`: a due poll (`read`, with the surface's
-/// `offer`; on Wayland, an event) changed `reading` or `caps`, or Auto's grace `since` is
-/// over. Its end reads the display once more first, however long until the next poll, unless
-/// a read since the deadline did (the last read is a `DISPLAY_POLL` before the next).
-fn poll_display(
-    watch: Option<&mut DisplayWatch>,
-    reading: &mut DisplayReading,
-    caps: &mut OutputCapabilities,
-    since: Option<Instant>,
-    now: Instant,
-    read: impl FnOnce() -> DisplayReading,
-    offer: impl FnOnce() -> Option<Option<hdr::Output>>,
-) -> bool {
-    let over = grace_over(since, now);
-    let Some(watch) = watch else {
-        return over;
-    };
-    if let (Some(since), Some(next)) = (since.filter(|_| over), &mut watch.polled)
-        && *next < since + AUTO_OFF_DELAY + super::DISPLAY_POLL
-    {
-        *next = now;
-    }
-    let Some(read) = watch.poll(*reading, now, read) else {
-        return over;
-    };
-    observe(reading, caps, read, offer()) || over
-}
-
-/// What `surface` offers now (`None` offscreen): Vulkan's offered formats can change with
-/// desktop HDR or the window's output, and a display can offer the other encoding.
-fn offer(surface: Option<&wgpu::Surface>, adapter: &wgpu::Adapter) -> Option<Option<hdr::Output>> {
-    Some(hdr::output(&surface?.get_capabilities(adapter)))
-}
-
 /// Takes what a due poll read into `reading` and `caps`: the display's report `now`, and what
 /// the surface offers (`offer`, `None` without a surface). Whether either changed, the offer
 /// alone included.
@@ -314,26 +219,12 @@ impl Renderer {
         settings: &crate::graphics::Graphics,
         marker: &std::path::Path,
     ) {
-        let now = Instant::now();
         self.watch_hdr(settings.hdr);
-        // Auto's grace ends on a fresh read, also where a settings change comes before the
-        // frame's `display_changed`.
-        if grace_over(self.auto_off_since, now) {
-            self.read_display(now);
-        }
         self.hold_hdr_back(settings);
-        let reading = auto_grace(
-            now,
-            settings.hdr,
-            self.output_caps.hdr,
-            self.reading,
-            &self.output,
-            &mut self.auto_off_since,
-        );
         let candidate = output::resolve_output(
             settings,
             self.output_caps,
-            reading,
+            self.reading,
             self.output.frame,
             self.surface.is_some() || self.offscreen.is_some(),
         );
@@ -378,24 +269,24 @@ impl Renderer {
             let (watch, now) =
                 DisplayWatch::new(&self.window, self.surface.as_deref(), &self.adapter);
             self.display = Some(watch);
-            let offer = offer(self.surface.as_deref(), &self.adapter);
-            self.output_caps.hdr = offer.unwrap_or(self.output_caps.hdr);
+            self.output_caps.hdr = self.surface_offer().unwrap_or(self.output_caps.hdr);
             self.reading = now;
             self.display_fresh = true;
         }
     }
 
-    /// The swapchain's configuration: `config` (what every pipeline draws in), or
-    /// HDR10 or scRGB while HDR output is on.
-    pub(super) fn surface_config(&self) -> wgpu::SurfaceConfiguration {
-        surface_config(&self.config, self.hdr.as_ref().map(|hdr| hdr.output))
+    /// What the window's surface offers now (`None` offscreen): Vulkan's offered formats can
+    /// change with desktop HDR or the window's output, and a display can offer the other
+    /// encoding.
+    fn surface_offer(&self) -> Option<Option<hdr::Output>> {
+        let surface = self.surface.as_ref()?;
+        Some(hdr::output(&surface.get_capabilities(&self.adapter)))
     }
 
     /// After a new window surface: what it offers, and an output that failed on the old one
     /// may be tried again. The settings apply again.
     pub(super) fn surface_recreated(&mut self) {
-        let offer = offer(self.surface.as_deref(), &self.adapter);
-        self.output_caps.hdr = offer.unwrap_or(self.output_caps.hdr);
+        self.output_caps.hdr = self.surface_offer().unwrap_or(self.output_caps.hdr);
         self.display_fresh = true;
         self.output_rejected = None;
     }
@@ -404,28 +295,22 @@ impl Renderer {
     /// (another output, the player recalibrating the desktop, desktop HDR offering the other
     /// encoding): the settings' Auto values and the output follow it then, so apply them
     /// again. Each due poll reads the surface's capabilities as well, even when the display
-    /// reports the same. So does the end of Auto's grace (`auto_grace`), with or without a
-    /// poll or an event then.
+    /// reports the same.
     pub fn display_changed(&mut self) -> bool {
         super::flush_display_log();
         if std::mem::take(&mut self.display_fresh) {
             return true;
         }
-        self.read_display(Instant::now())
-    }
-
-    /// The display read where a poll is due or Auto's grace is over (`poll_display`).
-    fn read_display(&mut self, now: Instant) -> bool {
+        let Some(watch) = self.display.as_mut() else {
+            return false;
+        };
         let (surface, adapter) = (self.surface.as_deref(), &self.adapter);
-        poll_display(
-            self.display.as_mut(),
-            &mut self.reading,
-            &mut self.output_caps,
-            self.auto_off_since,
-            now,
-            || DisplayReading::read(surface, adapter),
-            || offer(surface, adapter),
-        )
+        let read = || DisplayReading::read(surface, adapter);
+        let Some(now) = watch.poll(self.reading, std::time::Instant::now(), read) else {
+            return false;
+        };
+        let offer = self.surface_offer();
+        observe(&mut self.reading, &mut self.output_caps, now, offer)
     }
 }
 
@@ -549,10 +434,8 @@ mod tests {
         reading.luminance = Some(Reported {
             paper_white: 250,
             peak: 600,
-            peak_guessed: false,
         });
-        // 150 nits under the reported paper white of 250: 0.6 of it.
-        settings.hdr_ui_nits = 150;
+        settings.hdr_ui_brightness = 60;
         let mut swapchain = Swapchain::default();
         let next = candidate(&settings, caps, reading, &applied);
         let published = commit(&mut swapchain, &applied, next, caps, &mut None);
@@ -585,7 +468,6 @@ mod tests {
             reading.luminance = Some(Reported {
                 paper_white,
                 peak: 1000,
-                peak_guessed: false,
             });
             let next = candidate(&settings, caps, reading, &published);
             let again = commit(&mut swapchain, &published, next, caps, &mut rejected);
@@ -647,299 +529,4 @@ mod tests {
         commit(&mut swapchain, &pq, next, caps, &mut rejected);
         assert_eq!(swapchain.asked.len(), 4);
     }
-
-    /// A window in Auto presenting HDR10 at 400/1000 nits on the layered frame, followed on
-    /// fake time as the game follows a renderer each frame: `display_changed`, then
-    /// `update_output` where it says so.
-    struct Auto {
-        settings: Graphics,
-        start: Instant,
-        watch: DisplayWatch,
-        reading: DisplayReading,
-        caps: OutputCapabilities,
-        applied: EffectiveOutput,
-        since: Option<Instant>,
-        swapchain: Swapchain,
-        /// What the system reports when it is read, and when (ms) it was.
-        report: DisplayReading,
-        reads: Vec<u64>,
-    }
-    impl Auto {
-        /// `polled`: the system is read every `DISPLAY_POLL` from 0, else it sends events
-        /// (`event`), as on Wayland.
-        fn new(polled: bool) -> Self {
-            let settings = Graphics {
-                hdr: HdrMode::Auto,
-                ..Graphics::default()
-            };
-            let (caps, reading) = window(Some(Pq), Some(true));
-            let applied = snapshot(&settings, NO_PACK, caps, reading);
-            assert!(applied.encoding == Some(Pq) && applied.frame.hud_layer);
-            let start = Instant::now();
-            Self {
-                settings,
-                start,
-                watch: DisplayWatch {
-                    #[cfg(target_os = "linux")]
-                    wayland: None,
-                    polled: polled.then_some(start),
-                },
-                reading,
-                caps,
-                applied,
-                since: None,
-                swapchain: Swapchain::default(),
-                report: reading,
-                reads: Vec::new(),
-            }
-        }
-        /// A frame at `ms`.
-        fn frame(&mut self, ms: u64) {
-            if self.read_display(ms) {
-                self.update(ms);
-            }
-        }
-        /// `Renderer::read_display` at `ms`.
-        fn read_display(&mut self, ms: u64) -> bool {
-            let now = self.start + Duration::from_millis(ms);
-            let (report, offer, reads) = (self.report, Some(self.caps.hdr), &mut self.reads);
-            let read = || {
-                reads.push(ms);
-                report
-            };
-            let (reading, caps) = (&mut self.reading, &mut self.caps);
-            poll_display(
-                Some(&mut self.watch),
-                reading,
-                caps,
-                self.since,
-                now,
-                read,
-                || offer,
-            )
-        }
-        /// Frames from `from` to `to` ms, every 10 ms.
-        fn frames(&mut self, from: u64, to: u64) {
-            for ms in (from..=to).step_by(10) {
-                self.frame(ms);
-            }
-        }
-        /// What the system reports from `ms` on: HDR `hdr`, with no luminance unless it is
-        /// HDR, at 300/800 nits then.
-        fn reports(&mut self, hdr: Option<bool>, offer: Option<hdr::Output>) {
-            self.report = DisplayReading {
-                luminance: (hdr == Some(true)).then_some(Reported {
-                    paper_white: 300,
-                    peak: 800,
-                    peak_guessed: false,
-                }),
-                hdr,
-            };
-            self.caps.hdr = offer;
-        }
-        /// The system's event at `ms`, with what it now `reports`.
-        fn event(&mut self, ms: u64, hdr: Option<bool>, offer: Option<hdr::Output>) {
-            self.reports(hdr, offer);
-            self.reading = self.report;
-            self.update(ms);
-        }
-        /// `update_output` at `ms`, in its order.
-        fn update(&mut self, ms: u64) {
-            let now = self.start + Duration::from_millis(ms);
-            if grace_over(self.since, now) {
-                self.read_display(ms);
-            }
-            let applied = &self.applied;
-            let reading = auto_grace(
-                now,
-                self.settings.hdr,
-                self.caps.hdr,
-                self.reading,
-                applied,
-                &mut self.since,
-            );
-            let next = candidate(&self.settings, self.caps, reading, applied);
-            self.applied = commit(&mut self.swapchain, applied, next, self.caps, &mut None);
-            // While HDR stays on, the frame the game asks for (`Renderer::requested_frame`) is
-            // this one: no new renderer.
-            let reading = graced(self.since, self.reading, &self.applied);
-            let frame = output::resolve_frame(
-                &self.settings,
-                NO_PACK,
-                self.caps,
-                reading,
-                wgpu::TextureFormat::Bgra8UnormSrgb,
-            );
-            assert_eq!(
-                frame == self.applied.frame,
-                self.applied.hdr_on(),
-                "{ms} ms"
-            );
-        }
-        fn presented(&self) -> Vec<Option<hdr::Output>> {
-            self.swapchain.asked.iter().map(|a| a.0).collect()
-        }
-    }
-
-    /// The display's report flickers off and back, false or unknown: HDR stays on, nothing
-    /// is presented again, and the shader `Frame`, what the settings show as active and the
-    /// nits stay as they were applied, even while the report says nothing of them.
-    #[test]
-    fn a_report_that_flickers_off_and_back_swaps_nothing() {
-        for lost in [Some(false), None] {
-            let mut auto = Auto::new(false);
-            let before = auto.applied;
-            auto.event(0, Some(true), Some(Pq));
-            auto.frames(0, 90);
-            let fresh = auto.applied;
-            assert_eq!(fresh.nits, [300.0, 800.0, 0.0], "a positive report applies");
-            auto.event(100, lost, Some(Pq));
-            auto.frames(100, 390);
-            assert_eq!(auto.applied, fresh, "{lost:?}");
-            assert!(auto.applied.requests_hdr(HdrMode::Auto) && auto.applied.display().hdr);
-            auto.event(400, Some(true), Some(Pq));
-            auto.frames(400, 1500);
-            assert_eq!((auto.applied, auto.since), (fresh, None), "{lost:?}");
-            assert!(auto.presented().is_empty(), "{lost:?}");
-            assert_eq!(auto.applied.frame, before.frame);
-        }
-    }
-
-    /// A loss held through 600 ms turns HDR off once, at 500 ms, and on an event-driven
-    /// display with no event then. The same loss reported again doesn't restart the timer.
-    #[test]
-    fn a_loss_held_turns_hdr_off_once_at_the_deadline() {
-        for lost in [Some(false), None] {
-            let mut auto = Auto::new(false);
-            auto.event(0, lost, Some(Pq));
-            auto.frames(0, 190);
-            auto.event(200, lost, Some(Pq));
-            auto.frames(200, 490);
-            assert_eq!(auto.applied.encoding, Some(Pq), "{lost:?}");
-            auto.frame(500);
-            assert_eq!(auto.applied.encoding, None, "{lost:?}");
-            auto.frames(500, 3000);
-            assert_eq!(auto.presented(), [None], "{lost:?}");
-            assert_eq!(auto.since, None);
-        }
-    }
-
-    /// Where the system is polled, a false read by the poll that starts the timer is read
-    /// again at the deadline, not two seconds after, before it counts: the display came back
-    /// meanwhile, so HDR stays; where it didn't, HDR turns off then. The two-second cadence
-    /// stays otherwise.
-    #[test]
-    fn a_polled_false_is_read_again_at_the_deadline() {
-        for back in [true, false] {
-            let mut auto = Auto::new(true);
-            auto.frames(0, 1990);
-            auto.reports(Some(false), Some(Pq));
-            auto.frame(2000);
-            assert_eq!(
-                (auto.applied.encoding, auto.since.is_some()),
-                (Some(Pq), true)
-            );
-            if back {
-                auto.reports(Some(true), Some(Pq));
-            }
-            auto.frames(2010, 2490);
-            assert_eq!(auto.applied.encoding, Some(Pq), "never before the deadline");
-            auto.frames(2500, 4990);
-            assert_eq!(auto.reads, [0, 2000, 2500, 4500], "back {back}");
-            let after = if back { vec![] } else { vec![None] };
-            assert_eq!(auto.presented(), after, "back {back}");
-        }
-    }
-
-    /// A settings change at the deadline, before the frame's poll (a slider, F11), reads the
-    /// display before the grace ends, and the frame after reads it no more: the display came
-    /// back meanwhile, so HDR stays; where it didn't, HDR turns off then, once.
-    #[test]
-    fn a_settings_change_at_the_deadline_reads_the_display_first() {
-        for back in [true, false] {
-            let mut auto = Auto::new(true);
-            auto.frames(0, 1990);
-            auto.reports(Some(false), Some(Pq));
-            auto.frame(2000);
-            if back {
-                auto.reports(Some(true), Some(Pq));
-            }
-            auto.frames(2010, 2490);
-            auto.update(2500);
-            assert_eq!(auto.applied.hdr_on(), back, "back {back}");
-            auto.frames(2500, 4990);
-            assert_eq!(auto.reads, [0, 2000, 2500, 4500], "back {back}");
-            let after = if back { vec![] } else { vec![None] };
-            assert_eq!(auto.presented(), after, "back {back}");
-        }
-    }
-
-    /// A positive report clears the timer: a later loss has its own 500 ms.
-    #[test]
-    fn a_positive_report_clears_the_timer() {
-        let mut auto = Auto::new(false);
-        auto.event(100, Some(false), Some(Pq));
-        auto.event(300, Some(true), Some(Pq));
-        auto.event(700, Some(false), Some(Pq));
-        auto.frames(700, 1190);
-        assert_eq!(auto.applied.encoding, Some(Pq));
-        auto.frame(1200);
-        assert_eq!(auto.presented(), [None]);
-    }
-
-    /// Off acts at once, and On or Off clear the timer: Auto again starts it anew.
-    #[test]
-    fn off_and_on_take_no_grace() {
-        let mut auto = Auto::new(false);
-        auto.event(100, Some(false), Some(Pq));
-        auto.settings.hdr = HdrMode::Off;
-        auto.update(200);
-        assert_eq!((auto.presented(), auto.since), (vec![None], None));
-        let mut auto = Auto::new(false);
-        auto.event(100, Some(false), Some(Pq));
-        auto.settings.hdr = HdrMode::On;
-        auto.update(200);
-        assert_eq!((auto.applied.encoding, auto.since), (Some(Pq), None));
-        auto.settings.hdr = HdrMode::Auto;
-        auto.update(300);
-        auto.frames(300, 790);
-        assert_eq!(auto.applied.encoding, Some(Pq));
-        auto.frame(800);
-        assert_eq!(auto.presented(), [None]);
-    }
-
-    /// The surface no longer offering the encoding presented ends the grace at once: SDR
-    /// without a report, the other encoding with one.
-    #[test]
-    fn an_encoding_no_longer_offered_is_not_kept() {
-        for offer in [None, Some(ScRgb)] {
-            let mut auto = Auto::new(false);
-            auto.event(100, Some(false), Some(Pq));
-            auto.event(200, Some(false), offer);
-            assert_eq!((auto.presented(), auto.since), (vec![None], None));
-            let mut auto = Auto::new(false);
-            auto.event(100, None, offer);
-            assert_eq!(auto.presented(), [None], "{offer:?}");
-        }
-        let mut auto = Auto::new(false);
-        auto.event(100, Some(false), Some(Pq));
-        auto.event(200, Some(true), Some(ScRgb));
-        assert_eq!(auto.presented(), [Some(ScRgb)]);
-    }
-
-    /// Two windows' timers run apart.
-    #[test]
-    fn two_renderers_keep_their_own_timer() {
-        let (mut a, mut b) = (Auto::new(false), Auto::new(false));
-        b.start = a.start;
-        a.event(100, Some(false), Some(Pq));
-        b.event(300, Some(false), Some(Pq));
-        a.event(400, Some(true), Some(Pq));
-        for ms in (300..=900).step_by(10) {
-            a.frame(ms);
-            b.frame(ms);
-            assert_eq!(b.applied.hdr_on(), ms < 800, "{ms} ms");
-        }
-        assert_eq!((a.presented(), b.presented()), (vec![], vec![None]));
-    }
 }

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

@@ -4,7 +4,8 @@
 
 use std::collections::BTreeMap;
 
-use horizon_shaders::{BufferObject, CustomImage, Format, Kind};
+use horizon_render_pipeline::{Format, Kind};
+use horizon_shaders::{BufferObject, CustomImage};
 
 pub(super) struct PackImage {
     pub(super) def: CustomImage,

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

@@ -18,7 +18,8 @@
 use std::collections::HashMap;
 
 use glam::{DMat4, DVec3};
-use horizon_shaders::{BUFFERS, Format, Group, Kind, Post, SHADOW_COLORS};
+use horizon_render_pipeline::{BUFFERS, Format, Kind, SHADOW_COLORS};
+use horizon_shaders::{Group, Post};
 use smallvec::SmallVec;
 
 use super::pack_draw::DrawUniforms;
@@ -54,10 +55,6 @@ mod sky_disc_blend_tests;
 #[cfg(test)]
 mod undrawn_terrain_tests;
 
-mod image_formats;
-use image_formats::{image_format, storage_formats_of};
-#[cfg(test)]
-mod full_outputs_tests;
 #[cfg(test)]
 mod shadow_faces_tests;
 
@@ -892,7 +889,7 @@ fn depth_linear(interface: &horizon_shaders::Interface, linear: u8) -> [f32; 4]
 }
 
 fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool) -> Source {
-    let shadow_color = horizon_shaders::shadow_color(name);
+    let shadow_color = horizon_render_pipeline::shadow_color(name);
     let shadow_depth = match name {
         "shadowtex0" | "watershadow" | "shadowtex0HW" => Some(0),
         "shadowtex1" | "shadowtex1HW" => Some(1),
@@ -911,7 +908,7 @@ fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool)
             };
         }
     }
-    if shadow_space && horizon_shaders::buffer_index(name).is_some() {
+    if shadow_space && horizon_render_pipeline::buffer_index(name).is_some() {
         // colortex buffers are not this pass's.
         return Source::Dummy;
     }
@@ -925,7 +922,7 @@ fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool)
         "normals" => Source::Normals,
         "specular" => Source::Specular,
         horizon_shaders::WATER_MASK => Source::WaterMask,
-        n => horizon_shaders::buffer_index(n).map_or(Source::Dummy, Source::Color),
+        n => horizon_render_pipeline::buffer_index(n).map_or(Source::Dummy, Source::Color),
     }
 }
 
@@ -1582,7 +1579,7 @@ fn bindings(
             !unbound
                 && (t.stage != pack_textures::stage(group)
                     || released.0 != t.stage
-                    || horizon_shaders::buffer_index(&t.name)
+                    || horizon_render_pipeline::buffer_index(&t.name)
                         .is_none_or(|b| released.1 & 1 << b == 0))
         });
         let image = pack
@@ -1829,6 +1826,98 @@ fn bindings(
     Some((entries, samplers, slots, reads, shadow_reads, images))
 }
 
+/// Makes each storage image of `module` in group 0 declare the format its layout entry binds:
+/// a `layout(r11f_g11f_b10f)` image whose texture is the `RGBA16F` stand-in (`bindings`).
+fn storage_formats_of(module: &mut naga::Module, entries: &[wgpu::BindGroupLayoutEntry]) {
+    let globals: Vec<_> = module.global_variables.iter().map(|(h, _)| h).collect();
+    for handle in globals {
+        let var = &module.global_variables[handle];
+        let Some(naga::ResourceBinding { group: 0, binding }) = var.binding else {
+            continue;
+        };
+        let naga::TypeInner::Image {
+            dim,
+            arrayed,
+            class: naga::ImageClass::Storage { format, access },
+        } = module.types[var.ty].inner
+        else {
+            continue;
+        };
+        let bound = entries.iter().find_map(|e| match e.ty {
+            wgpu::BindingType::StorageTexture { format, .. } if e.binding == binding => {
+                Some(format)
+            }
+            _ => None,
+        });
+        if format == naga::StorageFormat::Rg11b10Ufloat
+            && bound == Some(wgpu::TextureFormat::Rgba16Float)
+        {
+            let ty = module.types.insert(
+                naga::Type {
+                    name: module.types[var.ty].name.clone(),
+                    inner: naga::TypeInner::Image {
+                        dim,
+                        arrayed,
+                        class: naga::ImageClass::Storage {
+                            format: naga::StorageFormat::Rgba16Float,
+                            access,
+                        },
+                    },
+                },
+                naga::Span::UNDEFINED,
+            );
+            module.global_variables[handle].ty = ty;
+        }
+    }
+}
+
+/// The wgpu format of an image's format qualifier.
+fn image_format(qualifier: &str) -> Option<wgpu::TextureFormat> {
+    use wgpu::TextureFormat as T;
+    Some(match qualifier {
+        "rgba32f" => T::Rgba32Float,
+        "rgba16f" => T::Rgba16Float,
+        "rg32f" => T::Rg32Float,
+        "rg16f" => T::Rg16Float,
+        "r11f_g11f_b10f" => T::Rg11b10Ufloat,
+        "r32f" => T::R32Float,
+        "r16f" => T::R16Float,
+        "rgba16" => T::Rgba16Unorm,
+        "rgb10_a2" => T::Rgb10a2Unorm,
+        "rgba8" => T::Rgba8Unorm,
+        "rg16" => T::Rg16Unorm,
+        "rg8" => T::Rg8Unorm,
+        "r16" => T::R16Unorm,
+        "r8" => T::R8Unorm,
+        "rgba16_snorm" => T::Rgba16Snorm,
+        "rgba8_snorm" => T::Rgba8Snorm,
+        "rg16_snorm" => T::Rg16Snorm,
+        "rg8_snorm" => T::Rg8Snorm,
+        "r16_snorm" => T::R16Snorm,
+        "r8_snorm" => T::R8Snorm,
+        "rgba32i" => T::Rgba32Sint,
+        "rgba16i" => T::Rgba16Sint,
+        "rgba8i" => T::Rgba8Sint,
+        "rg32i" => T::Rg32Sint,
+        "rg16i" => T::Rg16Sint,
+        "rg8i" => T::Rg8Sint,
+        "r32i" => T::R32Sint,
+        "r16i" => T::R16Sint,
+        "r8i" => T::R8Sint,
+        "rgba32ui" => T::Rgba32Uint,
+        "rgba16ui" => T::Rgba16Uint,
+        "rgb10_a2ui" => T::Rgb10a2Uint,
+        "rgba8ui" => T::Rgba8Uint,
+        "rg32ui" => T::Rg32Uint,
+        "rg16ui" => T::Rg16Uint,
+        "rg8ui" => T::Rg8Uint,
+        "r32ui" => T::R32Uint,
+        "r16ui" => T::R16Uint,
+        "r8ui" => T::R8Uint,
+        _ => return None,
+    })
+}
+
 /// The value slot of the pack's custom uniform `name` for a program declaring it as GLSL type
 /// `ty`: after the frame's uniforms, in the order of `custom` (each with the type
 /// `shaders.properties` gives it). A `float`, `int`, `vec2`, `vec3` or `vec4` custom uniform
@@ -2432,7 +2521,7 @@ impl PackPost {
         let shadow_config = post.config.shadow.clone();
         let noise_size = post.config.noise_resolution.unwrap_or(256);
         let half_lives = post.config.half_lives;
-        for (name, ticks) in horizon_shaders::HALF_LIVES.iter().zip(half_lives) {
+        for (name, ticks) in horizon_render_pipeline::HALF_LIVES.iter().zip(half_lives) {
             if let Some(t) = ticks {
                 notes.push(format!("`{name}` is {t} ticks"));
             }
@@ -2716,21 +2805,10 @@ impl PackPost {
             .shadow
             .zip(shadow_geometry.as_ref())
             .and_then(|(p, g)| build(p, Some(g)));
-        // A GPU that refuses translucent terrain's program with the boats' water patches gets it
-        // without them (`Post::shadow_water_plain`), rather than no translucent shadows at all.
-        let mut plain = post.shadow_water_plain;
         let shadow_water = post
             .shadow_water
             .zip(shadow_geometry.as_ref())
             .and_then(|(p, g)| build(p, Some(g)));
-        let unpatched = shadow_water.is_none().then(|| plain.take()).flatten();
-        let unpatched_name = unpatched.as_ref().map(|p| p.name.clone());
-        let shadow_water = shadow_water.or_else(|| {
-            unpatched
-                .zip(shadow_geometry.as_ref())
-                .and_then(|(p, g)| build(p, Some(g)))
-        });
-        let water_unpatched = unpatched_name.filter(|_| shadow_water.is_some());
         let (hides_sky, hides_celestial) = (post.sky.is_some(), post.sky_textured.is_some());
         let sky = (post.sky.is_some() || post.sky_textured.is_some()).then(|| {
             let geometry = PackSky::new(device);
@@ -3287,17 +3365,6 @@ impl PackPost {
         let white = [255u8; 4];
         let black = [0u8; 4];
         let flat_normal = [128u8, 128, 255, 255];
-        // Said as what it is, not as a program skipped.
-        if let Some(name) = water_unpatched {
-            let skipped = format!("{name}: skipped: ");
-            if let Some(n) = notes.iter_mut().rev().find(|n| n.starts_with(&skipped)) {
-                *n = format!(
-                    "{name}: translucent terrain without the boats' water patches, as the GPU \
-                     refused it with them ({})",
-                    &n[skipped.len()..]
-                );
-            }
-        }
         let jobs = (pack.jobs.as_ref())
             .map(std::cell::RefCell::take)
             .unwrap_or_default();

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

@@ -1,109 +0,0 @@
-//! A shadow program writing as many vertex outputs as the GPU takes leaves no room for the boats'
-//! water patches (`GbuffersInputs::water_patches`, one output more): translucent terrain gets
-//! the program without them, not no shadow program. The programs here are original.
-use super::destination_tests::Fixture;
-use super::*;
-use std::io::{Cursor, Write};
-
-fn pack(outputs: u32) -> Post {
-    let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
-    let mut add = |name: &str, source: &str| {
-        zip.start_file(
-            format!("shaders/{name}"),
-            zip::write::SimpleFileOptions::default(),
-        )
-        .unwrap();
-        zip.write_all(source.as_bytes()).unwrap();
-    };
-    let declared: String = (0..outputs)
-        .map(|i| format!("varying vec4 v{i};\n"))
-        .collect();
-    let written: String = (0..outputs).map(|i| format!("v{i}=vec4({i}.0);")).collect();
-    let read: String = (0..outputs).map(|i| format!("+v{i}")).collect();
-    add(
-        "shadow.vsh",
-        &format!(
-            "#version 120\n{declared}void main() {{ gl_Position=vec4(gl_Vertex.xy,0.5,1.0); {written} }}\n"
-        ),
-    );
-    add(
-        "shadow.fsh",
-        &format!("#version 120\n{declared}void main() {{ gl_FragData[0]=vec4(0.0){read}; }}\n"),
-    );
-    add(
-        "final.vsh",
-        "#version 120\nvarying vec2 uv;\nvoid main() { uv=gl_MultiTexCoord0.xy; gl_Position=ftransform(); }\n",
-    );
-    add(
-        "final.fsh",
-        "#version 120\nconst int shadowMapResolution=16;\nuniform sampler2D shadowcolor0;\n\
-         varying vec2 uv;\nvoid main() { gl_FragColor=texture2D(shadowcolor0,uv); }\n",
-    );
-    let pack = horizon_shaders::Pack::from_zip_bytes(
-        "original-full-outputs",
-        zip.finish().unwrap().into_inner(),
-    )
-    .unwrap();
-    let mut macros = horizon_shaders::Macros::standard();
-    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
-    let inputs = horizon_shaders::GameInputs {
-        terrain: Some(horizon_shaders::GbuffersInputs {
-            item_id_declared: false,
-            far_depth: false,
-            paged_maps: false,
-            water_mask: false,
-            water_patches: false,
-            declarations: "layout(location=0)in vec3 fixture_position;\n".into(),
-            body: "hz_Vertex=vec4(fixture_position,1.0);hz_Color=vec4(1.0);\
-                   hz_MultiTexCoord0=vec4(0.0);hz_MultiTexCoord1=vec4(240.0);\
-                   hz_MultiTexCoord2=vec4(240.0);hz_Normal=vec3(0.0,0.0,1.0);\n"
-                .into(),
-            attributes: vec![],
-            after: String::new(),
-            alpha_test: None,
-        }),
-        ..Default::default()
-    };
-    horizon_shaders::load_post(&pack, "", &properties, &macros, &inputs)
-}
-
-#[test]
-fn a_shadow_program_with_every_output_drops_the_boats_patches_not_its_water() {
-    let Some(gpu) = Fixture::new() else { return };
-    const ATTRS: [wgpu::VertexAttribute; 1] = wgpu::vertex_attr_array![0=>Float32x3];
-    let layouts = [Some(wgpu::VertexBufferLayout {
-        array_stride: 12,
-        step_mode: wgpu::VertexStepMode::Vertex,
-        attributes: &ATTRS,
-    })];
-    let geometry = || {
-        Some(Geometry {
-            material_maps: false,
-            buffers: &layouts,
-            table: None,
-            depth_write: true,
-            atlas: None,
-            ids: None,
-            cull: true,
-        })
-    };
-    let outputs = gpu.device.limits().max_inter_stage_shader_variables;
-    let post = gpu.build_with_terrain(pack(outputs), geometry());
-    assert!(post.has_shadow(), "{:?}", post.notes);
-    assert!(post.shadow_water.is_some(), "{:?}", post.notes);
-    assert!(
-        post.notes
-            .iter()
-            .any(|n| n.contains("without the boats' water patches")),
-        "{:?}",
-        post.notes
-    );
-    // With room for them, the patches stay and nothing is said.
-    let post = gpu.build_with_terrain(pack(outputs - 1), geometry());
-    assert!(post.shadow_water.is_some(), "{:?}", post.notes);
-    assert!(
-        !post.notes.iter().any(|n| n.contains("water patches")),
-        "{:?}",
-        post.notes
-    );
-}

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

@@ -1,97 +0,0 @@
-//! Image formats: a storage image's format qualifier as wgpu's, and the stand-in a module's
-//! storage images declare.
-
-/// Makes each storage image of `module` in group 0 declare the format its layout entry binds:
-/// a `layout(r11f_g11f_b10f)` image whose texture is the `RGBA16F` stand-in (`bindings`).
-pub(super) fn storage_formats_of(
-    module: &mut naga::Module,
-    entries: &[wgpu::BindGroupLayoutEntry],
-) {
-    let globals: Vec<_> = module.global_variables.iter().map(|(h, _)| h).collect();
-    for handle in globals {
-        let var = &module.global_variables[handle];
-        let Some(naga::ResourceBinding { group: 0, binding }) = var.binding else {
-            continue;
-        };
-        let naga::TypeInner::Image {
-            dim,
-            arrayed,
-            class: naga::ImageClass::Storage { format, access },
-        } = module.types[var.ty].inner
-        else {
-            continue;
-        };
-        let bound = entries.iter().find_map(|e| match e.ty {
-            wgpu::BindingType::StorageTexture { format, .. } if e.binding == binding => {
-                Some(format)
-            }
-            _ => None,
-        });
-        if format == naga::StorageFormat::Rg11b10Ufloat
-            && bound == Some(wgpu::TextureFormat::Rgba16Float)
-        {
-            let ty = module.types.insert(
-                naga::Type {
-                    name: module.types[var.ty].name.clone(),
-                    inner: naga::TypeInner::Image {
-                        dim,
-                        arrayed,
-                        class: naga::ImageClass::Storage {
-                            format: naga::StorageFormat::Rgba16Float,
-                            access,
-                        },
-                    },
-                },
-                naga::Span::UNDEFINED,
-            );
-            module.global_variables[handle].ty = ty;
-        }
-    }
-}
-
-/// The wgpu format of an image's format qualifier.
-pub(super) fn image_format(qualifier: &str) -> Option<wgpu::TextureFormat> {
-    use wgpu::TextureFormat as T;
-    Some(match qualifier {
-        "rgba32f" => T::Rgba32Float,
-        "rgba16f" => T::Rgba16Float,
-        "rg32f" => T::Rg32Float,
-        "rg16f" => T::Rg16Float,
-        "r11f_g11f_b10f" => T::Rg11b10Ufloat,
-        "r32f" => T::R32Float,
-        "r16f" => T::R16Float,
-        "rgba16" => T::Rgba16Unorm,
-        "rgb10_a2" => T::Rgb10a2Unorm,
-        "rgba8" => T::Rgba8Unorm,
-        "rg16" => T::Rg16Unorm,
-        "rg8" => T::Rg8Unorm,
-        "r16" => T::R16Unorm,
-        "r8" => T::R8Unorm,
-        "rgba16_snorm" => T::Rgba16Snorm,
-        "rgba8_snorm" => T::Rgba8Snorm,
-        "rg16_snorm" => T::Rg16Snorm,
-        "rg8_snorm" => T::Rg8Snorm,
-        "r16_snorm" => T::R16Snorm,
-        "r8_snorm" => T::R8Snorm,
-        "rgba32i" => T::Rgba32Sint,
-        "rgba16i" => T::Rgba16Sint,
-        "rgba8i" => T::Rgba8Sint,
-        "rg32i" => T::Rg32Sint,
-        "rg16i" => T::Rg16Sint,
-        "rg8i" => T::Rg8Sint,
-        "r32i" => T::R32Sint,
-        "r16i" => T::R16Sint,
-        "r8i" => T::R8Sint,
-        "rgba32ui" => T::Rgba32Uint,
-        "rgba16ui" => T::Rgba16Uint,
-        "rgb10_a2ui" => T::Rgb10a2Uint,
-        "rgba8ui" => T::Rgba8Uint,
-        "rg32ui" => T::Rg32Uint,
-        "rg16ui" => T::Rg16Uint,
-        "rg8ui" => T::Rg8Uint,
-        "r32ui" => T::R32Uint,
-        "r16ui" => T::R16Uint,
-        "r8ui" => T::R8Uint,
-        _ => return None,
-    })
-}

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

@@ -10,7 +10,7 @@
 //! a fit to one driver's values, not a rule Iris states. `RGBA4` and `RGBA2` read back the `RGBA8`
 //! bytes in the same probe, as Horizon's 8-bit buffers already do.
 
-use horizon_shaders::{Format, Kind};
+use horizon_render_pipeline::{Format, Kind};
 use naga::{BinaryOperator, Expression, Literal, MathFunction, Statement, VectorSize};
 
 /// The bits each channel keeps in a buffer of format `f`, for the formats that keep fewer than

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

@@ -3,7 +3,7 @@
 //! with two sides that `shadowcomp` programs flip as composite programs flip colortex (6.1.6).
 //! Square, `shadowMapResolution` pixels.
 
-use horizon_shaders::SHADOW_COLORS;
+use horizon_render_pipeline::SHADOW_COLORS;
 
 type Ops<T> = wgpu::Operations<T>;
 type Color = wgpu::Color;
@@ -97,7 +97,11 @@ pub(super) fn stand_in(device: &wgpu::Device) -> wgpu::TextureView {
 }
 
 impl ShadowTargets {
-    pub fn reset_history(&mut self, device: &wgpu::Device, shadow: &horizon_shaders::Shadow) {
+    pub fn reset_history(
+        &mut self,
+        device: &wgpu::Device,
+        shadow: &horizon_render_pipeline::Shadow,
+    ) {
         let mut colors = 0;
         let mut doubled = 0;
         let formats = std::array::from_fn(|n| match &self.color[n] {
@@ -125,7 +129,7 @@ impl ShadowTargets {
     /// resolution is kept within the device's limit.
     pub fn new(
         device: &wgpu::Device,
-        shadow: &horizon_shaders::Shadow,
+        shadow: &horizon_render_pipeline::Shadow,
         formats: [wgpu::TextureFormat; SHADOW_COLORS],
         colors: u16,
         doubled: u16,

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

@@ -1,7 +1,8 @@
 //! A shader pack's custom textures (`texture.<stage>.<name>`, `texture.noise`) on the GPU, and
 //! which of them a program's sampler reads.
 
-use horizon_shaders::{CustomTexture, Group, Kind, Texels, Texture, TextureDim, TextureSource};
+use horizon_render_pipeline::Kind;
+use horizon_shaders::{CustomTexture, Group, Texels, Texture, TextureDim, TextureSource};
 
 /// What a custom texture is once uploaded: an image of ours, or one the game already has.
 pub(super) enum Image {
@@ -118,12 +119,12 @@ pub(super) fn find(textures: &[PackTexture], group: Group, ty: &str, name: &str)
     } else {
         wgpu::TextureViewDimension::D2
     };
-    let buffer = horizon_shaders::buffer_index(name);
+    let buffer = horizon_render_pipeline::buffer_index(name);
     let staged = textures.iter().position(|t| {
         t.stage == stage(group)
             && t.dimension == dimension
             && (t.name == name
-                || buffer.is_some() && horizon_shaders::buffer_index(&t.name) == buffer)
+                || buffer.is_some() && horizon_render_pipeline::buffer_index(&t.name) == buffer)
     });
     staged.or_else(|| {
         textures.iter().position(|t| {

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

@@ -28,7 +28,7 @@
 //! [-w, w], and the depth buffers packs read hold GL window depth.
 
 use glam::{DMat4, DVec3, Mat4, Vec3, Vec4};
-use horizon_shaders::Shadow;
+use horizon_render_pipeline::Shadow;
 
 use super::Frame;
 
@@ -440,7 +440,7 @@ pub struct FrameUniforms {
     center_depth: Option<f32>,
     /// The pack's shadow settings (7.1).
     pub shadow: Shadow,
-    /// The pack's smoothing half-lives in ticks (`horizon_shaders::HALF_LIVES`).
+    /// The pack's smoothing half-lives in ticks (`horizon_render_pipeline::HALF_LIVES`).
     pub half_lives: [Option<f32>; 4],
 }
 

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

@@ -1,79 +0,0 @@
-//! Hardware ray queries, only on request (#13780, after the #1180 spike): `HORIZON_RAY_TRACING=1`
-//! at startup asks the device for wgpu's `EXPERIMENTAL_RAY_QUERY` when the GPU has it. Nothing
-//! draws with it yet. Without the variable, and in a build without `horizon-extras` (a Horizon
-//! extra, docs/layers.md), the device is opened exactly as before.
-
-/// The ray query feature.
-const RAY_QUERY: wgpu::Features = wgpu::Features::EXPERIMENTAL_RAY_QUERY;
-
-/// Whether the player asked for ray tracing (the device needs the feature from its creation).
-fn requested() -> bool {
-    asked(std::env::var("HORIZON_RAY_TRACING").ok().as_deref())
-}
-
-/// Whether `HORIZON_RAY_TRACING` set to `var` asks for ray tracing: only in a `horizon-extras`
-/// build.
-fn asked(var: Option<&str>) -> bool {
-    cfg!(feature = "horizon-extras") && var == Some("1")
-}
-
-/// The features to request on `adapter`: ray queries, when asked for and offered.
-pub(super) fn features(adapter: &wgpu::Adapter) -> wgpu::Features {
-    let features = pick(requested(), adapter.features());
-    if requested() {
-        let info = adapter.get_info();
-        if features.is_empty() {
-            log::warn!(
-                "Horizon renderer: ray tracing asked for, but {} on {:?} has no hardware ray \
-                 queries; it stays off",
-                info.name,
-                info.backend
-            );
-        } else {
-            log::info!(
-                "Horizon renderer: ray queries on ({} on {:?})",
-                info.name,
-                info.backend
-            );
-        }
-    }
-    features
-}
-
-fn pick(requested: bool, offered: wgpu::Features) -> wgpu::Features {
-    if requested {
-        offered & RAY_QUERY
-    } else {
-        wgpu::Features::empty()
-    }
-}
-
-/// The device's opt-in to `features`' experimental ones.
-pub(super) fn experimental(features: wgpu::Features) -> wgpu::ExperimentalFeatures {
-    if features.contains(RAY_QUERY) {
-        horizon_hdr::experimental_features()
-    } else {
-        wgpu::ExperimentalFeatures::disabled()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn only_an_extras_build_asks_for_ray_tracing() {
-        assert_eq!(asked(Some("1")), cfg!(feature = "horizon-extras"));
-        assert!(!asked(None));
-        assert!(!asked(Some("0")));
-    }
-
-    #[test]
-    fn ray_queries_only_when_asked_and_offered() {
-        let all = wgpu::Features::all();
-        assert_eq!(pick(true, all), RAY_QUERY);
-        assert!(pick(false, all).is_empty());
-        assert!(pick(true, all - RAY_QUERY).is_empty());
-        assert!(!experimental(wgpu::Features::empty()).is_enabled());
-    }
-}

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

@@ -5,9 +5,6 @@ use super::{
     Renderer, check_layers, cull, describe_adapter, is_software, oit, startup_step, surface_format,
     timing,
 };
-// Ray tracing on request, which the device needs from its creation (gfx.rs may not grow).
-#[path = "ray_query.rs"]
-mod ray_query;
 use std::sync::Arc;
 use winit::window::Window;
 
@@ -137,7 +134,6 @@ pub(super) async fn open_adapter(
     let features = timing::GpuTimer::features(adapter)
         | cull::Cull::features(adapter)
         | oit::features(adapter)
-        | ray_query::features(adapter)
         | (adapter.features()
             & (wgpu::Features::INDIRECT_FIRST_INSTANCE
                 | wgpu::Features::MULTI_DRAW_INDIRECT_COUNT
@@ -170,7 +166,6 @@ pub(super) async fn open_adapter(
         // with the larger blocks a few small buffers kept whole blocks the arena's pages had
         // left, and over half the video memory reserved was unused (1,344 MiB for 500).
         memory_hints: wgpu::MemoryHints::MemoryUsage,
-        experimental_features: ray_query::experimental(features),
         ..Default::default()
     };
     #[cfg(not(target_os = "macos"))]

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

@@ -30,22 +30,6 @@ fn marker_driver(text: &str) -> &str {
 pub struct Reported {
     pub paper_white: u32,
     pub peak: u32,
-    /// The peak is the display's own claim (DXGI's `MaxLuminance`, mostly its EDID figure),
-    /// which often runs high: Auto still uses it, but the HDR page asks to calibrate.
-    pub peak_guessed: bool,
-}
-
-/// Whether HDR is set up for the display, and whether the player kept the system's setup.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum HdrSetup {
-    /// The system says nothing: the player calibrates.
-    Unknown,
-    /// The system says, but only guesses the peak: the player calibrates.
-    Guessed,
-    /// Peak Brightness and Paper White follow the system.
-    Automatic,
-    /// The system said, and the player changed them anyway.
-    Changed,
 }
 
 /// The top of Peak Brightness's scale: `peak_nits_at(PEAK_STEPS)` is PQ's 10 000 nits.
@@ -68,23 +52,6 @@ pub fn peak_step_of(nits: f32) -> f32 {
     };
     step.clamp(0.0, PEAK_STEPS as f32)
 }
-/// The steps of Paper White's and UI Brightness's scale: Auto (0), then 10 to 480 nits by 10.
-pub const NITS_STEPS: u32 = 48;
-/// Paper White's or UI Brightness's setting at slider position `v`, 0 to 1 ([`NITS_STEPS`]).
-pub fn nits_at(v: f32) -> u32 {
-    (v * NITS_STEPS as f32).round() as u32 * 10
-}
-/// Where a Paper White or UI Brightness setting sits on its slider, 0 to 1.
-pub fn nits_position(nits: u32) -> f32 {
-    nits as f32 / (NITS_STEPS * 10) as f32
-}
-/// A saved Paper White or UI Brightness: Auto (0), or 10 to 480 nits.
-fn nits_setting(nits: u32) -> u32 {
-    match nits {
-        0 => 0,
-        n => n.clamp(10, 480),
-    }
-}
 
 /// Simple-level presets. `Custom` leaves every option as the player set it.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
@@ -537,6 +504,8 @@ pub fn reduced_far_detail_suggested() -> bool {
     REDUCED_SUGGESTED.load(std::sync::atomic::Ordering::Relaxed)
 }
 
+/// 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];
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
@@ -846,12 +815,14 @@ pub struct Graphics {
     /// HDR black level: the display's darkest black, in hundredths of a nit; 0, the default,
     /// lifts nothing. Shadows are lifted onto it, and the HDR metadata says it.
     pub hdr_black_level: u32,
-    /// HDR brightness of the HUD and menus, in nits; 0 is Auto: at paper white
-    /// ([`Graphics::ui_nits`]). The first-person hand stays at the world's.
-    pub hdr_ui_nits: u32,
+    /// HDR brightness of the HUD and menus, in percent of paper white (25..=100); the
+    /// first-person hand stays at the world's.
+    pub hdr_ui_brightness: u32,
     /// HDR Lighting: Horizon's own HDR look, light sources, the sun and sunlight above paper
     /// white. Off, HDR output shows the same picture as SDR, for shader packs or the vanilla look.
     pub hdr_lighting: bool,
+    /// A vanilla key name (`HDR_KEY`): opens HDR's settings from the game. Unbound by default.
+    pub hdr_key: String,
     /// The graphics driver whose last start ended before HDR output showed a frame (the
     /// marker found, [`HDR_MARKER`]): a window on it stays SDR whatever the mode, until the
     /// mode is changed or the window starts on another driver ([`Graphics::hdr_held`]).
@@ -929,8 +900,9 @@ impl Default for Graphics {
             hdr_paper_white: 0,
             hdr_peak: 0,
             hdr_black_level: 0,
-            hdr_ui_nits: 0,
+            hdr_ui_brightness: 100,
             hdr_lighting: true,
+            hdr_key: "key.keyboard.unknown".into(),
             hdr_failed_start: None,
             battery: false,
             shadow_cache: false,
@@ -1003,8 +975,6 @@ impl Graphics {
     }
     pub fn parse(text: &str) -> Self {
         let mut g = Self::default();
-        // UI Brightness: `hdrUiNits`, else an older file's share of Paper White.
-        let (mut ui_nits, mut ui_share) = (None, None);
         for line in text.lines() {
             let Some((key, value)) = line.split_once(':') else {
                 continue;
@@ -1094,9 +1064,12 @@ impl Graphics {
                 "frameGeneration" => g.frame_generation = FrameGeneration::parse(value),
                 "hdr" => g.hdr = HdrMode::parse(value, g.hdr),
                 "hdrLighting" => g.hdr_lighting = flag(g.hdr_lighting),
-                "hdrPaperWhite" => g.hdr_paper_white = nits_setting(number(g.hdr_paper_white)),
-                "hdrUiNits" => ui_nits = value.parse().ok().map(nits_setting),
-                "hdrUiBrightness" => ui_share = value.parse::<u32>().ok(),
+                "hdrPaperWhite" => {
+                    g.hdr_paper_white = match number(g.hdr_paper_white) {
+                        0 => 0,
+                        n => n.clamp(10, 480),
+                    }
+                }
                 "hdrPeak" => {
                     g.hdr_peak = match number(g.hdr_peak) {
                         0 => 0,
@@ -1104,6 +1077,10 @@ impl Graphics {
                     }
                 }
                 "hdrBlackLevel" => g.hdr_black_level = number(g.hdr_black_level).min(100),
+                "hdrUiBrightness" => {
+                    g.hdr_ui_brightness = number(g.hdr_ui_brightness).clamp(25, 100)
+                }
+                "hdrKey" if value.starts_with("key.") => g.hdr_key = value.to_owned(),
                 "hdrFailedStart" => g.hdr_failed_start = Some(value.to_owned()),
                 "batteryMode" => g.battery = flag(g.battery),
                 "shadowCache" => g.shadow_cache = flag(g.shadow_cache),
@@ -1121,20 +1098,11 @@ impl Graphics {
                 _ => {}
             }
         }
-        // The share was 25 to 100% of Paper White. 100% is Auto, and so is any share of an
-        // Auto Paper White, whose nits the file doesn't hold; another share of a Paper White set
-        // by hand is its nits, to the nearest step.
-        g.hdr_ui_nits = ui_nits.unwrap_or(match (ui_share, g.hdr_paper_white) {
-            (Some(share), paper) if share < 100 && paper != 0 => {
-                ((paper * share.max(25) + 500) / 1000).max(1) * 10
-            }
-            _ => 0,
-        });
         g
     }
     pub fn serialize(&self) -> String {
         let mut text = format!(
-            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nentityCullingPrecheck:{}\nparticleCulling:{}\nleafCulling:{}\nopaqueIce:{}\nblockEntityCacheShulkerBoxes:{}\nblockEntityCacheSigns:{}\nblockEntityCacheDecoratedPots:{}\nblockEntityCacheBells:{}\nblockEntityCacheChests:{}\nblockEntityCacheBanners:{}\nblockEntityCacheCopperGolemStatues:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\ntextureBudgetMiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\nditherCutoutMips:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nupscalingSharpness:{}\nscreenshotQuality:{}\nframeGeneration:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiNits:{}\nhdrLighting:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\nbatchTranslucent:{}\nhdrSmoothGradients:{}\ngpuCulling:{}\n",
+            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nentityCullingPrecheck:{}\nparticleCulling:{}\nleafCulling:{}\nopaqueIce:{}\nblockEntityCacheShulkerBoxes:{}\nblockEntityCacheSigns:{}\nblockEntityCacheDecoratedPots:{}\nblockEntityCacheBells:{}\nblockEntityCacheChests:{}\nblockEntityCacheBanners:{}\nblockEntityCacheCopperGolemStatues:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\ntextureBudgetMiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\nditherCutoutMips:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nupscalingSharpness:{}\nscreenshotQuality:{}\nframeGeneration:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrLighting:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\nbatchTranslucent:{}\nhdrSmoothGradients:{}\ngpuCulling:{}\n",
             self.preset.name(),
             self.lod_distance,
             self.far_detail.name(),
@@ -1181,8 +1149,9 @@ impl Graphics {
             self.hdr_paper_white,
             self.hdr_peak,
             self.hdr_black_level,
-            self.hdr_ui_nits,
+            self.hdr_ui_brightness,
             bool_text(self.hdr_lighting),
+            self.hdr_key,
             bool_text(self.battery),
             bool_text(self.shadow_cache),
             self.api.name(),
@@ -1197,6 +1166,14 @@ impl Graphics {
         text += &self.blue_map.serialize();
         text
     }
+    /// Binds Horizon's graphics key `name` (`HDR_KEY`); false for another name.
+    pub fn set_key(&mut self, name: &str, value: String) -> bool {
+        match name {
+            HDR_KEY => self.hdr_key = value,
+            _ => return false,
+        }
+        true
+    }
     pub fn save(&self, dir: &Path) {
         let _ = fs::write(dir.join(FILE), self.serialize());
     }
@@ -1208,13 +1185,6 @@ impl Graphics {
             n => n,
         }
     }
-    /// The HUD and menus' brightness, in nits: the player's, or on Auto paper white's.
-    pub fn ui_nits(&self, reported: Option<Reported>) -> u32 {
-        match self.hdr_ui_nits {
-            0 => self.paper_white_nits(reported),
-            n => n,
-        }
-    }
     /// The peak the world's highlights reach, in nits: the player's, or on Auto
     /// what the system `reported`, else 1000.
     pub fn peak_nits(&self, reported: Option<Reported>) -> u32 {
@@ -1223,15 +1193,6 @@ impl Graphics {
             n => n,
         }
     }
-    /// How HDR is set up for the display the system `reported`.
-    pub fn hdr_setup(&self, reported: Option<Reported>) -> HdrSetup {
-        match reported {
-            None => HdrSetup::Unknown,
-            Some(_) if self.hdr_peak != 0 || self.hdr_paper_white != 0 => HdrSetup::Changed,
-            Some(r) if r.peak_guessed => HdrSetup::Guessed,
-            Some(_) => HdrSetup::Automatic,
-        }
-    }
     /// The black level, in nits. Not the system's: files from before saved 0 for that
     /// (Auto), and a reported black would lift every display's shadows by default.
     pub fn black_level_nits(&self) -> f32 {
@@ -1304,83 +1265,6 @@ pub fn apply_preset(preset: Preset, s: &mut crate::settings::Settings) {
 mod tests {
     use super::*;
 
-    /// UI Brightness is saved in nits, 0 for Auto. An older file's share of Paper White reads
-    /// as Auto at 100% or with Paper White on Auto, else as that share of it to the nearest step.
-    #[test]
-    fn ui_brightness_round_trips_in_nits_and_reads_older_shares() {
-        for (file, nits) in [
-            ("", 0),
-            ("hdrUiNits:0\n", 0),
-            ("hdrUiNits:160\n", 160),
-            ("hdrUiNits:5\n", 10),
-            ("hdrUiNits:9000\n", 480),
-            ("hdrUiNits:x\n", 0),
-            // Older files: 100% is Auto,
-            ("hdrPaperWhite:200\nhdrUiBrightness:100\n", 0),
-            // any share of Paper White's Auto too,
-            ("hdrUiBrightness:60\n", 0),
-            ("hdrPaperWhite:0\nhdrUiBrightness:25\n", 0),
-            // and another share of a Paper White set by hand is its nits.
-            ("hdrPaperWhite:200\nhdrUiBrightness:60\n", 120),
-            ("hdrUiBrightness:50\nhdrPaperWhite:203\n", 100),
-            ("hdrPaperWhite:250\nhdrUiBrightness:75\n", 190),
-            ("hdrPaperWhite:10\nhdrUiBrightness:25\n", 10),
-            ("hdrPaperWhite:480\nhdrUiBrightness:10\n", 120),
-            // The new key wins over the old one.
-            (
-                "hdrPaperWhite:200\nhdrUiBrightness:60\nhdrUiNits:300\n",
-                300,
-            ),
-            ("hdrUiNits:0\nhdrPaperWhite:200\nhdrUiBrightness:60\n", 0),
-        ] {
-            let g = Graphics::parse(file);
-            assert_eq!(g.hdr_ui_nits, nits, "{file}");
-            let saved = g.serialize();
-            assert!(!saved.contains("hdrUiBrightness"), "{file}");
-            assert!(saved.contains(&format!("\nhdrUiNits:{nits}\n")), "{file}");
-            assert_eq!(Graphics::parse(&saved), g, "{file}");
-        }
-        let mut g = Graphics::default();
-        assert_eq!(g.ui_nits(None), 203);
-        let reported = Some(Reported {
-            paper_white: 300,
-            peak: 1000,
-            peak_guessed: false,
-        });
-        assert_eq!(g.ui_nits(reported), 300);
-        g.hdr_paper_white = 120;
-        assert_eq!(g.ui_nits(reported), 120);
-        g.hdr_ui_nits = 400;
-        assert_eq!((g.ui_nits(None), g.ui_nits(reported)), (400, 400));
-    }
-
-    #[test]
-    fn hdr_setup_asks_to_calibrate_where_the_peak_is_guessed() {
-        let wayland = Reported {
-            paper_white: 203,
-            peak: 1015,
-            peak_guessed: false,
-        };
-        let windows = Reported {
-            paper_white: 400,
-            peak: 1000,
-            peak_guessed: true,
-        };
-        let mut g = Graphics::default();
-        assert_eq!(g.hdr_setup(None), HdrSetup::Unknown);
-        assert_eq!(g.hdr_setup(Some(wayland)), HdrSetup::Automatic);
-        assert_eq!(g.hdr_setup(Some(windows)), HdrSetup::Guessed);
-        // Auto still takes the guess, over the 1000-nit default.
-        assert_eq!(g.peak_nits(Some(windows)), 1000);
-        assert_eq!(g.paper_white_nits(Some(windows)), 400);
-        for (peak, paper_white) in [(800, 0), (0, 240)] {
-            (g.hdr_peak, g.hdr_paper_white) = (peak, paper_white);
-            assert_eq!(g.hdr_setup(Some(windows)), HdrSetup::Changed);
-            assert_eq!(g.hdr_setup(Some(wayland)), HdrSetup::Changed);
-            assert_eq!(g.hdr_setup(None), HdrSetup::Unknown);
-        }
-    }
-
     #[test]
     fn hdr_modes_keep_boolean_files_and_round_trip_auto() {
         assert_eq!(Graphics::parse("").hdr, HdrMode::Off);
@@ -1546,8 +1430,9 @@ mod tests {
             hdr_paper_white: 240,
             hdr_peak: 1400,
             hdr_black_level: 12,
-            hdr_ui_nits: 160,
+            hdr_ui_brightness: 60,
             hdr_lighting: false,
+            hdr_key: "key.keyboard.h".into(),
             hdr_failed_start: Some(
                 "Vulkan 10de:2684 NVIDIA GeForce RTX 4090; NVIDIA; 581.57".into(),
             ),
@@ -1689,10 +1574,6 @@ mod tests {
             Graphics::parse("shaderPack:Pack.zip\n"),
             Graphics::default()
         );
-        // The HDR page's old shortcut key loads as nothing, and the next save drops it.
-        let old = Graphics::parse("hdr:true\nhdrKey:key.keyboard.h\nhdrPeak:1000\n");
-        assert_eq!((old.hdr, old.hdr_peak), (HdrMode::On, 1000));
-        assert!(!old.serialize().contains("hdrKey"));
         assert_eq!(
             Graphics::parse(
                 "workers:abc\nsky:maybe\ncullLeaves:true\nentityCulling:maybe\nleafCulling:maybe\n"

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

@@ -8,14 +8,13 @@ use crate::{
     gfx::EffectiveOutput,
     graphics::{
         EntityCullingMode, FarDetail, FrameGeneration, GpuCullingMode, GraphicsApi, HdrMode,
-        HdrSetup as Setup, LeafCullingMode, Overlay, Pacing, ParticleCullingMode, PresentMode,
-        Preset, Upscaling,
+        LeafCullingMode, Overlay, Pacing, ParticleCullingMode, PresentMode, Preset, Upscaling,
     },
     graphics_style::Cost,
     lang,
     options_ui::{Event, Page as OptionsPage},
     settings::{Opt, Settings},
-    settings_shell::{self as shell, Group, Output, Row, Screen, Sheet, Value},
+    settings_shell::{self as shell, Binding, Group, Output, Row, Screen, Sheet, Value},
     text::Text,
 };
 
@@ -107,6 +106,8 @@ pub enum H {
     FrameGeneration,
     Hdr,
     HdrBlackLevel,
+    /// Binds `Graphics::hdr_key`.
+    HdrKey,
     /// Starts HDR calibration (`crate::hdr_calibration`).
     HdrCalibrate,
     HdrPeak,
@@ -613,7 +614,7 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
                         h(
                             H::HdrUiBrightness,
                             None,
-                            "How bright the HUD and menus are. Auto: at paper white.",
+                            "How bright the HUD and menus are, against paper white.",
                         ),
                         h(
                             H::HdrLighting,
@@ -622,6 +623,14 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
                         ),
                     ],
                 ),
+                (
+                    "Shortcut",
+                    vec![h(
+                        H::HdrKey,
+                        None,
+                        "A key that opens this screen from the game. Not bound at first.",
+                    )],
+                ),
             ],
         ),
     ];
@@ -676,9 +685,28 @@ const LOD_STEPS: [u32; 24] = [
     crate::lod::MAX_CHUNKS,
 ];
 
+/// Whether the system set HDR up for the display, and whether the player kept it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Setup {
+    /// The system says nothing: the player calibrates.
+    Unknown,
+    /// Peak Brightness and Paper White follow the system.
+    Automatic,
+    /// The system said, and the player changed them anyway.
+    Changed,
+}
 /// `out`: the output of the renderer the settings are shown for, with what its display reports.
 fn setup(s: &Settings, out: &EffectiveOutput) -> Setup {
-    s.horizon.hdr_setup(out.reported)
+    setup_of(&s.horizon, out.reported.is_some())
+}
+fn setup_of(g: &crate::graphics::Graphics, reported: bool) -> Setup {
+    if !reported {
+        Setup::Unknown
+    } else if g.hdr_peak == 0 && g.hdr_paper_white == 0 {
+        Setup::Automatic
+    } else {
+        Setup::Changed
+    }
 }
 /// What the HDR page says while HDR output is held back on this window's graphics driver
 /// (`EffectiveOutput::held`): picking a mode tries again (`H::cycle`).
@@ -696,19 +724,13 @@ fn description(
         (Item::Horizon(H::HdrCalibrate), Setup::Unknown) => {
             "Your display didn't say how bright it gets: calibrate to set it up."
         }
-        (Item::Horizon(H::HdrCalibrate), Setup::Guessed) => {
-            "Your display's reported peak is often too high: calibrate to set it up."
-        }
         (Item::Horizon(H::HdrCalibrate), Setup::Automatic) => {
             "Already set up for your display. Only calibrate if HDR looks wrong."
         }
         (Item::Horizon(H::HdrCalibrate), Setup::Changed) => {
             "Puts Peak Brightness and Paper White back to your display's setup."
         }
-        // A guessed peak's Auto is what calibration replaced; paper white is the player's own.
-        (Item::Horizon(h @ (H::HdrPeak | H::HdrPaperWhite)), Setup::Automatic | Setup::Changed)
-            if h == H::HdrPaperWhite || out.reported.is_some_and(|r| !r.peak_guessed) =>
-        {
+        (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::GpuCulling), _) if s.horizon.gpu_culling == GpuCullingMode::Auto => {
@@ -797,14 +819,14 @@ impl H {
             H::ResolutionScale => Some((g.resolution_scale as f32 - 50.0) / 150.0),
             H::UpscalingSharpness => Some(g.upscaling_sharpness as f32 / 100.0),
             // Auto, then 10..480 by 10.
-            H::HdrPaperWhite => Some(crate::graphics::nits_position(g.hdr_paper_white)),
-            H::HdrUiBrightness => Some(crate::graphics::nits_position(g.hdr_ui_nits)),
+            H::HdrPaperWhite => Some(g.hdr_paper_white as f32 / 480.0),
             // Auto, then the peak's scale.
             H::HdrPeak => Some(match g.hdr_peak {
                 0 => 0.0,
                 n => (1.0 + crate::graphics::peak_step_of(n as f32)) / PEAK_POSITIONS as f32,
             }),
             H::HdrBlackLevel => Some(g.hdr_black_level as f32 / 100.0),
+            H::HdrUiBrightness => Some((g.hdr_ui_brightness as f32 - 25.0) / 75.0),
             _ => None,
         }
     }
@@ -816,26 +838,13 @@ impl H {
             H::Workers => Some(max_workers()),
             H::ResolutionScale => Some(30),
             H::UpscalingSharpness => Some(20),
-            H::HdrPaperWhite | H::HdrUiBrightness => Some(crate::graphics::NITS_STEPS),
+            H::HdrPaperWhite => Some(48),
             H::HdrPeak => Some(PEAK_POSITIONS),
             H::HdrBlackLevel => Some(100),
+            H::HdrUiBrightness => Some(15),
             _ => None,
         }
     }
-    /// "Paper White: Auto (203)" or "Paper White: 160": a setting in nits, 0 for Auto, which
-    /// shows the nits Auto gives.
-    fn nits_label(self, s: &Settings, out: &EffectiveOutput) -> Text {
-        let (g, r) = (&s.horizon, out.reported);
-        let (caption, set, auto) = match self {
-            H::HdrPaperWhite => ("Paper White", g.hdr_paper_white, g.paper_white_nits(r)),
-            H::HdrPeak => ("Peak Brightness", g.hdr_peak, g.peak_nits(r)),
-            _ => ("UI Brightness", g.hdr_ui_nits, g.ui_nits(r)),
-        };
-        match set {
-            0 => labelled(caption, lang::tr("Auto (%s)", &[&auto])),
-            n => labelled(caption, n),
-        }
-    }
     fn label(self, s: &Settings, out: &EffectiveOutput) -> Text {
         let g = &s.horizon;
         match self {
@@ -932,13 +941,30 @@ impl H {
             H::FrameGeneration => labelled("Frame Generation", g.frame_generation.label()),
             H::Hdr => labelled("HDR", g.hdr.label()),
             H::HdrCalibrate => Text::literal(lang::get(match setup(s, out) {
-                Setup::Unknown | Setup::Guessed => "Calibrate...",
+                Setup::Unknown => "Calibrate...",
                 Setup::Automatic => "Calibrate Anyway...",
                 Setup::Changed => "Use Automatic Setup",
             })),
-            H::HdrPaperWhite | H::HdrPeak | H::HdrUiBrightness => self.nits_label(s, out),
+            H::HdrPaperWhite => match g.hdr_paper_white {
+                0 => labelled(
+                    "Paper White",
+                    lang::tr("Auto (%s)", &[&g.paper_white_nits(out.reported)]),
+                ),
+                n => labelled("Paper White", n.to_string()),
+            },
+            H::HdrPeak => match g.hdr_peak {
+                0 => labelled(
+                    "Peak Brightness",
+                    lang::tr("Auto (%s)", &[&g.peak_nits(out.reported)]),
+                ),
+                n => labelled("Peak Brightness", n.to_string()),
+            },
             H::HdrBlackLevel => labelled("Black Level", format!("{:.2}", g.black_level_nits())),
+            H::HdrUiBrightness => labelled_percent("UI Brightness", g.hdr_ui_brightness),
             H::HdrLighting => labelled("HDR Lighting", on_off(g.hdr_lighting)),
+            H::HdrKey => {
+                Text::translate("Shortcut: %s", &[crate::keybinds::display_name(&g.hdr_key)])
+            }
             H::BatteryMode => labelled("Battery Mode", on_off(g.battery)),
             H::ShadowCache => labelled("Shadow Cache", on_off(g.shadow_cache)),
             // A press across the row, as Calibrate...: the list it opens shows the pick.
@@ -979,8 +1005,7 @@ impl H {
             H::Workers => g.workers = (v * max_workers() as f32).round() as u32,
             H::ResolutionScale => g.resolution_scale = (50.0 + (v * 30.0).round() * 5.0) as u32,
             H::UpscalingSharpness => g.upscaling_sharpness = (v * 20.0).round() as u32 * 5,
-            H::HdrPaperWhite => g.hdr_paper_white = crate::graphics::nits_at(v),
-            H::HdrUiBrightness => g.hdr_ui_nits = crate::graphics::nits_at(v),
+            H::HdrPaperWhite => g.hdr_paper_white = (v * 48.0).round() as u32 * 10,
             H::HdrPeak => {
                 g.hdr_peak = match (v * PEAK_POSITIONS as f32).round() as u32 {
                     0 => 0,
@@ -988,6 +1013,7 @@ impl H {
                 }
             }
             H::HdrBlackLevel => g.hdr_black_level = (v * 100.0).round() as u32,
+            H::HdrUiBrightness => g.hdr_ui_brightness = (25.0 + (v * 15.0).round() * 5.0) as u32,
             _ => {}
         }
     }
@@ -1163,7 +1189,10 @@ impl Item {
     fn steps(self, s: &Settings, out: &EffectiveOutput) -> bool {
         self.switch(s, out).is_none()
             && self.slider(s).is_none()
-            && !matches!(self, Item::Horizon(H::HdrCalibrate | H::ShaderPacks))
+            && !matches!(
+                self,
+                Item::Horizon(H::HdrKey | H::HdrCalibrate | H::ShaderPacks)
+            )
     }
     /// On/off settings and their value.
     pub fn switch(self, s: &Settings, out: &EffectiveOutput) -> Option<bool> {
@@ -1318,6 +1347,12 @@ fn shown(item: Item, s: &Settings) -> bool {
 }
 /// A control's label as its name and its value ("Render Distance" and "12 chunks").
 fn parts(item: Item, s: &Settings, out: &EffectiveOutput) -> (String, Option<String>) {
+    // The shortcut's label is one translated "Shortcut: %s"; the row shows its key apart, as
+    // KeyBindsScreen does ("> key <" while it waits, `settings_shell::Value::Binding`).
+    if item == Item::Horizon(H::HdrKey) {
+        let key = crate::keybinds::display_name(&s.horizon.hdr_key).plain();
+        return (lang::get("Shortcut"), Some(key));
+    }
     shell::name_and_value(&item.label(s, out).plain())
 }
 
@@ -1326,9 +1361,13 @@ fn parts(item: Item, s: &Settings, out: &EffectiveOutput) -> (String, Option<Str
 fn row(setting: Setting, s: &Settings, out: &EffectiveOutput) -> Row<Item> {
     let item = setting.item;
     let (name, value) = parts(item, s, out);
-    let value = match (item.switch(s, out), item.slider(s)) {
-        (Some(on), _) => Value::Switch(on),
-        (None, Some(position)) => Value::Slider {
+    let value = match (item, item.switch(s, out), item.slider(s)) {
+        (Item::Horizon(H::HdrKey), ..) => Value::Binding(Binding::key(
+            crate::graphics::HDR_KEY,
+            value.unwrap_or_default(),
+        )),
+        (_, Some(on), _) => Value::Switch(on),
+        (_, None, Some(position)) => Value::Slider {
             position,
             steps: item.slider_steps(),
             text: value.unwrap_or_default(),
@@ -1544,7 +1583,7 @@ mod tests {
     use super::*;
     use crate::{
         graphics_style as style,
-        settings_shell::{Columns, Hosted, Shell, Target},
+        settings_shell::{Capture, Columns, Hosted, Shell, Target},
     };
     use winit::keyboard::KeyCode as K;
 
@@ -2010,6 +2049,10 @@ mod tests {
             precheck.why.as_deref(),
             Some("Only applies to asynchronous entity culling.")
         );
+        let key = find(&s, Item::Horizon(H::HdrKey));
+        assert_eq!(key.name, "Shortcut");
+        let waits = Capture::Key(crate::graphics::HDR_KEY);
+        assert!(matches!(key.value, Value::Binding(ref b) if b.capture == waits));
         let calibrate = find(&s, Item::Horizon(H::HdrCalibrate));
         assert_eq!(calibrate.value, Value::Press);
     }
@@ -2694,7 +2737,7 @@ mod tests {
             H::HdrPaperWhite => s.horizon.hdr_paper_white,
             H::HdrPeak => s.horizon.hdr_peak,
             H::HdrBlackLevel => s.horizon.hdr_black_level,
-            H::HdrUiBrightness => s.horizon.hdr_ui_nits,
+            H::HdrUiBrightness => s.horizon.hdr_ui_brightness,
             _ => unreachable!(),
         };
         let fresh = || {

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

@@ -2,7 +2,7 @@
 //! reports.
 use super::tests::{CHANGED, CLICK, DRAGGED, FB, NONE, SIZE, Ui, offering, press, row, ui};
 use super::*;
-use crate::settings_shell::{Columns, Hosted};
+use crate::settings_shell::{Capture, Columns, Hosted};
 use winit::keyboard::KeyCode as K;
 
 #[test]
@@ -64,12 +64,17 @@ fn hdr_auto_can_be_selected_before_querying_and_brightness_waits_for_output() {
     let peak = row(&mut ui, &s, Item::Horizon(H::HdrPeak));
     assert_eq!(press(&mut ui, &mut s, (tx + 2.0, peak[1] + 4.0)), [DRAGGED]);
     ui.release();
-    // Calibrate starts the calibration.
+    // Calibrate starts the calibration; the shortcut row waits for a key.
     let calibrate = row(&mut ui, &s, Item::Horizon(H::HdrCalibrate));
     assert_eq!(
         press(&mut ui, &mut s, at(calibrate)),
         [CLICK, Output::Push(OptionsPage::HdrCalibration)]
     );
+    let key = row(&mut ui, &s, Item::Horizon(H::HdrKey));
+    assert_eq!(
+        press(&mut ui, &mut s, at(key)),
+        [CLICK, Output::Bind(Capture::Key(crate::graphics::HDR_KEY))]
+    );
     assert!(ui.changed());
 }
 
@@ -120,125 +125,14 @@ fn auto_levels_and_setup_read_their_own_renderers_report() {
     assert_eq!(label(H::HdrCalibrate, &silent), "Calibrate...");
 }
 
-/// The setup rows' label and description for each kind of report: none, a compositor's
-/// (Wayland), and Windows', whose peak is the display's own guess.
 #[test]
-fn the_setup_rows_ask_to_calibrate_unless_the_system_set_the_display_up() {
-    let trusted = offering(true, Some(true));
-    let mut guessed = trusted;
-    guessed.reported = guessed.reported.map(|r| crate::graphics::Reported {
-        peak_guessed: true,
-        ..r
-    });
-    let rows = |s: &Settings, out: &EffectiveOutput| {
-        [H::HdrCalibrate, H::HdrPeak, H::HdrPaperWhite].map(|h| {
-            let item = Item::Horizon(h);
-            (item.label(s, out).plain(), description(item, s, out, "-"))
-        })
-    };
-    let calibrate = "Calibrate...";
-    let set_up = "Set up for your display. Leave on Auto unless it looks wrong.";
-    let mut s = Settings::default();
-    s.horizon.hdr = HdrMode::On;
-    let none = (
-        calibrate.into(),
-        "Your display didn't say how bright it gets: calibrate to set it up.",
-    );
-    assert_eq!(
-        rows(&s, &NONE),
-        [
-            none.clone(),
-            ("Peak Brightness: Auto (1000)".into(), "-"),
-            ("Paper White: Auto (203)".into(), "-"),
-        ]
-    );
-    assert_eq!(
-        rows(&s, &guessed),
-        [
-            (
-                calibrate.into(),
-                "Your display's reported peak is often too high: calibrate to set it up."
-            ),
-            ("Peak Brightness: Auto (1000)".into(), "-"),
-            ("Paper White: Auto (400)".into(), "-"),
-        ]
-    );
-    assert_eq!(
-        rows(&s, &trusted),
-        [
-            (
-                "Calibrate Anyway...".into(),
-                "Already set up for your display. Only calibrate if HDR looks wrong."
-            ),
-            ("Peak Brightness: Auto (1000)".into(), set_up),
-            ("Paper White: Auto (400)".into(), set_up),
-        ]
-    );
-    // Calibrated or set by hand, either report offers its automatic setup back.
-    s.horizon.hdr_peak = 800;
-    // Peak's Auto stays a guess on Windows: only Paper White is said to be set up there.
-    let changed = |peak| {
-        [
-            (
-                "Use Automatic Setup".into(),
-                "Puts Peak Brightness and Paper White back to your display's setup.",
-            ),
-            ("Peak Brightness: 800".into(), peak),
-            ("Paper White: Auto (400)".into(), set_up),
-        ]
-    };
-    assert_eq!(rows(&s, &guessed), changed("-"));
-    assert_eq!(rows(&s, &trusted), changed(set_up));
-    assert_eq!(rows(&s, &NONE)[0], none);
-    let mut ui = ui();
-    ui.screen.output = guessed;
-    let at = |[x, y, ..]: [f32; 4]| (x + 8.0, y + 4.0);
-    let calibrate = row(&mut ui, &s, Item::Horizon(H::HdrCalibrate));
-    assert_eq!(press(&mut ui, &mut s, at(calibrate)), [CLICK, CHANGED]);
-    assert_eq!((s.horizon.hdr_peak, s.horizon.hdr_paper_white), (0, 0));
-    assert_eq!(
-        press(&mut ui, &mut s, at(calibrate)),
-        [CLICK, Output::Push(OptionsPage::HdrCalibration)]
-    );
-}
-
-/// UI Brightness reads as Paper White does, in nits apart from it: Auto shows the paper white
-/// in use, and a value set by hand its own nits, whatever Paper White is. Its slider has Paper
-/// White's steps: Auto, then 10 to 480 nits by 10.
-#[test]
-fn ui_brightness_reads_in_nits_on_paper_whites_steps() {
-    let mut s = Settings::default();
-    s.horizon.hdr = HdrMode::On;
-    let reporting = offering(true, Some(true));
-    let label = |s: &Settings, out| Item::Horizon(H::HdrUiBrightness).label(s, out).plain();
-    assert_eq!(label(&s, &reporting), "UI Brightness: Auto (400)");
-    assert_eq!(label(&s, &NONE), "UI Brightness: Auto (203)");
-    s.horizon.hdr_paper_white = 250;
-    assert_eq!(label(&s, &reporting), "UI Brightness: Auto (250)");
-    s.horizon.hdr_ui_nits = 160;
-    for paper_white in [0, 80, 250] {
-        s.horizon.hdr_paper_white = paper_white;
-        assert_eq!(label(&s, &reporting), "UI Brightness: 160");
-    }
-    let item = Item::Horizon(H::HdrUiBrightness);
-    assert_eq!(
-        H::HdrUiBrightness.slider_steps(),
-        H::HdrPaperWhite.slider_steps()
-    );
-    H::HdrUiBrightness.set_slider(&mut s, 0.0);
-    let mut reached = vec![s.horizon.hdr_ui_nits];
-    for _ in 0..H::HdrUiBrightness.slider_steps().unwrap() {
-        item.step_slider(&mut s, true, 200.0, &reporting);
-        reached.push(s.horizon.hdr_ui_nits);
-    }
-    let paper: Vec<u32> = std::iter::once(0).chain((10..=480).step_by(10)).collect();
-    assert_eq!(reached, paper);
-    // Each value sits where Paper White's same value does.
-    for nits in paper {
-        s.horizon.hdr_ui_nits = nits;
-        s.horizon.hdr_paper_white = nits;
-        assert_eq!(item.slider(&s), Item::Horizon(H::HdrPaperWhite).slider(&s));
-    }
+fn hdr_setup_follows_what_the_system_reported() {
+    let mut g = crate::graphics::Graphics::default();
+    assert_eq!(setup_of(&g, false), Setup::Unknown);
+    assert_eq!(setup_of(&g, true), Setup::Automatic);
+    g.hdr_paper_white = 80;
+    assert_eq!(setup_of(&g, true), Setup::Changed);
+    assert_eq!(setup_of(&g, false), Setup::Unknown);
 }
 
 /// While HDR output is held back on this window's driver, the HDR row says so and keeps

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

@@ -206,9 +206,8 @@ fn display(light: vec3<f32>) -> vec4<f32> {
     let shows = params.world > 0.5 && params.peak > 1.0
         && (hand || (!covered && shows_world(f.rgb, w.rgb)));
     var light = lit(f.rgb, w.a, shows, true).light;
-    // The HUD and menus at their own brightness, by how much they cover, no brighter than the
-    // peak (as `fs_hdr_layered`): UI Brightness can pass paper white.
-    light = min(light * mix(1.0, params.ui, ui), vec3(params.peak));
+    // The HUD and menus at their own brightness, by how much they cover.
+    light *= mix(1.0, params.ui, ui);
     return display(light);
 }
 
@@ -276,8 +275,8 @@ fn backdrop(w: vec3<f32>) -> vec3<f32> {
 
 // The HUD over the world in gamma, the space the HUD blends in: its own part, what its backdrop
 // B doesn't explain (H = P - (1 - c) B, exact for the layering blends), at UI Brightness, over
-// (1 - c) of the world, light above white included. Where the world is at or below white, with
-// UI Brightness at paper white, that is the HUD's picture as drawn.
+// (1 - c) of the world, light above white included. Where the world is at or below white, at
+// 100%, that is the HUD's picture as drawn.
 fn layered(at: vec2<i32>) -> vec3<f32> {
     let w = max(textureLoad(frame, at, 0).rgb, vec3(0.0));
     let p = textureLoad(hud, at, 0).rgb;

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

@@ -12,7 +12,6 @@ use std::{
 };
 use wgpu::util::DeviceExt;
 
-mod animate;
 pub mod cit_glint;
 mod pack_text;
 pub mod pictures;
@@ -2877,6 +2876,59 @@ impl HudRenderer {
             pack_text::PackText::new(device, self.format, &self.atlas_view, shader, self.coverage)
         });
     }
+    pub fn animate_sprites(
+        &mut self,
+        uploads: &mut crate::gfx::upload::Uploads,
+        encoder: &mut wgpu::CommandEncoder,
+        tick: u64,
+    ) {
+        let Some(texture) = &self.atlas_texture else {
+            return;
+        };
+        for (rect, animation, previous) in &mut self.sprite_animations {
+            // `SpriteContents.AnimationState`: the frame from the mcmeta's
+            // list, blended into the next one by the sub-frame's thousandths
+            // when the sprite interpolates.
+            let blend = animation.blend(tick);
+            let state = (blend.frame, blend.next, blend.millis);
+            if state == *previous {
+                continue;
+            }
+            let (w, h) = rect.texels((texture.width(), texture.height()));
+            let pixels = if blend.millis == 0 {
+                animation.resized_pixels(blend.frame, w, h)
+            } else {
+                let current = animation.resized_pixels(blend.frame, w, h);
+                let next = animation.resized_pixels(blend.next, w, h);
+                let millis = blend.millis;
+                current
+                    .iter()
+                    .zip(next)
+                    .map(|(&a, b)| {
+                        ((u32::from(a) * (1000 - millis) + u32::from(b) * millis + 500) / 1000)
+                            as u8
+                    })
+                    .collect()
+            };
+            uploads.texture(
+                encoder,
+                wgpu::TexelCopyTextureInfo {
+                    texture,
+                    mip_level: 0,
+                    origin: wgpu::Origin3d {
+                        x: (rect.u0 * texture.width() as f32).round() as u32,
+                        y: (rect.v0 * texture.height() as f32).round() as u32,
+                        z: 0,
+                    },
+                    aspect: wgpu::TextureAspect::All,
+                },
+                w,
+                h,
+                &pixels,
+            );
+            *previous = state;
+        }
+    }
     /// Stage `patches` into the shared atlas texture.
     pub fn upload_patches(
         &self,

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

@@ -1,61 +0,0 @@
-//! The GUI atlas's animated sprites, frame by frame (vanilla's or a Polytone `mode`'s).
-
-impl super::HudRenderer {
-    /// Shows each animated sprite's frame: its mcmeta's, or what its Polytone `mode` picks.
-    pub(crate) fn animate(
-        &mut self,
-        uploads: &mut crate::gfx::upload::Uploads,
-        encoder: &mut wgpu::CommandEncoder,
-        tick: u64,
-        animator: &crate::gfx::animate::SpriteAnimator,
-    ) {
-        let inputs = animator.mode_inputs();
-        let inputs = Some(&inputs);
-        let Some(texture) = &self.atlas_texture else {
-            return;
-        };
-        for (rect, animation, previous) in &mut self.sprite_animations {
-            // `SpriteContents.AnimationState`: the frame from the mcmeta's
-            // list, blended into the next one by the sub-frame's thousandths
-            // when the sprite interpolates; or what a Polytone `mode` picks.
-            let blend = animation.blend_with(tick, inputs);
-            let state = (blend.frame, blend.next, blend.millis);
-            if state == *previous {
-                continue;
-            }
-            let (w, h) = rect.texels((texture.width(), texture.height()));
-            let pixels = if blend.millis == 0 {
-                animation.resized_pixels(blend.frame, w, h)
-            } else {
-                let current = animation.resized_pixels(blend.frame, w, h);
-                let next = animation.resized_pixels(blend.next, w, h);
-                let millis = blend.millis;
-                current
-                    .iter()
-                    .zip(next)
-                    .map(|(&a, b)| {
-                        ((u32::from(a) * (1000 - millis) + u32::from(b) * millis + 500) / 1000)
-                            as u8
-                    })
-                    .collect()
-            };
-            uploads.texture(
-                encoder,
-                wgpu::TexelCopyTextureInfo {
-                    texture,
-                    mip_level: 0,
-                    origin: wgpu::Origin3d {
-                        x: (rect.u0 * texture.width() as f32).round() as u32,
-                        y: (rect.v0 * texture.height() as f32).round() as u32,
-                        z: 0,
-                    },
-                    aspect: wgpu::TextureAspect::All,
-                },
-                w,
-                h,
-                &pixels,
-            );
-            *previous = state;
-        }
-    }
-}

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

@@ -27,29 +27,4 @@ pub(crate) const SPRITES: &[(&str, &[u8])] = &[
         "search_background_v2",
         include_bytes!("jei_recipes/search_background_v2.png"),
     ),
-    ("slot", include_bytes!("jei_recipes/slot.png")),
-    (
-        "icons/list_badge",
-        include_bytes!("jei_recipes/icons/list_badge.png"),
-    ),
-    (
-        "interactive_ingredient_tooltip_background",
-        include_bytes!("jei_recipes/interactive_ingredient_tooltip_background.png"),
-    ),
-    (
-        "recipe_preview_background_v2",
-        include_bytes!("jei_recipes/recipe_preview_background_v2.png"),
-    ),
-    (
-        "ingredient_list_slot_background_v2",
-        include_bytes!("jei_recipes/ingredient_list_slot_background_v2.png"),
-    ),
-    (
-        "scrollbar_background_v2",
-        include_bytes!("jei_recipes/scrollbar_background_v2.png"),
-    ),
-    (
-        "scrollbar_marker_v2",
-        include_bytes!("jei_recipes/scrollbar_marker_v2.png"),
-    ),
 ];

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

@@ -67,7 +67,7 @@ mod jei_sprites;
 pub mod jigsaw_block;
 pub mod keypad;
 pub mod terrain_model;
-pub use horizon_polytone::creative_tabs as polytone_creative_tabs;
+pub use horizon_polytone::colors as polytone_colors;
 pub use horizon_world::json_folder;
 pub mod level_loading;
 pub mod light;
@@ -88,8 +88,6 @@ pub mod options_fixes;
 pub mod options_ui;
 pub mod overlay;
 pub mod pack_browser;
-pub mod pack_formats;
-pub mod pack_hooks;
 pub mod pack_options_ui;
 pub mod pack_palette;
 pub mod pack_screen;

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

@@ -2593,7 +2593,8 @@ impl Lod {
         self.returned_at = std::time::Instant::now();
         let nodes = &self.plan.nodes;
         self.mesh_samples.retain(|key| nodes.contains(key));
-        // Queued tiles the view left are not sampled; a running one is dropped (`finish_sample`).
+        // Queued tiles the view left are not sampled (a running one is
+        // dropped when it finishes, `finish_sample`).
         drop_queued_samples(&self.shared, &mut self.pending, |key| {
             self.plan.nodes.contains(key)
         });
@@ -2679,7 +2680,6 @@ impl Lod {
             }
             if let Some((columns, mask)) = self.kept.take(&key) {
                 self.ready.insert(key, columns);
-                self.sync_sample(key);
                 if let Some(mask) = mask {
                     self.detail_masks.insert(key, mask);
                 }

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

@@ -761,49 +761,6 @@ pub struct MeshTables {
     colormaps: Vec<Arc<crate::environment::Colormap>>,
     water_colormap: Option<u16>,
 }
-/// Vanilla's four biome colour functions (`BiomeColors`) with what the packs replace them by:
-/// `biome_colors` (a colormap or a flat colour), else the colormap a block modifier gives
-/// `grass_block`, `oak_leaves` or `leaf_litter`, or a fluid modifier gives water, which Polytone
-/// spreads to every block of that function. Each with the tints that read it.
-fn biome_functions(
-    pack_root: &std::path::Path,
-    modifiers: &[(bool, horizon_polytone::Targets, String)],
-) -> Vec<(&'static [Tint], crate::environment::Colormap)> {
-    use crate::environment::Colormap;
-    use horizon_polytone::colors::BiomeColor;
-    const FUNCTIONS: [(&str, &str, &[Tint]); 4] = [
-        (
-            "grass",
-            "minecraft:grass_block",
-            &[
-                Tint::Grass,
-                Tint::GrassBlock,
-                Tint::TallGrassUpper,
-                Tint::SugarCane,
-            ],
-        ),
-        ("foliage", "minecraft:oak_leaves", &[Tint::Foliage]),
-        ("dry_foliage", "minecraft:leaf_litter", &[Tint::DryFoliage]),
-        ("water", "minecraft:water", &[Tint::Water]),
-    ];
-    let colors = horizon_polytone::colors::PackColors::read(pack_root);
-    FUNCTIONS
-        .into_iter()
-        .filter_map(|(function, block, tints)| {
-            let colormap = match colors.biome_color(function) {
-                Some(BiomeColor::Flat(rgb)) => Some(Colormap::flat(rgb)),
-                Some(BiomeColor::Colormap(id)) => Colormap::load(pack_root, &id),
-                None => modifiers
-                    .iter()
-                    .find(|(fluid, targets, _)| {
-                        *fluid == (function == "water") && targets.matches(block, |_| false)
-                    })
-                    .and_then(|(_, _, id)| Colormap::load(pack_root, id)),
-            }?;
-            Some((tints, colormap))
-        })
-        .collect()
-}
 fn stem_color(age: u8) -> u32 {
     let a = u32::from(age);
     (a * 32) << 16 | (255 - a * 8) << 8 | (a * 4)
@@ -988,8 +945,7 @@ impl MeshTables {
     }
     /// These tables with the colormaps of the Polytone block and fluid modifiers of the packs
     /// merged at `pack_root` (wiki "Colormaps"): a tinted block they target takes its colour
-    /// from the colormap, and its own tint where the colormap's pixel is transparent. Vanilla's
-    /// four biome colour functions take the packs' `biome_colors` first (wiki "Custom Colors").
+    /// from the colormap, and its own tint where the colormap's pixel is transparent.
     #[must_use]
     pub fn with_polytone_colormaps(
         mut self,
@@ -997,8 +953,7 @@ impl MeshTables {
         registry: &horizon_world::registry::BlockRegistry,
     ) -> Self {
         let modifiers = crate::environment::polytone_colormap_modifiers(pack_root);
-        let biome_functions = biome_functions(pack_root, &modifiers);
-        if modifiers.is_empty() && biome_functions.is_empty() {
+        if modifiers.is_empty() {
             return self;
         }
         let mut loaded: std::collections::HashMap<String, Option<u16>> = Default::default();
@@ -1009,24 +964,7 @@ impl MeshTables {
                 Some((colormaps.len() - 1) as u16)
             })
         };
-        for (tints, colormap) in biome_functions {
-            self.colormaps.push(Arc::new(colormap));
-            let i = Some((self.colormaps.len() - 1) as u16);
-            if tints == [Tint::Water] {
-                self.water_colormap = i;
-            }
-            for info in &mut self.info {
-                let own = &info.tints[..usize::from(info.tint_count).min(2)];
-                if own.iter().any(|t| tints.contains(t)) {
-                    info.colormap = i;
-                }
-            }
-        }
-        let water_function = self.water_colormap;
         for (fluid, targets, id) in &modifiers {
-            if *fluid && water_function.is_some() {
-                continue;
-            }
             if *fluid {
                 if targets.matches("minecraft:water", |_| false) {
                     self.water_colormap = index(id, &mut self.colormaps);
@@ -1557,9 +1495,9 @@ struct Tints<'a> {
     /// by colormap and section-local block.
     colormaps: &'a [Arc<crate::environment::Colormap>],
     water_colormap: Option<u16>,
-    sampled: crate::fast_hash::FxHashMap<(u16, [i32; 3]), Option<u32>>,
+    sampled: std::collections::HashMap<(u16, [i32; 3]), Option<u32>>,
     /// Each colormap's own colour by block, before the blend averages them.
-    cells: crate::fast_hash::FxHashMap<(u16, [i32; 3]), Option<u32>>,
+    cells: std::collections::HashMap<(u16, [i32; 3]), Option<u32>>,
 }
 impl<'a> Tints<'a> {
     fn new(
@@ -1580,8 +1518,8 @@ impl<'a> Tints<'a> {
             uniform: None,
             colormaps: &[],
             water_colormap: None,
-            sampled: Default::default(),
-            cells: Default::default(),
+            sampled: std::collections::HashMap::new(),
+            cells: std::collections::HashMap::new(),
         }
     }
     /// With the packs' colormaps of `tables`.
@@ -1593,16 +1531,10 @@ impl<'a> Tints<'a> {
     /// Colormap `index`'s colour at block `(x, y, z)` (section-local), `None` where its pixel
     /// is transparent.
     fn colormap(&mut self, index: u16, x: i32, y: i32, z: i32) -> Option<u32> {
-        let colormap = self.colormaps.get(usize::from(index))?.clone();
-        // A colormap that ignores the height, over one biome: one colour per column.
-        let y = if colormap.column && self.uniform_biome().is_some() {
-            0
-        } else {
-            y
-        };
         if let Some(&known) = self.sampled.get(&(index, [x, y, z])) {
             return known;
         }
+        let colormap = self.colormaps.get(usize::from(index))?.clone();
         // ClientLevel.calculateBlockTint: the mean of the (2r+1)^2 colours around the block, each
         // channel summed and divided. A transparent pixel in the square leaves the block's own.
         let r = if colormap.biome_blend { self.radius } else { 0 };
@@ -1641,11 +1573,7 @@ impl<'a> Tints<'a> {
         if let Some(&known) = self.cells.get(&(index, at)) {
             return known;
         }
-        // One biome over the section and its blend margin: no zoom per block.
-        let id = match self.uniform_biome() {
-            Some(biome) => biome,
-            None => Self::biome_id(&self.zoom, self.region, self.plains, self.origin, at),
-        };
+        let id = Self::biome_id(&self.zoom, self.region, self.plains, self.origin, at);
         let [cx, cz, base_y] = self.origin;
         let block = [cx * 16 + at[0], base_y + at[1], cz * 16 + at[2]];
         let mut host = crate::environment::BlockHost::new(block, self.biomes.get(id));

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

@@ -251,117 +251,3 @@ fn a_biome_colormap_blends_over_a_biome_edge_as_the_vanilla_water_tint_does() {
     }
     assert!(edge_differs, "the square must cross the edge somewhere");
 }
-
-#[test]
-fn biome_colors_and_a_grass_block_colormap_replace_their_whole_biome_function() {
-    let biomes = Biomes::from_jsons(&[(
-        "minecraft:plains",
-        serde_json::json!({"effects": {"water_color": 0x3F76E4}}),
-    )]);
-    // biome_colors gives water a flat green; a block modifier colours oak leaves with a map,
-    // which Polytone spreads to the whole foliage function.
-    let root = pack(&[
-        (
-            "assets/mypack/polytone/colors.json",
-            br#"{"biome_colors": {"water": "0x00ff00"}}"#.to_vec(),
-        ),
-        (
-            "assets/mypack/polytone/colormaps/leaves.png",
-            png_row(&[[0, 0, 255, 255]]),
-        ),
-        (
-            "assets/mypack/polytone/block_modifiers/oak.json",
-            br#"{"targets": ["minecraft:oak_leaves"], "colormap": "mypack:leaves"}"#.to_vec(),
-        ),
-    ]);
-    let modifiers = crate::environment::polytone_colormap_modifiers(&root);
-    let functions = biome_functions(&root, &modifiers);
-    let tints: Vec<_> = functions.iter().map(|(t, _)| *t).collect();
-    assert_eq!(tints.len(), 2);
-    assert!(tints[0] == [Tint::Foliage] && tints[1] == [Tint::Water]);
-    let colormaps: Vec<_> = functions.into_iter().map(|(_, c)| Arc::new(c)).collect();
-    let chunks: Vec<Vec<Chunk>> = (0..3)
-        .map(|rz| (0..3).map(|rx| filled(rx - 1, rz - 1, 0)).collect())
-        .collect();
-    let region: [[Option<&Chunk>; 3]; 3] =
-        std::array::from_fn(|rz| std::array::from_fn(|rx| Some(&chunks[rz][rx])));
-    let mut tints = Tints::new(&region, &biomes, BiomeZoom::new(0), 0, [0, 0, 64]);
-    tints.colormaps = &colormaps;
-    tints.water_colormap = Some(1);
-    assert_eq!(tints.water(3, 4, 5), 0x00_FF00);
-    std::fs::remove_dir_all(root).unwrap();
-}
-
-#[test]
-fn only_a_colormap_that_ignores_the_height_is_shared_up_a_column() {
-    let root = pack(&[
-        (
-            "assets/mypack/polytone/colormaps/flat.png",
-            png_row(&[[1, 2, 3, 255]]),
-        ),
-        (
-            "assets/mypack/polytone/colormaps/flat.json",
-            br#"{"x_axis": "biome_id", "y_axis": "r.noise(o.x/60, o.z/60)"}"#.to_vec(),
-        ),
-        (
-            "assets/mypack/polytone/colormaps/tall.png",
-            png_row(&[[1, 2, 3, 255]]),
-        ),
-        (
-            "assets/mypack/polytone/colormaps/tall.json",
-            br#"{"y_axis": "y_level"}"#.to_vec(),
-        ),
-    ]);
-    let load = |id| crate::environment::Colormap::load(&root, id).unwrap();
-    assert!(load("mypack:flat").column);
-    assert!(!load("mypack:tall").column);
-    std::fs::remove_dir_all(root).unwrap();
-}
-
-/// Times a section's colormap tints with the freepack's kind of grass colormap (a biome id
-/// column and a noise row) over the default Biome Blend: `cargo test --release ... -- --ignored
-/// --nocapture colormap_tint_cost`.
-#[test]
-#[ignore = "timing, not a check"]
-fn colormap_tint_cost() {
-    const RADIUS: i32 = 2;
-    const LAYERS: i32 = 16;
-    let biomes = Biomes::from_jsons(&[(
-        "minecraft:plains",
-        serde_json::json!({"effects": {"water_color": 0x3F76E4}}),
-    )]);
-    let pixels: Vec<[u8; 4]> = (0..16).map(|i| [i * 16, 200, 64, 255]).collect();
-    let root = pack(&[
-        ("assets/mypack/polytone/colormaps/grass.png", png_row(&pixels)),
-        (
-            "assets/mypack/polytone/colormaps/grass.json",
-            br#"{"x_axis": "biome_id", "y_axis": "0.5+(r.noise(o.x/60,5+o.z/60)*0.55)", "biome_id_mapper": {"minecraft:plains": 1, "texture_size": 16}}"#
-                .to_vec(),
-        ),
-    ]);
-    let colormaps = vec![Arc::new(
-        crate::environment::Colormap::load(&root, "mypack:grass").unwrap(),
-    )];
-    let chunks: Vec<Vec<Chunk>> = (0..3)
-        .map(|rz| (0..3).map(|rx| filled(rx - 1, rz - 1, 0)).collect())
-        .collect();
-    let region: [[Option<&Chunk>; 3]; 3] =
-        std::array::from_fn(|rz| std::array::from_fn(|rx| Some(&chunks[rz][rx])));
-    let rounds = 50;
-    let start = std::time::Instant::now();
-    let mut check = 0u64;
-    for _ in 0..rounds {
-        let mut tints = Tints::new(&region, &biomes, BiomeZoom::new(0), RADIUS, [0, 0, 64]);
-        tints.colormaps = &colormaps;
-        for y in 0..LAYERS {
-            for z in 0..16 {
-                for x in 0..16 {
-                    check += u64::from(tints.colormap(0, x, y, z).unwrap_or(0));
-                }
-            }
-        }
-    }
-    let per = start.elapsed() / rounds;
-    println!("{LAYERS} layers of 256 blended colormap tints: {per:?} (checksum {check})");
-    std::fs::remove_dir_all(root).unwrap();
-}

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

@@ -1,7 +1,6 @@
 //! Optional, texture-matched overlays drawn full bright over their base texture in the same
-//! terrain fragment: native mods' (`<ns>:emissive/...`) and a pack's emissive block textures
-//! (OptiFine's `block/stone_e.png` beside `block/stone.png`, the suffix from the pack formats,
-//! [`crate::pack_hooks`]). No extra draw calls or world light changes.
+//! terrain fragment: native mods' (`<ns>:emissive/...`) and OptiFine's emissive block textures
+//! (`block/stone_e.png` beside `block/stone.png`). No extra draw calls or world light changes.
 use crate::sprites::Sprites;
 use std::{collections::BTreeMap, path::Path};
 
@@ -36,12 +35,14 @@ fn tile_file(name: &str) -> Option<&str> {
     name.strip_suffix(".png")
 }
 
-/// A pack's emissive overlays of the block sprites already loaded (what the terrain draws;
-/// items draw from the HUD atlas): for each `<ns>:block/<name>`, or connected-texture tile
-/// `assets/<ns>/.../<name>.png`, whose `<name><suffix>.png` sits beside it, the overlay is loaded
-/// too and paired with it, blocks first, then tiles, each by name, at most [`MAX`] - [`NATIVE`]
-/// (native mods keep their share of the table). A pack without such files adds nothing.
-pub fn load_overlays(root: &Path, suffix: &str, sprites: &mut Sprites) -> Vec<(String, String)> {
+/// OptiFine's emissive overlays of the block sprites already loaded (what the terrain draws;
+/// items draw from the HUD atlas): for each
+/// `<ns>:block/<name>`, or connected-texture tile `assets/<ns>/.../<name>.png`, whose
+/// `<name><suffix>.png` sits beside it, the overlay is loaded too and paired with it, blocks
+/// first, then tiles, each by name, at most [`MAX`] - [`NATIVE`] (native mods keep their share of
+/// the table). A pack without such files adds nothing.
+pub fn load_optifine(root: &Path, sprites: &mut Sprites) -> Vec<(String, String)> {
+    let suffix = horizon_optifine::emissive::suffix(root);
     // Blocks with identical pixels share a layer (and the shader pairs by layer): a shared
     // base would glow on every block that shares it, so it gets no overlay.
     let mut sharing: BTreeMap<u32, usize> = BTreeMap::new();
@@ -55,8 +56,8 @@ pub fn load_overlays(root: &Path, suffix: &str, sprites: &mut Sprites) -> Vec<(S
             sharing[layer] == 1
                 && (name
                     .split_once(':')
-                    .is_some_and(|(_, p)| p.starts_with("block/") && !p.ends_with(suffix))
-                    || tile_file(name).is_some_and(|stem| !stem.ends_with(suffix)))
+                    .is_some_and(|(_, p)| p.starts_with("block/") && !p.ends_with(&suffix))
+                    || tile_file(name).is_some_and(|stem| !stem.ends_with(&suffix)))
         })
         .map(|(name, _)| name.clone())
         .collect();
@@ -109,7 +110,7 @@ pub fn load_overlays(root: &Path, suffix: &str, sprites: &mut Sprites) -> Vec<(S
 pub const CUTOUT: u32 = 1 << 31;
 
 /// The frame's overlay table: native mods' pairs (at most [`NATIVE`] requested), then the packs'
-/// OptiFine pairs flagged [`CUTOUT`] (at most [`MAX`] - [`NATIVE`], as [`load_overlays`] loads),
+/// OptiFine pairs flagged [`CUTOUT`] (at most [`MAX`] - [`NATIVE`], as [`load_optifine`] loads),
 /// one per base layer with native mods' first, sorted by base layer for the shader's early exit.
 pub fn table<'a>(
     layers: &BTreeMap<String, u32>,
@@ -203,7 +204,7 @@ mod tests {
         // Items draw from the HUD atlas, not the terrain: no pair.
         sprites.insert(&root, "minecraft:item/stick").unwrap();
         // glowstone isn't loaded: its overlay pairs with nothing.
-        let pairs = load_overlays(&root, "_e", &mut sprites);
+        let pairs = load_optifine(&root, &mut sprites);
         assert_eq!(
             pairs,
             [(
@@ -214,6 +215,9 @@ mod tests {
         assert!(sprites.layers.contains_key("minecraft:block/stone_e"));
         assert!(!sprites.layers.contains_key("minecraft:block/granite_e"));
         // The pack's own suffix.
+        let props = root.join("assets/minecraft/optifine/emissive.properties");
+        std::fs::create_dir_all(props.parent().unwrap()).unwrap();
+        std::fs::write(&props, "suffix.emissive=_glow").unwrap();
         // Connected-texture tiles pair with the overlay beside them.
         let tiles = root.join("assets/minecraft/optifine/ctm/lamp");
         png(&tiles.join("0.png"), 230);
@@ -230,7 +234,7 @@ mod tests {
                 .insert_file(&root, &format!("assets/minecraft/optifine/{tile}.png"))
                 .unwrap();
         }
-        let pairs = load_overlays(&root, "_glow", &mut sprites);
+        let pairs = load_optifine(&root, &mut sprites);
         assert_eq!(
             pairs,
             // Blocks first, then tiles.

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

@@ -339,7 +339,6 @@ impl Opt {
             Opt::SharePresence => "options.sharePresence",
             Opt::DirectionalAudio => "options.directionalAudio",
             Opt::MusicToast => "options.musicToast",
-            Opt::Page(page, row) => pages::slider_caption(page, row),
         }
     }
     pub(crate) fn kind(self, s: &Settings) -> Kind {
@@ -403,7 +402,6 @@ impl Opt {
             Opt::PadLookDeadzone => unit(s.controller.look_deadzone, 0.0, 0.5),
             Opt::PadTriggerThreshold => unit(s.controller.trigger_threshold, 0.1, 0.9),
             Opt::SprintWindow => unit(s.sprint_window as f32, 0.0, 10.0),
-            Opt::Page(page, row) => pages::slider_kind(page, row),
             _ => Kind::Cycle,
         }
     }
@@ -880,7 +878,6 @@ impl Opt {
                 gamepad::TextKeyboard::Horizon => "horizon.options.keyboard.horizon",
                 gamepad::TextKeyboard::Steam => "horizon.options.keyboard.steam",
             }),
-            Opt::Page(page, row) => pages::slider_text(page, row),
             _ => Text::empty(),
         }
     }
@@ -955,7 +952,6 @@ impl Opt {
             Opt::PadLookDeadzone => s.controller.look_deadzone = step(0.0, 50.0) / 100.0,
             Opt::PadTriggerThreshold => s.controller.trigger_threshold = step(10.0, 90.0) / 100.0,
             Opt::SprintWindow => s.sprint_window = step(0.0, 10.0) as i32,
-            Opt::Page(page, row) => pages::slide(page, row, v),
             _ => {}
         }
         if self.affects_preset() {
@@ -1335,8 +1331,6 @@ pub enum Page {
     ModProject,
     /// A native mod's settings page: its index in `mods.installed`.
     NativeMod(usize),
-    /// A page a crate registered (`horizon_hooks::pages`): its index in `OptionsUi::pages`.
-    Added(usize),
     /// Horizon's shader packs, either kind (`shader_pack_list`).
     ShaderPacks,
     /// The picked pack's options: the shader screen (`shader_ui`) at the pack's main screen.
@@ -1396,8 +1390,6 @@ enum Act {
     /// A native mod's key (mod, key) waits for a key; a button of its page.
     NativeKey(usize, usize),
     NativeButton(usize, usize),
-    /// A registered page's row: (page, row).
-    PageRow(usize, usize),
     OpenModFolder,
     /// Browse mods: the page of listing `.0` of `mod_browser`.
     ModProject(usize),
@@ -1625,8 +1617,7 @@ pub struct OptionsUi {
     /// Key Binds: the mapping waiting for a key ([`NATIVE_KEY`]: a native
     /// mod's, `selected_native_key`).
     pub selected_key: Option<&'static str>,
-    /// The native mod's key waiting: (mod, key) in `mods.installed`, or a registered page's
-    /// (page, row) ([`pages::PAGE_KEY`]).
+    /// The native mod's key waiting: (mod, key) in `mods.installed`.
     selected_native_key: Option<(usize, usize)>,
     /// Bindings: the action waiting for a pad button.
     pub selected_pad_action: Option<&'static str>,
@@ -1870,6 +1861,25 @@ fn wide_extras(s: &Settings, width: impl Fn(&str) -> f32) -> Vec<crate::extras::
         })
         .collect()
 }
+/// What a button opening one of Horizon's pages says on hover.
+fn horizon_page_tooltip(page: Page) -> Option<&'static str> {
+    Some(match page {
+        Page::Horizon => "horizon.pages.settings.tooltip",
+        Page::Studio => "horizon.pages.studio.tooltip",
+        Page::Graphics => "horizon.pages.graphics.tooltip",
+        Page::GraphicsAdvanced => "horizon.pages.graphics_advanced.tooltip",
+        Page::Controller => "horizon.pages.controller.tooltip",
+        Page::Extras => "horizon.pages.extras.tooltip",
+        Page::Pvp => "horizon.pages.pvp.tooltip",
+        Page::Agent => "horizon.pages.agent.tooltip",
+        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",
+        Page::Music => "horizon.pages.music.tooltip",
+        _ => return None,
+    })
+}
 /// Rows of an OptionsList: (big?, options) or a header.
 enum Row {
     Big(Opt),
@@ -1889,17 +1899,14 @@ fn tooltip_text(s: &Settings, wd: &Widget) -> Option<Text> {
             return None;
         };
         let key = opt.tooltip_key(s);
-        let Opt::Page(page, row) = opt else {
-            return lang::has(&key).then(|| tr(&key));
-        };
-        return pages::tooltip(*page, *row);
+        return lang::has(&key).then(|| tr(&key));
     };
     let mut tip = None;
     if let Act::Extra(item) = act {
         tip = Some(Text::literal(item.description_text()));
     }
     if let Act::Push(page) = act
-        && let Some(text) = pages::horizon_page_tooltip(*page)
+        && let Some(text) = horizon_page_tooltip(*page)
     {
         tip = Some(tr(text));
     }
@@ -1919,7 +1926,6 @@ fn tooltip_text(s: &Settings, wd: &Widget) -> Option<Text> {
     }
     match act {
         Act::Cycle(opt) if !opt.available() => Some(tr("horizon.options.unavailable")),
-        Act::PageRow(page, row) => pages::tooltip(*page, *row),
         Act::ToggleMod(i) => match s.mods.installed.get(*i) {
             Some(installed) => {
                 let description = installed
@@ -2361,7 +2367,6 @@ impl OptionsUi {
             Page::ModBrowser => "horizon.mods.browse.title",
             Page::ModProject => "horizon.mods.browse.project",
             Page::NativeMod(_) => "Mod Settings",
-            Page::Added(i) => pages::title(i),
             Page::ShaderPacks => "horizon.pages.shader_packs",
             Page::ShaderOptions => "horizon.pages.shader_options",
             Page::PackOptions => "horizon.pack.options.title",
@@ -2578,6 +2583,43 @@ impl OptionsUi {
         }
         rows
     }
+    /// A native mod's page: its name, its keys as Key Binds rows (the
+    /// player's choice, else the default), then its buttons.
+    fn native_rows(&self, s: &Settings, i: usize) -> Vec<Row> {
+        let Some(m) = s.mods.installed.get(i) else {
+            return Vec::new();
+        };
+        let mut rows = vec![Row::Note(m.title.clone())];
+        let Some(page) = &m.native else {
+            return rows;
+        };
+        let chosen = s.mods.keys.get(&m.id);
+        for (k, [name, label, default]) in page.keys.iter().enumerate() {
+            let key = chosen.and_then(|c| c.get(name)).unwrap_or(default);
+            let mut message = keybinds::display_name(key);
+            if self.selected_native_key == Some((i, k)) {
+                message = Text::literal("> ")
+                    .append(message.with_color(text::WHITE))
+                    .append(" <")
+                    .with_color(text::YELLOW);
+            }
+            let caption = button(0.0, 0.0, 150.0, Text::literal(label.clone()), Act::None);
+            let change = button(0.0, 0.0, 150.0, message, Act::NativeKey(i, k));
+            rows.push(Row::Buttons(inactive(caption), Some(change)));
+        }
+        for (b, label) in page.buttons.iter().enumerate() {
+            let widget = button(
+                0.0,
+                0.0,
+                310.0,
+                Text::literal(label.clone()),
+                Act::NativeButton(i, b),
+            );
+            rows.push(Row::Buttons(widget, None));
+        }
+        rows
+    }
+
     fn list_rows(&self, s: &Settings) -> Vec<Row> {
         match self.page() {
             Page::SplitSetup => Vec::new(),
@@ -2642,7 +2684,47 @@ impl OptionsUi {
                 flush(&mut rows, &mut section);
                 rows
             }
-            Page::Horizon => self.horizon_rows(s),
+            Page::Horizon => {
+                // Two to a row, as vanilla's OptionsList.addSmall lays out
+                // buttons; each opens one of Horizon's settings pages. Each page has
+                // one way in: graphics and shader packs are Video Settings' (the graphics
+                // screen), the controller is Controls', mods are the Options screen's.
+                let open =
+                    |key: &str, page: Page| button(0.0, 0.0, 150.0, tr(key), Act::Push(page));
+                vec![
+                    Row::Buttons(
+                        open("horizon.pages.open.extras", Page::Extras),
+                        Some(open("horizon.pages.open.pvp", Page::Pvp)),
+                    ),
+                    Row::Buttons(
+                        open(
+                            "horizon.pages.open.split_setup",
+                            if self.split_guest {
+                                Page::SplitProfiles
+                            } else {
+                                Page::SplitSetup
+                            },
+                        ),
+                        Some(open("horizon.pages.open.studio", Page::Studio)),
+                    ),
+                    // No AI hides the AI Agent page and everything AI.
+                    Row::Buttons(
+                        self.extra_button(s, crate::extras::Item::DiscordPresence),
+                        Some(if s.extras.no_ai {
+                            self.extra_button(s, crate::extras::Item::NoAi)
+                        } else {
+                            open("horizon.pages.open.agent", Page::Agent)
+                        }),
+                    ),
+                ]
+                .into_iter()
+                .chain(
+                    (!s.extras.no_ai).then(|| {
+                        Row::Buttons(self.extra_button(s, crate::extras::Item::NoAi), None)
+                    }),
+                )
+                .collect()
+            }
             Page::Agent => {
                 let mut rows = vec![Row::Buttons(
                     self.extra_button(s, crate::extras::Item::AgentControl),
@@ -2925,7 +3007,6 @@ impl OptionsUi {
             Page::ModBrowser => self.mod_browser_rows(),
             Page::ModProject => self.mod_project_rows(s),
             Page::NativeMod(i) => self.native_rows(s, i),
-            Page::Added(i) => self.added_rows(i),
             _ => {
                 let _ = s;
                 Vec::new()
@@ -4192,9 +4273,11 @@ impl OptionsUi {
                             self.push(Page::NativeMod(i));
                             events.push(Event::NativeSettings(i));
                         }
-                        Act::NativeKey(i, k) => self.wait_native_key(i, k),
+                        Act::NativeKey(i, k) => {
+                            self.selected_key = Some(NATIVE_KEY);
+                            self.selected_native_key = Some((i, k));
+                        }
                         Act::NativeButton(i, b) => events.push(Event::NativeButton(i, b)),
-                        Act::PageRow(p, r) => events.extend(self.page_act(p, r, self.shift)),
                         Act::OpenModFolder => events.push(Event::OpenModFolder),
                         Act::ModProject(i) => {
                             if let Some(listing) = self.mod_browser.listings.get(i) {
@@ -4698,10 +4781,19 @@ impl OptionsUi {
         let Some(name) = self.selected_key.take() else {
             return Vec::new();
         };
-        if name == NATIVE_KEY || name == pages::PAGE_KEY {
-            return self.bind_native_key(s, name, value);
+        if name == NATIVE_KEY {
+            let (i, k) = self.selected_native_key.take().unwrap_or_default();
+            let Some(m) = s.mods.installed.get(i) else {
+                return Vec::new();
+            };
+            let Some([key, ..]) = m.native.as_ref().and_then(|p| p.keys.get(k)) else {
+                return Vec::new();
+            };
+            let keys = s.mods.keys.entry(m.id.clone()).or_default();
+            keys.insert(key.clone(), value);
+            return vec![Event::Changed];
         }
-        if !s.extras.set_key(name, value.clone()) {
+        if !s.extras.set_key(name, value.clone()) && !s.horizon.set_key(name, value.clone()) {
             s.keys.set(name, &value);
         }
         vec![Event::Changed]
@@ -5081,9 +5173,11 @@ impl OptionsUi {
                             self.push(Page::NativeMod(i));
                             events.push(Event::NativeSettings(i));
                         }
-                        Act::NativeKey(i, k) => self.wait_native_key(i, k),
+                        Act::NativeKey(i, k) => {
+                            self.selected_key = Some(NATIVE_KEY);
+                            self.selected_native_key = Some((i, k));
+                        }
                         Act::NativeButton(i, b) => events.push(Event::NativeButton(i, b)),
-                        Act::PageRow(p, r) => events.extend(self.page_act(p, r, shift)),
                         Act::OpenModFolder => events.push(Event::OpenModFolder),
                         Act::ModProject(i) => {
                             if let Some(listing) = self.mod_browser.listings.get(i) {
@@ -7254,7 +7348,7 @@ mod tests {
             MouseButton::Back,
             MouseButton::Forward,
         ] {
-            for name in [SORT_KEY, "key.jump"] {
+            for name in [SORT_KEY, crate::graphics::HDR_KEY, "key.jump"] {
                 let mut ui = OptionsUi::default();
                 let mut s = Settings::default();
                 ui.selected_key = Some(name);
@@ -7263,6 +7357,7 @@ mod tests {
                 let value = keybinds::mouse_name(button);
                 match name {
                     SORT_KEY => assert_eq!(s.extras.sort_key, value),
+                    crate::graphics::HDR_KEY => assert_eq!(s.horizon.hdr_key, value),
                     _ => assert_eq!(s.keys.get(name), value),
                 }
                 assert_eq!(Extras::parse(&s.extras.serialize()), s.extras);
@@ -8344,5 +8439,3 @@ mod tests {
 #[cfg(test)]
 #[path = "options_ui_graphics_tests.rs"]
 mod graphics_tests;
-#[path = "options_ui_pages.rs"]
-mod pages;

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

@@ -1,575 +0,0 @@
-//! The pages crates add to the options screens: a native mod's settings page (its keys and
-//! buttons), and the pages crates above the engine register (`horizon_hooks::pages`, docs/layers.md
-//! "Platform registries") with their entries on Horizon Settings. Kept out of options_ui.rs, which
-//! may not grow (tools/check_file_size.py).
-use super::*;
-use horizon_hooks::pages as added;
-
-/// `selected_key` while a registered page's key waits (`selected_native_key`: page, row).
-pub(super) const PAGE_KEY: &str = "horizon.pageKey";
-
-#[cfg(test)]
-thread_local! {
-    /// A test's own pages, instead of the game's registered ones: each test runs on its thread.
-    static TEST_PAGES: std::cell::Cell<Option<&'static [&'static dyn added::Page]>> =
-        const { std::cell::Cell::new(None) };
-}
-
-/// The pages crates registered.
-fn registered() -> &'static [&'static dyn added::Page] {
-    #[cfg(test)]
-    if let Some(pages) = TEST_PAGES.get() {
-        return pages;
-    }
-    added::engine::all()
-}
-
-/// A registered page's title (a translation key).
-pub(super) fn title(page: usize) -> &'static str {
-    registered().get(page).map_or("", |p| p.title())
-}
-
-/// Row `r` of a registered page, as it is now.
-fn row(page: usize, r: usize) -> Option<added::Row> {
-    let mut rows = Vec::new();
-    registered().get(page)?.rows(&mut rows);
-    rows.into_iter().nth(r)
-}
-
-/// A registered page's slider ([`Opt::Page`]): its caption (a translation key).
-pub(super) fn slider_caption(page: usize, r: usize) -> &'static str {
-    match row(page, r) {
-        Some(added::Row::Slider { label, .. }) => label,
-        _ => "",
-    }
-}
-
-/// A registered page's slider: its position.
-pub(super) fn slider_kind(page: usize, r: usize) -> Kind {
-    match row(page, r) {
-        Some(added::Row::Slider { value, .. }) => Kind::Slider(value.clamp(0.0, 1.0)),
-        _ => Kind::Cycle,
-    }
-}
-
-/// A registered page's slider: the value its message shows after the caption.
-pub(super) fn slider_text(page: usize, r: usize) -> Text {
-    match row(page, r) {
-        Some(added::Row::Slider { text, .. }) => label_text(text),
-        _ => Text::empty(),
-    }
-}
-
-/// A registered page's slider moved.
-pub(super) fn slide(page: usize, r: usize, value: f32) {
-    if let Some(registered) = registered().get(page) {
-        registered.act(r, added::Act::Slide(value));
-    }
-}
-
-/// What a registered page's row says on hover.
-pub(super) fn tooltip(page: usize, r: usize) -> Option<Text> {
-    registered().get(page)?.tooltip(r).map(label_text)
-}
-
-/// What a button opening one of Horizon's pages says on hover.
-pub(super) fn horizon_page_tooltip(page: Page) -> Option<&'static str> {
-    Some(match page {
-        Page::Horizon => "horizon.pages.settings.tooltip",
-        Page::Studio => "horizon.pages.studio.tooltip",
-        Page::Graphics => "horizon.pages.graphics.tooltip",
-        Page::GraphicsAdvanced => "horizon.pages.graphics_advanced.tooltip",
-        Page::Controller => "horizon.pages.controller.tooltip",
-        Page::Extras => "horizon.pages.extras.tooltip",
-        Page::Pvp => "horizon.pages.pvp.tooltip",
-        Page::Agent => "horizon.pages.agent.tooltip",
-        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",
-        Page::Music => "horizon.pages.music.tooltip",
-        _ => return None,
-    })
-}
-
-fn label_text(label: added::Label) -> Text {
-    match label {
-        added::Label::Key(key) => tr(key),
-        added::Label::Value(value) => Text::literal(value),
-    }
-}
-
-impl OptionsUi {
-    /// Horizon Settings: its pages, then the pages crates registered for it.
-    pub(super) fn horizon_rows(&self, s: &Settings) -> Vec<Row> {
-        // Two to a row, as vanilla's OptionsList.addSmall lays out
-        // buttons; each opens one of Horizon's settings pages. Each page has
-        // one way in: graphics and shader packs are Video Settings' (the graphics
-        // screen), the controller is Controls', mods are the Options screen's.
-        let open = |key: &str, page: Page| button(0.0, 0.0, 150.0, tr(key), Act::Push(page));
-        let mut rows: Vec<Row> = vec![
-            Row::Buttons(
-                open("horizon.pages.open.extras", Page::Extras),
-                Some(open("horizon.pages.open.pvp", Page::Pvp)),
-            ),
-            Row::Buttons(
-                open(
-                    "horizon.pages.open.split_setup",
-                    if self.split_guest {
-                        Page::SplitProfiles
-                    } else {
-                        Page::SplitSetup
-                    },
-                ),
-                Some(open("horizon.pages.open.studio", Page::Studio)),
-            ),
-            // No AI hides the AI Agent page and everything AI.
-            Row::Buttons(
-                self.extra_button(s, crate::extras::Item::DiscordPresence),
-                Some(if s.extras.no_ai {
-                    self.extra_button(s, crate::extras::Item::NoAi)
-                } else {
-                    open("horizon.pages.open.agent", Page::Agent)
-                }),
-            ),
-        ]
-        .into_iter()
-        .chain(
-            (!s.extras.no_ai)
-                .then(|| Row::Buttons(self.extra_button(s, crate::extras::Item::NoAi), None)),
-        )
-        .collect();
-        self.added_entries(&mut rows);
-        rows
-    }
-
-    /// The entries of the pages registered for Horizon Settings, two to a row like the engine's.
-    fn added_entries(&self, rows: &mut Vec<Row>) {
-        let mut entries = registered()
-            .iter()
-            .enumerate()
-            .filter(|(_, page)| page.place() == added::Place::HorizonSettings)
-            .map(|(i, page)| button(0.0, 0.0, 150.0, tr(page.title()), Act::Push(Page::Added(i))));
-        while let Some(first) = entries.next() {
-            rows.push(Row::Buttons(first, entries.next()));
-        }
-    }
-
-    /// A registered page's rows, asked of it each time the page is drawn.
-    pub(super) fn added_rows(&self, page: usize) -> Vec<Row> {
-        let Some(registered) = registered().get(page) else {
-            return Vec::new();
-        };
-        let mut rows = Vec::new();
-        registered.rows(&mut rows);
-        let mut out = Vec::new();
-        // The row a half-width button started, waiting for the next to sit beside it.
-        let mut half_open = false;
-        for (r, row) in rows.into_iter().enumerate() {
-            match row {
-                // Wrapped as the engine's own notes; space is for pages drawn as a screen.
-                added::Row::Text { text, .. } => {
-                    out.extend(wrap(&text, 64).into_iter().map(Row::Note))
-                }
-                added::Row::Space(_) | added::Row::Field { .. } => continue,
-                added::Row::Button {
-                    label,
-                    active,
-                    half: true,
-                    ..
-                } => {
-                    let mut half = button(0.0, 0.0, 150.0, tr(label), Act::PageRow(page, r));
-                    if !active {
-                        half = inactive(half);
-                    }
-                    match out.last_mut() {
-                        Some(Row::Buttons(_, second @ None)) if half_open => *second = Some(half),
-                        _ => out.push(Row::Buttons(half, None)),
-                    }
-                    half_open = !half_open;
-                    continue;
-                }
-                row => out.push(self.added_row(page, r, row)),
-            }
-            half_open = false;
-        }
-        out
-    }
-
-    fn added_row(&self, page: usize, r: usize, row: added::Row) -> Row {
-        let act = Act::PageRow(page, r);
-        let wide = |label: Text| Row::Buttons(button(0.0, 0.0, 310.0, label, act.clone()), None);
-        match row {
-            added::Row::Heading(key) => Row::Heading(key.to_owned()),
-            added::Row::Note(text) => Row::Note(text),
-            added::Row::Toggle { label, on } => wide(generic(label, on_off(on))),
-            added::Row::Cycle { label, value } => wide(generic(label, label_text(value))),
-            added::Row::Slider { .. } => Row::Big(Opt::Page(page, r)),
-            added::Row::Button { label, active, .. } => {
-                let wide = button(0.0, 0.0, 310.0, tr(label), act);
-                Row::Buttons(if active { wide } else { inactive(wide) }, None)
-            }
-            added::Row::Key { label, key } => {
-                let mut message = keybinds::display_name(&key);
-                if self.selected_key == Some(PAGE_KEY)
-                    && self.selected_native_key == Some((page, r))
-                {
-                    message = Text::literal("> ")
-                        .append(message.with_color(text::WHITE))
-                        .append(" <")
-                        .with_color(text::YELLOW);
-                }
-                let caption = button(0.0, 0.0, 150.0, tr(label), Act::None);
-                let change = button(0.0, 0.0, 150.0, message, act);
-                Row::Buttons(inactive(caption), Some(change))
-            }
-            // A row kind newer than this engine: shown empty.
-            _ => Row::Note(String::new()),
-        }
-    }
-
-    /// A registered page's row was pressed: a key row waits for a key, any other row hears it.
-    pub(super) fn page_act(&mut self, page: usize, r: usize, shift: bool) -> Vec<Event> {
-        let Some(registered) = registered().get(page) else {
-            return Vec::new();
-        };
-        let mut rows = Vec::new();
-        registered.rows(&mut rows);
-        match rows.get(r) {
-            Some(added::Row::Key { .. }) => {
-                self.selected_key = Some(PAGE_KEY);
-                self.selected_native_key = Some((page, r));
-                Vec::new()
-            }
-            Some(_) => {
-                registered.act(
-                    r,
-                    if shift {
-                        added::Act::PressBack
-                    } else {
-                        added::Act::Press
-                    },
-                );
-                vec![Event::Changed]
-            }
-            None => Vec::new(),
-        }
-    }
-
-    /// A native mod's page: its name, its keys as Key Binds rows (the
-    /// player's choice, else the default), then its buttons.
-    pub(super) fn native_rows(&self, s: &Settings, i: usize) -> Vec<Row> {
-        let Some(m) = s.mods.installed.get(i) else {
-            return Vec::new();
-        };
-        let mut rows = vec![Row::Note(m.title.clone())];
-        let Some(page) = &m.native else {
-            return rows;
-        };
-        let chosen = s.mods.keys.get(&m.id);
-        for (k, [name, label, default]) in page.keys.iter().enumerate() {
-            let key = chosen.and_then(|c| c.get(name)).unwrap_or(default);
-            let mut message = keybinds::display_name(key);
-            if self.selected_native_key == Some((i, k)) {
-                message = Text::literal("> ")
-                    .append(message.with_color(text::WHITE))
-                    .append(" <")
-                    .with_color(text::YELLOW);
-            }
-            let caption = button(0.0, 0.0, 150.0, Text::literal(label.clone()), Act::None);
-            let change = button(0.0, 0.0, 150.0, message, Act::NativeKey(i, k));
-            rows.push(Row::Buttons(inactive(caption), Some(change)));
-        }
-        for (b, label) in page.buttons.iter().enumerate() {
-            let widget = button(
-                0.0,
-                0.0,
-                310.0,
-                Text::literal(label.clone()),
-                Act::NativeButton(i, b),
-            );
-            rows.push(Row::Buttons(widget, None));
-        }
-        rows
-    }
-
-    /// A native mod's key waits for the next key or button pressed.
-    pub(super) fn wait_native_key(&mut self, i: usize, k: usize) {
-        self.selected_key = Some(NATIVE_KEY);
-        self.selected_native_key = Some((i, k));
-    }
-
-    /// The key pressed for the native mod's key, or the registered page's ([`PAGE_KEY`]), that
-    /// waited for one.
-    pub(super) fn bind_native_key(
-        &mut self,
-        s: &mut Settings,
-        name: &str,
-        value: String,
-    ) -> Vec<Event> {
-        let (i, k) = self.selected_native_key.take().unwrap_or_default();
-        if name == PAGE_KEY {
-            if let Some(page) = registered().get(i) {
-                page.act(k, added::Act::Bind(value));
-            }
-            return vec![Event::Changed];
-        }
-        let Some(m) = s.mods.installed.get(i) else {
-            return Vec::new();
-        };
-        let Some([key, ..]) = m.native.as_ref().and_then(|p| p.keys.get(k)) else {
-            return Vec::new();
-        };
-        let keys = s.mods.keys.entry(m.id.clone()).or_default();
-        keys.insert(key.clone(), value);
-        vec![Event::Changed]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::sync::Mutex;
-
-    /// A page with a heading, a switch, a number that steps either way, a key and a volume.
-    struct Sample {
-        on: Mutex<bool>,
-        step: Mutex<i32>,
-        key: Mutex<String>,
-        volume: Mutex<f32>,
-    }
-
-    impl added::Page for Sample {
-        fn id(&self) -> &'static str {
-            "test.sample"
-        }
-        fn title(&self) -> &'static str {
-            "test.sample.title"
-        }
-        fn place(&self) -> added::Place {
-            added::Place::HorizonSettings
-        }
-        fn rows(&self, rows: &mut Vec<added::Row>) {
-            rows.push(added::Row::Heading("test.sample.heading"));
-            rows.push(added::Row::Toggle {
-                label: "test.sample.switch",
-                on: *self.on.lock().unwrap(),
-            });
-            rows.push(added::Row::Cycle {
-                label: "test.sample.step",
-                value: added::Label::Value(self.step.lock().unwrap().to_string()),
-            });
-            rows.push(added::Row::Key {
-                label: "test.sample.key",
-                key: self.key.lock().unwrap().clone(),
-            });
-            let volume = *self.volume.lock().unwrap();
-            rows.push(added::Row::Slider {
-                label: "test.sample.volume",
-                value: volume,
-                text: added::Label::Value(format!("{}%", (volume * 100.0).round())),
-            });
-        }
-        fn act(&self, row: usize, act: added::Act) {
-            match (row, act) {
-                (1, added::Act::Press) => {
-                    let mut on = self.on.lock().unwrap();
-                    *on = !*on;
-                }
-                (2, added::Act::Press) => *self.step.lock().unwrap() += 1,
-                (2, added::Act::PressBack) => *self.step.lock().unwrap() -= 1,
-                (3, added::Act::Bind(key)) => *self.key.lock().unwrap() = key,
-                (4, added::Act::Slide(v)) => *self.volume.lock().unwrap() = v,
-                other => panic!("row and act the page doesn't expect: {other:?}"),
-            }
-        }
-        fn tooltip(&self, row: usize) -> Option<added::Label> {
-            (row == 1).then_some(added::Label::Key("test.sample.switch.tooltip"))
-        }
-    }
-
-    static SAMPLE: Sample = Sample {
-        on: Mutex::new(false),
-        step: Mutex::new(0),
-        key: Mutex::new(String::new()),
-        volume: Mutex::new(0.0),
-    };
-    static PAGES: [&dyn added::Page; 1] = [&SAMPLE];
-
-    /// Clicks the active button that does `act`, with Shift held or not.
-    fn press(ui: &mut OptionsUi, s: &mut Settings, act: Act, shift: bool) -> Vec<Event> {
-        let size = (480.0, 240.0);
-        let (widgets, ..) = ui.layout(s, size.0, size.1);
-        let (x, y) = widgets
-            .iter()
-            .find_map(|w| match &w.kind {
-                WKind::Button {
-                    act: a,
-                    active: true,
-                    ..
-                } if *a == act => Some((w.x + 1.0, w.y + 1.0)),
-                _ => None,
-            })
-            .unwrap_or_else(|| panic!("no button does {act:?}"));
-        ui.shift = shift;
-        let atlas = super::super::tests::atlas();
-        ui.click(s, &atlas, x, y, size, [480, 240], false, false)
-    }
-
-    #[test]
-    fn a_registered_page_opens_from_horizon_settings_and_hears_its_rows() {
-        let mut s = Settings::default();
-        TEST_PAGES.set(Some(&PAGES));
-        let mut ui = OptionsUi::default();
-        ui.show(Page::Horizon);
-        press(&mut ui, &mut s, Act::Push(Page::Added(0)), false);
-        assert_eq!(ui.page(), Page::Added(0));
-        // Rows: the heading (0), the switch (1), the step (2), the key (3).
-        let events = press(&mut ui, &mut s, Act::PageRow(0, 1), false);
-        assert_eq!(
-            events.last(),
-            Some(&Event::Changed),
-            "the settings get saved"
-        );
-        assert!(*SAMPLE.on.lock().unwrap());
-        press(&mut ui, &mut s, Act::PageRow(0, 2), false);
-        press(&mut ui, &mut s, Act::PageRow(0, 2), true);
-        press(&mut ui, &mut s, Act::PageRow(0, 2), true);
-        assert_eq!(*SAMPLE.step.lock().unwrap(), -1, "Shift steps back");
-        // A key row waits for the next key, as on Key Binds, and the page gets its name.
-        press(&mut ui, &mut s, Act::PageRow(0, 3), false);
-        let atlas = super::super::tests::atlas();
-        let events = ui.key(&mut s, &atlas, winit::keyboard::KeyCode::KeyZ, None);
-        assert_eq!(events, [Event::Changed]);
-        assert_eq!(*SAMPLE.key.lock().unwrap(), "key.keyboard.z");
-        assert_eq!(ui.selected_key, None);
-        // The volume is one of the screen's own sliders: dragged to its middle, then let go.
-        let size = (480.0, 240.0);
-        let (widgets, ..) = ui.layout(&s, size.0, size.1);
-        let slider = widgets
-            .iter()
-            .find(|w| {
-                matches!(
-                    w.kind,
-                    WKind::Slider {
-                        opt: Opt::Page(0, 4),
-                        ..
-                    }
-                )
-            })
-            .expect("the volume's slider");
-        let (x, y) = (slider.x + slider.w / 2.0, slider.y + 1.0);
-        ui.click(&mut s, &atlas, x, y, size, [480, 240], false, false);
-        let volume = *SAMPLE.volume.lock().unwrap();
-        assert!((0.45..0.55).contains(&volume), "{volume}");
-        assert!(ui.release().contains(&Event::Changed));
-        // The slider shows the page's value once let go.
-        let (widgets, ..) = ui.layout(&s, size.0, size.1);
-        let shown = widgets.iter().find_map(|w| match w.kind {
-            WKind::Slider {
-                opt: Opt::Page(0, 4),
-                value,
-                ..
-            } => Some(value),
-            _ => None,
-        });
-        assert_eq!(shown, Some(volume));
-        // The page's tooltip for its switch.
-        let switch = widgets
-            .iter()
-            .find(|w| {
-                matches!(
-                    &w.kind,
-                    WKind::Button {
-                        act: Act::PageRow(0, 1),
-                        ..
-                    }
-                )
-            })
-            .expect("the switch");
-        assert_eq!(
-            tooltip_text(&s, switch).map(|t| t.plain()),
-            Some(tr("test.sample.switch.tooltip").plain())
-        );
-    }
-
-    /// Text, a grey note, space, two half buttons (the second inactive) and a footer button.
-    struct Shaped(Mutex<Vec<usize>>);
-
-    impl added::Page for Shaped {
-        fn id(&self) -> &'static str {
-            "test.shaped"
-        }
-        fn title(&self) -> &'static str {
-            "test.shaped.title"
-        }
-        fn place(&self) -> added::Place {
-            added::Place::HorizonSettings
-        }
-        fn rows(&self, rows: &mut Vec<added::Row>) {
-            rows.push(added::Row::text("ABCDE-FGHIJ").groups());
-            rows.push(added::Row::text("grey").quiet());
-            rows.push(added::Row::Space(6));
-            rows.push(added::Row::button("test.shaped.copy").half());
-            rows.push(added::Row::button("test.shaped.stop").half().active(false));
-            rows.push(added::Row::button("test.shaped.help").footer());
-        }
-        fn act(&self, row: usize, _: added::Act) {
-            self.0.lock().unwrap().push(row);
-        }
-    }
-
-    static SHAPED: Shaped = Shaped(Mutex::new(Vec::new()));
-    static SHAPED_PAGES: [&dyn added::Page; 1] = [&SHAPED];
-
-    #[test]
-    fn half_buttons_share_a_row_and_an_inactive_one_is_never_pressed() {
-        let mut s = Settings::default();
-        TEST_PAGES.set(Some(&SHAPED_PAGES));
-        let ui = OptionsUi::default();
-        let rows = ui.added_rows(0);
-        // The two texts as notes (space shows nothing here), the halves on one row, the
-        // footer button below them (the settings shell has no footer of its own).
-        assert!(matches!(&rows[0], Row::Note(t) if t == "ABCDE-FGHIJ"));
-        assert!(matches!(&rows[1], Row::Note(t) if t == "grey"));
-        let Row::Buttons(copy, Some(stop)) = &rows[2] else {
-            panic!("the halves sit side by side: {:?}", rows.len());
-        };
-        assert_eq!((copy.w, stop.w), (150.0, 150.0));
-        assert!(matches!(&rows[3], Row::Buttons(help, None) if help.w == 310.0));
-        assert_eq!(rows.len(), 4);
-        let mut ui = ui;
-        ui.show(Page::Added(0));
-        press(&mut ui, &mut s, Act::PageRow(0, 3), false);
-        press(&mut ui, &mut s, Act::PageRow(0, 5), false);
-        let (widgets, ..) = ui.layout(&s, 480.0, 240.0);
-        let stop = widgets
-            .iter()
-            .find(|w| {
-                matches!(
-                    &w.kind,
-                    WKind::Button {
-                        act: Act::PageRow(0, 4),
-                        ..
-                    }
-                )
-            })
-            .expect("Stop is drawn");
-        let atlas = super::super::tests::atlas();
-        ui.click(
-            &mut s,
-            &atlas,
-            stop.x + 1.0,
-            stop.y + 1.0,
-            (480.0, 240.0),
-            [480, 240],
-            false,
-            false,
-        );
-        assert_eq!(
-            *SHAPED.0.lock().unwrap(),
-            [3, 5],
-            "the inactive half heard nothing"
-        );
-    }
-}

crates/horizon-client-render/src/pack_formats/colors.rs

@@ -1,67 +0,0 @@
-//! Polytone's custom colours (`horizon_polytone::colors`, `colors.json` or `color.properties`)
-//! as the engine's pack colours ([`crate::pack_palette::PackColors`]).
-use std::path::Path;
-
-use horizon_polytone::colors::PackColors;
-
-use crate::block_entity_render::DYES;
-use crate::pack_palette::{self, Environment};
-
-/// The colours of every namespace's file under the pack overlay at `root`.
-pub fn read(root: &Path) -> pack_palette::PackColors {
-    let colors = PackColors::read(root);
-    let by_dye = |f: &dyn Fn(&str) -> Option<u32>| std::array::from_fn(|i| f(DYES[i].0));
-    let env = colors.env;
-    pack_palette::PackColors {
-        dye_diffuse: by_dye(&|name| colors.dye(name, "diffuse")),
-        dye_text: by_dye(&|name| colors.dye(name, "text")),
-        sheep: by_dye(&|name| colors.sheep(name)),
-        redstone: std::array::from_fn(|i| colors.redstone(i as u8)),
-        effects: colors.effects(),
-        entity_shadows: colors.entity_shadows(),
-        xp_bar: colors.xp_bar(),
-        env: Environment {
-            powder_snow_fog: env.powder_snow_fog,
-            blindness_fog_distance: env.blindness_fog_distance,
-            darkness_fog_distance: env.darkness_fog_distance,
-            boss_fog_distance: env.boss_fog_distance,
-            water_fog_brightening: env.water_fog_brightening,
-            water_fog_brightening_time: env.water_fog_brightening_time,
-            horizon_height: env.horizon_height,
-        },
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::pack_palette::{diffuse, redstone, sheep_wool, text};
-
-    #[test]
-    fn a_pack_recolours_only_what_it_names() {
-        // Dyes no other test draws: the table is process-wide.
-        let dir = std::env::temp_dir().join(format!("pack-dyes-{}", std::process::id()));
-        let polytone = dir.join("assets/obs/polytone");
-        std::fs::create_dir_all(&polytone).unwrap();
-        std::fs::write(
-            polytone.join("colors.json"),
-            r#"{"dye": {"cyan": {"diffuse": "00ff00", "text": "0000ff"}}, "sheep": {"pink": "2040ff"}, "redstone": {"7": "0x123456"}}"#,
-        )
-        .unwrap();
-        crate::pack_palette::set(&read(&dir));
-        let (cyan, pink, purple) = (9, 6, 10);
-        assert_eq!(diffuse(cyan), 0x00ff00);
-        assert_eq!(text(cyan), 0x0000ff);
-        assert_eq!(sheep_wool(pink as u8), 0x2040ff);
-        // Wool reads vanilla's dye, not the pack's diffuse: 75% of 0x169C9C.
-        assert_eq!(sheep_wool(cyan as u8), 0x107575);
-        assert_eq!(diffuse(purple), 0x8932B8);
-        assert_eq!(text(purple), 0xA020F0);
-        assert_eq!((redstone(7), redstone(15)), (Some(0x123456), None));
-        crate::pack_palette::set(&Default::default());
-        assert_eq!(redstone(7), None);
-        assert_eq!(diffuse(cyan), 0x169C9C);
-        assert_eq!(sheep_wool(pink as u8), 0xB6687F);
-        std::fs::remove_dir_all(&dir).ok();
-    }
-}

crates/horizon-client-render/src/pack_formats/custom_sky.rs

@@ -1,252 +0,0 @@
-//! OptiFine custom skies (`horizon_optifine::sky`) on the engine's sky layers
-//! ([`crate::custom_sky`]): a pack's layers with their decoded textures, read once with the pack,
-//! and each frame's choice of layers, their brightness and rotation. A pack without
-//! `optifine/sky` has none, and the sky stays vanilla.
-
-use std::path::Path;
-
-use glam::{Mat4, Vec3};
-use horizon_optifine::sky::{Blend, Conditions, Now, Skies, SkyLayer, Transition};
-
-use crate::custom_sky::{self as engine, Draw, Image, SkyLayers, State};
-
-/// The pack's layers, by world, with one texture per layer (`images[i]` for the `i`th layer
-/// over all worlds, in `worlds` order).
-#[derive(Default)]
-pub struct CustomSky {
-    worlds: Vec<(i32, Vec<SkyLayer>)>,
-    pub images: Vec<Image>,
-}
-
-/// Textures past this many texels in all are left out (a skybox is a few megapixels at most).
-const TEXEL_BUDGET: u64 = 64 << 20;
-
-impl CustomSky {
-    /// The custom skies of the overlay at `root`. A layer whose texture does not decode is
-    /// dropped with a warning.
-    pub fn load(root: &Path) -> Self {
-        let skies = Skies::scan(root);
-        let mut out = Self::default();
-        let mut texels = 0u64;
-        for (world, sky) in skies.worlds {
-            let mut layers = Vec::new();
-            for layer in sky.layers {
-                match crate::hud::decode(&root.join(&layer.source)) {
-                    Ok((width, height, rgba))
-                        if texels + u64::from(width) * u64::from(height) <= TEXEL_BUDGET =>
-                    {
-                        texels += u64::from(width) * u64::from(height);
-                        out.images.push(Image {
-                            width,
-                            height,
-                            rgba,
-                        });
-                        layers.push(layer);
-                    }
-                    Ok(_) => log::warn!("{}: past the custom sky's texture budget", layer.source),
-                    Err(e) => log::warn!("{}: {e:#}", layer.source),
-                }
-            }
-            if !layers.is_empty() {
-                out.worlds.push((world, layers));
-            }
-        }
-        out
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.worlds.is_empty()
-    }
-}
-
-/// The engine's sky blend for OptiFine's.
-fn blend(blend: Blend) -> engine::Blend {
-    match blend {
-        Blend::Add => engine::Blend::Add,
-        Blend::Subtract => engine::Blend::Subtract,
-        Blend::Multiply => engine::Blend::Multiply,
-        Blend::Dodge => engine::Blend::Dodge,
-        Blend::Burn => engine::Blend::Burn,
-        Blend::Screen => engine::Blend::Screen,
-        Blend::Replace => engine::Blend::Replace,
-        Blend::Overlay => engine::Blend::Overlay,
-        Blend::Alpha => engine::Blend::Alpha,
-    }
-}
-
-impl SkyLayers for CustomSky {
-    fn images(&self) -> &[Image] {
-        &self.images
-    }
-
-    /// Whether `world` has layers (`0` the Overworld, `1` the End).
-    fn has(&self, world: i32) -> bool {
-        self.worlds.iter().any(|(w, _)| *w == world)
-    }
-
-    /// The layers whose conditions hold, eased over their `transition`, at the brightness of
-    /// their fade times.
-    fn draws(
-        &self,
-        world: i32,
-        conditions: &engine::Conditions,
-        sun_turns: f32,
-        seconds: f32,
-        state: &mut State,
-        out: &mut Vec<Draw>,
-    ) {
-        let conditions = &Conditions {
-            day_time: conditions.day_time,
-            weather: match conditions.weather {
-                engine::Weather::Clear => Now::Clear,
-                engine::Weather::Rain => Now::Rain,
-                engine::Weather::Thunder => Now::Thunder,
-            },
-            biome: conditions.biome,
-            y: conditions.y,
-        };
-        out.clear();
-        let mut first = 0;
-        let mut found = None;
-        for (w, layers) in &self.worlds {
-            if *w == world {
-                found = Some(layers);
-                break;
-            }
-            first += layers.len();
-        }
-        let Some(layers) = found else {
-            state.world = None;
-            return;
-        };
-        // A new world (or pack) starts each layer where its conditions put it: no fade in.
-        let snap = state.world != Some(world) || state.eased.len() != layers.len();
-        if snap {
-            state.world = Some(world);
-            state.eased.clear();
-            state.eased.resize(layers.len(), 0.0);
-        }
-        for (i, (layer, eased)) in layers.iter().zip(&mut state.eased).enumerate() {
-            let target = if layer.shows(conditions) { 1.0 } else { 0.0 };
-            let shown = if snap {
-                *eased = target;
-                target
-            } else {
-                let mut t = Transition { value: *eased };
-                *eased = t.step(target, seconds, layer.transition);
-                *eased
-            };
-            let brightness = shown * layer.brightness(conditions.day_time);
-            if brightness <= 0.0 {
-                continue;
-            }
-            let turns = layer.turns(conditions.day_time, sun_turns);
-            let rotation = if turns == 0.0 {
-                Mat4::IDENTITY
-            } else {
-                Mat4::from_axis_angle(Vec3::from_array(layer.axis), turns * std::f32::consts::TAU)
-            };
-            out.push(Draw {
-                image: (first + i) as u16,
-                blend: blend(layer.blend),
-                brightness,
-                rotation,
-            });
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::custom_sky::{Conditions, Weather};
-
-    fn pack(files: &[(&str, &str)]) -> (std::path::PathBuf, CustomSky) {
-        let root = std::env::temp_dir().join(format!(
-            "horizon-custom-sky-{}-{}",
-            std::process::id(),
-            files.len()
-        ));
-        let _ = std::fs::remove_dir_all(&root);
-        let dir = root.join("assets/minecraft/optifine/sky/world0");
-        std::fs::create_dir_all(&dir).unwrap();
-        let png = {
-            let mut bytes = Vec::new();
-            let mut encoder = png::Encoder::new(&mut bytes, 6, 4);
-            encoder.set_color(png::ColorType::Rgba);
-            encoder.set_depth(png::BitDepth::Eight);
-            let mut writer = encoder.write_header().unwrap();
-            writer
-                .write_image_data(&[255, 0, 0, 255].repeat(24))
-                .unwrap();
-            writer.finish().unwrap();
-            bytes
-        };
-        for (name, text) in files {
-            std::fs::write(dir.join(format!("{name}.properties")), text).unwrap();
-            std::fs::write(dir.join(format!("{name}.png")), &png).unwrap();
-        }
-        let sky = CustomSky::load(&root);
-        (root, sky)
-    }
-
-    fn noon(biome: &str) -> Conditions<'_> {
-        Conditions {
-            day_time: 6000,
-            weather: Weather::Clear,
-            biome,
-            y: 64,
-        }
-    }
-
-    #[test]
-    fn layers_ease_in_at_a_biome_border_but_not_on_arrival() {
-        let (root, sky) = pack(&[
-            ("sky1", "biomes=desert\ntransition=2"),
-            ("sky2", "blend=alpha\nrotate=false"),
-        ]);
-        let _ = std::fs::remove_dir_all(root);
-        assert!(sky.has(0) && !sky.has(1));
-        assert_eq!(sky.images[0].width, 6);
-        let (mut state, mut out) = (State::default(), Vec::new());
-        sky.draws(
-            0,
-            &noon("minecraft:desert"),
-            0.0,
-            0.05,
-            &mut state,
-            &mut out,
-        );
-        assert_eq!(
-            out.iter().map(|d| d.brightness).collect::<Vec<_>>(),
-            [1.0, 1.0]
-        );
-        // Out of the desert: the first layer fades over its two seconds.
-        sky.draws(0, &noon("minecraft:plains"), 0.0, 0.5, &mut state, &mut out);
-        assert_eq!(out[0].brightness, 0.75);
-        assert_eq!(out[1].blend, engine::Blend::Alpha);
-        sky.draws(0, &noon("minecraft:plains"), 0.0, 2.0, &mut state, &mut out);
-        assert_eq!(out.len(), 1, "a dark layer is not drawn");
-        assert_eq!(out[0].image, 1);
-        // Into the End, which has no layers, and back: no fade.
-        sky.draws(1, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
-        assert!(out.is_empty());
-        sky.draws(0, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
-        assert_eq!(out.len(), 2);
-    }
-
-    #[test]
-    fn a_layer_turns_west_like_the_sun() {
-        let (root, sky) = pack(&[("sky1", "")]);
-        let _ = std::fs::remove_dir_all(root);
-        let (mut state, mut out) = (State::default(), Vec::new());
-        // A quarter turn after noon (sunset): the skybox's zenith has gone down to the west.
-        let c = Conditions {
-            day_time: 12000,
-            ..noon("minecraft:plains")
-        };
-        sky.draws(0, &c, 0.25, 0.0, &mut state, &mut out);
-        let up = out[0].rotation.transform_vector3(Vec3::Y);
-        assert!((up - Vec3::NEG_X).length() < 1e-5, "{up}");
-    }
-}

crates/horizon-client-render/src/pack_formats/item_bars.rs

@@ -1,146 +0,0 @@
-//! Polytone's item modifiers' durability bar colours, on the engine's
-//! [`crate::pack_palette::ItemBars`].
-use std::path::Path;
-use std::sync::Arc;
-
-/// An item modifier's `bar_color` of the `damage` type: a row of colours picked by the stack's
-/// damage, the first pixel undamaged, the last at full damage (measured on the real mod).
-struct DamageBar {
-    targets: horizon_polytone::Targets,
-    row: Vec<u32>,
-}
-
-/// The packs' damage bars, the last read first.
-struct Bars(Vec<DamageBar>);
-
-impl crate::pack_palette::ItemBars for Bars {
-    fn color(&self, item: &str, damage: f32) -> Option<u32> {
-        let bar = self
-            .0
-            .iter()
-            .rev()
-            .find(|b| b.targets.matches(item, |_| false))?;
-        let last = (bar.row.len() - 1) as f32;
-        Some(bar.row[(damage.clamp(0.0, 1.0) * last).round() as usize])
-    }
-}
-
-/// Reads the packs' item modifiers' durability bar colours under a pack overlay root: an
-/// `<item>_bar.png` alone, or a json whose `bar_color` is `damage` with its `<name>_bar.png` (or
-/// `<name>.png`) beside it. Colormap ids and inline colormaps aren't read. `None` without any.
-pub fn read(root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
-    let mut bars = Vec::new();
-    for namespace in std::fs::read_dir(root.join("assets"))
-        .into_iter()
-        .flatten()
-        .flatten()
-    {
-        let base = namespace.path().join("polytone/item_modifiers");
-        let mut stack = vec![base.clone()];
-        while let Some(dir) = stack.pop() {
-            for entry in std::fs::read_dir(&dir).into_iter().flatten().flatten() {
-                let path = entry.path();
-                if path.is_dir() {
-                    stack.push(path);
-                } else if let Some(bar) = item_bar(root, &base, &path) {
-                    bars.push(bar);
-                }
-            }
-        }
-    }
-    (!bars.is_empty()).then(|| Arc::new(Bars(bars)) as _)
-}
-
-fn item_bar(root: &Path, base: &Path, path: &Path) -> Option<DamageBar> {
-    let name = path.file_name()?.to_str()?;
-    let row = |png: &Path| {
-        let (width, _, rgba) = crate::sprites::read_rgba(png).ok()?;
-        let row: Vec<u32> = rgba[..width as usize * 4]
-            .as_chunks::<4>()
-            .0
-            .iter()
-            .map(|p| u32::from(p[0]) << 16 | u32::from(p[1]) << 8 | u32::from(p[2]))
-            .collect();
-        (!row.is_empty()).then_some(row)
-    };
-    if let Some(stem) = name.strip_suffix("_bar.png") {
-        // A json of the same name owns its png.
-        if path.with_file_name(format!("{stem}.json")).exists() {
-            return None;
-        }
-        let relative = path.parent()?.strip_prefix(base).ok()?.join(stem);
-        let namespace = base.parent()?.parent()?.file_name()?.to_str()?;
-        let id = format!("{namespace}:{}", relative.to_str()?.replace('\\', "/"));
-        let targets = horizon_polytone::Targets::parse(None, Some(&id)).ok()?;
-        return Some(DamageBar {
-            targets,
-            row: row(path)?,
-        });
-    }
-    let stem = name.strip_suffix(".json")?;
-    let json: serde_json::Value = horizon_world::json_file::read(path).ok()?;
-    if json.get("bar_color")?.as_str()? != "damage" {
-        return None;
-    }
-    let png = [format!("{stem}_bar.png"), format!("{stem}.png")]
-        .into_iter()
-        .map(|png| path.with_file_name(png))
-        .find(|png| png.exists())?;
-    let relative = path.strip_prefix(root).unwrap_or(path).to_string_lossy();
-    let implicit = horizon_polytone::implicit_id(&relative, "item_modifiers");
-    let targets =
-        horizon_polytone::Targets::parse(json.get("targets"), implicit.as_deref()).ok()?;
-    Some(DamageBar {
-        targets,
-        row: row(&png)?,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn png_row(path: &Path, pixels: &[[u8; 3]]) {
-        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
-        let file = std::fs::File::create(path).unwrap();
-        let mut encoder = png::Encoder::new(file, pixels.len() as u32, 1);
-        encoder.set_color(png::ColorType::Rgba);
-        let data: Vec<u8> = pixels
-            .iter()
-            .flat_map(|p| [p[0], p[1], p[2], 255])
-            .collect();
-        encoder
-            .write_header()
-            .unwrap()
-            .write_image_data(&data)
-            .unwrap();
-    }
-
-    #[test]
-    fn a_damage_bar_picks_its_pixel_by_the_stacks_damage() {
-        let dir = std::env::temp_dir().join(format!("pack-bars-{}", std::process::id()));
-        let modifiers = dir.join("assets/minecraft/polytone/item_modifiers");
-        let rgby = [[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 0]];
-        png_row(&modifiers.join("diamond_pickaxe_bar.png"), &rgby);
-        std::fs::write(
-            modifiers.join("tools.json"),
-            r#"{"targets": ["minecraft:iron_axe"], "bar_color": "damage"}"#,
-        )
-        .unwrap();
-        png_row(&modifiers.join("tools_bar.png"), &[[1, 2, 3], [4, 5, 6]]);
-        let bars = read(&dir).unwrap();
-        // The real mod: damage 200 of 1561 shows the first pixel, 1400 the last.
-        assert_eq!(
-            bars.color("minecraft:diamond_pickaxe", 200.0 / 1561.0),
-            Some(0xFF0000)
-        );
-        assert_eq!(
-            bars.color("minecraft:diamond_pickaxe", 1400.0 / 1561.0),
-            Some(0xFFFF00)
-        );
-        assert_eq!(bars.color("minecraft:iron_axe", 0.9), Some(0x040506));
-        assert_eq!(bars.color("minecraft:diamond_shovel", 0.5), None);
-        assert!(read(&dir.join("none")).is_none());
-        std::fs::remove_dir_all(&dir).ok();
-    }
-}

crates/horizon-client-render/src/pack_formats/mod.rs

@@ -1,40 +0,0 @@
-//! The resource pack formats vanilla doesn't read (OptiFine's, Polytone's) on the engine's
-//! extension points ([`crate::pack_hooks`]). This is platform code (docs/layers.md) kept in this
-//! crate until the platform's executable installs it: it uses only the crate's public API, so it
-//! moves to a platform crate unchanged, and nothing else in the crate names it.
-
-mod colors;
-mod custom_sky;
-mod item_bars;
-
-use std::path::Path;
-use std::sync::Arc;
-
-use crate::pack_hooks::PackFormats;
-
-/// OptiFine's and Polytone's formats.
-pub struct Formats;
-
-impl PackFormats for Formats {
-    fn colors(&self, root: &Path) -> Option<crate::pack_palette::PackColors> {
-        Some(colors::read(root))
-    }
-
-    fn emissive_suffix(&self, root: &Path) -> Option<String> {
-        Some(horizon_optifine::emissive::suffix(root))
-    }
-
-    fn custom_sky(&self, root: &Path) -> Option<Arc<dyn crate::custom_sky::SkyLayers>> {
-        let sky = custom_sky::CustomSky::load(root);
-        (!sky.is_empty()).then(|| Arc::new(sky) as _)
-    }
-
-    fn item_bars(&self, root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
-        item_bars::read(root)
-    }
-}
-
-/// Installs these formats ([`crate::pack_hooks::install`]); the game does at startup.
-pub fn install() {
-    crate::pack_hooks::install(&Formats);
-}

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

@@ -1,51 +0,0 @@
-//! The engine's extension points for resource pack formats vanilla doesn't read (OptiFine's,
-//! Polytone's: platform code, docs/layers.md). The engine asks [`formats`] once per pack load and
-//! gets engine types back (tables, or an object it calls at most once a frame), never a format's
-//! own types. The platform installs its formats at startup ([`install`]); with none installed,
-//! packs load as vanilla reads them.
-
-use std::path::Path;
-use std::sync::{Arc, OnceLock};
-
-/// What the pack formats beyond vanilla's add to a pack. Each method reads one overlay of a pack
-/// (its folder at `root`); the default is "nothing in this format".
-pub trait PackFormats: Send + Sync {
-    /// The colours the overlay replaces where vanilla hardcodes them.
-    fn colors(&self, _root: &Path) -> Option<crate::pack_palette::PackColors> {
-        None
-    }
-
-    /// The name ending of the overlay's emissive textures (`stone_e.png` beside `stone.png`),
-    /// if its format has them.
-    fn emissive_suffix(&self, _root: &Path) -> Option<String> {
-        None
-    }
-
-    /// The sky layers the overlay draws over the vanilla sky, if it has any.
-    fn custom_sky(&self, _root: &Path) -> Option<Arc<dyn crate::custom_sky::SkyLayers>> {
-        None
-    }
-
-    /// The durability bar colours the overlay sets by item, if any.
-    fn item_bars(&self, _root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
-        None
-    }
-}
-
-/// No format beyond vanilla's.
-struct Vanilla;
-
-impl PackFormats for Vanilla {}
-
-static FORMATS: OnceLock<&'static dyn PackFormats> = OnceLock::new();
-
-/// Installs the pack formats, before the first pack loads. The first call wins: later ones are
-/// ignored, so each test or probe that needs the formats may install them.
-pub fn install(formats: &'static dyn PackFormats) {
-    let _ = FORMATS.set(formats);
-}
-
-/// The installed pack formats, or vanilla's alone.
-pub fn formats() -> &'static dyn PackFormats {
-    FORMATS.get().copied().unwrap_or(&Vanilla)
-}

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

@@ -1,87 +1,12 @@
-//! The colours a pack replaces where vanilla hardcodes them (Polytone's `colors.json`, read by the
-//! platform's pack formats, [`crate::pack_hooks`]): dye, sheep and redstone colours, for drawing
-//! only (the pack recolours collars, tropical fish, banners, wool, sign text and redstone wire and
-//! dust, while gameplay keeps vanilla's `DyeColor`), mob effect colours, the experience number's,
-//! entity shadows, the effect fogs' settings and durability bar colours. Lock-free: the draw paths
-//! and the mesher's workers read the dye, sheep and redstone tables per face.
-use std::path::Path;
+//! Polytone's dye, sheep and redstone colours (`dye.<name>.diffuse|text`, `sheep.<name>`,
+//! `redstone.<power>`), for drawing only: the pack recolours collars, tropical fish, banners, wool,
+//! sign text and redstone wire and dust, while gameplay (crafting, item data, the beacon) keeps
+//! vanilla's `DyeColor`. Lock-free: the draw paths and the mesher's workers read it per face.
 use std::sync::atomic::{AtomicU64, Ordering::Relaxed};
-use std::sync::{Arc, RwLock};
 
 use crate::block_entity_render::DYES;
 use crate::signs::DYE_TEXT;
-
-/// The fog settings vanilla hardcodes, as the packs set them (vanilla's by default).
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Environment {
-    /// The fog colour inside powder snow (RGB).
-    pub powder_snow_fog: Option<u32>,
-    /// The fog ends of Blindness (5), Darkness (15) and bosses that add world fog (96).
-    pub blindness_fog_distance: f32,
-    pub darkness_fog_distance: f32,
-    pub boss_fog_distance: f32,
-    /// How much the underwater fog colour washes out (1 vanilla, 0 none).
-    pub water_fog_brightening: f32,
-    /// The ticks under water it takes (vanilla's 600).
-    pub water_fog_brightening_time: f32,
-    /// Below it the sky draws its dark disc (vanilla's 63; flat worlds keep their floor).
-    pub horizon_height: f32,
-}
-
-impl Default for Environment {
-    fn default() -> Self {
-        Self {
-            powder_snow_fog: None,
-            blindness_fog_distance: 5.0,
-            darkness_fog_distance: 15.0,
-            boss_fog_distance: 96.0,
-            water_fog_brightening: 1.0,
-            water_fog_brightening_time: 600.0,
-            horizon_height: 63.0,
-        }
-    }
-}
-
-/// The packs' colours; `None` (and the defaults) where they keep vanilla's.
-#[derive(Clone, Debug, PartialEq)]
-pub struct PackColors {
-    /// By dye id (`DyeColor` order): `getTextureDiffuseColor`, `getTextColor`, the sheep's wool.
-    pub dye_diffuse: [Option<u32>; 16],
-    pub dye_text: [Option<u32>; 16],
-    pub sheep: [Option<u32>; 16],
-    /// `RedStoneWireBlock.COLORS` by power.
-    pub redstone: [Option<u32>; 16],
-    /// Mob effects' colours, by effect id without vanilla's namespace.
-    pub effects: Vec<(String, u32)>,
-    /// False hides every entity's round shadow, whatever the video option says.
-    pub entity_shadows: bool,
-    /// The experience level number's colour and outline.
-    pub xp_bar: [Option<u32>; 2],
-    /// The effect fogs' settings: the fog reads them every frame.
-    pub env: Environment,
-}
-
-impl Default for PackColors {
-    fn default() -> Self {
-        Self {
-            dye_diffuse: [None; 16],
-            dye_text: [None; 16],
-            sheep: [None; 16],
-            redstone: [None; 16],
-            effects: Vec::new(),
-            entity_shadows: true,
-            xp_bar: [None; 2],
-            env: Environment::default(),
-        }
-    }
-}
-
-impl PackColors {
-    /// Whether entities draw their round shadow, as far as the packs say.
-    pub fn entity_shadows(&self) -> bool {
-        self.entity_shadows
-    }
-}
+use horizon_polytone::colors::PackColors;
 
 /// 0 is unset, else `1 << 32 | rgb`.
 static DIFFUSE: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
@@ -89,30 +14,6 @@ static TEXT: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
 static SHEEP: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
 static REDSTONE: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
 
-/// The colours of the pack overlay at `root`, from the installed pack formats; their dye, sheep
-/// and redstone colours go to the draw paths' tables ([`set`]).
-pub fn read(root: &Path) -> PackColors {
-    let formats = crate::pack_hooks::formats();
-    let colors = formats.colors(root).unwrap_or_default();
-    set(&colors);
-    *ITEM_BARS.write().unwrap_or_else(|e| e.into_inner()) = formats.item_bars(root);
-    colors
-}
-
-/// The packs' durability bar colours by item (Polytone's item modifiers' `bar_color`).
-pub trait ItemBars: Send + Sync {
-    /// The bar colour (RGB) of `item` at this damage (0 to 1), when a pack sets one.
-    fn color(&self, item: &str, damage: f32) -> Option<u32>;
-}
-
-static ITEM_BARS: RwLock<Option<Arc<dyn ItemBars>>> = RwLock::new(None);
-
-/// A pack's durability bar colour (RGB) for an item at this damage (0 to 1).
-pub fn item_bar_color(item: &str, damage: f32) -> Option<u32> {
-    let bars = ITEM_BARS.read().unwrap_or_else(|e| e.into_inner());
-    bars.as_ref()?.color(item, damage)
-}
-
 /// Takes the colours of the packs just loaded (vanilla's where they set none).
 pub fn set(colors: &PackColors) {
     let store = |table: &[AtomicU64; 16], i: usize, color: Option<u32>| {
@@ -121,39 +22,39 @@ pub fn set(colors: &PackColors) {
             Relaxed,
         );
     };
-    for i in 0..16 {
-        store(&DIFFUSE, i, colors.dye_diffuse[i]);
-        store(&TEXT, i, colors.dye_text[i]);
-        store(&SHEEP, i, colors.sheep[i]);
-        store(&REDSTONE, i, colors.redstone[i]);
+    for (i, (name, _)) in DYES.iter().enumerate() {
+        store(&DIFFUSE, i, colors.dye(name, "diffuse"));
+        store(&TEXT, i, colors.dye(name, "text"));
+        store(&SHEEP, i, colors.sheep(name));
+        store(&REDSTONE, i, colors.redstone(i as u8));
     }
 }
 
-fn get(table: &[AtomicU64; 16], i: usize) -> Option<u32> {
+fn read(table: &[AtomicU64; 16], i: usize) -> Option<u32> {
     let v = table[i & 15].load(Relaxed);
     (v != 0).then_some(v as u32)
 }
 
 /// `DyeColor.getTextureDiffuseColor` (RGB) as the packs draw it.
 pub fn diffuse(dye: usize) -> u32 {
-    get(&DIFFUSE, dye).unwrap_or(DYES[dye & 15].1)
+    read(&DIFFUSE, dye).unwrap_or(DYES[dye & 15].1)
 }
 
 /// `DyeColor.getTextColor` (RGB) as the packs draw it.
 pub fn text(dye: usize) -> u32 {
-    get(&TEXT, dye).unwrap_or(DYE_TEXT[dye & 15].1)
+    read(&TEXT, dye).unwrap_or(DYE_TEXT[dye & 15].1)
 }
 
 /// A pack's `RedStoneWireBlock.COLORS` entry for this power (RGB), when it sets one.
 pub fn redstone(power: u8) -> Option<u32> {
-    get(&REDSTONE, usize::from(power))
+    read(&REDSTONE, usize::from(power))
 }
 
 /// `ColorLerper.Type.SHEEP` wool colour: a pack's `sheep.<name>`, else white 0xE6E6E6 and the
 /// others 75% of vanilla's dye (a pack's `dye.*.diffuse` doesn't reach wool).
 pub fn sheep_wool(dye: u8) -> u32 {
     let i = usize::from(dye & 15);
-    if let Some(color) = get(&SHEEP, i) {
+    if let Some(color) = read(&SHEEP, i) {
         return color;
     }
     if i == 0 {
@@ -163,3 +64,36 @@ pub fn sheep_wool(dye: u8) -> u32 {
     let f = |c: u32| ((c as f32 * 0.75).floor() as u32).min(255);
     f(src >> 16 & 255) << 16 | f(src >> 8 & 255) << 8 | f(src & 255)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_pack_recolours_only_what_it_names() {
+        // Dyes no other test draws: the table is process-wide.
+        let dir = std::env::temp_dir().join(format!("pack-dyes-{}", std::process::id()));
+        let polytone = dir.join("assets/obs/polytone");
+        std::fs::create_dir_all(&polytone).unwrap();
+        std::fs::write(
+            polytone.join("colors.json"),
+            r#"{"dye": {"cyan": {"diffuse": "00ff00", "text": "0000ff"}}, "sheep": {"pink": "2040ff"}, "redstone": {"7": "0x123456"}}"#,
+        )
+        .unwrap();
+        set(&PackColors::read(&dir));
+        let (cyan, pink, purple) = (9, 6, 10);
+        assert_eq!(diffuse(cyan), 0x00ff00);
+        assert_eq!(text(cyan), 0x0000ff);
+        assert_eq!(sheep_wool(pink as u8), 0x2040ff);
+        // Wool reads vanilla's dye, not the pack's diffuse: 75% of 0x169C9C.
+        assert_eq!(sheep_wool(cyan as u8), 0x107575);
+        assert_eq!(diffuse(purple), 0x8932B8);
+        assert_eq!(text(purple), 0xA020F0);
+        assert_eq!((redstone(7), redstone(15)), (Some(0x123456), None));
+        set(&PackColors::default());
+        assert_eq!(redstone(7), None);
+        assert_eq!(diffuse(cyan), 0x169C9C);
+        assert_eq!(sheep_wool(pink as u8), 0xB6687F);
+        std::fs::remove_dir_all(&dir).ok();
+    }
+}

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

@@ -31,7 +31,6 @@ mod native;
 pub mod polytone;
 mod polytone_gpu;
 mod polytone_model;
-mod spawn;
 pub use native::{ParticleController, ParticleUpdate};
 
 /// `ParticleOptions` with the parameters of the option classes used here.
@@ -1223,9 +1222,8 @@ pub struct ParticleLevel<'a> {
     pub collision: &'a BlockCollisionRegistry<'a>,
     /// Local player feet position and vertical velocity (`PlayerCloudParticle`).
     pub player: Option<([f64; 3], f64)>,
-    pub cached_chunk: std::cell::Cell<Option<((i32, i32), Option<&'a crate::chunk::Chunk>)>>,
 }
-impl<'a> ParticleLevel<'a> {
+impl ParticleLevel<'_> {
     fn collide(&self, bb: Aabb, d: [f64; 3]) -> [f64; 3] {
         let mut scene = SceneCollisions {
             world: self.world,
@@ -1233,6 +1231,9 @@ impl<'a> ParticleLevel<'a> {
             subject: None,
         };
         let movement = Vec3::new(d[0], d[1], d[2]);
+        // `Entity.collideBoundingBox(null, ...)`: no entity shapes, no border. Where no
+        // block of the swept box's cells can collide, it finds no shape and the
+        // movement stands, as the resolution below would return it.
         if scene.cells_without_collision(bb.expand_towards(movement)) {
             return d;
         }
@@ -1248,46 +1249,38 @@ impl<'a> ParticleLevel<'a> {
             p[2].floor() as i32,
         ]
     }
-    #[inline]
-    pub fn block(&self, x: i32, y: i32, z: i32) -> horizon_world::registry::BlockStateId {
-        let (cx, cz) = (x >> 4, z >> 4);
-        let chunk = match self.cached_chunk.get() {
-            Some(((ccx, ccz), c)) if ccx == cx && ccz == cz => c,
-            _ => {
-                let c = self.world.chunks.get(&(cx, cz)).map(|c| c.as_ref());
-                self.cached_chunk.set(Some(((cx, cz), c)));
-                c
-            }
-        };
-        chunk.map_or(self.world.air, |c| c.block(x & 15, y, z & 15))
-    }
     /// The fluid at a block and `FluidState.getHeight`.
     fn fluid(&self, b: [i32; 3]) -> (Fluid, f64) {
-        let s = self.facts.get(self.block(b[0], b[1], b[2]));
+        let s = self.facts.get(self.world.block(b[0], b[1], b[2]));
         if s.fluid == Fluid::None {
             return (Fluid::None, 0.0);
         }
-        let above = self.facts.get(self.block(b[0], b[1] + 1, b[2]));
-        let h = if above.fluid == s.fluid {
+        let above = self.facts.get(self.world.block(b[0], b[1] + 1, b[2]));
+        let height = if above.fluid == s.fluid {
             1.0
         } else {
             f64::from(s.fluid_level) / 9.0
         };
-        (s.fluid, h)
+        (s.fluid, height)
     }
     /// The fluid at a block and whether it is a source (`FluidState.isSource`).
     pub(crate) fn fluid_source(&self, b: [i32; 3]) -> (Fluid, bool) {
-        let s = self.facts.get(self.block(b[0], b[1], b[2]));
+        let s = self.facts.get(self.world.block(b[0], b[1], b[2]));
         (s.fluid, s.fluid_level == 8 && !s.fluid_falling)
     }
     /// `getCollisionShape(...).max(Y, x, z)` for cached shapes.
     fn collision_top(&self, b: [i32; 3], fx: f64, fz: f64) -> f64 {
-        let state = self.block(b[0], b[1], b[2]);
+        let state = self.world.block(b[0], b[1], b[2]);
         match self.collision.cached_shapes().cached_shape(state) {
             Ok(Some(shape)) if !shape.is_empty() => shape.max_at(Axis::Y, fx, fz),
             Ok(Some(_)) => 0.0,
-            _ if self.facts.get(state).full_collision => 1.0,
-            _ => 0.0,
+            _ => {
+                if self.facts.get(state).full_collision {
+                    1.0
+                } else {
+                    0.0
+                }
+            }
         }
     }
 }
@@ -2027,6 +2020,73 @@ impl ParticleEngine {
             (eye[0] - pos[0]).powi(2) + (eye[1] - pos[1]).powi(2) + (eye[2] - pos[2]).powi(2) <= 9.0
         })
     }
+    /// `ClientPacketListener.handleParticleEvent` for `ServerLevel.sendParticles`.
+    pub fn send_particles(
+        &mut self,
+        options: &ParticleOptions,
+        at: [f64; 3],
+        spread: [f64; 3],
+        speed: f64,
+        count: u32,
+    ) {
+        if count == 0 {
+            let v = [speed * spread[0], speed * spread[1], speed * spread[2]];
+            self.add(options, at, v);
+            return;
+        }
+        for _ in 0..count {
+            let r = &mut self.random;
+            let p = [
+                at[0] + r.next_gaussian() * spread[0],
+                at[1] + r.next_gaussian() * spread[1],
+                at[2] + r.next_gaussian() * spread[2],
+            ];
+            let v = [
+                r.next_gaussian() * speed,
+                r.next_gaussian() * speed,
+                r.next_gaussian() * speed,
+            ];
+            self.add(options, p, v);
+        }
+    }
+    /// `ParticleEngine.createParticle`: always spawned, but `ParticleEngine.add`
+    /// drops a spore blossom air particle once `ParticleLimit.SPORE_BLOSSOM` is full.
+    pub fn create(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) {
+        if let Some(requests) = &mut self.created_requests {
+            requests.push((options.clone(), p, v));
+            return;
+        }
+        let seed = self.seeds.next_long();
+        if let Some(mut particle) = self.make(options, p, v, seed) {
+            *self.made.entry(options.ty.name()).or_default() += 1;
+            // Resource packs' Polytone particle modifiers (#11486), once as it spawns.
+            if let Some(registry) = &self.polytone
+                && registry.modifies_particles()
+            {
+                let id = match &options.mod_particle {
+                    Some(name) => name.clone(),
+                    None => format!("minecraft:{}", options.ty.name()),
+                };
+                polytone::modify(registry, &id, options.source.as_deref(), &mut particle);
+            }
+            // The provider has drawn, so rejecting here keeps vanilla's RNG order.
+            // shortcut: counts live plus queued particles by scanning instead of
+            // vanilla's counted map; use a counter if spore spawning shows in profiles.
+            if particle.ty == ParticleType::SporeBlossomAir
+                && self.particles.len() + self.pending.len() >= SPORE_BLOSSOM_LIMIT
+                && self
+                    .particles
+                    .iter()
+                    .chain(self.pending.iter())
+                    .filter(|q| q.ty == ParticleType::SporeBlossomAir)
+                    .count()
+                    >= SPORE_BLOSSOM_LIMIT
+            {
+                return;
+            }
+            self.pending.push(particle);
+        }
+    }
     /// How many particles of each type were made so far.
     pub fn made(&self) -> &std::collections::BTreeMap<&'static str, u64> {
         &self.made
@@ -3992,12 +4052,15 @@ impl ParticleEngine {
             }
             Behaviour::Lava => {
                 p.base_tick(level);
-                if !p.removed && p.random.next_float() > p.age as f32 / p.lifetime as f32 {
-                    self.add(
-                        &ParticleOptions::simple(ParticleType::Smoke),
-                        p.position,
-                        p.velocity,
-                    );
+                if !p.removed {
+                    let odds = p.age as f32 / p.lifetime as f32;
+                    if p.random.next_float() > odds {
+                        self.add(
+                            &ParticleOptions::simple(ParticleType::Smoke),
+                            p.position,
+                            p.velocity,
+                        );
+                    }
                 }
             }
             Behaviour::Crit => {
@@ -4081,7 +4144,9 @@ impl ParticleEngine {
                     *c *= f64::from(0.98f32);
                 }
                 if p.on_ground {
-                    p.removed |= p.random.next_float() < 0.5;
+                    if p.random.next_float() < 0.5 {
+                        p.removed = true;
+                    }
                     p.velocity[0] *= f64::from(0.7f32);
                     p.velocity[2] *= f64::from(0.7f32);
                 }
@@ -4121,10 +4186,13 @@ impl ParticleEngine {
             } => {
                 p.base_tick(level);
                 let (fluid, source) = level.fluid_source(ParticleLevel::block_at(p.position));
-                if !(fluid == Fluid::Water && source)
-                    || p.position[1] >= y_end
-                    || p.position[1] <= y_prev
-                {
+                if !(p.removed || (fluid == Fluid::Water && source)) {
+                    p.removed = true;
+                }
+                if !p.removed && p.position[1] >= y_end {
+                    p.removed = true;
+                }
+                if !p.removed && p.position[1] <= y_prev {
                     p.removed = true;
                 }
                 // randomHorizontalWiggling, then a second, horizontal move.
@@ -4148,8 +4216,9 @@ impl ParticleEngine {
                 p.base_tick(level);
                 self.sprite_from_age(p);
                 if p.age as f32 > fade_start {
+                    let frames_since_fade_out_start = p.age as f32 - fade_start;
                     p.rgba[3] =
-                        (p.lifetime as f32 - (p.age as f32 - fade_start)) / p.lifetime as f32;
+                        (p.lifetime as f32 - frames_since_fade_out_start) / p.lifetime as f32;
                 }
             }
             Behaviour::NoxiousGasCloud => {
@@ -4613,7 +4682,7 @@ impl ParticleEngine {
                     self.sprite_from_age(p);
                     half(p);
                     let b = ParticleLevel::block_at(p.position);
-                    if level.facts.is_air(level.block(b[0], b[1], b[2])) {
+                    if level.facts.is_air(level.world.block(b[0], b[1], b[2])) {
                         p.velocity[1] -= f64::from(0.0074f32);
                     }
                 }
@@ -4621,7 +4690,7 @@ impl ParticleEngine {
             Behaviour::Firefly => {
                 p.base_tick(level);
                 let b = ParticleLevel::block_at(p.position);
-                if !level.facts.is_air(level.block(b[0], b[1], b[2])) {
+                if !level.facts.is_air(level.world.block(b[0], b[1], b[2])) {
                     p.removed = true;
                 } else {
                     p.rgba[3] = fade_amount(p.lifetime_progress(p.age as f32), 0.3, 0.5);
@@ -5085,12 +5154,11 @@ fn hdr_tier(ty: ParticleType) -> u8 {
 }
 /// `Particle.LifetimeAlpha.currentAlphaForAge`.
 fn lifetime_alpha(a: [f32; 4], age: i32, lifetime: i32, partial: f32) -> f32 {
-    let t = ((age as f32 + partial) / lifetime as f32 - a[2]) / (a[3] - a[2]);
     if (a[0] - a[1]).abs() < 1.0e-5 {
-        a[0]
-    } else {
-        a[0] + (a[1] - a[0]) * t.clamp(0.0, 1.0)
+        return a[0];
     }
+    let t = ((age as f32 + partial) / lifetime as f32 - a[2]) / (a[3] - a[2]);
+    a[0] + (a[1] - a[0]) * t.clamp(0.0, 1.0)
 }
 
 struct Starter {
@@ -5521,7 +5589,6 @@ mod tests {
             facts: &facts,
             collision: &collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
         engine.set_sprites.push(vec![10, 11, 12]);
@@ -5613,7 +5680,6 @@ mod tests {
             facts: &facts,
             collision: &collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
         let mut particle = Particle::blank(ParticleType::Smoke, [0.0; 3]);

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

@@ -124,7 +124,6 @@ mod tests {
             facts: &facts,
             collision: &collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut e = engine();
         let mut p = e

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

@@ -490,14 +490,14 @@ enum Subject<'a> {
 }
 
 /// What one expression runs against: its subject, the frame and the level.
-struct Ctx<'a, 'l> {
+struct Ctx<'a> {
     subject: Subject<'a>,
     random: &'a mut LegacyRandom,
     custom: &'a mut f64,
     customs: &'a mut BTreeMap<String, f64>,
     frame: &'a Frame,
     registry: &'a Registry,
-    level: Option<&'a ParticleLevel<'l>>,
+    level: Option<&'a ParticleLevel<'a>>,
     blocks: Vec<[i32; 3]>,
 }
 
@@ -515,7 +515,7 @@ fn axis(name: &str) -> usize {
     usize::from(name.as_bytes()[0] - b'x')
 }
 
-impl Ctx<'_, '_> {
+impl Ctx<'_> {
     fn position(&self) -> [f64; 3] {
         match &self.subject {
             Subject::Particle(p) => p.position,
@@ -683,7 +683,7 @@ impl Ctx<'_, '_> {
     }
 }
 
-impl Host for Ctx<'_, '_> {
+impl Host for Ctx<'_> {
     fn root(&mut self, root: Root) -> V {
         match root {
             Root::Object => V::Object(SELF),
@@ -1662,7 +1662,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         // Air has no emitters; the torch fires its first emitter only.
@@ -1702,7 +1701,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         engine.polytone_animate(&level, [1, 64, 1]);
@@ -1724,7 +1722,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         engine.polytone_animate(&level, [1, 64, 1]);
@@ -1770,7 +1767,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let registry = Registry::read(&root, Default::default(), blocks);
         let frame = registry.frame.clone();
@@ -1824,7 +1820,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let registry = Registry::read(&root, Default::default(), blocks);
         let mut engine = engine(registry);
@@ -1858,7 +1853,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         let rect = crate::hud::Rect {
@@ -1911,7 +1905,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         let rect = crate::hud::Rect {
@@ -1973,7 +1966,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         engine.polytone_entity(&level, "minecraft:player", [1.0, 70.0, 1.0]);
@@ -2022,7 +2014,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         let rect = crate::hud::Rect {
@@ -2089,7 +2080,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let registry = Arc::new(Registry::read(&root, Default::default(), blocks));
         // The chunk's biome is id 0: plains, whose foliage is #336699.
@@ -2208,7 +2198,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         engine.polytone_entity(&level, "minecraft:player", [1.5, 70.0, 1.5]);
@@ -2287,7 +2276,6 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
-            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         // The test chunk's biome is the table's first: a cold one first, then a warm one.

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

@@ -1,73 +0,0 @@
-//! Where particles come into the engine: a server's particle packet and a single particle made
-//! where the game asks for one.
-use super::*;
-
-impl ParticleEngine {
-    /// `ClientPacketListener.handleParticleEvent` for `ServerLevel.sendParticles`.
-    pub fn send_particles(
-        &mut self,
-        options: &ParticleOptions,
-        at: [f64; 3],
-        spread: [f64; 3],
-        speed: f64,
-        count: u32,
-    ) {
-        if count == 0 {
-            let v = [speed * spread[0], speed * spread[1], speed * spread[2]];
-            self.add(options, at, v);
-            return;
-        }
-        for _ in 0..count {
-            let r = &mut self.random;
-            let p = [
-                at[0] + r.next_gaussian() * spread[0],
-                at[1] + r.next_gaussian() * spread[1],
-                at[2] + r.next_gaussian() * spread[2],
-            ];
-            let v = [
-                r.next_gaussian() * speed,
-                r.next_gaussian() * speed,
-                r.next_gaussian() * speed,
-            ];
-            self.add(options, p, v);
-        }
-    }
-    /// `ParticleEngine.createParticle`: always spawned, but `ParticleEngine.add`
-    /// drops a spore blossom air particle once `ParticleLimit.SPORE_BLOSSOM` is full.
-    pub fn create(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) {
-        if let Some(requests) = &mut self.created_requests {
-            requests.push((options.clone(), p, v));
-            return;
-        }
-        let seed = self.seeds.next_long();
-        if let Some(mut particle) = self.make(options, p, v, seed) {
-            *self.made.entry(options.ty.name()).or_default() += 1;
-            // Resource packs' Polytone particle modifiers (#11486), once as it spawns.
-            if let Some(registry) = &self.polytone
-                && registry.modifies_particles()
-            {
-                let id = match &options.mod_particle {
-                    Some(name) => name.clone(),
-                    None => format!("minecraft:{}", options.ty.name()),
-                };
-                polytone::modify(registry, &id, options.source.as_deref(), &mut particle);
-            }
-            // The provider has drawn, so rejecting here keeps vanilla's RNG order.
-            // shortcut: counts live plus queued particles by scanning instead of
-            // vanilla's counted map; use a counter if spore spawning shows in profiles.
-            if particle.ty == ParticleType::SporeBlossomAir
-                && self.particles.len() + self.pending.len() >= SPORE_BLOSSOM_LIMIT
-                && self
-                    .particles
-                    .iter()
-                    .chain(self.pending.iter())
-                    .filter(|q| q.ty == ParticleType::SporeBlossomAir)
-                    .count()
-                    >= SPORE_BLOSSOM_LIMIT
-            {
-                return;
-            }
-            self.pending.push(particle);
-        }
-    }
-}

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

@@ -93,7 +93,6 @@ fn particle_tick_cost() {
         facts: &facts,
         collision: &collision,
         player: None,
-        cached_chunk: std::cell::Cell::new(None),
     };
     let ty = |name: &str| ParticleType::from_name(name).unwrap();
     let (fx, fy, fz) = (0.5, f64::from(FLOOR_Y + 5), 20.5);

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

@@ -362,13 +362,6 @@ impl Settings {
             .and_then(|dir| fs::read_to_string(dir.join(crate::extras::FILE)).ok())
             .unwrap_or_default();
         let mut extras = crate::extras::Extras::parse(&extras_text);
-        // The settings stores of the crates above the engine: their lines of this file, or of
-        // their own (docs/layers.md, "Platform registries").
-        horizon_hooks::settings::engine::load(&mut |file| match path.parent() {
-            _ if file == crate::extras::FILE => Some(extras_text.clone()),
-            Some(dir) => fs::read_to_string(dir.join(file)).ok(),
-            None => None,
-        });
         // The enabled mods are the game folder's, shared by its players (`--player-dir`).
         let mods = path
             .parent()
@@ -697,7 +690,6 @@ impl Settings {
             let mut extras = self.extras.clone();
             extras.emote_key = self.keys.get("key.emote").to_owned();
             extras.save(dir);
-            horizon_hooks::settings::engine::save_own(dir, &[crate::extras::FILE]);
             self.mods.save(&crate::logging::shared_dir(dir));
         }
     }
@@ -864,8 +856,6 @@ pub enum Opt {
     PadGameplayGuide,
     /// `options.modelPart.*`: one skin layer (index into `options_file::MODEL_PARTS`).
     ModelPart(usize),
-    /// A slider of a page a crate registered (`horizon_hooks::pages`): (page, row).
-    Page(usize, usize),
     /// 3D skin layers: the player's outer layer as extruded slabs.
     SkinLayers3d,
     MainHand,

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

@@ -192,12 +192,7 @@ impl SignData {
         let side = |t: Option<&Tag>| -> SignText {
             let mut out = SignText::default();
             let Some(t) = t else { return out };
-            if let Some(messages) = t.get("messages") {
-                // `SignText.CODEC` reads a side all or nothing: a messages
-                // field that is not a list leaves the side empty.
-                let Tag::List(messages) = messages else {
-                    return SignText::default();
-                };
+            if let Some(Tag::List(messages)) = t.get("messages") {
                 for (i, m) in messages.iter().take(4).enumerate() {
                     out.lines[i] = component_text(m);
                     out.click[i] = click_event(m);
@@ -312,27 +307,6 @@ pub fn editor_sprite(folder: &str, wood: &str) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
-    /// `SignText.CODEC` reads messages as a list: a string field fails the
-    /// whole side, taking its colour and glow with it.
-    #[test]
-    fn messages_that_are_not_a_list_load_an_empty_side() {
-        let tag = Tag::compound([(
-            "front_text",
-            Tag::compound([
-                ("messages", Tag::String("not a list".into())),
-                ("color", Tag::String("red".into())),
-                ("has_glowing_text", Tag::Byte(1)),
-            ]),
-        )]);
-        let mut decoded = SignData::default();
-        decoded.decode(&tag);
-        assert_eq!(
-            decoded.front,
-            SignText::default(),
-            "a failed message list takes the side's colour and glow with it"
-        );
-    }
-
     #[test]
     fn waxed_and_glowing_text_take_any_number() {
         let tag = Tag::compound([

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

@@ -549,9 +549,6 @@ pub struct Streaming {
     pub mod_forced: HashSet<(i32, i32)>,
     /// No work is scheduled while paused (title screen).
     pub paused: bool,
-    /// Finished meshes the renderer has not taken yet (the game's pending
-    /// uploads): they count against the meshing room as the jobs do.
-    pub upload_backlog: usize,
     /// Dimension flags: sky light, Nether face shading.
     pub sky_light: bool,
     pub nether_shading: bool,
@@ -1065,9 +1062,7 @@ pub struct WorkerContext {
     pub biomes: Arc<crate::biome::Biomes>,
     pub light: Arc<LightTables>,
 }
-mod bounded;
 mod relight_now;
-use bounded::nearest_first;
 impl Streaming {
     pub fn new<G: ChunkGenerator>(
         generator: Arc<G>,
@@ -1152,7 +1147,6 @@ impl Streaming {
             forced: HashSet::new(),
             mod_forced: HashSet::new(),
             paused: false,
-            upload_backlog: 0,
             sky_light: true,
             nether_shading: false,
             shader_pack_lighting: false,
@@ -2089,10 +2083,7 @@ impl Streaming {
         // jobs went stale long before a worker reached them (#3629). What
         // stays dirty is asked for again, from the current centre, as
         // capacity frees; `requeue` then has a small queue to keep close.
-        // Meshes waiting for upload count too: when uploads fall behind (a
-        // low frame rate at a wide distance), meshing on held gigabytes of
-        // them until the system swapped.
-        let room = (self.workers * 32).saturating_sub(self.meshing.len() + self.upload_backlog);
+        let room = (self.workers * 32).saturating_sub(self.meshing.len());
         nearest_first(&mut candidates, room);
         for (_, x, z, sections) in candidates.drain(..) {
             let Some(region) = Self::region(world, x, z) else {
@@ -3030,6 +3021,19 @@ fn light_region_ready(
     }
     true
 }
+/// The nearest `room` of the `candidates`, ordered: the light and mesh
+/// stages submit bounded work, chosen from everything that is ready each
+/// `update`, so what runs is always the nearest of what is left — chosen
+/// again, from the current centre, as capacity frees, the way vanilla's
+/// chunk task queues follow the current ticket levels. The selection is
+/// O(n); the sort orders only what is submitted.
+fn nearest_first<T: Ord>(candidates: &mut Vec<T>, room: usize) {
+    if candidates.len() > room {
+        candidates.select_nth_unstable(room);
+        candidates.truncate(room);
+    }
+    candidates.sort_unstable();
+}
 /// What `keep_unchanged_sections` found changed.
 #[derive(Debug, Default, PartialEq)]
 struct Resent {
@@ -3582,6 +3586,37 @@ mod tests {
         assert_eq!(pops(queue), [None]);
     }
 
+    /// The light and mesh stages submit bounded work, the nearest first:
+    /// what exceeds the room stays dirty, to be chosen again — from the
+    /// current centre — as capacity frees. Submitted whole, the queue once
+    /// held every ready column's jobs and grew with the render distance
+    /// (#3629); ties break by position, so the choice is deterministic.
+    #[test]
+    fn bounded_submission_takes_the_nearest_first() {
+        let candidates: Vec<(i64, i32, i32, u32)> = (0..40i32)
+            .map(|i| {
+                let (x, z) = (i / 8 - 2, i % 8 - 3);
+                (
+                    i64::from((x - 3).pow(2) + (z - 2).pow(2)),
+                    x,
+                    z,
+                    1 << (i % 24),
+                )
+            })
+            .collect();
+        let mut expected = candidates.clone();
+        expected.sort_unstable();
+        let mut none = candidates.clone();
+        nearest_first(&mut none, 0);
+        assert!(none.is_empty());
+        let mut nearest = candidates;
+        nearest_first(&mut nearest, 5);
+        assert_eq!(nearest, expected[..5]);
+        let mut past = expected.clone();
+        nearest_first(&mut past, expected.len() + 10);
+        assert_eq!(past, expected);
+    }
+
     /// What the scheduler counts as ready to light: every neighbour a
     /// finished column, or a decorated proto chunk past the area — the
     /// walk `light_region` makes without its snapshot.

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

@@ -1,52 +0,0 @@
-//! Bounded submission: the light and mesh stages hand the workers only the
-//! nearest of what is ready.
-
-/// The nearest `room` of the `candidates`, ordered: the light and mesh
-/// stages submit bounded work, chosen from everything that is ready each
-/// `update`, so what runs is always the nearest of what is left — chosen
-/// again, from the current centre, as capacity frees, the way vanilla's
-/// chunk task queues follow the current ticket levels. The selection is
-/// O(n); the sort orders only what is submitted.
-pub(super) fn nearest_first<T: Ord>(candidates: &mut Vec<T>, room: usize) {
-    if candidates.len() > room {
-        candidates.select_nth_unstable(room);
-        candidates.truncate(room);
-    }
-    candidates.sort_unstable();
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// The light and mesh stages submit bounded work, the nearest first:
-    /// what exceeds the room stays dirty, to be chosen again — from the
-    /// current centre — as capacity frees. Submitted whole, the queue once
-    /// held every ready column's jobs and grew with the render distance
-    /// (#3629); ties break by position, so the choice is deterministic.
-    #[test]
-    fn bounded_submission_takes_the_nearest_first() {
-        let candidates: Vec<(i64, i32, i32, u32)> = (0..40i32)
-            .map(|i| {
-                let (x, z) = (i / 8 - 2, i % 8 - 3);
-                (
-                    i64::from((x - 3).pow(2) + (z - 2).pow(2)),
-                    x,
-                    z,
-                    1 << (i % 24),
-                )
-            })
-            .collect();
-        let mut expected = candidates.clone();
-        expected.sort_unstable();
-        let mut none = candidates.clone();
-        nearest_first(&mut none, 0);
-        assert!(none.is_empty());
-        let mut nearest = candidates;
-        nearest_first(&mut nearest, 5);
-        assert_eq!(nearest, expected[..5]);
-        let mut past = expected.clone();
-        nearest_first(&mut past, expected.len() + 10);
-        assert_eq!(past, expected);
-    }
-}

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

@@ -138,10 +138,6 @@ fn scaling(sprite: &str, r: &Rect) -> NineSlice {
             | "horizon/jei/button_disabled_v2"
             | "horizon/jei/button_highlight_v2" => [6; 4],
             "horizon/jei/search_background_v2" => [6; 4],
-            "horizon/jei/interactive_ingredient_tooltip_background" => [16; 4],
-            "horizon/jei/recipe_preview_background_v2" => [16; 4],
-            "horizon/jei/scrollbar_background_v2" => [6; 4],
-            "horizon/jei/scrollbar_marker_v2" => [2, 2, 2, 1],
             "gui/sprites/widget/button"
             | "gui/sprites/widget/button_highlighted"
             | "gui/sprites/widget/button_disabled" => [3; 4],
@@ -810,14 +806,8 @@ fn slider_sprites(hover: bool, active: bool, dragging: bool) -> (&'static str, &
     slider_sprites_ext(hover, active, false, false, dragging)
 }
 
-/// `AbstractSliderButton.getSprite` and `getHandleSprite`: the track outline
-/// lights while the slider is focused and its value cannot change
-/// (`isActive() && isFocused() && !canChangeValue`), the handle while it is
-/// hovered or its value can change (`isActive() && (isHovered || canChangeValue)`).
-/// `canChangeValue` is set when the slider is focused with the mouse or Tab and
-/// flipped by Enter (`setFocused`, `keyPressed`): Horizon's `can_change_value`
-/// for the keyboard, and a drag for the mouse, which focuses it with the value
-/// free to change. So a dragged slider keeps its plain track.
+/// Track and handle sprites: the track outline shows while dragged or focused with
+/// keyboard navigation (!can_change_value), hovering or editing highlights the handle.
 fn slider_sprites_ext(
     hover: bool,
     active: bool,
@@ -825,13 +815,12 @@ fn slider_sprites_ext(
     can_change_value: bool,
     dragging: bool,
 ) -> (&'static str, &'static str) {
-    let can_change_value = can_change_value || dragging;
-    let track = if active && focused && !can_change_value {
+    let track = if dragging || (active && focused && !can_change_value) {
         "gui/sprites/widget/slider_highlighted"
     } else {
         "gui/sprites/widget/slider"
     };
-    let handle = if active && (hover || can_change_value) {
+    let handle = if active && (hover || can_change_value || dragging) {
         "gui/sprites/widget/slider_handle_highlighted"
     } else {
         "gui/sprites/widget/slider_handle"
@@ -1238,9 +1227,6 @@ pub struct EditBox {
     /// Grey completion shown after the text (EditBox.setSuggestion).
     pub suggestion: Option<String>,
     pub text_color: u32,
-    /// `EditBox.setCentered`: the text starts in the middle of the box's
-    /// width, not at its left edge (`BookSignScreen`'s title).
-    pub centered: bool,
     /// `EditBox.textColorUneditable`: the colour of a box `setEditable(false)`
     /// made read-only, which still shows its value and caret.
     pub text_color_uneditable: u32,
@@ -1539,7 +1525,6 @@ impl EditBox {
             focused_at: Instant::now(),
             suggestion: None,
             text_color: rgba(224, 224, 224, 255),
-            centered: false,
             text_color_uneditable: rgba(112, 112, 112, 255),
             editable: true,
             message: String::new(),
@@ -1563,16 +1548,6 @@ impl EditBox {
             self.y
         }
     }
-    /// `EditBox.updateTextPosition`: where the text starts, `(width - text
-    /// width) / 2` in for a centred box (vanilla's `textX`), else at
-    /// `text_x` (4 in from a border).
-    pub fn text_start_x(&self, text_width: f32) -> f32 {
-        if self.centered {
-            self.x + ((self.width - text_width) / 2.0).floor()
-        } else {
-            self.text_x()
-        }
-    }
     pub fn reset_blink(&mut self) {
         self.focused_at = Instant::now();
     }
@@ -1655,13 +1630,8 @@ impl EditBox {
     /// EditBox.findClickedPositionInText: the character boundary under GUI `x`.
     pub fn position_at(&mut self, atlas: &HudAtlas, x: f32) -> usize {
         self.layout(atlas);
+        let room = (x.floor() - self.text_x()).min(self.inner_width());
         let rest: String = self.value.chars().skip(self.display).collect();
-        let shown: String = rest
-            .chars()
-            .take(atlas.font.fit(&rest, self.inner_width()))
-            .collect();
-        let start = self.text_start_x(atlas.font.width_text(&Text::literal(shown.as_str())));
-        let room = (x.floor() - start).min(self.inner_width());
         self.display + atlas.font.fit(&rest, room)
     }
     /// EditBox.onClick: the cursor to the pointer, extending the selection
@@ -1868,12 +1838,7 @@ impl EditBox {
                 ),
             }
         };
-        let start = if self.centered {
-            self.text_start_x(atlas.font.width_text(&Text::literal(displayed.as_str())))
-        } else {
-            self.text_x()
-        };
-        let (tx, ty) = (start, self.text_y());
+        let (tx, ty) = (self.text_x(), self.text_y());
         let mut draw_x = tx;
         if !displayed.is_empty() {
             let half = if on_screen {
@@ -2206,38 +2171,17 @@ mod tests {
         }
     }
 
-    /// `AbstractSliderButton.getSprite`/`getHandleSprite`: a focused slider
-    /// whose value can't change lights its track, a hovered one or one whose
-    /// value can change (Tab or Enter, or the mouse's drag) lights its handle.
     #[test]
-    fn slider_sprites_follow_focus_and_the_drag() {
-        // Hovered, at rest: plain track, lit handle.
+    fn slider_track_is_outlined_only_while_dragged() {
         let (track, handle) = slider_sprites(true, true, false);
         assert_eq!(track, "gui/sprites/widget/slider");
         assert_eq!(handle, "gui/sprites/widget/slider_handle_highlighted");
-        // Dragged: still a plain track, lit handle.
         let (track, handle) = slider_sprites(true, true, true);
-        assert_eq!(track, "gui/sprites/widget/slider");
-        assert_eq!(handle, "gui/sprites/widget/slider_handle_highlighted");
-        // Focused with the arrow keys: the value can't change, the track lights.
-        let (track, handle) = slider_sprites_ext(false, true, true, false, false);
         assert_eq!(track, "gui/sprites/widget/slider_highlighted");
-        assert_eq!(handle, "gui/sprites/widget/slider_handle");
-        // Focused with Tab, or Enter pressed on it: the value can change, the handle lights.
-        let (track, handle) = slider_sprites_ext(false, true, true, true, false);
-        assert_eq!(track, "gui/sprites/widget/slider");
         assert_eq!(handle, "gui/sprites/widget/slider_handle_highlighted");
-        // Focused while the mouse drags: the track stays plain.
-        let (track, _) = slider_sprites_ext(true, true, true, false, true);
-        assert_eq!(track, "gui/sprites/widget/slider");
-        // Not hovered, not dragged: nothing is lit.
         let (track, handle) = slider_sprites(false, true, false);
         assert_eq!(track, "gui/sprites/widget/slider");
         assert_eq!(handle, "gui/sprites/widget/slider_handle");
-        // An inactive slider highlights neither, even when focused.
-        let (track, handle) = slider_sprites_ext(true, false, true, true, true);
-        assert_eq!(track, "gui/sprites/widget/slider");
-        assert_eq!(handle, "gui/sprites/widget/slider_handle");
     }
     #[test]
     fn separator_tiles_sample_both_rows_and_clip_the_last_column() {
@@ -2674,19 +2618,4 @@ mod tests {
         assert!(edit.key(winit::keyboard::KeyCode::Backspace, false, false));
         assert_eq!(edit.value, "name");
     }
-
-    /// `EditBox.setCentered` (`BookSignScreen`'s title box): with the flag the
-    /// text starts `(width - text width) / 2` in, which is also where a click
-    /// maps; without it the text starts at the box's left edge.
-    #[test]
-    fn a_centred_box_starts_its_text_in_the_middle() {
-        let mut edit = EditBox::new(10.0, 0.0, 114.0, 9.0);
-        edit.bordered = false;
-        assert_eq!(edit.text_start_x(0.0), 10.0);
-        edit.centered = true;
-        assert_eq!(edit.text_start_x(0.0), 67.0);
-        assert_eq!(edit.text_start_x(18.0), 58.0);
-        // (114 - 5) / 2 = 54.5, rounded down.
-        assert_eq!(edit.text_start_x(5.0), 64.0);
-    }
 }

crates/horizon-client/Cargo.toml

@@ -39,6 +39,8 @@ horizon-chat-filter = { path = "../horizon-chat-filter" }
 horizon-shaders = { path = "../horizon-shaders" }
 # Horizon's own shader packs: the format, the stages and the check (docs/shaders.md).
 horizon-shader-api = { path = "../horizon-shader-api" }
+# Play with Friends: invite codes and their tunnel; the `friends` feature.
+horizon-friends = { path = "../horizon-friends", optional = true }
 # The narrator (GameNarrator): text-to-speech of chat, system messages and screens.
 horizon-narrator = { path = "../horizon-narrator" }
 # Horizon mods: sandboxed WebAssembly components, off unless installed and turned on (docs/mods.md).
@@ -117,14 +119,15 @@ audio = ["horizon-client-render/audio", "horizon-client-lib/audio"]
 controllers = ["horizon-client-lib/controllers", "dep:gilrs", "dep:horizon-dualsense", "horizon-client-input/controllers"]
 # Horizon's own extras over the vanilla game, for a fork that wants them out (docs/forking.md):
 # cosmetics and emotes, the "Horizon player" presence, the official server added to
-# the server list, the Horizon Settings and Mods pages, Discord and Play with Friends, and ray
-# tracing on request (`HORIZON_RAY_TRACING=1`). Players always get them; there is no switch. `grep -rn horizon-extras crates/` lists
+# the server list, the Horizon Settings and Mods pages, Discord and Play with Friends. Players always get them; there is no switch. `grep -rn horizon-extras crates/` lists
 # every place it gates. Without it (`--no-default-features --features audio,controllers`) the
 # client is best effort: CI builds only the default.
-horizon-extras = ["horizon-client-lib/horizon-extras", "horizon-client-render/horizon-extras", "discord"]
+horizon-extras = ["discord", "friends"]
 # Online extras a server or a port can leave out; the server build has none of them. "Playing Horizon"
 # on Discord (game/discord.rs).
 discord = ["horizon-client-lib/discord"]
+# Play with Friends: sharing a world behind an invite code (game/friends.rs) and joining one.
+friends = ["horizon-client-lib/friends", "dep:horizon-friends"]
 # Records the call sites of mob random draws (`mob_ai_probe` traces).
 rng-trace = ["horizon-core/rng-trace", "horizon-client-lib/rng-trace"]
 # Rust's allocations go to the system heap instead of mimalloc, where heap profilers that replace

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Lig skaduwees na jou skerm se donkerste swart. 0: suiwer swart, geen ligting.",
   "How bright highlights get. Auto: the peak your system reports.": "Hoe helder hoogtepunte word. Outo: die hoogtepunt wat jou stelsel rapporteer.",
   "How bright white looks in the world. Auto: your desktop's white.": "Hoe helder wit in die wêreld lyk. Outo: jou lessenaar se wit.",
+  "How bright the HUD and menus are, against paper white.": "Hoe helder die HUD en spyskaarte is, teenoor papierwit.",
   "How far mobs, crops and machines keep working. CPU time.": "Hoe ver skare, gewasse en masjiene aanhou werk. SVE tyd.",
   "How far away mobs and items are drawn, as a share of normal.": "Hoe ver weg skares en items getrek word, as 'n deel van normaal.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Slaan terrein oor wat agter geslote gedeeltes versteek is. Af kos baie.",
@@ -366,6 +367,7 @@
   "Advanced": "Gevorderd",
   "Undo": "Ontdoen",
   "Search options": "Soek opsies",
+  "Shortcut": "Kortpad",
   "Distance": "Afstand",
   "Display": "Vertoon",
   "Interface": "Koppelvlak",
@@ -436,9 +438,11 @@
   "Calibrate...": "Kalibreer...",
   "Calibrate Anyway...": "Kalibreer in elk geval...",
   "Use Automatic Setup": "Gebruik outomatiese opstelling",
+  "Shortcut: %s": "Kortpad: %s",
   "Next": "Volgende",
   "HDR Calibration %s/%s: %s": "HDR-kalibrasie %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Stel die drie hieronder volskerm, een toetsprent op 'n slag.",
+  "A key that opens this screen from the game. Not bound at first.": "'n Sleutel wat hierdie skerm vanaf die speletjie oopmaak. Eers nie gebonde nie.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Jou skerm het nie gesê hoe helder dit word nie: kalibreer om dit op te stel.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Reeds opgestel vir jou vertoning. Kalibreer slegs as HDR verkeerd lyk.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Plaas Peak Brightness en Paper White terug na jou skerm se opstelling.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Vanlyn profiele behoort aan hierdie geval",
   "horizon.splitscreen.profiles.move": "Beweeg waar jy speel",
   "horizon.splitscreen.profiles.move_place": "Beweeg waar jy speel: %s",
+  "horizon.friends.title": "Speel met vriende",
+  "horizon.friends.hint": "Vriende plak die kode na die titelskerm se Vriende-knoppie, in Direkte verbinding, of op die lanseerder se Speel-bladsy.",
+  "horizon.friends.copied": "Gekopieer",
+  "horizon.friends.copy_code": "Kopieer kode",
+  "horizon.friends.stop_sharing": "Hou op deel",
+  "horizon.friends.none_yet": "Nog geen vriende hier nie.",
+  "horizon.friends.here_now": "Hier nou: %s",
+  "horizon.friends.share_intro": "Deel hierdie wêreld agter 'n uitnodigingskode: dit maak oop na LAN, en vriende op die internet sluit aan met die kode. Geen bediener van ons is betrokke nie.",
+  "horizon.friends.start_sharing": "Begin deel",
+  "horizon.friends.troubleshooting": "Foutsporing …",
+  "horizon.friends.stopped": "Het opgehou om die uitnodigingkode te deel.",
+  "horizon.friends.short_code_changed": "Iemand het aanhou om 'n verkeerde kort kode te probeer, so dit het verander.",
+  "horizon.friends.wrong_code": "Iemand het 'n verkeerde kode probeer.",
+  "horizon.friends.relay_stopped": "Te veel verkeerde kort kodes, so die aflos is af totdat jy weer deel. Vriende kan steeds met die volle kode aansluit.",
+  "horizon.friends.code_ready": "Jou uitnodigingskode is gereed: Speletjie-kieslys, Speel met vriende. Kopieer dit en stuur dit aan jou vriende.",
+  "horizon.friends.share_failed": "Kon nie die wêreld deel nie: %s",
+  "horizon.friends.finding_route": "Vind tans hoe vriende jou kan bereik …",
   "horizon.osk.shift": "Verskuiwing",
   "horizon.osk.space": "Ruimte",
   "horizon.osk.delete": "Vee uit",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "يرفع الظلال إلى أغمق أسود في شاشتك. 0: أسود حقيقي، دون رفع.",
   "How bright highlights get. Auto: the peak your system reports.": "كيف تحصل على النقاط البارزة الساطعة. تلقائي: ذروة تقارير النظام الخاص بك.",
   "How bright white looks in the world. Auto: your desktop's white.": "مدى سطوع الأبيض في العالم. تلقائي: أبيض سطح المكتب.",
+  "How bright the HUD and menus are, against paper white.": "مدى سطوع شاشة HUD والقوائم مقابل الورق الأبيض.",
   "How far mobs, crops and machines keep working. CPU time.": "إلى أي مدى يستمر الغوغاء والمحاصيل والآلات في العمل. وقت وحدة المعالجة المركزية.",
   "How far away mobs and items are drawn, as a share of normal.": "إلى أي مدى يتم رسم الغوغاء والعناصر، كنسبة من المعدل الطبيعي.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "يتخطى التضاريس المخفية خلف الأقسام المغلقة. قبالة تكاليف الكثير.",
@@ -366,6 +367,7 @@
   "Advanced": "متقدم",
   "Undo": "تراجع",
   "Search options": "خيارات البحث",
+  "Shortcut": "الاختصار",
   "Distance": "المسافة",
   "Display": "عرض",
   "Interface": "واجهة",
@@ -436,9 +438,11 @@
   "Calibrate...": "معايرة...",
   "Calibrate Anyway...": "معايرة على أية حال...",
   "Use Automatic Setup": "استخدم الإعداد التلقائي",
+  "Shortcut: %s": "الاختصار: %s",
   "Next": "التالي",
   "HDR Calibration %s/%s: %s": "معايرة HDR %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "لتعيين الصور الثلاثة أدناه بملء الشاشة، صورة اختبارية واحدة في كل مرة.",
+  "A key that opens this screen from the game. Not bound at first.": "المفتاح الذي يفتح هذه الشاشة من اللعبة. غير ملزمة في البداية.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "لم توضح شاشتك مدى سطوعها: قم بالمعايرة لإعدادها.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "تم إعداده بالفعل للعرض الخاص بك. قم بالمعايرة فقط إذا كان تقرير HDR يبدو خاطئًا.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "يعيد ذروة السطوع والورق الأبيض إلى إعداد شاشتك.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "تنتمي الملفات الشخصية غير المتصلة بالإنترنت إلى هذه الحالة",
   "horizon.splitscreen.profiles.move": "تحرك حيث تلعب",
   "horizon.splitscreen.profiles.move_place": "تحرك حيث تلعب: %s",
+  "horizon.friends.title": "العب مع الأصدقاء",
+  "horizon.friends.hint": "يقوم الأصدقاء بلصق الرمز بعد زر الأصدقاء على شاشة العنوان، أو في الاتصال المباشر، أو على صفحة التشغيل الخاصة بالمشغل.",
+  "horizon.friends.copied": "منقول",
+  "horizon.friends.copy_code": "نسخ الرمز",
+  "horizon.friends.stop_sharing": "توقف عن المشاركة",
+  "horizon.friends.none_yet": "لا يوجد أصدقاء هنا بعد.",
+  "horizon.friends.here_now": "هنا الآن: %s",
+  "horizon.friends.share_intro": "شارك هذا العالم خلف رمز الدعوة: فهو يفتح على شبكة LAN، وينضم الأصدقاء على الإنترنت باستخدام الرمز. لا يوجد خادم خاص بنا متورط.",
+  "horizon.friends.start_sharing": "ابدأ المشاركة",
+  "horizon.friends.troubleshooting": "استكشاف الأخطاء وإصلاحها...",
+  "horizon.friends.stopped": "تم إيقاف مشاركة رمز الدعوة.",
+  "horizon.friends.short_code_changed": "استمر شخص ما في تجربة رمز قصير خاطئ، لذلك تغير.",
+  "horizon.friends.wrong_code": "حاول شخص ما رمزا خاطئا.",
+  "horizon.friends.relay_stopped": "رموز قصيرة خاطئة كثيرة، لذا أُوقف التتابع حتى تشارك مجددًا. يمكن للأصدقاء الانضمام بالرمز الكامل.",
+  "horizon.friends.code_ready": "رمز الدعوة الخاص بك جاهز: قائمة الألعاب، العب مع الأصدقاء. انسخها وأرسلها إلى أصدقائك.",
+  "horizon.friends.share_failed": "لا يمكن مشاركة العالم: %s",
+  "horizon.friends.finding_route": "التعرف على كيفية وصول الأصدقاء إليك...",
   "horizon.osk.shift": "التحول",
   "horizon.osk.space": "الفضاء",
   "horizon.osk.delete": "حذف",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Kölgələri ekranınızın ən tünd qarasına qaldırır. 0: həqiqi qara, qaldırma yoxdur.",
   "How bright highlights get. Auto: the peak your system reports.": "Parlaq məqamlar necə əldə edilir. Avtomatik: sisteminizin ən yüksək hesabatı.",
   "How bright white looks in the world. Auto: your desktop's white.": "Dünyada ağ rəngin nə qədər parlaq göründüyü. Avtomatik: iş masanızın ağı.",
+  "How bright the HUD and menus are, against paper white.": "HUD və menyular ağ kağıza qarşı nə qədər parlaqdır.",
   "How far mobs, crops and machines keep working. CPU time.": "Kütlələr, məhsullar və maşınlar nə qədər işləməyə davam edir. CPU vaxtı.",
   "How far away mobs and items are drawn, as a share of normal.": "Nə qədər uzağa mob və əşyalar çəkilir, normal bir pay olaraq.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Qapalı hissələrin arxasında gizlənmiş ərazini ötür. Sıxılma çox baha başa gəlir.",
@@ -366,6 +367,7 @@
   "Advanced": "Qabaqcıl",
   "Undo": "Geri alın",
   "Search options": "Axtarış seçimləri",
+  "Shortcut": "Qısayol",
   "Distance": "Məsafə",
   "Display": "Ekran",
   "Interface": "İnterfeys",
@@ -436,9 +438,11 @@
   "Calibrate...": "Kalibrləmə...",
   "Calibrate Anyway...": "İstənilən halda kalibrləyin...",
   "Use Automatic Setup": "Avtomatik Quraşdırmadan istifadə edin",
+  "Shortcut: %s": "Qısayol: %s",
   "Next": "Sonrakı",
   "HDR Calibration %s/%s: %s": "HDR Kalibrləmə %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Aşağıdakı üç tam ekranı, hər dəfə bir sınaq şəklini təyin edir.",
+  "A key that opens this screen from the game. Not bound at first.": "Oyundan bu ekranı açan açar. Əvvəlcə bağlı deyil.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Ekranınız nə qədər parlaq olduğunu deməyib: onu qurmaq üçün kalibrləyin.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Ekranınız üçün artıq qurulub. Yalnız HDR səhv görünürsə kalibrləyin.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Pik Parlaqlığı və Kağız Ağı ekranınızın quraşdırılmasına qaytarır.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Oflayn profillər bu instansiyaya aiddir",
   "horizon.splitscreen.profiles.move": "Oynadığınız yerdə hərəkət edin",
   "horizon.splitscreen.profiles.move_place": "Oynadığınız yerə köçürün: %s",
+  "horizon.friends.title": "Dostlarla oynayın",
+  "horizon.friends.hint": "Dostlar kodu başlıq ekranının Dostlar düyməsindən sonra, Birbaşa Bağlantıda və ya başlatma qurğusunun Play səhifəsində yerləşdirin.",
+  "horizon.friends.copied": "Kopyalandı",
+  "horizon.friends.copy_code": "Kodu kopyalayın",
+  "horizon.friends.stop_sharing": "Paylaşmağı dayandırın",
+  "horizon.friends.none_yet": "Burada hələ dost yoxdur.",
+  "horizon.friends.here_now": "İndi burada: %s",
+  "horizon.friends.share_intro": "Bu dünyanı dəvət kodunun arxasında paylaşın: o, LAN-a açılır və internetdəki dostlar kodla qoşulur. Heç bir serverimiz iştirak etmir.",
+  "horizon.friends.start_sharing": "Paylaşmağa başlayın",
+  "horizon.friends.troubleshooting": "Problem həll olunur...",
+  "horizon.friends.stopped": "Dəvət kodunu paylaşmağı dayandırdı.",
+  "horizon.friends.short_code_changed": "Kimsə səhv qısa kodu sınamağa davam etdi, ona görə də dəyişdi.",
+  "horizon.friends.wrong_code": "Kimsə səhv kodu sınadı.",
+  "horizon.friends.relay_stopped": "Çox sayda yanlış qısa kod daxil edildi, ona görə yenidən paylaşana qədər rele söndürülüb. Dostlar hələ də tam kodla qoşula bilər.",
+  "horizon.friends.code_ready": "Dəvət kodunuz hazırdır: Oyun Menyu, Dostlarla Oyna. Kopyalayın və dostlarınıza göndərin.",
+  "horizon.friends.share_failed": "Dünyanı paylaşmaq mümkün olmadı: %s",
+  "horizon.friends.finding_route": "Dostların sizinlə necə əlaqə saxlaya biləcəyi tapılır...",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Kosmos",
   "horizon.osk.delete": "Sil",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Күләгәләрҙе дисплейығыҙҙың иң ҡара ҡараһына күтәрә. 0: ысын ҡара, күтәреү юҡ.",
   "How bright highlights get. Auto: the peak your system reports.": "Нисек сағыу өҫтөнлөктәр ала. Авто: пик һеҙҙең система отчеттар.",
   "How bright white looks in the world. Auto: your desktop's white.": "Донъяла аҡ ни тиклем сағыу күренә. Авто: эш өҫтәлегеҙҙең ағы.",
+  "How bright the HUD and menus are, against paper white.": "Нисек сағыу HUD һәм менюлар, ҡағыҙ аҡ ҡаршы.",
   "How far mobs, crops and machines keep working. CPU time.": "Күпме алыҫҡа мобтар, культуралар һәм машиналар эшләп тора. Процессор ваҡыты.",
   "How far away mobs and items are drawn, as a share of normal.": "Нисек алыҫҡа мобтар һәм әйберҙәр тартыла, өлөшө булараҡ нормаль.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Ябыҡ участкалар артында йәшеренгән ерҙәрҙе һикерә. Офф күп сығымдар талап итә.",
@@ -366,6 +367,7 @@
   "Advanced": "Алдынғы",
   "Undo": "Кире ҡайтарыу",
   "Search options": "Эҙләү варианттары",
+  "Shortcut": "Ярлыҡ",
   "Distance": "Арауыҡ",
   "Display": "Дисплей",
   "Interface": "Интерфейс",
@@ -436,9 +438,11 @@
   "Calibrate...": "Калибрлау...",
   "Calibrate Anyway...": "Калибрлау барыбер...",
   "Use Automatic Setup": "Автоматик ҡуйыуҙы ҡулланыу",
+  "Shortcut: %s": "Ҡыҫҡа юл: %s",
   "Next": "Артабан",
   "HDR Calibration %s/%s: %s": "HDR калибровкаһы %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Өс аҫтында тулы экран ҡуя, бер һынау һүрәте бер юлы.",
+  "A key that opens this screen from the game. Not bound at first.": "Уйындан был экранды асҡан асҡыс. Тәүҙә бәйләнмәгән.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Һеҙҙең дисплей нисек яҡты ала, тип әйтмәне: калибровка, уны ҡуйырға.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Һеҙҙең дисплей өсөн инде ҡуйылған. Тик калибровка, әгәр HDR дөрөҫ түгел күренә.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Ҡуя Пик Яркость һәм Ҡағыҙ Аҡ кире һеҙҙең дисплей’ы ҡороу.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Офлайн профилдәр был данаға ҡарай",
   "horizon.splitscreen.profiles.move": "Уйнаған ергә күсерегеҙ .",
   "horizon.splitscreen.profiles.move_place": "Уйнаған урынға күсегеҙ: %s .",
+  "horizon.friends.title": "Дуҫтар менән уйнау .",
+  "horizon.friends.hint": "Дуҫтар кодты титул экранының «Дуҫтар» төймәһенән һуң, туранан-тура бәйләнештә йәки стартердың «Уйнау» битендә йәбештерә.",
+  "horizon.friends.copied": "Күсерелгән",
+  "horizon.friends.copy_code": "Код күсермәһе",
+  "horizon.friends.stop_sharing": "Бүлешеүҙе туҡтатығыҙ",
+  "horizon.friends.none_yet": "Бында әлегә дуҫтар юҡ.",
+  "horizon.friends.here_now": "Бында хәҙер: %s",
+  "horizon.friends.share_intro": "Был донъя менән бүлешергә артында саҡырыу коды: ул LAN асыла, һәм дуҫтар интернетта код менән ҡушыла. Беҙҙең бер сервер ҙа ҡатнашмай.",
+  "horizon.friends.start_sharing": "Бүлешергә башлағыҙ",
+  "horizon.friends.troubleshooting": "Неисправность...",
+  "horizon.friends.stopped": "Саҡырыу коды менән бүлешеүҙе туҡтатты.",
+  "horizon.friends.short_code_changed": "Кемдер дөрөҫ булмаған ҡыҫҡа кодты һынап ҡараны, шуға күрә ул үҙгәрҙе.",
+  "horizon.friends.wrong_code": "Кемдер дөрөҫ булмаған кодты ҡулланып ҡараған.",
+  "horizon.friends.relay_stopped": "Дөрөҫ булмаған ҡыҫҡа кодтар бик күп булды, шуға күрә ҡабат бүлешкәнгә тиклем реле һүндерелгән. Дуҫтар тулы код менән килеүен дауам итә ала.",
+  "horizon.friends.code_ready": "Һеҙҙең саҡырыу коды әҙер: Уйын Менюһы, Дуҫтар менән уйнау. Күсереп яҙып, дуҫтарығыҙға ебәрегеҙ.",
+  "horizon.friends.share_failed": "Донъяны бүлешә алманым: %s",
+  "horizon.friends.finding_route": "Һеҙгә дуҫтар нисек барып етә алыуын табыу...",
   "horizon.osk.shift": "Смена",
   "horizon.osk.space": "Йыһан",
   "horizon.osk.delete": "Юйырға",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Падымае цені да самага цёмнага чорнага вашага дысплея. 0: сапраўдны чорны, без пад'ёму.",
   "How bright highlights get. Auto: the peak your system reports.": "Якія яркія моманты становяцца. Аўта: пік, пра які паведамляе ваша сістэма.",
   "How bright white looks in the world. Auto: your desktop's white.": "Наколькі ярка выглядае белы ў свеце. Аўто: белы колер вашага працоўнага стала.",
+  "How bright the HUD and menus are, against paper white.": "Наколькі яркія HUD і меню на фоне белай паперы.",
   "How far mobs, crops and machines keep working. CPU time.": "Як далёка працягваюць працаваць мобы, ураджай і машыны. працэсарны час.",
   "How far away mobs and items are drawn, as a share of normal.": "Наколькі далёка намаляваны мобы і прадметы ў долі звычайнага.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Прапускае мясцовасць, схаваную за закрытымі ўчасткамі. Off каштуе шмат.",
@@ -366,6 +367,7 @@
   "Advanced": "Пашыраны",
   "Undo": "Адмяніць",
   "Search options": "Параметры пошуку",
+  "Shortcut": "Ярлык",
   "Distance": "Дыстанцыя",
   "Display": "Дысплей",
   "Interface": "Інтэрфейс",
@@ -436,9 +438,11 @@
   "Calibrate...": "Адкалібраваць...",
   "Calibrate Anyway...": "Усё роўна адкалібраваць...",
   "Use Automatic Setup": "Выкарыстоўвайце аўтаматычную наладу",
+  "Shortcut: %s": "Ярлык: %s",
   "Next": "Далей",
   "HDR Calibration %s/%s: %s": "Каліброўка HDR %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Устанаўлівае тры ніжэй на ўвесь экран, па адным тэставым малюнку.",
+  "A key that opens this screen from the game. Not bound at first.": "Ключ, які адкрывае гэты экран з гульні. Спачатку не звязаны.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "На вашым дысплеі не пазначана, наколькі ён яркім: адкалібруйце, каб наладзіць яго.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Ужо наладжана для вашага дысплея. Калібруйце, толькі калі HDR выглядае няправільна.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Вяртае пікавую яркасць і папяровы белы ў налады вашага дысплея.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Афлайн-профілі належаць да гэтага асобніка",
   "horizon.splitscreen.profiles.move": "Рухайцеся туды, дзе гуляеце",
   "horizon.splitscreen.profiles.move_place": "Рухайцеся туды, дзе вы гуляеце: %s",
+  "horizon.friends.title": "Гуляць з сябрамі",
+  "horizon.friends.hint": "Сябры ўстаўце код пасля кнопкі \"Сябры\" на тытульным экране ў раздзеле \"Прамое злучэнне\" або на старонцы \"Прайграванне\" праграмы запуску.",
+  "horizon.friends.copied": "Скапіравана",
+  "horizon.friends.copy_code": "Скапіруйце код",
+  "horizon.friends.stop_sharing": "Спыніць абагульванне",
+  "horizon.friends.none_yet": "Тут пакуль няма сяброў.",
+  "horizon.friends.here_now": "Вось зараз: %s",
+  "horizon.friends.share_intro": "Падзяліцеся гэтым светам за кодам запрашэння: ён адкрываецца ў лакальнай сеткі, і сябры ў Інтэрнэце далучаюцца з кодам. Наш сервер не задзейнічаны.",
+  "horizon.friends.start_sharing": "Пачніце абагульваць",
+  "horizon.friends.troubleshooting": "Ліквідацыя непаладак...",
+  "horizon.friends.stopped": "Абагульванне кода запрашэння спынена.",
+  "horizon.friends.short_code_changed": "Хтосьці спрабаваў увесці няправільны кароткі код, таму ён змяніўся.",
+  "horizon.friends.wrong_code": "Хтосьці паспрабаваў увесці няправільны код.",
+  "horizon.friends.relay_stopped": "Занадта шмат няправільных кароткіх кодаў, таму рэле выключана, пакуль вы не падзеліцеся зноў. Сябры ўсё яшчэ могуць далучыцца з поўным кодам.",
+  "horizon.friends.code_ready": "Ваш код запрашэння гатовы: меню гульні, гульня з сябрамі. Скапіруйце яго і адпраўце сваім сябрам.",
+  "horizon.friends.share_failed": "Не атрымалася падзяліцца светам: %s",
+  "horizon.friends.finding_route": "Пошук, як сябры могуць звязацца з вамі...",
   "horizon.osk.shift": "зрух",
   "horizon.osk.space": "космас",
   "horizon.osk.delete": "Выдаліць",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Повдига сенките до най-тъмното черно на вашия дисплей. 0: истинско черно, без повдигане.",
   "How bright highlights get. Auto: the peak your system reports.": "Колко ярки стават акцентите. Автоматично: пикът, който вашата система отчита.",
   "How bright white looks in the world. Auto: your desktop's white.": "Колко ярко изглежда бялото в света. Авто: бялото на вашия работен плот.",
+  "How bright the HUD and menus are, against paper white.": "Колко ярки са HUD и менютата на бяла хартия.",
   "How far mobs, crops and machines keep working. CPU time.": "Докъде продължават да работят тълпите, културите и машините. процесорно време.",
   "How far away mobs and items are drawn, as a share of normal.": "Колко далеч са изтеглени тълпите и предметите, като дял от нормалното.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Пропуска терен, скрит зад затворени участъци. Off струва много.",
@@ -366,6 +367,7 @@
   "Advanced": "Разширено",
   "Undo": "Отмяна",
   "Search options": "Опции за търсене",
+  "Shortcut": "Пряк път",
   "Distance": "Разстояние",
   "Display": "Дисплей",
   "Interface": "Интерфейс",
@@ -436,9 +438,11 @@
   "Calibrate...": "Калибриране...",
   "Calibrate Anyway...": "Калибриране все пак...",
   "Use Automatic Setup": "Използвайте автоматична настройка",
+  "Shortcut: %s": "Пряк път: %s",
   "Next": "Следваща",
   "HDR Calibration %s/%s: %s": "HDR калибриране %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Задава трите под цял екран, една тестова картина наведнъж.",
+  "A key that opens this screen from the game. Not bound at first.": "Ключ, който отваря този екран от играта. В началото не е обвързан.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Вашият дисплей не каза колко ярък става: калибрирайте, за да го настроите.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Вече е настроен за вашия дисплей. Калибрирайте само ако HDR изглежда грешно.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Връща Peak Brightness и Paper White обратно към настройката на вашия дисплей.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Офлайн профилите принадлежат към този екземпляр",
   "horizon.splitscreen.profiles.move": "Движете се там, където играете",
   "horizon.splitscreen.profiles.move_place": "Преместете се там, където играете: %s",
+  "horizon.friends.title": "Играйте с приятели",
+  "horizon.friends.hint": "Приятели поставете кода след бутона Приятели на заглавния екран, в Direct Connection или на страницата за възпроизвеждане на стартовия панел.",
+  "horizon.friends.copied": "Копирано",
+  "horizon.friends.copy_code": "Копиране на код",
+  "horizon.friends.stop_sharing": "Спиране на споделянето",
+  "horizon.friends.none_yet": "Тук все още няма приятели.",
+  "horizon.friends.here_now": "Тук сега: %s",
+  "horizon.friends.share_intro": "Споделете този свят зад код за покана: той се отваря към LAN и приятели в интернет се присъединяват с кода. Не е включен наш сървър.",
+  "horizon.friends.start_sharing": "Започнете споделяне",
+  "horizon.friends.troubleshooting": "Отстраняване на неизправности...",
+  "horizon.friends.stopped": "Спря споделянето на кода за покана.",
+  "horizon.friends.short_code_changed": "Някой продължаваше да опитва грешен кратък код, така че той се промени.",
+  "horizon.friends.wrong_code": "Някой е опитал грешен код.",
+  "horizon.friends.relay_stopped": "Твърде много грешни кратки кодове, затова релето е изключено, докато не споделите отново. Приятелите все още могат да се присъединят с пълния код.",
+  "horizon.friends.code_ready": "Вашият код за покана е готов: Меню за игри, Играйте с приятели. Копирайте го и го изпратете на приятелите си.",
+  "horizon.friends.share_failed": "Не можах да споделя света: %s",
+  "horizon.friends.finding_route": "Търся как приятелите могат да се свържат с вас...",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "пространство",
   "horizon.osk.delete": "Изтриване",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Sevel a ra ar skeudoù betek du teñvalañ ho skramm. 0 : du gwir, sevel ebet.",
   "How bright highlights get. Auto: the peak your system reports.": "Pegen skedus e teu ar sklêrijennoù. Emgefre : ar pik a vez embannet gant ho reizhiad.",
   "How bright white looks in the world. Auto: your desktop's white.": "Pegen skedus e seblant ar gwenn er bed. Emgefreek : gwenn ho kefridi.",
+  "How bright the HUD and menus are, against paper white.": "Pegen skedus eo an HUD hag ar mennozhioù, a-enep gwenn ar paper.",
   "How far mobs, crops and machines keep working. CPU time.": "Pegen pell e kendalc'h ar mobs, ar c'hoadoù hag ar mekanikoù da labourat. Amzer ar CPU.",
   "How far away mobs and items are drawn, as a share of normal.": "Pegen pell e vez tennet ar mobs hag an traoù, evel ul lodenn eus ar pezh a vez graet normal.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Tremen a ra an douaroù kuzhet a-dreñv rannoù serr. Koustañ a ra kalz.",
@@ -366,6 +367,7 @@
   "Advanced": "Araokaet",
   "Undo": "Dizober",
   "Search options": "Dibarzhioù klask",
+  "Shortcut": "Berradennoù",
   "Distance": "Pellder",
   "Display": "Diskouez",
   "Interface": "Etrefas",
@@ -436,9 +438,11 @@
   "Calibrate...": "Kalibrañ...",
   "Calibrate Anyway...": "Kalibrañ koulskoude...",
   "Use Automatic Setup": "Implijout arventennoù emgefre",
+  "Shortcut: %s": "Berradennoù : %s",
   "Next": "Da heul",
   "HDR Calibration %s/%s: %s": "Kalibradur HDR %s/%s : %s",
   "Sets the three below full screen, one test picture at a time.": "Lakaat a ra an tri skramm leun a-is, ur skeudenn amprouiñ bep tro.",
+  "A key that opens this screen from the game. Not bound at first.": "Un alc'hwez a zigor ar skramm-mañ eus ar c'hoari. N'eo ket stag da gentañ.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "N'eo ket bet embannet gant ho skramm pegen sklaer e teu da vezañ : kalibret evit e lakaat war-sav.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Kefluniet dija evit ho skramm. Kalibret nemet ma seblant HDR bezañ fazius.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Lakaat a ra ar sked uhelañ hag ar gwenn paper en-dro e kefluniadur ho skramm.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Ar profiloù ezlinenn a ya d'ober an ensavadur-mañ",
   "horizon.splitscreen.profiles.move": "Dilec'hiañ el lec'h ma c'hoarier",
   "horizon.splitscreen.profiles.move_place": "Dilec'hiañ el lec'h ma c'hoarier : %s",
+  "horizon.friends.title": "C'hoari gant mignoned",
+  "horizon.friends.hint": "Pegañ a ra ar vignoned ar c'hod goude bouton Mignoned ar skramm titl, e Kevreadur war-eeun, pe war bajenn C'hoari al lañser.",
+  "horizon.friends.copied": "Eilet",
+  "horizon.friends.copy_code": "Eilañ ar c'hod",
+  "horizon.friends.stop_sharing": "Paouez da rannañ",
+  "horizon.friends.none_yet": "Mignon ebet amañ c'hoazh.",
+  "horizon.friends.here_now": "Setu bremañ : %s",
+  "horizon.friends.share_intro": "Rannañ ar bed-mañ a-dreñv ur c'hod pediñ : digeriñ a ra d'ar LAN, ha mignoned war internet a gemer perzh gant ar c'hod. N'eus servijer ebet ac'hanomp e-barzh.",
+  "horizon.friends.start_sharing": "Kregiñ da rannañ",
+  "horizon.friends.troubleshooting": "Diskoulmañ kudennoù...",
+  "horizon.friends.stopped": "Paouezet da rannañ ar c'hod pediñ.",
+  "horizon.friends.short_code_changed": "Unan bennak a gendalc'has da glask ur c'hod berr fazius, setu m'eo cheñchet.",
+  "horizon.friends.wrong_code": "Unan bennak en deus klasket ur c'hod fall.",
+  "horizon.friends.relay_stopped": "Re a godoù berr fazius, setu m'eo diweredekaet an treuzkas betek ma rannit en-dro. Ar vignoned a c'hall c'hoazh mont e-barzh gant ar c'hod klok.",
+  "horizon.friends.code_ready": "Prest eo ho kod pediñ : Menü ar c'hoari, C'hoari gant mignoned. Eilañ anezhañ ha kas anezhañ d'ho mignoned.",
+  "horizon.friends.share_failed": "N'hall ket rannañ ar bed : %s",
+  "horizon.friends.finding_route": "Kavout penaos e c'hall mignoned tizhout ac'hanoc'h...",
   "horizon.osk.shift": "Dilec'hiañ",
   "horizon.osk.space": "Egor",
   "horizon.osk.delete": "Dilemel",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Podiže sjene do najcrnje crne vašeg ekrana. 0: prava crna, bez podizanja.",
   "How bright highlights get. Auto: the peak your system reports.": "Kako svetli naglasci postaju. Automatski: vrhunac o kojem vaš sistem prijavljuje.",
   "How bright white looks in the world. Auto: your desktop's white.": "Koliko svijetlo izgleda bijelo u svijetu. Automatski: bijela vaše radne površine.",
+  "How bright the HUD and menus are, against paper white.": "Koliko su svijetli HUD i meniji, naspram bijelog papira.",
   "How far mobs, crops and machines keep working. CPU time.": "Koliko mobovi, usjevi i mašine rade. CPU vrijeme.",
   "How far away mobs and items are drawn, as a share of normal.": "Koliko su udaljeni mobovi i predmeti, kao udio normalnog.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Preskače teren skriven iza zatvorenih dijelova. Isključenje košta puno.",
@@ -366,6 +367,7 @@
   "Advanced": "Napredno",
   "Undo": "Poništi",
   "Search options": "Opcije pretraživanja",
+  "Shortcut": "Prečica",
   "Distance": "Udaljenost",
   "Display": "Ekran",
   "Interface": "Interfejs",
@@ -436,9 +438,11 @@
   "Calibrate...": "Kalibriraj...",
   "Calibrate Anyway...": "Kalibriraj svejedno...",
   "Use Automatic Setup": "Koristite automatsko podešavanje",
+  "Shortcut: %s": "Prečica: %s",
   "Next": "Sledeći",
   "HDR Calibration %s/%s: %s": "HDR kalibracija %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Postavlja tri ispod preko celog ekrana, jednu po jednu probnu sliku.",
+  "A key that opens this screen from the game. Not bound at first.": "Taster koji otvara ovaj ekran iz igre. U početku nije vezan.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Vaš displej nije rekao koliko svetli: kalibrirajte da biste ga postavili.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Već postavljeno za vaš ekran. Kalibrirajte samo ako HDR izgleda pogrešno.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Vraća Peak Brightness i Paper White u postavke vašeg ekrana.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Offline profili pripadaju ovoj instanci",
   "horizon.splitscreen.profiles.move": "Krećite se tamo gdje igrate",
   "horizon.splitscreen.profiles.move_place": "Premjestite se gdje igrate: %s",
+  "horizon.friends.title": "Igrajte se s prijateljima",
+  "horizon.friends.hint": "Prijatelji zalijepe kod iza dugmeta Prijatelji na naslovnom ekranu, u Direktnu vezu ili na Play stranicu pokretača.",
+  "horizon.friends.copied": "Kopirano",
+  "horizon.friends.copy_code": "Kopiraj kod",
+  "horizon.friends.stop_sharing": "Prekini dijeljenje",
+  "horizon.friends.none_yet": "Ovdje još nema prijatelja.",
+  "horizon.friends.here_now": "Evo sada: %s",
+  "horizon.friends.share_intro": "Podijelite ovaj svijet iza pozivnog koda: otvara se na LAN, a prijatelji na internetu se pridružuju kodu. Nijedan naš server nije uključen.",
+  "horizon.friends.start_sharing": "Počnite dijeliti",
+  "horizon.friends.troubleshooting": "Rješavanje problema...",
+  "horizon.friends.stopped": "Zaustavljeno je dijeljenje pozivnog koda.",
+  "horizon.friends.short_code_changed": "Neko je nastavio pokušavati s pogrešnim kratkim kodom, pa se to promijenilo.",
+  "horizon.friends.wrong_code": "Neko je probao pogrešan kod.",
+  "horizon.friends.relay_stopped": "Previše pogrešnih kratkih kodova, pa je relej isključen dok ponovo ne podijelite. Prijatelji se još mogu pridružiti s punim kodom.",
+  "horizon.friends.code_ready": "Vaš pozivni kod je spreman: Meni igre, Igrajte se sa prijateljima. Kopirajte ga i pošaljite svojim prijateljima.",
+  "horizon.friends.share_failed": "Ne mogu dijeliti svijet: %s",
+  "horizon.friends.finding_route": "Pronalaženje načina na koji prijatelji mogu doći do vas…",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Razmak",
   "horizon.osk.delete": "Izbriši",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Puja les ombres fins al negre més fosc de la teva pantalla. 0: negre pur, sense pujar.",
   "How bright highlights get. Auto: the peak your system reports.": "Com es fan els reflexos brillants. Automàtic: el pic que informa el vostre sistema.",
   "How bright white looks in the world. Auto: your desktop's white.": "Com de brillant es veu el blanc al món. Automàtic: el blanc de l'escriptori.",
+  "How bright the HUD and menus are, against paper white.": "Què brillants són l'HUD i els menús, contra el paper blanc.",
   "How far mobs, crops and machines keep working. CPU time.": "Fins on segueixen treballant les turbes, els conreus i les màquines. Temps de CPU.",
   "How far away mobs and items are drawn, as a share of normal.": "A quina distància es dibuixen les turbes i els articles, com a part de la normalitat.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Salta el terreny amagat darrere de seccions tancades. Off costa molt.",
@@ -366,6 +367,7 @@
   "Advanced": "Avançat",
   "Undo": "Desfer",
   "Search options": "Opcions de cerca",
+  "Shortcut": "Drecera",
   "Distance": "Distància",
   "Display": "Mostra",
   "Interface": "Interfície",
@@ -436,9 +438,11 @@
   "Calibrate...": "Calibrar...",
   "Calibrate Anyway...": "Calibra de totes maneres...",
   "Use Automatic Setup": "Utilitzeu la configuració automàtica",
+  "Shortcut: %s": "Drecera: %s",
   "Next": "A continuació",
   "HDR Calibration %s/%s: %s": "Calibració HDR %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Estableix les tres imatges de sota de pantalla completa, una imatge de prova a la vegada.",
+  "A key that opens this screen from the game. Not bound at first.": "Una clau que obre aquesta pantalla des del joc. No lligat al principi.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "La pantalla no va dir la brillantor que té: calibra per configurar-la.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Ja està configurat per a la vostra pantalla. Calibreu només si l'HDR sembla incorrecte.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Torna a posar la brillantor màxima i el blanc del paper a la configuració de la pantalla.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Els perfils fora de línia pertanyen a aquesta instància",
   "horizon.splitscreen.profiles.move": "Mou-te on jugues",
   "horizon.splitscreen.profiles.move_place": "Mou on jugues: %s",
+  "horizon.friends.title": "Juga amb els amics",
+  "horizon.friends.hint": "Els amics enganxen el codi després del botó Amics de la pantalla del títol, a la connexió directa o a la pàgina de reproducció del llançador.",
+  "horizon.friends.copied": "Copiat",
+  "horizon.friends.copy_code": "Copia el codi",
+  "horizon.friends.stop_sharing": "Deixa de compartir",
+  "horizon.friends.none_yet": "Encara no hi ha amics.",
+  "horizon.friends.here_now": "Aquí ara: %s",
+  "horizon.friends.share_intro": "Comparteix aquest món darrere d'un codi d'invitació: s'obre a LAN i els amics d'Internet s'uneixen amb el codi. Cap servidor nostre està implicat.",
+  "horizon.friends.start_sharing": "Comenceu a compartir",
+  "horizon.friends.troubleshooting": "Resolució de problemes...",
+  "horizon.friends.stopped": "S'ha deixat de compartir el codi d'invitació.",
+  "horizon.friends.short_code_changed": "Algú va seguir provant un codi curt equivocat, així que va canviar.",
+  "horizon.friends.wrong_code": "Algú ha provat un codi incorrecte.",
+  "horizon.friends.relay_stopped": "Massa codis curts incorrectes, així que el relé està aturat fins que tornis a compartir. Els amics encara s'hi poden unir amb el codi complet.",
+  "horizon.friends.code_ready": "El teu codi d'invitació està preparat: Menú de joc, Juga amb els amics. Copia'l i envia'l als teus amics.",
+  "horizon.friends.share_failed": "No s'ha pogut compartir el món: %s",
+  "horizon.friends.finding_route": "Trobar com els amics et poden arribar...",
   "horizon.osk.shift": "Canvi",
   "horizon.osk.space": "Espai",
   "horizon.osk.delete": "Suprimeix",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Zvedne stíny na nejtemnější černou vašeho displeje. 0: skutečná černá, bez zvednutí.",
   "How bright highlights get. Auto: the peak your system reports.": "Jak se získá jasný melír. Auto: vrchol, který váš systém hlásí.",
   "How bright white looks in the world. Auto: your desktop's white.": "Jak jasně bílá ve světě vypadá. Auto: bílá vaší plochy.",
+  "How bright the HUD and menus are, against paper white.": "Jak jasný je HUD a nabídky oproti bílé na papíře.",
   "How far mobs, crops and machines keep working. CPU time.": "Jak dalece davy, plodiny a stroje fungují. CPU čas.",
   "How far away mobs and items are drawn, as a share of normal.": "Jak daleko jsou mobové a předměty nakresleny jako podíl normálu.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Přeskočí terén skrytý za uzavřenými úseky. Vypnutí stojí hodně.",
@@ -366,6 +367,7 @@
   "Advanced": "Pokročilé",
   "Undo": "Vrátit zpět",
   "Search options": "Možnosti vyhledávání",
+  "Shortcut": "Zkratka",
   "Distance": "Vzdálenost",
   "Display": "Displej",
   "Interface": "Rozhraní",
@@ -436,9 +438,11 @@
   "Calibrate...": "Kalibrovat...",
   "Calibrate Anyway...": "Přesto kalibrovat...",
   "Use Automatic Setup": "Použijte Automatické nastavení",
+  "Shortcut: %s": "Zkratka: %s",
   "Next": "Další",
   "HDR Calibration %s/%s: %s": "Kalibrace HDR %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Nastaví tři pod celou obrazovkou, vždy jeden testovací obrázek.",
+  "A key that opens this screen from the game. Not bound at first.": "Klíč, který otevře tuto obrazovku ze hry. Zpočátku bez vazby.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Váš displej neříkal, jak jasný je: zkalibrujte jej, abyste jej nastavili.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Již nastaveno pro váš displej. Kalibrujte pouze v případě, že HDR vypadá špatně.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Vrátí maximální jas a papírovou bílou zpět do nastavení vašeho displeje.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Offline profily patří k této instanci",
   "horizon.splitscreen.profiles.move": "Pohybujte se tam, kde hrajete",
   "horizon.splitscreen.profiles.move_place": "Přesuňte se, kde hrajete: %s",
+  "horizon.friends.title": "Hrajte s přáteli",
+  "horizon.friends.hint": "Přátelé vloží kód za tlačítko Přátelé na titulní obrazovce, do Přímého připojení nebo na stránku Play spouštěče.",
+  "horizon.friends.copied": "Zkopírováno",
+  "horizon.friends.copy_code": "Kopírovat kód",
+  "horizon.friends.stop_sharing": "Přestat sdílet",
+  "horizon.friends.none_yet": "Zatím tu nejsou žádní přátelé.",
+  "horizon.friends.here_now": "Tady teď: %s",
+  "horizon.friends.share_intro": "Sdílejte tento svět pomocí zvacího kódu: otevře se na LAN a přátelé na internetu se připojí pomocí kódu. Není zapojen žádný náš server.",
+  "horizon.friends.start_sharing": "Začněte sdílet",
+  "horizon.friends.troubleshooting": "Odstraňování problémů...",
+  "horizon.friends.stopped": "Sdílení kódu pozvánky bylo zastaveno.",
+  "horizon.friends.short_code_changed": "Někdo neustále zkoušel špatný krátký kód, takže se to změnilo.",
+  "horizon.friends.wrong_code": "Někdo zkusil špatný kód.",
+  "horizon.friends.relay_stopped": "Příliš mnoho špatných krátkých kódů, takže relé je vypnuté, dokud nebudete sdílet znovu. Přátelé se stále mohou připojit s plným kódem.",
+  "horizon.friends.code_ready": "Váš zvací kód je připraven: Herní menu, Hrajte s přáteli. Zkopírujte jej a pošlete svým přátelům.",
+  "horizon.friends.share_failed": "Nepodařilo se sdílet svět: %s",
+  "horizon.friends.finding_route": "Zjištění, jak vás mohou přátelé kontaktovat…",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Prostor",
   "horizon.osk.delete": "Smazat",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Мӗлкесене дисплейӑн чи тӗттӗм хури ҫине ҫӗклет. 0: чӑн хура, ҫӗклевсӗр.",
   "How bright highlights get. Auto: the peak your system reports.": "Мӗнле ҫутӑ ҫутӑсем пулаҫҫӗ. Авто: сирӗн системӑн пӗлтерекен пикӗ.",
   "How bright white looks in the world. Auto: your desktop's white.": "Тӗнчере шурӑ мӗнле ҫутӑ курӑнать. Авто: эсир рабочий столӑн шурри.",
+  "How bright the HUD and menus are, against paper white.": "HUD тата менюсем мӗнле ҫутӑ, хут ҫинчи шурӑ тӗспе танлаштарсан.",
   "How far mobs, crops and machines keep working. CPU time.": "Мобсем, культурӑсем тата машинӑсем мӗн таран ӗҫлеҫҫӗ. Процессор вӑхӑчӗ.",
   "How far away mobs and items are drawn, as a share of normal.": "Мобсемпе япаласем мӗн чухлӗ аяккалла туртӑнаҫҫӗ, йӗркеллӗ пай пек.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Хупӑ участоксем хыҫӗнче пытаннӑ ҫӗре сиктерсе хӑварать. Офф нумай тӑкакланать.",
@@ -366,6 +367,7 @@
   "Advanced": "Малалла",
   "Undo": "Каялла тавӑр",
   "Search options": "Шырав опцийӗсем",
+  "Shortcut": "Кӗске ҫул",
   "Distance": "Инҫет",
   "Display": "Дисплей",
   "Interface": "Интерфейс",
@@ -436,9 +438,11 @@
   "Calibrate...": "Калибровка...",
   "Calibrate Anyway...": "Ҫапах та калибровка...",
   "Use Automatic Setup": "Автоматла настройкӑпа усӑ курӑр",
+  "Shortcut: %s": "Кӗске ҫул: %s",
   "Next": "Малалла",
   "HDR Calibration %s/%s: %s": "HDR калибровка %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Аялта виҫҫӗшне тулли экран ҫине лартать, пӗрер тӗрӗслев ӳкерчӗкӗ.",
+  "A key that opens this screen from the game. Not bound at first.": "Вӑйӑран ҫак экрана уҫакан уҫҫи. Малтанах ҫыхӑнман.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Сирӗн дисплей ҫинче вӑл мӗнле ҫутӑ пулнине каламан: ӑна лартма калибровка тумалла.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Сирӗн дисплей валли хатӗрленӗ ӗнтӗ. HDR тӗрӗс мар курӑнсан ҫеҫ калибровка тӑвӑр.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Чи пысӑк ҫутӑлӑха тата хут шуррине сирӗн дисплей настройкине каялла тавӑрать.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Офлайн профильсем ҫак экземпляра кӗреҫҫӗ",
   "horizon.splitscreen.profiles.move": "Ӑҫта вылятӑн, ҫавӑнта куҫ",
   "horizon.splitscreen.profiles.move_place": "Ӑҫта вылятӑн, ҫавӑнта куҫ: %s",
+  "horizon.friends.title": "Юлташсемпе выля",
+  "horizon.friends.hint": "Туссем ҫак кода титул экранӗнчи Туссем кнопки хыҫҫӑн, Тӳрӗ ҫыхӑнура е пуҫлаканӑн Play страницинче ҫыпӑҫтараҫҫӗ.",
+  "horizon.friends.copied": "Копиленӗ",
+  "horizon.friends.copy_code": "Код копийӗ",
+  "horizon.friends.stop_sharing": "Пайлама пӑрахӑр",
+  "horizon.friends.none_yet": "Кунта туссем ҫук-ха.",
+  "horizon.friends.here_now": "Акӑ халӗ: %s",
+  "horizon.friends.share_intro": "Ҫак тӗнчене йыхрав кодӗ хыҫӗнче пайла: вӑл LAN-а уҫӑлать, интернетри туссем вара ҫав кодпа хутшӑнаҫҫӗ. Пирӗн пӗр сервер та ҫак ӗҫе хутшӑнмасть.",
+  "horizon.friends.start_sharing": "Пайлама пуҫлӑр",
+  "horizon.friends.troubleshooting": "Ҫитменлӗхсене пӗтересси...",
+  "horizon.friends.stopped": "Чӗнӳ кодне пайлама пӑрахрӑм.",
+  "horizon.friends.short_code_changed": "Такам кӗске кода йӑнӑш ҫырса пӑхрӗ, ҫавӑнпа вӑл улшӑнчӗ.",
+  "horizon.friends.wrong_code": "Такам йӑнӑш кодпа усӑ курса пӑхнӑ.",
+  "horizon.friends.relay_stopped": "Ытла нумай тӗрӗс мар кӗске код, ҫавӑнпа реле эсир тепӗр хут пайласан ҫеҫ ӗҫлӗ. Тусем тулли кодпа кӗме пултараҫҫӗ.",
+  "horizon.friends.code_ready": "Сирӗн чӗнӳ кодӗ хатӗр: Вӑйӑ меню, Туссемпе выля. Ӑна копилесе юлташсене ярса парӑр.",
+  "horizon.friends.share_failed": "Тӗнчене пайлаймарӑм: %s",
+  "horizon.friends.finding_route": "Юлташсем сирӗн пата мӗнле ҫитме пултарнине тупасси...",
   "horizon.osk.shift": "Смена",
   "horizon.osk.space": "Космос",
   "horizon.osk.delete": "Пӗтер",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Yn codi cysgodion i ddu tywyllaf eich arddangosfa. 0: du go iawn, dim codi.",
   "How bright highlights get. Auto: the peak your system reports.": "Sut mae uchafbwyntiau disglair yn ei gael. Auto: yr uchafbwynt y mae eich system yn ei adrodd.",
   "How bright white looks in the world. Auto: your desktop's white.": "Pa mor llachar y mae gwyn yn edrych yn y byd. Awtomatig: gwyn eich bwrdd gwaith.",
+  "How bright the HUD and menus are, against paper white.": "Pa mor llachar yw'r HUD a'r bwydlenni, yn erbyn papur gwyn.",
   "How far mobs, crops and machines keep working. CPU time.": "Pa mor bell y mae mobs, cnydau a pheiriannau yn dal i weithio. Amser CPU.",
   "How far away mobs and items are drawn, as a share of normal.": "Pa mor bell i ffwrdd mae mobs ac eitemau yn cael eu tynnu, fel cyfran o'r arferol.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Sgipiau tir wedi'i guddio y tu ôl i adrannau caeedig. Mae i ffwrdd yn costio llawer.",
@@ -366,6 +367,7 @@
   "Advanced": "Uwch",
   "Undo": "Dadwneud",
   "Search options": "Dewisiadau chwilio",
+  "Shortcut": "Llwybr byr",
   "Distance": "Pellter",
   "Display": "Arddangos",
   "Interface": "Rhyngwyneb",
@@ -436,9 +438,11 @@
   "Calibrate...": "Graddnodi...",
   "Calibrate Anyway...": "Calibro beth bynnag...",
   "Use Automatic Setup": "Defnyddiwch Gosodiad Awtomatig",
+  "Shortcut: %s": "Llwybr byr: %s",
   "Next": "Nesaf",
   "HDR Calibration %s/%s: %s": "Graddnodi HDR %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Yn gosod y tri isod sgrin lawn, un llun prawf ar y tro.",
+  "A key that opens this screen from the game. Not bound at first.": "Allwedd sy'n agor y sgrin hon o'r gêm. Heb ei rwymo ar y dechrau.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Ni ddywedodd eich arddangosfa pa mor llachar y mae'n ei gael: graddnodwch i'w osod.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Eisoes wedi'i osod ar gyfer eich arddangosfa. Calibrowch dim ond os yw HDR yn edrych yn anghywir.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Yn rhoi Disgleirdeb Peak a Phapur Gwyn yn ôl i drefniant eich arddangosfa.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Mae proffiliau all-lein yn perthyn i'r achos hwn",
   "horizon.splitscreen.profiles.move": "Symudwch lle rydych chi'n chwarae",
   "horizon.splitscreen.profiles.move_place": "Symudwch ble rydych chi'n chwarae: %s",
+  "horizon.friends.title": "Chwarae gyda Ffrindiau",
+  "horizon.friends.hint": "Mae ffrindiau'n gludo'r cod ar ôl botwm Friends y sgrin deitl, yn Direct Connection, neu ar dudalen Chwarae'r lansiwr.",
+  "horizon.friends.copied": "Wedi'i gopïo",
+  "horizon.friends.copy_code": "Copi Cod",
+  "horizon.friends.stop_sharing": "Stopio Rhannu",
+  "horizon.friends.none_yet": "Dim ffrindiau yma eto.",
+  "horizon.friends.here_now": "Yma nawr: %s",
+  "horizon.friends.share_intro": "Rhannwch y byd hwn y tu ôl i god gwahoddiad: mae'n agor i LAN, ac mae ffrindiau ar y rhyngrwyd yn ymuno â'r cod. Nid oes unrhyw weinydd ohonom yn cymryd rhan.",
+  "horizon.friends.start_sharing": "Dechrau Rhannu",
+  "horizon.friends.troubleshooting": "Datrys Problemau...",
+  "horizon.friends.stopped": "Wedi stopio rhannu'r cod gwahoddiad.",
+  "horizon.friends.short_code_changed": "Roedd rhywun yn ceisio cod byr anghywir o hyd, felly fe newidiodd.",
+  "horizon.friends.wrong_code": "Ceisiodd rhywun god anghywir.",
+  "horizon.friends.relay_stopped": "Gormod o godau byr anghywir, felly mae'r cyfnewidydd i ffwrdd nes i chi rannu eto. Gall ffrindiau ymuno o hyd â'r cod llawn.",
+  "horizon.friends.code_ready": "Mae eich cod gwahoddiad yn barod: Dewislen Gêm, Chwarae gyda Ffrindiau. Copïwch ef a'i anfon at eich ffrindiau.",
+  "horizon.friends.share_failed": "Methu rhannu'r byd: %s",
+  "horizon.friends.finding_route": "Darganfod sut y gall ffrindiau eich cyrraedd…",
   "horizon.osk.shift": "Turn",
   "horizon.osk.space": "Gofod",
   "horizon.osk.delete": "Dileu",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Løfter skygger op på skærmens mørkeste sort. 0: ægte sort, ingen løft.",
   "How bright highlights get. Auto: the peak your system reports.": "Hvor lyse højdepunkter bliver. Auto: det højeste, dit system rapporterer.",
   "How bright white looks in the world. Auto: your desktop's white.": "Hvor lyst hvid ser ud i verden. Auto: din skrivebords hvide.",
+  "How bright the HUD and menus are, against paper white.": "Hvor lys HUD og menuer er i forhold til hvidt papir.",
   "How far mobs, crops and machines keep working. CPU time.": "Hvor langt mobs, afgrøder og maskiner bliver ved med at arbejde. CPU tid.",
   "How far away mobs and items are drawn, as a share of normal.": "Hvor langt væk mobs og genstande trækkes, som en andel af normalen.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Springer over terræn skjult bag lukkede sektioner. Off koster meget.",
@@ -366,6 +367,7 @@
   "Advanced": "Avanceret",
   "Undo": "Fortryd",
   "Search options": "Søgemuligheder",
+  "Shortcut": "Genvej",
   "Distance": "Afstand",
   "Display": "Skærm",
   "Interface": "Grænseflade",
@@ -436,9 +438,11 @@
   "Calibrate...": "Kalibrer...",
   "Calibrate Anyway...": "Kalibrer alligevel...",
   "Use Automatic Setup": "Brug automatisk opsætning",
+  "Shortcut: %s": "Genvej: %s",
   "Next": "Næste",
   "HDR Calibration %s/%s: %s": "HDR-kalibrering %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Indstiller de tre nedenfor i fuld skærm, et testbillede ad gangen.",
+  "A key that opens this screen from the game. Not bound at first.": "En tast, der åbner denne skærm fra spillet. Ikke bundet i starten.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Din skærm sagde ikke, hvor lys den bliver: Kalibrer for at konfigurere den.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Allerede konfigureret til din skærm. Kalibrer kun, hvis HDR ser forkert ud.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Sætter Peak Brightness og Paper White tilbage til din skærms opsætning.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Offlineprofiler hører til denne instans",
   "horizon.splitscreen.profiles.move": "Flyt hvor du spiller",
   "horizon.splitscreen.profiles.move_place": "Flyt hvor du spiller: %s",
+  "horizon.friends.title": "Spil med venner",
+  "horizon.friends.hint": "Venner indsætter koden efter titelskærmens Venner-knap, i Direct Connection eller på launcherens Play-side.",
+  "horizon.friends.copied": "Kopieret",
+  "horizon.friends.copy_code": "Kopiér kode",
+  "horizon.friends.stop_sharing": "Stop deling",
+  "horizon.friends.none_yet": "Ingen venner her endnu.",
+  "horizon.friends.here_now": "Her nu: %s",
+  "horizon.friends.share_intro": "Del denne verden bag en invitationskode: den åbner til LAN, og venner på internettet deltager med koden. Ingen af vores servere er involveret.",
+  "horizon.friends.start_sharing": "Begynd at dele",
+  "horizon.friends.troubleshooting": "Fejlfinding...",
+  "horizon.friends.stopped": "Stoppet med at dele invitationskoden.",
+  "horizon.friends.short_code_changed": "Nogen blev ved med at prøve en forkert kort kode, så den ændrede sig.",
+  "horizon.friends.wrong_code": "Nogen prøvede en forkert kode.",
+  "horizon.friends.relay_stopped": "For mange forkerte kortkoder, så relæet er slået fra, indtil du deler igen. Venner kan stadig deltage med den fulde kode.",
+  "horizon.friends.code_ready": "Din invitationskode er klar: Spilmenu, Spil med venner. Kopier det og send det til dine venner.",
+  "horizon.friends.share_failed": "Kunne ikke dele verden: %s",
+  "horizon.friends.finding_route": "Finder, hvordan venner kan nå dig...",
   "horizon.osk.shift": "Skift",
   "horizon.osk.space": "Plads",
   "horizon.osk.delete": "Slet",

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

@@ -290,6 +290,7 @@
   "Advanced": "Erweitert",
   "Undo": "Rückgängig",
   "Search options": "Einstellungen durchsuchen",
+  "Shortcut": "Tastenkürzel",
   "Distance": "Entfernung",
   "Display": "Anzeige",
   "Interface": "Oberfläche",
@@ -323,6 +324,7 @@
   "horizon.extras.wheel_cycles_settings": "Mausrad ändert Einstellungen",
   "horizon.extras.pack_browser": "Ressourcenpaket-Browser",
   "horizon.extras.music_page.tooltip": "Musik & Geräusche erhält eine Seite „Musik …“: Spiele jeden eingebauten Titel jetzt ab oder schalte einen aus, damit das Spiel ihn nicht mehr wählt. Nichts ändert sich, bis du einen Titel ausschaltest.",
+  "horizon.friends.relay_stopped": "Zu viele falsche Kurzcodes, deshalb ist das Relay aus, bis du erneut teilst. Freunde können weiterhin mit dem vollständigen Code beitreten.",
   "horizon.extras.pack_browser.tooltip": "Ressourcenpakete auswählen erhält eine Schaltfläche „Hinzufügen“, die Modrinth durchsucht und ein Paket in deinen Paketordner installiert. Aus kontaktiert das Spiel Modrinth nie.",
   "horizon.splitscreen.setup.monitor": "Monitor %s",
   "horizon.splitscreen.setup.monitor_unknown": "ein Monitor",
@@ -438,6 +440,7 @@
   "Sets the options below together. Changing one makes it Custom.": "Stellt Optionen darunter ein. Änderung = „Benutzerdefiniert“.",
   "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Lava, Feuer, Sonne heller als Weiß. Braucht HDR-Bildschirm.",
   "How bright highlights get. Auto: the peak your system reports.": "Wie hell Lichter werden. Auto: der Spitzenwert, den dein System meldet.",
+  "How bright the HUD and menus are, against paper white.": "Wie hell HUD und Menüs im Vergleich zu Papierweiß sind.",
   "How far mobs, crops and machines keep working. CPU time.": "Wie weit Kreaturen, Pflanzen und Maschinen weiterarbeiten. Kostet CPU-Zeit.",
   "How far away mobs and items are drawn, as a share of normal.": "Zeichenweite für Kreaturen und Gegenstände, anteilig zur Norm.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Überspringt Gelände hinter geschlossenen Abschnitten. Aus kostet viel.",
@@ -516,9 +519,11 @@
   "Calibrate...": "Kalibrieren …",
   "Calibrate Anyway...": "Trotzdem kalibrieren …",
   "Use Automatic Setup": "Automatische Einrichtung verwenden",
+  "Shortcut: %s": "Tastenkürzel: %s",
   "Next": "Weiter",
   "HDR Calibration %s/%s: %s": "HDR-Kalibrierung %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Stellt die drei Werte darunter im Vollbild ein, jeweils mit einem Testbild.",
+  "A key that opens this screen from the game. Not bound at first.": "Eine Taste, die diesen Bildschirm im Spiel öffnet. Zunächst nicht belegt.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Bildschirm meldete keine Helligkeit: zum Einrichten kalibrieren.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Bereits eingerichtet. Nur kalibrieren, wenn HDR falsch aussieht.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Stellt Spitzenhelligkeit und Papierweiß des Bildschirms wieder her.",
@@ -542,6 +547,22 @@
   "horizon.splitscreen.profiles.offline_note": "Offline-Profile gehören zu dieser Instanz",
   "horizon.splitscreen.profiles.move": "Spielort wechseln",
   "horizon.splitscreen.profiles.move_place": "Spielort wechseln: %s",
+  "horizon.friends.title": "Mit Freunden spielen",
+  "horizon.friends.hint": "Freunde fügen den Code nach dem Freunde-Knopf des Titelbildschirms ein, bei „Direktverbindung“ oder auf der Spielen-Seite des Launchers.",
+  "horizon.friends.copied": "Kopiert",
+  "horizon.friends.copy_code": "Code kopieren",
+  "horizon.friends.stop_sharing": "Teilen beenden",
+  "horizon.friends.none_yet": "Noch keine Freunde hier.",
+  "horizon.friends.here_now": "Gerade hier: %s",
+  "horizon.friends.share_intro": "Teile diese Welt mit einem Einladungscode: Sie wird im LAN geöffnet, und Freunde im Internet treten mit dem Code bei. Es ist kein Server von uns beteiligt.",
+  "horizon.friends.start_sharing": "Teilen starten",
+  "horizon.friends.troubleshooting": "Fehlerbehebung …",
+  "horizon.friends.stopped": "Das Teilen des Einladungscodes wurde beendet.",
+  "horizon.friends.short_code_changed": "Jemand hat immer wieder einen falschen Kurzcode versucht, deshalb wurde er geändert.",
+  "horizon.friends.wrong_code": "Jemand hat einen falschen Code versucht.",
+  "horizon.friends.code_ready": "Dein Einladungscode ist bereit: Spielmenü, Mit Freunden spielen. Kopiere ihn und schicke ihn an deine Freunde.",
+  "horizon.friends.share_failed": "Die Welt konnte nicht geteilt werden: %s",
+  "horizon.friends.finding_route": "Es wird ermittelt, wie Freunde dich erreichen können …",
   "horizon.osk.shift": "Umschalt",
   "horizon.osk.space": "Leertaste",
   "horizon.osk.delete": "Löschen",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Ανεβάζει τις σκιές στο πιο σκοτεινό μαύρο της οθόνης σας. 0: αληθινό μαύρο, χωρίς ανύψωση.",
   "How bright highlights get. Auto: the peak your system reports.": "Πόσο φωτεινά σημεία αποκτούν. Auto: η κορύφωση που αναφέρει το σύστημά σας.",
   "How bright white looks in the world. Auto: your desktop's white.": "Πόσο φωτεινό φαίνεται το λευκό στον κόσμο. Αυτόματο: το λευκό της επιφάνειας εργασίας σας.",
+  "How bright the HUD and menus are, against paper white.": "Πόσο φωτεινά είναι τα HUD και τα μενού, σε σχέση με το λευκό χαρτί.",
   "How far mobs, crops and machines keep working. CPU time.": "Πόσο μακριά συνεχίζουν να λειτουργούν όχλοι, καλλιέργειες και μηχανές. Χρόνος CPU.",
   "How far away mobs and items are drawn, as a share of normal.": "Πόσο μακριά κληρώνονται όχλοι και αντικείμενα, ως ποσοστό του κανονικού.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Παρακάμπτει το έδαφος που κρύβεται πίσω από κλειστά τμήματα. Το off κοστίζει πολύ.",
@@ -366,6 +367,7 @@
   "Advanced": "Προχωρημένο",
   "Undo": "Αναίρεση",
   "Search options": "Επιλογές αναζήτησης",
+  "Shortcut": "Συντόμευση",
   "Distance": "Απόσταση",
   "Display": "Εμφάνιση",
   "Interface": "Διασύνδεση",
@@ -436,9 +438,11 @@
   "Calibrate...": "Βαθμονόμηση...",
   "Calibrate Anyway...": "Βαθμονόμηση πάντως...",
   "Use Automatic Setup": "Χρησιμοποιήστε την Αυτόματη Ρύθμιση",
+  "Shortcut: %s": "Συντόμευση: %s",
   "Next": "Επόμενο",
   "HDR Calibration %s/%s: %s": "Βαθμονόμηση HDR %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Ορίζει τις τρεις παρακάτω πλήρη οθόνη, μία δοκιμαστική εικόνα τη φορά.",
+  "A key that opens this screen from the game. Not bound at first.": "Ένα κλειδί που ανοίγει αυτήν την οθόνη από το παιχνίδι. Δεν δεσμεύεται στην αρχή.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Η οθόνη σας δεν έλεγε πόσο φωτεινή γίνεται: βαθμονομήστε για να τη ρυθμίσετε.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Έχει ήδη ρυθμιστεί για την οθόνη σας. Βαθμονόμηση μόνο εάν το HDR φαίνεται λάθος.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Επαναφέρει το Peak Brightness και το Paper White στη ρύθμιση της οθόνης σας.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Τα προφίλ εκτός σύνδεσης ανήκουν σε αυτήν την περίπτωση",
   "horizon.splitscreen.profiles.move": "Μετακινηθείτε όπου παίζετε",
   "horizon.splitscreen.profiles.move_place": "Μετακινηθείτε όπου παίζετε: %s",
+  "horizon.friends.title": "Παίξτε με φίλους",
+  "horizon.friends.hint": "Οι φίλοι επικολλούν τον κώδικα μετά το κουμπί Φίλοι της οθόνης τίτλου, στην Άμεση σύνδεση ή στη σελίδα Αναπαραγωγή του προγράμματος εκκίνησης.",
+  "horizon.friends.copied": "Αντιγράφηκε",
+  "horizon.friends.copy_code": "Αντιγραφή Κωδικού",
+  "horizon.friends.stop_sharing": "Διακοπή κοινής χρήσης",
+  "horizon.friends.none_yet": "Δεν υπάρχουν φίλοι εδώ ακόμα.",
+  "horizon.friends.here_now": "Εδώ τώρα: %s",
+  "horizon.friends.share_intro": "Μοιραστείτε αυτόν τον κόσμο πίσω από έναν κωδικό πρόσκλησης: ανοίγει σε LAN και οι φίλοι στο Διαδίκτυο συμμετέχουν με τον κωδικό. Κανένας διακομιστής μας δεν εμπλέκεται.",
+  "horizon.friends.start_sharing": "Ξεκινήστε την κοινή χρήση",
+  "horizon.friends.troubleshooting": "Αντιμετώπιση προβλημάτων...",
+  "horizon.friends.stopped": "Σταμάτησε η κοινή χρήση του κωδικού πρόσκλησης.",
+  "horizon.friends.short_code_changed": "Κάποιος συνέχισε να δοκιμάζει έναν λάθος σύντομο κωδικό, οπότε άλλαξε.",
+  "horizon.friends.wrong_code": "Κάποιος δοκίμασε λάθος κωδικό.",
+  "horizon.friends.relay_stopped": "Πολλοί λάθος σύντομοι κωδικοί, οπότε το ρελέ είναι κλειστό μέχρι να μοιραστείτε ξανά. Οι φίλοι μπορούν ακόμη να συνδεθούν με τον πλήρη κωδικό.",
+  "horizon.friends.code_ready": "Ο κωδικός πρόσκλησής σας είναι έτοιμος: Μενού παιχνιδιού, Παίξτε με φίλους. Αντιγράψτε το και στείλτε το στους φίλους σας.",
+  "horizon.friends.share_failed": "Δεν μπορούσα να μοιραστώ τον κόσμο: %s",
+  "horizon.friends.finding_route": "Βρείτε πώς μπορούν να σας φτάσουν οι φίλοι…",
   "horizon.osk.shift": "Μετατόπιση",
   "horizon.osk.space": "Διάστημα",
   "horizon.osk.delete": "Διαγραφή",

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

@@ -310,7 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Lifts shadows onto your display's darkest black. 0: true black, no lift.",
   "How bright highlights get. Auto: the peak your system reports.": "How bright highlights get. Auto: the peak your system reports.",
   "How bright white looks in the world. Auto: your desktop's white.": "How bright white looks in the world. Auto: your desktop's white.",
-  "How bright the HUD and menus are. Auto: at paper white.": "How bright the HUD and menus are. Auto: at paper white.",
+  "How bright the HUD and menus are, against paper white.": "How bright the HUD and menus are, against paper white.",
   "How far mobs, crops and machines keep working. CPU time.": "How far mobs, crops and machines keep working. CPU time.",
   "How far away mobs and items are drawn, as a share of normal.": "How far away mobs and items are drawn, as a share of normal.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Skips terrain hidden behind closed sections. Off costs a lot.",
@@ -367,6 +367,7 @@
   "Advanced": "Advanced",
   "Undo": "Undo",
   "Search options": "Search options",
+  "Shortcut": "Shortcut",
   "Distance": "Distance",
   "Display": "Display",
   "Interface": "Interface",
@@ -437,11 +438,12 @@
   "Calibrate...": "Calibrate...",
   "Calibrate Anyway...": "Calibrate Anyway...",
   "Use Automatic Setup": "Use Automatic Setup",
+  "Shortcut: %s": "Shortcut: %s",
   "Next": "Next",
   "HDR Calibration %s/%s: %s": "HDR Calibration %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Sets the three below full screen, one test picture at a time.",
+  "A key that opens this screen from the game. Not bound at first.": "A key that opens this screen from the game. Not bound at first.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Your display didn't say how bright it gets: calibrate to set it up.",
-  "Your display's reported peak is often too high: calibrate to set it up.": "Your display's reported peak is often too high: calibrate to set it up.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Already set up for your display. Only calibrate if HDR looks wrong.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Puts Peak Brightness and Paper White back to your display's setup.",
   "Set up for your display. Leave on Auto unless it looks wrong.": "Set up for your display. Leave on Auto unless it looks wrong.",
@@ -465,6 +467,23 @@
   "horizon.splitscreen.profiles.offline_note": "Offline profiles belong to this instance",
   "horizon.splitscreen.profiles.move": "Move where you play",
   "horizon.splitscreen.profiles.move_place": "Move where you play: %s",
+  "horizon.friends.title": "Play with Friends",
+  "horizon.friends.hint": "Friends paste the code after the title screen's Friends button, in Direct Connection, or on the launcher's Play page.",
+  "horizon.friends.copied": "Copied",
+  "horizon.friends.copy_code": "Copy Code",
+  "horizon.friends.stop_sharing": "Stop Sharing",
+  "horizon.friends.none_yet": "No friends here yet.",
+  "horizon.friends.here_now": "Here now: %s",
+  "horizon.friends.share_intro": "Share this world behind an invite code: it opens to LAN, and friends on the internet join with the code. No server of ours is involved.",
+  "horizon.friends.start_sharing": "Start Sharing",
+  "horizon.friends.troubleshooting": "Troubleshooting...",
+  "horizon.friends.stopped": "Stopped sharing the invite code.",
+  "horizon.friends.short_code_changed": "Someone kept trying a wrong short code, so it changed.",
+  "horizon.friends.wrong_code": "Someone tried a wrong code.",
+  "horizon.friends.relay_stopped": "Too many wrong short codes, so the relay is off until you share again. Friends can still join with the full code.",
+  "horizon.friends.code_ready": "Your invite code is ready: Game Menu, Play with Friends. Copy it and send it to your friends.",
+  "horizon.friends.share_failed": "Couldn't share the world: %s",
+  "horizon.friends.finding_route": "Finding how friends can reach you…",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Space",
   "horizon.osk.delete": "Delete",
@@ -1039,8 +1058,5 @@
   "horizon.studio.topbar.add_marker": "Add Marker",
   "horizon.studio.topbar.clear_keyframes": "🗑 Clear Keyframes",
   "horizon.studio.topbar.timeline_hud": "⏱ Timeline",
-  "horizon.studio.topbar.split_scene": "Split Scene",
-  "horizon.recipes.fuel.options": "Hold SHIFT to pin this tooltip, then click an ingredient to view recipes.",
-  "horizon.recipes.fuel.any": "Any Fuel",
-  "horizon.recipes.fuel.minecraft": "Minecraft"
+  "horizon.studio.topbar.split_scene": "Split Scene"
 }

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Levas ombrojn al la plej malhela nigro de via ekrano. 0: vera nigro, sen levo.",
   "How bright highlights get. Auto: the peak your system reports.": "Kiel brilaj brilaĵoj ricevas. Aŭtomata: la pinto kiun via sistemo raportas.",
   "How bright white looks in the world. Auto: your desktop's white.": "Kiom hela blanko aspektas en la mondo. Aŭtomate: la blanko de via labortablo.",
+  "How bright the HUD and menus are, against paper white.": "Kiel brilaj la HUD kaj menuoj estas, kontraŭ papera blanka.",
   "How far mobs, crops and machines keep working. CPU time.": "Kiom malproksime amasoj, kultivaĵoj kaj maŝinoj daŭre funkcias. CPU-tempo.",
   "How far away mobs and items are drawn, as a share of normal.": "Kiom malproksime amasoj kaj eroj estas tiritaj, kiel parto de normalo.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Saltas terenon kaŝitan malantaŭ fermitaj sekcioj. For kostas multe.",
@@ -366,6 +367,7 @@
   "Advanced": "Altnivela",
   "Undo": "Malfari",
   "Search options": "Serĉaj opcioj",
+  "Shortcut": "Ŝparvojo",
   "Distance": "Distanco",
   "Display": "Montru",
   "Interface": "Interfaco",
@@ -436,9 +438,11 @@
   "Calibrate...": "Kalibri...",
   "Calibrate Anyway...": "Kalibru ĉiuokaze...",
   "Use Automatic Setup": "Uzu Aŭtomatan Agordon",
+  "Shortcut: %s": "Ŝparvojo: %s",
   "Next": "Poste",
   "HDR Calibration %s/%s: %s": "HDR-Kalibrado %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Agordas la tri sub plenan ekranon, unu testan bildon samtempe.",
+  "A key that opens this screen from the game. Not bound at first.": "Ŝlosilo, kiu malfermas ĉi tiun ekranon de la ludo. Komence ne ligita.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Via ekrano ne diris kiom brilas ĝi fariĝas: kalibru por agordi ĝin.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Jam agordita por via ekrano. Nur kalibru se HDR aspektas malĝusta.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Remetas Pintan Brilon kaj Paperan Blankan al la agordo de via ekrano.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Senretaj profiloj apartenas al ĉi tiu kazo",
   "horizon.splitscreen.profiles.move": "Movu kien vi ludas",
   "horizon.splitscreen.profiles.move_place": "Movu kien vi ludas: %s",
+  "horizon.friends.title": "Ludu kun Amikoj",
+  "horizon.friends.hint": "Amikoj algluas la kodon post la butono Amikoj de la titolekrano, en Rekta Konekto aŭ sur la Luda paĝo de la lanĉilo.",
+  "horizon.friends.copied": "Kopiita",
+  "horizon.friends.copy_code": "Kopiu Kodon",
+  "horizon.friends.stop_sharing": "Ĉesu Kundividon",
+  "horizon.friends.none_yet": "Ankoraŭ neniuj amikoj ĉi tie.",
+  "horizon.friends.here_now": "Ĉi tie nun: %s",
+  "horizon.friends.share_intro": "Kunhavigu ĉi tiun mondon malantaŭ invitkodo: ĝi malfermiĝas al LAN, kaj amikoj en la interreto aliĝas kun la kodo. Neniu servilo nia estas implikita.",
+  "horizon.friends.start_sharing": "Komencu Kunhavigi",
+  "horizon.friends.troubleshooting": "Solvado de problemoj...",
+  "horizon.friends.stopped": "Ĉesis kunhavigi la invitkodon.",
+  "horizon.friends.short_code_changed": "Iu daŭre provis malĝustan mallongan kodon, do ĝi ŝanĝiĝis.",
+  "horizon.friends.wrong_code": "Iu provis malĝustan kodon.",
+  "horizon.friends.relay_stopped": "Tro da malĝustaj mallongaj kodoj, do la relajso estas malŝaltita ĝis vi denove kundividos. Amikoj ankoraŭ povas aliĝi per la plena kodo.",
+  "horizon.friends.code_ready": "Via invitkodo estas preta: Luda Menuo, Ludu kun Amikoj. Kopiu ĝin kaj sendu ĝin al viaj amikoj.",
+  "horizon.friends.share_failed": "Ne povis dividi la mondon: %s",
+  "horizon.friends.finding_route": "Trovi kiel amikoj povas atingi vin...",
   "horizon.osk.shift": "Majusklo",
   "horizon.osk.space": "Spaco",
   "horizon.osk.delete": "Forigi",

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

@@ -310,6 +310,7 @@
   "Lifts shadows onto your display's darkest black. 0: true black, no lift.": "Eleva las sombras hasta el negro más oscuro de tu pantalla. 0: negro puro, sin elevación.",
   "How bright highlights get. Auto: the peak your system reports.": "Cuánto brillan los reflejos. Automático: el pico que informa tu sistema.",
   "How bright white looks in the world. Auto: your desktop's white.": "Qué tan brillante se ve el blanco en el mundo. Automático: el blanco de tu escritorio.",
+  "How bright the HUD and menus are, against paper white.": "Qué tan brillantes son el HUD y los menús respecto al blanco de papel.",
   "How far mobs, crops and machines keep working. CPU time.": "Hasta dónde siguen funcionando mobs, cultivos y máquinas. Tiempo de CPU.",
   "How far away mobs and items are drawn, as a share of normal.": "A qué distancia se dibujan mobs y objetos, como proporción de lo normal.",
   "Skips terrain hidden behind closed sections. Off costs a lot.": "Omite el terreno oculto tras secciones cerradas. Desactivarlo cuesta mucho.",
@@ -366,6 +367,7 @@
   "Advanced": "Avanzado",
   "Undo": "Deshacer",
   "Search options": "Buscar opciones",
+  "Shortcut": "Atajo",
   "Distance": "Distancia",
   "Display": "Pantalla",
   "Interface": "Interfaz",
@@ -436,9 +438,11 @@
   "Calibrate...": "Calibrar...",
   "Calibrate Anyway...": "Calibrar de todos modos...",
   "Use Automatic Setup": "Usar la configuración automática",
+  "Shortcut: %s": "Atajo: %s",
   "Next": "Siguiente",
   "HDR Calibration %s/%s: %s": "Calibración HDR %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Configura las tres opciones siguientes a pantalla completa, con una imagen de prueba cada vez.",
+  "A key that opens this screen from the game. Not bound at first.": "Una tecla que abre esta pantalla desde el juego. Sin asignar al principio.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Tu pantalla no indicó cuánto brilla: calíbrala para configurarla.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Ya está configurado para tu pantalla. Calibra solo si el HDR se ve mal.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Devuelve Brillo máximo y Blanco de papel a la configuración de tu pantalla.",
@@ -462,6 +466,23 @@
   "horizon.splitscreen.profiles.offline_note": "Los perfiles sin conexión pertenecen a esta instancia",
   "horizon.splitscreen.profiles.move": "Mover dónde juegas",
   "horizon.splitscreen.profiles.move_place": "Mover dónde juegas: %s",
+  "horizon.friends.title": "Jugar con amigos",
+  "horizon.friends.hint": "Tus amigos pegan el código tras el botón Amigos de la pantalla de título, en Conexión directa o en la página Jugar del launcher.",
+  "horizon.friends.copied": "Copiado",
+  "horizon.friends.copy_code": "Copiar código",
+  "horizon.friends.stop_sharing": "Dejar de compartir",
+  "horizon.friends.none_yet": "Aún no hay amigos aquí.",
+  "horizon.friends.here_now": "Aquí ahora: %s",
+  "horizon.friends.share_intro": "Comparte este mundo con un código de invitación: se abre a la LAN y tus amigos de internet se unen con el código. No interviene ningún servidor nuestro.",
+  "horizon.friends.start_sharing": "Empezar a compartir",
+  "horizon.friends.troubleshooting": "Solución de problemas...",
+  "horizon.friends.stopped": "Se ha dejado de compartir el código de invitación.",
+  "horizon.friends.short_code_changed": "Alguien intentó varias veces un código corto incorrecto, así que ha cambiado.",
+  "horizon.friends.wrong_code": "Alguien ha probado un código incorrecto.",
+  "horizon.friends.relay_stopped": "Demasiados códigos cortos incorrectos: el relé queda apagado hasta que vuelvas a compartir. Tus amigos aún pueden unirse con el código completo.",
+  "horizon.friends.code_ready": "Tu código de invitación está listo: Menú del juego, Jugar con amigos. Cópialo y envíaselo a tus amigos.",
+  "horizon.friends.share_failed": "No se pudo compartir el mundo: %s",
+  "horizon.friends.finding_route": "Buscando cómo pueden llegar tus amigos hasta ti…",
   "horizon.osk.shift": "Mayús",
   "horizon.osk.space": "Espacio",
   "horizon.osk.delete": "Borrar",