From 14bd239141ffedab749097a6a5f97d6b897a3b69 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 10:37:40 +0200 Subject: [PATCH 01/62] Solid section draws grouped by arena page within 64-block bands A list sorted only by distance switched vertex buffer every few sections: about 1200 indirect multi-draws a frame at render distance 32, most of a few entries, which Mesa's Intel driver unrolls on the CPU. Grouping each band's sections by page keeps the list front to back within the band, with one call per page and band. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx.rs | 47 +++++- crates/horizon-client/src/gfx/page_runs.rs | 181 +++++++++++++++++++++ 2 files changed, 224 insertions(+), 4 deletions(-) create mode 100644 crates/horizon-client/src/gfx/page_runs.rs diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 127aaf737..cbd5e8b8c 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -66,6 +66,7 @@ mod java_stages; mod lod; mod occlusion; mod pack_stages; +mod page_runs; pub mod panorama; mod resident; mod stars; @@ -421,6 +422,9 @@ pub struct Renderer { /// built, and their pages. phase2_draws: Vec<[u32; 5]>, phase2_pages: Vec<(u32, Option)>, + /// Each section's solid draws, to group them by arena page. + solid_runs: page_runs::PageRuns, + phase2_runs: page_runs::PageRuns, /// Block-entity blocks per meshed section (world position, state id). block_entities: HashMap>, /// Changes whenever `block_entities` does (unique across renderers). @@ -2170,6 +2174,8 @@ impl Renderer { draw_pages: Vec::new(), phase2_draws: Vec::new(), phase2_pages: Vec::new(), + solid_runs: page_runs::PageRuns::default(), + phase2_runs: page_runs::PageRuns::default(), block_entities: HashMap::new(), block_entity_revision: next_block_entity_revision(), occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16), @@ -3042,6 +3048,8 @@ impl Renderer { .and_then(|cull| cull.begin(&self.device).then_some(cull)); self.phase2_draws.clear(); self.phase2_pages.clear(); + self.solid_runs.clear(); + self.phase2_runs.clear(); for (i, v) in visible.iter().enumerate() { let s = self.sections.get(v.slot); let first_phase = cull.as_ref().is_none_or(|c| c.first(v.slot)); @@ -3060,22 +3068,53 @@ impl Renderer { pages.push((s.page, None)); indices += quads * 6; }); - match &mut cull { - Some(c) if first_phase => c.drawn(i, v.slot, indices), - Some(c) => c.deferred(i, v.slot, start, draws.len() - start, indices), - None => {} + let runs = if first_phase { + &mut self.solid_runs + } else { + &mut self.phase2_runs + }; + runs.push( + v.distance, + s.page, + start, + draws.len() - start, + [i as u32, v.slot, indices], + ); + if let Some(c) = &mut cull + && first_phase + { + c.drawn(i, v.slot, indices); + } + } + self.solid_runs + .regroup(&mut self.draws, &mut self.draw_pages, 0); + // Phase 2's draws are tested where grouping left them. + let runs = self + .phase2_runs + .regroup(&mut self.phase2_draws, &mut self.phase2_pages, 0); + if let Some(c) = &mut cull { + for r in runs { + let [i, slot, indices] = r.tag; + c.deferred(i as usize, slot, r.start as usize, r.len as usize, indices); } } // Distant terrain tiles are never occlusion tested: phase 1. + let tiles = self.draws.len(); + self.solid_runs.clear(); for (i, v) in visible_lods.iter().enumerate() { let s = &self.lods[&v.key].mesh; + let start = self.draws.len(); s.faces.ranges(eye - Vec3::from(v.origin), |first, quads| { let first = s.start + u64::from(first) * 4; self.draws .push([quads * 6, 1, 0, first as u32, (visible.len() + i) as u32]); self.draw_pages.push((s.page, None)); }); + self.solid_runs + .push(v.distance, s.page, start, self.draws.len() - start, [0; 3]); } + self.solid_runs + .regroup(&mut self.draws, &mut self.draw_pages, tiles); let phase1_draws = self.draws.len() as u32; self.draws.extend_from_slice(&self.phase2_draws); self.draw_pages.extend_from_slice(&self.phase2_pages); diff --git a/crates/horizon-client/src/gfx/page_runs.rs b/crates/horizon-client/src/gfx/page_runs.rs new file mode 100644 index 000000000..3ada45737 --- /dev/null +++ b/crates/horizon-client/src/gfx/page_runs.rs @@ -0,0 +1,181 @@ +//! Solid draws grouped by vertex arena page within distance bands. +//! +//! Sections sit in arena pages of 256 MiB, so render distance 32 spreads +//! them over half a dozen pages, and a list sorted only by distance switches +//! page every few sections: about a thousand indirect multi-draws of two or +//! three entries a frame. Mesa's Intel driver (and wgpu-core, for each +//! vertex buffer change) pays per call, and below four entries Mesa unrolls +//! the call on the CPU entry by entry. Grouping the sections of one band of +//! distance by page keeps the list front to back to within the band (what +//! the depth test needs to reject hidden fragments early) with one call per +//! page and band. +//! +//! The picture does not change: solid draws write depth and are tested +//! against it, so their order only decides which of two fragments at the +//! same depth stays, and sections do not share faces. + +/// The width of a band, in blocks. +const BAND: f64 = 64.0; + +/// One section's draws: `start..start + len` of the list. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(super) struct Run { + key: u64, + pub start: u32, + pub len: u32, + /// The caller's data, carried along (occlusion culling's test inputs). + pub tag: [u32; 3], +} + +#[derive(Default)] +pub(super) struct PageRuns { + runs: Vec, + scratch: Vec<([u32; 5], (u32, Option))>, +} + +impl PageRuns { + pub fn clear(&mut self) { + self.runs.clear(); + } + + /// The draws `start..start + len` of a section `distance` from the + /// camera (squared, as bits) in arena `page`; runs come nearest first. + pub fn push(&mut self, distance: u64, page: u32, start: usize, len: usize, tag: [u32; 3]) { + if len > 0 { + let band = (f64::from_bits(distance).sqrt() / BAND) as u64; + self.runs.push(Run { + key: band << 32 | u64::from(page), + start: start as u32, + len: len as u32, + tag, + }); + } + } + + /// Reorders `draws[base..]` and their `pages`, which the pushed runs + /// cover in order, so that each band's runs in one page are adjacent + /// (in distance order); returns the runs at their new places. + pub fn regroup( + &mut self, + draws: &mut [[u32; 5]], + pages: &mut [(u32, Option)], + base: usize, + ) -> &[Run] { + let page = |r: &Run| r.key as u32; + if self.runs.windows(2).all(|w| page(&w[0]) == page(&w[1])) { + return &self.runs; + } + // Stable: within a band and page the runs stay nearest first. + self.runs.sort_by_key(|r| r.key); + self.scratch.clear(); + for r in &mut self.runs { + let (s, e) = (r.start as usize, (r.start + r.len) as usize); + r.start = (base + self.scratch.len()) as u32; + self.scratch + .extend(draws[s..e].iter().copied().zip(pages[s..e].iter().copied())); + } + for (i, &(draw, p)) in self.scratch.iter().enumerate() { + draws[base + i] = draw; + pages[base + i] = p; + } + &self.runs + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn bits(blocks: f64) -> u64 { + (blocks * blocks).to_bits() + } + + /// Runs of (distance in blocks, page, draws), as the list builder pushes them. + fn list(runs: &[(f64, u32, u32)]) -> (PageRuns, Vec<[u32; 5]>, Vec<(u32, Option)>) { + let mut grouped = PageRuns::default(); + let (mut draws, mut pages) = (Vec::new(), Vec::new()); + for (n, &(distance, page, count)) in runs.iter().enumerate() { + let start = draws.len(); + for k in 0..count { + draws.push([n as u32, k, 0, 0, 0]); + pages.push((page, None)); + } + grouped.push( + bits(distance), + page, + start, + count as usize, + [n as u32, 0, 0], + ); + } + (grouped, draws, pages) + } + + #[test] + fn a_band_draws_each_page_once_keeping_the_order_inside_it() { + let (mut grouped, mut draws, mut pages) = list(&[ + (10.0, 1, 2), + (20.0, 0, 1), + (30.0, 1, 3), + (40.0, 0, 2), + (70.0, 1, 1), + ]); + let runs: Vec<_> = grouped + .regroup(&mut draws, &mut pages, 0) + .iter() + .map(|r| (r.tag[0], r.start, r.len)) + .collect(); + assert_eq!( + runs, + [(1, 0, 1), (3, 1, 2), (0, 3, 2), (2, 5, 3), (4, 8, 1)] + ); + let order: Vec<_> = draws.iter().map(|d| (d[0], d[1])).collect(); + assert_eq!( + order, + [ + (1, 0), + (3, 0), + (3, 1), + (0, 0), + (0, 1), + (2, 0), + (2, 1), + (2, 2), + (4, 0) + ] + ); + let pages: Vec<_> = pages.iter().map(|p| p.0).collect(); + assert_eq!(pages, [0, 0, 0, 1, 1, 1, 1, 1, 1]); + } + + #[test] + fn bands_stay_in_distance_order() { + let (mut grouped, mut draws, mut pages) = + list(&[(10.0, 1, 1), (100.0, 0, 1), (200.0, 0, 1)]); + grouped.regroup(&mut draws, &mut pages, 0); + let order: Vec<_> = draws.iter().map(|d| d[0]).collect(); + assert_eq!(order, [0, 1, 2]); + } + + #[test] + fn one_page_and_an_offset_list() { + let (mut grouped, mut draws, mut pages) = list(&[(10.0, 3, 2), (90.0, 3, 1)]); + let before = draws.clone(); + assert_eq!(grouped.regroup(&mut draws, &mut pages, 0)[1].start, 2); + assert_eq!(draws, before); + // A list after other draws: starts are absolute. + let mut grouped = PageRuns::default(); + let mut draws = vec![[9; 5], [7, 0, 0, 0, 0], [8, 0, 0, 0, 0]]; + let mut pages = vec![(5, None), (1, None), (0, None)]; + grouped.push(bits(5.0), 1, 1, 1, [0; 3]); + grouped.push(bits(6.0), 0, 2, 1, [1, 0, 0]); + let runs = grouped.regroup(&mut draws, &mut pages, 1).to_vec(); + assert_eq!(draws, [[9; 5], [8, 0, 0, 0, 0], [7, 0, 0, 0, 0]]); + assert_eq!(pages, [(5, None), (0, None), (1, None)]); + assert_eq!((runs[0].tag[0], runs[0].start), (1, 1)); + // Empty runs are left out. + grouped.clear(); + grouped.push(bits(1.0), 0, 0, 0, [0; 3]); + assert!(grouped.regroup(&mut [], &mut [], 0).is_empty()); + } +} From d0330061bdbb896d9c3b3b4d3447caba3230df1f Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 10:45:33 +0200 Subject: [PATCH 02/62] Far Detail: an opt-in Reduced level for far terrain, suggested on integrated GPUs Reduced starts each far tile level at half the distance Full does (about a quarter of the far quads beyond the full-detail edge, whose finest tiles stay). Full stays the default everywhere and no preset changes it. On integrated GPUs other than Apple's, the setting's description suggests Reduced. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 4 ++ crates/horizon-client/src/game/control.rs | 2 + crates/horizon-client/src/gfx.rs | 8 +++ crates/horizon-client/src/graphics.rs | 68 ++++++++++++++++++- crates/horizon-client/src/graphics_ui.rs | 20 +++++- crates/horizon-client/src/lod.rs | 80 +++++++++++++++++++---- 6 files changed, 168 insertions(+), 14 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 2df6aa9b0..a115796e5 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -10247,6 +10247,10 @@ impl Game<'_> { if let (Some(lod), Some(player)) = (&mut self.lod, &self.player) { let lod_distance = self.settings.horizon.lod_distance_on(&renderer.info); lod.set_near_loading(self.streaming.busy()); + lod.set_reduced_detail( + self.settings.horizon.far_detail + == horizon_client::graphics::FarDetail::Reduced, + ); // The covered columns change only with the complete ones and // the render area: rebuilt then, not every frame. let at = ( diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index d79f69d3c..df641d5c2 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -838,6 +838,8 @@ impl Game<'_> { "source_attempted": self.lod_source_attempted, "active_tiles": self.lod.as_ref().map_or(0, |lod| lod.stats().0), "cached_tiles": self.lod.as_ref().map_or(0, |lod| lod.stats().1), + "far_detail": self.settings.horizon.far_detail.name(), + "resident_quads": self.renderer.as_ref().map_or(0, |r| r.lod_quads()), "pending_observations": self.lod_observe.len(), "refined_samples": self.lod.as_ref().map_or(0, |lod| lod.refined_samples()), }); diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 127aaf737..9be2958fb 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -850,6 +850,13 @@ impl Renderer { pub fn resident_sections(&self) -> usize { self.sections.len() } + /// Quads of the far terrain tiles with GPU buffers. + pub fn lod_quads(&self) -> u64 { + self.lods + .values() + .map(|tile| u64::from(tile.mesh.solid + tile.mesh.translucent)) + .sum() + } /// Bytes of the section vertex arena's buffers, and of the vertices /// resident sections hold in them. pub fn section_vertex_bytes(&self) -> [u64; 2] { @@ -916,6 +923,7 @@ impl Renderer { None => open_device(&window, offscreen, api, layers).await?, }; let info = adapter.get_info(); + crate::graphics::suggest_reduced_far_detail(crate::graphics::lod_capped(&info)); let size = window.inner_size(); let (config, present_modes) = if let Some(surface) = &surface { let mut config = surface diff --git a/crates/horizon-client/src/graphics.rs b/crates/horizon-client/src/graphics.rs index bea0ffaa9..1974c4538 100644 --- a/crates/horizon-client/src/graphics.rs +++ b/crates/horizon-client/src/graphics.rs @@ -156,6 +156,48 @@ pub enum Overlay { Graph, } +/// How finely far terrain is drawn (`FarDetail` in the LOD options). +#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)] +pub enum FarDetail { + /// Each tile level starts at eight times its size from the camera. + #[default] + Full, + /// Coarser levels start at half that distance: about a quarter of the + /// far quads, for GPUs that far terrain slows down. Changes the picture. + Reduced, +} +impl FarDetail { + pub fn name(self) -> &'static str { + match self { + FarDetail::Full => "full", + FarDetail::Reduced => "reduced", + } + } + pub fn label(self) -> &'static str { + match self { + FarDetail::Full => "Full", + FarDetail::Reduced => "Reduced", + } + } + fn parse(s: &str) -> Self { + if s == "reduced" { + FarDetail::Reduced + } else { + FarDetail::Full + } + } +} + +static REDUCED_SUGGESTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false); +/// Whether the settings suggest Reduced far detail: set when the renderer +/// starts, on the GPUs `lod_capped` names (far terrain slows them most). +pub fn suggest_reduced_far_detail(on: bool) { + REDUCED_SUGGESTED.store(on, std::sync::atomic::Ordering::Relaxed); +} +pub fn reduced_far_detail_suggested() -> bool { + REDUCED_SUGGESTED.load(std::sync::atomic::Ordering::Relaxed) +} + /// The farthest LOD Distance, in chunks, on integrated GPUs other than /// Apple's: they share the CPU's memory bandwidth, and past it far terrain /// costs them more frame time than it is worth. @@ -181,6 +223,8 @@ pub struct Graphics { pub preset: Preset, /// Distant surface terrain range, in chunks; 0 disables LODs. pub lod_distance: u32, + /// How finely far terrain is drawn; Full unless the player picks Reduced. + pub far_detail: FarDetail, /// Skip sections hidden behind closed ones (vanilla's occlusion graph). pub cave_culling: bool, /// Hide shared leaf and mangrove-root faces, reducing foliage density. @@ -221,6 +265,7 @@ impl Default for Graphics { Self { preset: Preset::Custom, lod_distance: 0, + far_detail: FarDetail::Full, cave_culling: true, cull_leaves: false, entity_culling: false, @@ -268,6 +313,7 @@ impl Graphics { match key.trim() { "preset" => g.preset = Preset::parse(value), "lodDistance" => g.lod_distance = number(g.lod_distance).min(1024), + "farDetail" => g.far_detail = FarDetail::parse(value), "caveCulling" => g.cave_culling = flag(g.cave_culling), "cullLeaves" => g.cull_leaves = flag(g.cull_leaves), "entityCulling" => g.entity_culling = flag(g.entity_culling), @@ -306,9 +352,10 @@ impl Graphics { } pub fn serialize(&self) -> String { format!( - "preset:{}\nlodDistance:{}\ncaveCulling:{}\ncullLeaves:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nlevel:{}\nbatteryMode:{}\nshaderPack:{}\ngraphicsApi:{}\n", + "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\ncullLeaves:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nlevel:{}\nbatteryMode:{}\nshaderPack:{}\ngraphicsApi:{}\n", self.preset.name(), self.lod_distance, + self.far_detail.name(), bool_text(self.cave_culling), bool_text(self.cull_leaves), bool_text(self.entity_culling), @@ -410,6 +457,7 @@ mod tests { let g = Graphics { preset: Preset::Balanced, lod_distance: 256, + far_detail: FarDetail::Reduced, cave_culling: false, cull_leaves: true, entity_culling: true, @@ -491,6 +539,24 @@ mod tests { assert_eq!(Graphics::parse("lodDistance:invalid\n").lod_distance, 0); } + #[test] + fn far_detail_is_full_unless_reduced_is_picked() { + assert_eq!(Graphics::default().far_detail, FarDetail::Full); + assert_eq!( + Graphics::parse("farDetail:reduced\n").far_detail, + FarDetail::Reduced + ); + for text in ["farDetail:full\n", "farDetail:other\n", ""] { + assert_eq!(Graphics::parse(text).far_detail, FarDetail::Full); + } + // No preset changes it. + for preset in Preset::ALL { + let mut s = crate::settings::Settings::default(); + apply_preset(preset, &mut s); + assert_eq!(s.horizon.far_detail, FarDetail::Full, "{preset:?}"); + } + } + #[test] fn automatic_workers_leave_cores_for_the_render_and_server_threads() { let g = Graphics::default(); diff --git a/crates/horizon-client/src/graphics_ui.rs b/crates/horizon-client/src/graphics_ui.rs index eea2d03cb..cc27b9488 100644 --- a/crates/horizon-client/src/graphics_ui.rs +++ b/crates/horizon-client/src/graphics_ui.rs @@ -2,7 +2,7 @@ //! they show, in what groups, with what description and cost, and their //! input. How they look comes from `graphics_style`. use crate::{ - graphics::{GraphicsApi, Overlay, Pacing, PresentMode, Preset}, + graphics::{FarDetail, GraphicsApi, Overlay, Pacing, PresentMode, Preset}, graphics_style::{Cost, STYLE}, hud::{HudAtlas, HudBatch}, options_ui::Opt, @@ -22,6 +22,7 @@ pub enum Level { pub enum H { Preset, LodDistance, + FarDetail, CaveCulling, CullLeaves, EntityCulling, @@ -85,6 +86,16 @@ pub fn rows(level: Level) -> Vec { Medium, "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.", ); + // Suggested, never switched on, where far terrain costs the GPU most. + let far = h( + H::FarDetail, + Medium, + if crate::graphics::reduced_far_detail_suggested() { + "Reduced draws far terrain coarser: faster on this integrated GPU." + } else { + "Reduced draws far terrain coarser, for GPUs it slows down." + }, + ); let fov = v( Opt::Fov, Low, @@ -107,11 +118,12 @@ pub fn rows(level: Level) -> Vec { "Sets the options below together. Changing one makes it Custom.", ); let mut rows = match level { - Level::Simple => vec![preset, render, lod, fov, fps, vsync, gui], + Level::Simple => vec![preset, render, lod, far, fov, fps, vsync, gui], Level::Advanced => vec![ Row::Header("Rendering"), render, lod, + far, v( Opt::SimulationDistance, Medium, @@ -335,6 +347,7 @@ impl H { 0 => labelled("LOD Distance", "Off"), n => labelled("LOD Distance", format!("{n} chunks")), }, + H::FarDetail => labelled("Far Detail", g.far_detail.label()), H::CaveCulling => labelled("Cave Culling", on_off(g.cave_culling)), H::CullLeaves => labelled("Cull Leaves", on_off(g.cull_leaves)), H::EntityCulling => labelled("Entity Culling", on_off(g.entity_culling)), @@ -411,6 +424,9 @@ impl H { H::LodDistance => { g.lod_distance = step(&[0, 64, 128, 256, 512, 1024], g.lod_distance, back) } + H::FarDetail => { + g.far_detail = step(&[FarDetail::Full, FarDetail::Reduced], g.far_detail, back) + } H::CaveCulling => g.cave_culling = !g.cave_culling, H::CullLeaves => g.cull_leaves = !g.cull_leaves, H::EntityCulling => g.entity_culling = !g.entity_culling, diff --git a/crates/horizon-client/src/lod.rs b/crates/horizon-client/src/lod.rs index 0aa7b1f94..f8adb1f16 100644 --- a/crates/horizon-client/src/lod.rs +++ b/crates/horizon-client/src/lod.rs @@ -326,14 +326,17 @@ struct Plan { impl Plan { #[cfg(test)] fn new(camera: [i32; 2], detail: i32, distance: u32) -> Self { - Self::with_previous(camera, detail, distance, &Self::default(), 0) + Self::with_previous(camera, detail, distance, &Self::default(), 0, false) } + /// `reduced`: Reduced far detail (`graphics::FarDetail`), each level from + /// half the distance. fn with_previous( camera: [i32; 2], detail: i32, distance: u32, previous: &Self, elevation: i32, + reduced: bool, ) -> Self { let range = distance.min(1024) as i32 * 16; let mut level = 0; @@ -349,25 +352,35 @@ impl Plan { for x in (camera[0] - range).div_euclid(size)..=(camera[0] + range).div_euclid(size) { let key = TileKey { x, z, level }; result.roots.push(key); - result.visit(key, camera, detail, range, previous); + result.visit(key, camera, detail, range, previous, reduced); } } result } - fn visit(&mut self, key: TileKey, camera: [i32; 2], detail: i32, range: i32, previous: &Self) { + fn visit( + &mut self, + key: TileKey, + camera: [i32; 2], + detail: i32, + range: i32, + previous: &Self, + reduced: bool, + ) { if key.distance(camera) > range { return; } self.nodes.insert(key); - // Keep distant cells small on screen; finest tiles retain individual blocks. - let threshold = key.size() * if previous.split.contains(&key) { 10 } else { 8 }; + // Keep distant cells small on screen; finest tiles retain individual + // blocks. Reduced keeps them twice as large (a quarter of the cells). + let split = if previous.split.contains(&key) { 10 } else { 8 }; + let threshold = key.size() * if reduced { split / 2 } else { split }; if key.level > 0 && (key.distance(camera) < detail * 16 + 16 || key.distance(camera).max(self.elevation) < threshold) { self.split.insert(key); for child in key.children() { - self.visit(child, camera, detail, range, previous); + self.visit(child, camera, detail, range, previous, reduced); } } } @@ -517,8 +530,10 @@ pub struct Lod { /// The plan or the covered columns changed: covered leaves need stand-ins. replanned: bool, invalidated: FxHashSet<(i32, i32)>, - area: Option<([i32; 2], i32, u32, i32)>, + area: Option<([i32; 2], i32, u32, i32, bool)>, plan: Plan, + /// Reduced far detail (`set_reduced_detail`). + reduced_detail: bool, pending: FxHashSet, sample_nearby: bool, detail_masks: FxHashMap, @@ -714,6 +729,7 @@ impl Lod { replanned: true, invalidated: FxHashSet::default(), area: None, + reduced_detail: false, plan: Plan::default(), pending: FxHashSet::default(), sample_nearby: true, @@ -930,6 +946,11 @@ impl Lod { pub fn set_near_loading(&mut self, loading: bool) { self.near_loading = loading; } + /// Reduced far detail (`graphics::FarDetail::Reduced`): the next update + /// replans when it changes. + pub fn set_reduced_detail(&mut self, reduced: bool) { + self.reduced_detail = reduced; + } fn held(&self) -> bool { self.small && self.near_loading } @@ -1021,11 +1042,19 @@ impl Lod { detail, distance, elevation, + self.reduced_detail, ); if self.area != Some(area) { crate::spans::time("lod_plan", || { self.area = Some(area); - self.plan = Plan::with_previous(camera, detail, distance, &self.plan, elevation); + self.plan = Plan::with_previous( + camera, + detail, + distance, + &self.plan, + elevation, + self.reduced_detail, + ); self.ready.retain(|key, _| self.plan.nodes.contains(key)); self.detail_masks .retain(|key, _| self.plan.nodes.contains(key)); @@ -1421,6 +1450,35 @@ mod tests { use super::*; use crate::mesher::TerrainVertex; #[test] + fn reduced_far_detail_only_merges_tiles_away_from_the_near_terrain() { + let leaves = |plan: &Plan| { + plan.nodes + .iter() + .filter(|k| !plan.split.contains(k)) + .count() + }; + for camera in [[0, 0], [100, -40]] { + for distance in [64, 128, 512, 1024] { + let full = Plan::new(camera, 12, distance); + let reduced = Plan::with_previous(camera, 12, distance, &Plan::default(), 0, true); + // Never finer than Full anywhere, and as fine next to the + // full-detail area, whose edge the finest tiles match. + assert!(reduced.split.is_subset(&full.split)); + assert_eq!(reduced.roots, full.roots); + for key in reduced.nodes.iter().filter(|k| !reduced.split.contains(k)) { + if key.distance(camera) < 12 * 16 + 16 { + assert_eq!(key.level, 0, "{key:?}"); + } + } + let (full, reduced) = (leaves(&full), leaves(&reduced)); + assert!( + reduced * 2 < full, + "{reduced} of {full} tiles at {distance}" + ); + } + } + } + #[test] fn far_plan_is_bounded_and_near_tiles_align_with_chunks() { for camera in [[0, 0], [-1, -17], [1023, -4097]] { for distance in [64, 256, 1024] { @@ -1453,7 +1511,7 @@ mod tests { #[test] fn aerial_distance_avoids_unseen_full_detail_outside_the_near_area() { let ground = Plan::new([0, 0], 12, 1024); - let high = Plan::with_previous([0, 0], 12, 1024, &Plan::default(), 1024); + let high = Plan::with_previous([0, 0], 12, 1024, &Plan::default(), 1024, false); assert!(high.nodes.len() < ground.nodes.len()); assert!( high.nodes.contains(&TileKey { @@ -1505,7 +1563,7 @@ mod tests { #[test] fn detail_survives_movement_across_a_split_threshold() { let before = Plan::new([0, 0], 2, 256); - let after = Plan::with_previous([16, 0], 2, 256, &before, 0); + let after = Plan::with_previous([16, 0], 2, 256, &before, 0, false); let mut retained = 0; for key in &before.split { if key.distance([16, 0]) < key.size() * 10 { @@ -1804,7 +1862,7 @@ mod tests { // Exercise the actual worker/update seam: a parent stays displayed // until all four child meshes can replace it in the same update. let camera = [-256.0, 100.0, -256.0]; - lod.area = Some(([-16, -16], 2, 64, 0)); + lod.area = Some(([-16, -16], 2, 64, 0, false)); lod.plan.roots = vec![key]; lod.plan.nodes.insert(key); // As a replan does (`update` only selects after a change). From 8a03758c3a41c9d113864ddab3271bf523c6e8a6 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 11:47:03 +0200 Subject: [PATCH 03/62] Load time: build a pack's content root and load its sprites and models in parallel A content pack's first start rewrote 19 per-state tables one after another and reopened each zip mod's archive for every file it copied (its whole index each time). Every start then decoded the atlases' mod textures and parsed the mods' block models one file at a time on the main thread: with ATM10's 42 data mods that was about 70 % of the sampled startup. - mod_content: the tables are rewritten on up to three threads, largest first; a zip mod's archive is opened once for all its files (horizon-mods' Content::reader). - hud::atlas_sprites and ParsedModels::load list their files first, then decode and parse them on every core (par::par_map, results in the input order). The sprites come out in the order the one-by-one loop gave, and the content root is byte-identical. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/hud.rs | 59 ++++++++++----- crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/mod_content.rs | 86 ++++++++++++++++------ crates/horizon-client/src/model_library.rs | 29 ++++++-- crates/horizon-client/src/par.rs | 54 ++++++++++++++ crates/horizon-mods/src/content.rs | 60 +++++++++------ 6 files changed, 216 insertions(+), 73 deletions(-) create mode 100644 crates/horizon-client/src/par.rs diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 0cc99b07b..b0c57f1d7 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -82,11 +82,13 @@ fn atlas_sprites(root: &Path, packed: &[PackedImage]) -> Vec { use crate::atlas_sources::{self, SpriteOrigin}; let have: std::collections::HashSet<&str> = packed.iter().map(|i| i.0.as_str()).collect(); let textures = atlas_sources::list_textures(root); - let load = |texture: &str, directory: &str| { - decode(&atlas_sources::texture_path(root, texture, directory)).ok() - }; - let mut out: Vec = Vec::new(); - let mut added = std::collections::HashSet::new(); + // Each new name with its origins in the atlases' order: the first that + // loads is the sprite. They load at once (a content pack's atlases list + // tens of thousands of files), and come out in the order a load of one + // after another would give. + let mut names: Vec<(String, Vec<(usize, SpriteOrigin)>)> = Vec::new(); + let mut slots = std::collections::HashMap::new(); + let mut order = 0; for (atlas, sources) in atlas_sources::atlases(root) { // The other atlases' renamed files (GUI sprites, particles...) are // looked up by their texture paths here. @@ -96,18 +98,33 @@ fn atlas_sprites(root: &Path, packed: &[PackedImage]) -> Vec { continue; } let name = id.strip_prefix("minecraft:").unwrap_or(&id).to_owned(); - if have.contains(name.as_str()) || added.contains(&name) { + if have.contains(name.as_str()) { continue; } - let image = match &origin { + // A vanilla file is packed under its own name already: only a + // renamed one is new. Other namespaces' files (content mods) are + // never in the walked directories. + if let SpriteOrigin::File(texture) = &origin + && texture.strip_prefix("minecraft:") == Some(name.as_str()) + { + continue; + } + let slot = *slots.entry(name.clone()).or_insert_with(|| { + names.push((name, Vec::new())); + names.len() - 1 + }); + names[slot].1.push((order, origin)); + order += 1; + } + } + let load = |texture: &str, directory: &str| { + decode(&atlas_sources::texture_path(root, texture, directory)).ok() + }; + let first = |(name, origins): &(String, Vec<(usize, SpriteOrigin)>)| { + origins.iter().find_map(|(order, origin)| { + let image = match origin { SpriteOrigin::File(texture) => { let path = texture.strip_prefix("minecraft:").unwrap_or(texture); - // A vanilla file is packed under its own name already: - // only a renamed one is new. Other namespaces' files - // (content mods) are never in the walked directories. - if texture.starts_with("minecraft:") && path == name { - continue; - } load(texture, "textures").map(|(w, h, p)| { // Animated strips keep their first frame, like the packed files. if h > w && (path.starts_with("block/") || path.starts_with("item/")) { @@ -119,13 +136,15 @@ fn atlas_sprites(root: &Path, packed: &[PackedImage]) -> Vec { } generated => atlas_sources::generate(generated, &load), }; - if let Some((w, h, pixels)) = image { - added.insert(name.clone()); - out.push((name, w, h, pixels)); - } - } - } - out + image.map(|(w, h, pixels)| (*order, (name.clone(), w, h, pixels))) + }) + }; + let mut out: Vec<_> = crate::par::par_map(&names, first) + .into_iter() + .flatten() + .collect(); + out.sort_unstable_by_key(|(order, _)| *order); + out.into_iter().map(|(_, image)| image).collect() } impl HudAtlas { /// A font glyph's atlas cell (8x8 GUI pixels) and advance. diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 7a69de4aa..f5c19bdc6 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -131,6 +131,7 @@ pub mod osk; pub mod overlay; pub mod pack_screen; pub mod packs; +pub mod par; pub mod particles; pub mod patrol; pub mod perf_overlay; diff --git a/crates/horizon-client/src/mod_content.rs b/crates/horizon-client/src/mod_content.rs index 0497f06b4..52e6d30ff 100644 --- a/crates/horizon-client/src/mod_content.rs +++ b/crates/horizon-client/src/mod_content.rs @@ -996,6 +996,66 @@ impl TagMerge { } } +/// Threads rewriting the tables at once. Each holds a whole table as a tree +/// (gameplay-facts.json's is over a gigabyte with ATM10's mods), so more +/// would mostly add memory. +const TABLE_THREADS: usize = 3; + +/// Rewrites the base's per-state tables for the mods' states into the +/// overlay. They are independent: [`TABLE_THREADS`] threads take them, +/// the largest first. +fn tables(base: &Path, plan: &Plan, overlay: &Overlay<'_>) -> Result<()> { + let mut jobs: Vec<(&str, u64)> = JSON_TABLES + .iter() + .chain(&NBT_TABLES) + .filter_map(|name| Some((*name, fs::metadata(base.join(name)).ok()?.len()))) + .collect(); + jobs.sort_by_key(|(_, size)| std::cmp::Reverse(*size)); + // Their directories become real here, so the threads only write files. + for (name, _) in &jobs { + if let Some(parent) = Path::new(name).parent() { + overlay.dir(parent)?; + } + } + let table = |name: &str| -> Result<()> { + let path = base.join(name); + let bytes = if JSON_TABLES.contains(&name) { + let mut doc = read_json(&path)?; + plan.json(name, &mut doc) + .map_err(|e| format!("{name}: {e}"))?; + serde_json::to_vec(&doc)? + } else { + let (mut named, _) = nbt::read_named(&fs::read(&path)?, Limits::tables()) + .map_err(|e| format!("{name}: {e}"))?; + plan.nbt(&mut named.tag); + nbt::write_named(&named, Limits::tables()).map_err(|e| format!("{name}: {e}"))? + }; + overlay.write(name, &bytes) + }; + let next = std::sync::atomic::AtomicUsize::new(0); + let threads = std::thread::available_parallelism().map_or(1, |n| n.get()); + std::thread::scope(|scope| { + let workers: Vec<_> = (0..threads.min(TABLE_THREADS)) + .map(|_| { + scope.spawn(|| -> std::result::Result<(), String> { + loop { + let i = next.fetch_add(1, std::sync::atomic::Ordering::Relaxed); + let Some((name, _)) = jobs.get(i) else { + return Ok(()); + }; + table(name).map_err(|e| e.to_string())?; + } + }) + }) + .collect(); + workers.into_iter().try_for_each(|w| { + w.join() + .unwrap_or_else(|_| Err("a table thread panicked".into())) + }) + })?; + Ok(()) +} + /// Builds the content root for `mods` over `base` in `out`. Returns the /// warnings for the log: the shared tags a mod replaced. pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result> { @@ -1015,28 +1075,7 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result let base = &std::path::absolute(base)?; let plan = Plan::new(base, mods)?; let overlay = Overlay::new(base, out)?; - for name in JSON_TABLES { - let path = base.join(name); - if !path.exists() { - continue; - } - let mut doc = read_json(&path)?; - plan.json(name, &mut doc) - .map_err(|e| format!("{name}: {e}"))?; - overlay.write(name, &serde_json::to_vec(&doc)?)?; - } - for name in NBT_TABLES { - let path = base.join(name); - if !path.exists() { - continue; - } - let (mut named, _) = nbt::read_named(&fs::read(&path)?, Limits::tables()) - .map_err(|e| format!("{name}: {e}"))?; - plan.nbt(&mut named.tag); - let bytes = - nbt::write_named(&named, Limits::tables()).map_err(|e| format!("{name}: {e}"))?; - overlay.write(name, &bytes)?; - } + tables(base, &plan, &overlay)?; // Mod files, and every tag addition gathered per tag file. let mut tags: BTreeMap = BTreeMap::new(); let mut warnings = Vec::new(); @@ -1044,8 +1083,9 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result let mut additions: BTreeMap<&str, Vec> = BTreeMap::new(); for m in mods { let declarations = format!("data/{}/horizon/", m.id); + let mut reader = m.content.reader()?; for file in &m.content.files { - let bytes = m.content.file(file)?; + let bytes = reader.read(file)?; let is_tag = file.starts_with("data/") && file.contains("/tags/"); if is_tag && file.ends_with(".json") { let doc: J = serde_json::from_slice(&bytes).map_err(|e| format!("{file}: {e}"))?; diff --git a/crates/horizon-client/src/model_library.rs b/crates/horizon-client/src/model_library.rs index c6a1a9d87..018bc6af2 100644 --- a/crates/horizon-client/src/model_library.rs +++ b/crates/horizon-client/src/model_library.rs @@ -10,10 +10,12 @@ pub(crate) struct ParsedModels { impl ParsedModels { /// Every `models/**.json` of a namespace directory, by identifier. pub(crate) fn load(root: &Path) -> Self { - let mut out = BTreeMap::new(); let Ok(namespaces) = fs::read_dir(root.join("assets")) else { - return Self { models: out }; + return Self::default(); }; + // Listed first, then read and parsed at once: a content pack has tens + // of thousands of models. + let mut files = Vec::new(); for ns in namespaces.flatten() { let namespace = ns.file_name().to_string_lossy().into_owned(); let base = ns.path().join("models"); @@ -24,20 +26,33 @@ impl ParsedModels { }; for e in entries.flatten() { let path = e.path(); - if path.is_dir() { + // The entry's own type saves a stat per file; a link + // (content roots link into the base) is followed. + let is_dir = match e.file_type() { + Ok(t) if !t.is_symlink() => t.is_dir(), + _ => path.is_dir(), + }; + if is_dir { stack.push(path); } else if path.extension().is_some_and(|x| x == "json") && let Ok(rel) = path.strip_prefix(&base) - && let Ok(text) = fs::read_to_string(&path) - && let Ok(model) = CuboidModel::from_json(&text) { let rel = rel.with_extension("").to_string_lossy().replace('\\', "/"); - out.insert(format!("{namespace}:{rel}"), Arc::new(model)); + files.push((format!("{namespace}:{rel}"), path)); } } } } - Self { models: out } + let parsed = crate::par::par_map(&files, |(_, path)| { + let text = fs::read_to_string(path).ok()?; + CuboidModel::from_json(&text).ok().map(Arc::new) + }); + let models = files + .into_iter() + .zip(parsed) + .filter_map(|((id, _), model)| Some((id, model?))) + .collect(); + Self { models } } /// Blocks require every referenced resource, including parents. Items instead diff --git a/crates/horizon-client/src/par.rs b/crates/horizon-client/src/par.rs new file mode 100644 index 000000000..b4861b7a6 --- /dev/null +++ b/crates/horizon-client/src/par.rs @@ -0,0 +1,54 @@ +//! Loading many small files at once: startup reads tens of thousands of +//! textures and models with a content pack, and one at a time it waits on +//! each open and read in turn. +use std::sync::atomic::{AtomicUsize, Ordering}; + +/// `f` over `items` on the machine's threads, results in `items`' order. +/// Threads take the next item as they finish one, so a run of slow items +/// doesn't hold back the others. +pub fn par_map(items: &[T], f: impl Fn(&T) -> R + Sync) -> Vec { + let threads = std::thread::available_parallelism() + .map_or(1, |n| n.get()) + .min(items.len()); + if threads <= 1 { + return items.iter().map(f).collect(); + } + let next = AtomicUsize::new(0); + let mut out: Vec<(usize, R)> = std::thread::scope(|scope| { + let workers: Vec<_> = (0..threads) + .map(|_| { + scope.spawn(|| { + let mut done = Vec::new(); + loop { + let i = next.fetch_add(1, Ordering::Relaxed); + let Some(item) = items.get(i) else { + return done; + }; + done.push((i, f(item))); + } + }) + }) + .collect(); + workers + .into_iter() + .flat_map(|w| w.join().unwrap_or_else(|e| std::panic::resume_unwind(e))) + .collect() + }); + out.sort_unstable_by_key(|(i, _)| *i); + out.into_iter().map(|(_, r)| r).collect() +} + +#[cfg(test)] +mod tests { + use super::par_map; + + #[test] + fn results_keep_the_items_order() { + let items: Vec = (0..1000).collect(); + assert_eq!( + par_map(&items, |x| x * 2), + items.iter().map(|x| x * 2).collect::>() + ); + assert!(par_map(&[] as &[u32], |x| *x).is_empty()); + } +} diff --git a/crates/horizon-mods/src/content.rs b/crates/horizon-mods/src/content.rs index f17c2bb8a..494e734ec 100644 --- a/crates/horizon-mods/src/content.rs +++ b/crates/horizon-mods/src/content.rs @@ -147,6 +147,33 @@ pub struct Content { pub namespaces: Vec, } +/// Reads a mod's content files ([`Content::reader`]). +pub enum FileReader<'a> { + Dir(&'a Path), + Zip(Box>), +} +impl FileReader<'_> { + /// One content file's bytes. + pub fn read(&mut self, name: &str) -> Result, String> { + check_path(name)?; + let reader: Box = match self { + Self::Dir(root) => { + Box::new(std::fs::File::open(root.join(name)).map_err(|e| format!("{name}: {e}"))?) + } + Self::Zip(zip) => Box::new(zip.by_name(name).map_err(|e| format!("{name}: {e}"))?), + }; + let mut out = Vec::new(); + reader + .take(MAX_FILE + 1) + .read_to_end(&mut out) + .map_err(|e| format!("{name}: {e}"))?; + if out.len() as u64 > MAX_FILE { + return Err(format!("{name} is over {} MiB", MAX_FILE >> 20)); + } + Ok(out) + } +} + /// Why two content mods cannot be on together: a namespace both own (one's /// id or listed namespace is the other's), which would mix their files. /// `a` and `b` are (mod id, owned namespaces). @@ -222,29 +249,16 @@ impl Content { /// One content file's bytes. pub fn file(&self, name: &str) -> Result, String> { - check_path(name)?; - let mut out = Vec::new(); - match &self.source { - Source::Dir(root) => { - let file = - std::fs::File::open(root.join(name)).map_err(|e| format!("{name}: {e}"))?; - file.take(MAX_FILE + 1) - .read_to_end(&mut out) - .map_err(|e| format!("{name}: {e}"))?; - } - Source::Zip(path) => { - let mut zip = open_zip(path)?; - let entry = zip.by_name(name).map_err(|e| format!("{name}: {e}"))?; - entry - .take(MAX_FILE + 1) - .read_to_end(&mut out) - .map_err(|e| format!("{name}: {e}"))?; - } - } - if out.len() as u64 > MAX_FILE { - return Err(format!("{name} is over {} MiB", MAX_FILE >> 20)); - } - Ok(out) + self.reader()?.read(name) + } + + /// A reader of its content files. A packaged mod's archive is opened + /// once for all of them (opening it reads its whole index). + pub fn reader(&self) -> Result, String> { + Ok(match &self.source { + Source::Dir(root) => FileReader::Dir(root), + Source::Zip(path) => FileReader::Zip(Box::new(open_zip(path)?)), + }) } /// Where content may go, and the declarations. From 21baf0dc995299309df2483a9d2bfb38c76f11b2 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 11:53:03 +0200 Subject: [PATCH 04/62] Screen overlays: blur and clamp from the texture's .png.mcmeta TextureMetadataSection's blur and clamp choose how vanilla samples a standalone texture (ReloadableTexture.setSampler). The atlas now keeps each texture's flags and the screen-effect quads (vignette, pumpkin blur, powder snow outline, underwater, equippable camera overlays) sample their sprite rectangle linearly and with clamp or repeat as those flags say, instead of always nearest and repeat. Fixes #335 Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/render_tick.rs | 1 + crates/horizon-client/src/gfx.rs | 2 +- crates/horizon-client/src/hud.rs | 43 +++++++- crates/horizon-client/src/screen.wgsl | 38 +++++-- crates/horizon-client/src/screen_effects.rs | 102 +++++++++++++++++- 5 files changed, 170 insertions(+), 16 deletions(-) diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index 4ad9db548..e947d2af5 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -222,6 +222,7 @@ impl Game<'_> { hud_overlays::camera_overlays(size[0] as i32, size[1] as i32, &overlays, &mut scope); self.screen_fx.build(&ScreenInputs { sprites: &self.gui.atlas.sprites, + flags: &self.gui.atlas.flags, aspect: size[0] as f32 / size[1].max(1) as f32, partial, block_overlay, diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 127aaf737..c03193be4 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -1921,7 +1921,7 @@ impl Renderer { source: wgpu::ShaderSource::Wgsl(include_str!("screen.wgsl").into()), }); let screen_attributes = - wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Float32x4,3=>Float32x4]; + wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Float32x4,3=>Float32x4,4=>Uint32]; let screen_vertex = [Some(wgpu::VertexBufferLayout { array_stride: std::mem::size_of::() as u64, step_mode: wgpu::VertexStepMode::Vertex, diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 0cc99b07b..cbf674136 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -18,11 +18,35 @@ pub struct Rect { pub w: u32, pub h: u32, } +/// `TextureMetadataSection`'s `blur` and `clamp`: how vanilla samples a +/// standalone texture (`ReloadableTexture.setSampler`: linear rather than +/// nearest filtering, clamp-to-edge rather than repeat addressing). +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub struct TextureFlags { + pub blur: bool, + pub clamp: bool, +} +impl TextureFlags { + /// The `texture` section of a `.png.mcmeta` file, if it sets either flag. + pub fn from_mcmeta(json: &str) -> Option { + let meta: serde_json::Value = serde_json::from_str(json).ok()?; + let section = meta.get("texture")?; + let flag = |key| section.get(key).and_then(serde_json::Value::as_bool) == Some(true); + let flags = Self { + blur: flag("blur"), + clamp: flag("clamp"), + }; + (flags != Self::default()).then_some(flags) + } +} pub struct HudAtlas { pub pixels: Vec, pub width: u32, pub height: u32, pub sprites: HashMap, + /// Sprites whose `.png.mcmeta` sets `blur` or `clamp`; the others + /// sample as vanilla's defaults (nearest, repeat). + pub flags: HashMap, pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation)>, /// The default font (bitmap sheets in this atlas, unifont rasterized on demand). pub font: crate::font::Font, @@ -211,7 +235,7 @@ impl HudAtlas { let s = p.to_string_lossy(); !s.contains("title/background") && !s.contains("realms") && !s.contains("presets") }); - let decode_one = |path: &PathBuf| -> Option<(String, u32, u32, Vec)> { + let decode_one = |path: &PathBuf| -> Option<(PackedImage, Option)> { let name = path .strip_prefix(&textures) .ok()? @@ -226,11 +250,15 @@ impl HudAtlas { } else { pixels }; - (w <= 1024 && (h <= 512 || name.starts_with("font/"))).then_some((name, w, h, pixels)) + let flags = fs::read_to_string(path.with_extension("png.mcmeta")) + .ok() + .and_then(|json| TextureFlags::from_mcmeta(&json)); + (w <= 1024 && (h <= 512 || name.starts_with("font/"))) + .then_some(((name, w, h, pixels), flags)) }; let threads = std::thread::available_parallelism().map_or(2, |n| n.get()); let chunk = files.len().div_ceil(threads).max(1); - let mut images: Vec<_> = std::thread::scope(|scope| { + let decoded: Vec<_> = std::thread::scope(|scope| { let handles: Vec<_> = files .chunks(chunk) .map(|part| { @@ -242,6 +270,14 @@ impl HudAtlas { .flat_map(|h| h.join().unwrap_or_default()) .collect() }); + let mut flags = HashMap::new(); + let mut images: Vec = Vec::with_capacity(decoded.len()); + for (image, image_flags) in decoded { + if let Some(f) = image_flags { + flags.insert(image.0.clone(), f); + } + images.push(image); + } if full { images.extend(atlas_sprites(root, &images)); } @@ -337,6 +373,7 @@ impl HudAtlas { width, height, sprites, + flags, fire_animations, font, white, diff --git a/crates/horizon-client/src/screen.wgsl b/crates/horizon-client/src/screen.wgsl index 62cb2ee6c..a82b0f890 100644 --- a/crates/horizon-client/src/screen.wgsl +++ b/crates/horizon-client/src/screen.wgsl @@ -1,26 +1,50 @@ -// Full-screen camera effects (screen_effects.rs): clip-space quads sampling -// the shared 2D atlas with repeat inside each sprite rectangle. +// Full-screen camera effects (screen_effects.rs): clip-space quads reading +// one sprite rectangle of the shared 2D atlas as if it were its own texture, +// with the sampler vanilla gives it (ReloadableTexture.setSampler: linear +// when `blur`, clamp-to-edge when `clamp`, else nearest and repeat). @group(0) @binding(1) var atlas: texture_2d; -@group(0) @binding(2) var atlas_sampler: sampler; struct Out { @builtin(position) clip: vec4, @location(0) uv: vec2, @location(1) @interpolate(flat) rect: vec4, @location(2) color: vec4, + @location(3) @interpolate(flat) sampling: u32, } @vertex fn vs_screen(@location(0) pos: vec2, @location(1) uv: vec2, - @location(2) rect: vec4, @location(3) color: vec4) -> Out { + @location(2) rect: vec4, @location(3) color: vec4, + @location(4) sampling: u32) -> Out { var out: Out; out.clip = vec4(pos, 0.0, 1.0); out.uv = uv; out.rect = rect; out.color = color; + out.sampling = sampling; return out; } +const SAMPLE_BLUR: u32 = 1u; +const SAMPLE_CLAMP: u32 = 2u; +// A texel of the sprite, addressed by repeat or clamp-to-edge. +fn texel(origin: vec2, size: vec2, p: vec2, clamp_edge: bool) -> vec4 { + var q = ((p % size) + size) % size; + if clamp_edge { q = clamp(p, vec2(0), size - 1); } + return textureLoad(atlas, origin + q, 0); +} fn sample(in: Out) -> vec4 { - let f = fract(in.uv); - let uv = in.rect.xy + f * (in.rect.zw - in.rect.xy); - return textureSampleLevel(atlas, atlas_sampler, uv, 0.0) * in.color; + let dims = vec2(textureDimensions(atlas)); + let origin = vec2(round(in.rect.xy * dims)); + let size = max(vec2(round((in.rect.zw - in.rect.xy) * dims)), vec2(1)); + let clamp_edge = (in.sampling & SAMPLE_CLAMP) != 0u; + let p = in.uv * vec2(size); + if (in.sampling & SAMPLE_BLUR) == 0u { + return texel(origin, size, vec2(floor(p)), clamp_edge) * in.color; + } + // GL_LINEAR: the four texels around the sample point, weighted. + let c = p - 0.5; + let i = vec2(floor(c)); + let t = c - floor(c); + let a = mix(texel(origin, size, i, clamp_edge), texel(origin, size, i + vec2(1, 0), clamp_edge), t.x); + let b = mix(texel(origin, size, i + vec2(0, 1), clamp_edge), texel(origin, size, i + vec2(1, 1), clamp_edge), t.x); + return mix(a, b, t.y) * in.color; } @fragment fn fs_screen(in: Out) -> @location(0) vec4 { let c = sample(in); diff --git a/crates/horizon-client/src/screen_effects.rs b/crates/horizon-client/src/screen_effects.rs index bc7756453..48f468d4d 100644 --- a/crates/horizon-client/src/screen_effects.rs +++ b/crates/horizon-client/src/screen_effects.rs @@ -4,7 +4,10 @@ //! `hud_overlays::camera_overlays` (vignette, pumpkin blur, powder-snow //! outline, nether portal swirl). Positions are clip-space quads; textures //! come from the shared 2D atlas and may repeat. -use crate::{hud::Rect, hud_layout::GuiDraw}; +use crate::{ + hud::{Rect, TextureFlags}, + hud_layout::GuiDraw, +}; use std::collections::HashMap; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -24,6 +27,17 @@ pub struct ScreenVertex { /// Atlas rectangle (u0, v0, u1, v1) of the sprite. pub rect: [f32; 4], pub color: [f32; 4], + /// How the sprite is sampled: [`SAMPLE_BLUR`] and [`SAMPLE_CLAMP`]. + pub sampling: u32, +} +/// Linear filtering (`TextureMetadataSection.blur`), else nearest. +pub const SAMPLE_BLUR: u32 = 1; +/// Clamp-to-edge addressing (`TextureMetadataSection.clamp`), else repeat. +pub const SAMPLE_CLAMP: u32 = 2; +/// The sampling bits of a standalone texture's flags. +pub fn sampling(flags: TextureFlags) -> u32 { + let bit = |on: bool, bit: u32| if on { bit } else { 0 }; + bit(flags.blur, SAMPLE_BLUR) | bit(flags.clamp, SAMPLE_CLAMP) } #[derive(Clone, Debug)] pub struct ScreenQuad { @@ -34,6 +48,8 @@ pub struct ScreenQuad { /// What the camera sees this frame. pub struct ScreenInputs<'a> { pub sprites: &'a HashMap, + /// `.png.mcmeta` sampling of the standalone textures among `sprites`. + pub flags: &'a HashMap, pub aspect: f32, pub partial: f32, /// Particle sprite of the view-blocking block around the eye. @@ -92,17 +108,23 @@ impl ScreenEffects { pub fn build(&self, input: &ScreenInputs) -> Vec { let mut out = Vec::new(); let sprite = |name: &str| input.sprites.get(name).map(|r| [r.u0, r.v0, r.u1, r.v1]); + // Standalone textures (`ReloadableTexture.setSampler`) follow their + // metadata; atlas sprites (block overlay, fire, portal) sample + // nearest with repeat. + let texture_sampling = |name: &str| input.flags.get(name).copied().map_or(0, sampling); let scale = hand_scale(input.aspect); // Screen-effect quads live at view depth 0.5 in the hand projection. let hand_quad = |corners: [[f32; 2]; 4], uv: [[f32; 2]; 4], rect: [f32; 4], - color: [f32; 4]| ScreenQuad { + color: [f32; 4], + sampling: u32| ScreenQuad { vertices: std::array::from_fn(|i| ScreenVertex { pos: [corners[i][0] * scale[0], corners[i][1] * scale[1]], uv: uv[i], rect, color, + sampling, }), blend: Blend::Alpha, }; @@ -117,6 +139,7 @@ impl ScreenEffects { [[1.0, 1.0], [0.0, 1.0], [0.0, 0.0], [1.0, 0.0]], rect, [c, c, c, 1.0], + 0, )); } if let Some((brightness, yaw, pitch)) = input.water @@ -129,6 +152,7 @@ impl ScreenEffects { uv, rect, [brightness, brightness, brightness, 0.1], + texture_sampling("misc/underwater"), )); } if input.on_fire @@ -150,11 +174,12 @@ impl ScreenEffects { [[1.0, 1.0], [0.0, 1.0], [0.0, 0.0], [1.0, 0.0]], rect, [1.0, 1.0, 1.0, alpha], + 0, )); } } // Hud camera overlays: GUI-space full-screen blits (v grows downwards). - let gui = |rect: [f32; 4], color: [f32; 4], blend: Blend| ScreenQuad { + let gui = |rect: [f32; 4], color: [f32; 4], blend: Blend, sampling: u32| ScreenQuad { vertices: std::array::from_fn(|i| { let p = [[-1.0f32, 1.0], [1.0, 1.0], [1.0, -1.0], [-1.0, -1.0]][i]; ScreenVertex { @@ -162,6 +187,7 @@ impl ScreenEffects { uv: [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]][i], rect, color, + sampling, } }), blend, @@ -188,7 +214,7 @@ impl ScreenEffects { Blend::Alpha }; if let Some(rect) = sprite(texture) { - out.push(gui(rect, rgba(*color), blend)); + out.push(gui(rect, rgba(*color), blend, texture_sampling(texture))); } } GuiDraw::AtlasSprite { @@ -197,7 +223,7 @@ impl ScreenEffects { .. } => { if let Some(rect) = sprite(name) { - out.push(gui(rect, rgba(*color), Blend::Alpha)); + out.push(gui(rect, rgba(*color), Blend::Alpha, 0)); } } _ => {} @@ -243,8 +269,10 @@ mod tests { }, ); let e = ScreenEffects::default(); + let flags = HashMap::new(); let input = ScreenInputs { sprites: &sprites, + flags: &flags, aspect: 1.6, partial: 0.0, block_overlay: None, @@ -255,5 +283,69 @@ mod tests { let quads = e.build(&input); assert_eq!(quads.len(), 1); assert_eq!(quads[0].blend, Blend::Vignette); + assert_eq!(quads[0].vertices[0].sampling, 0); + } + #[test] + fn standalone_textures_sample_by_their_metadata() { + let rect = Rect { + u0: 0.0, + v0: 0.0, + u1: 1.0, + v1: 1.0, + w: 16, + h: 16, + }; + let sprites: HashMap<_, _> = ["misc/vignette", "misc/underwater", "block/stone"] + .map(|name| (name.to_owned(), rect)) + .into(); + let blur = TextureFlags { + blur: true, + clamp: false, + }; + let clamp = TextureFlags { + blur: false, + clamp: true, + }; + let flags: HashMap<_, _> = [ + ("misc/vignette".to_owned(), blur), + ("misc/underwater".to_owned(), clamp), + // Atlas sprites ignore the texture section. + ("block/stone".to_owned(), blur), + ] + .into(); + let quads = ScreenEffects::default().build(&ScreenInputs { + sprites: &sprites, + flags: &flags, + aspect: 1.6, + partial: 0.0, + block_overlay: Some("block/stone".to_owned()), + water: Some((1.0, 0.0, 0.0)), + on_fire: false, + gui_overlays: &[crate::hud_overlays::vignette(320, 240, 1.0, 0.0)], + }); + let sampling: Vec<_> = quads.iter().map(|q| q.vertices[0].sampling).collect(); + assert_eq!(sampling, [0, SAMPLE_CLAMP, SAMPLE_BLUR]); + } + #[test] + fn mcmeta_texture_section() { + let parse = TextureFlags::from_mcmeta; + assert_eq!( + parse(r#"{"texture":{"blur":true}}"#), + Some(TextureFlags { + blur: true, + clamp: false + }) + ); + assert_eq!( + parse(r#"{"texture":{"clamp":true,"mipmap_strategy":"mean"}}"#), + Some(TextureFlags { + blur: false, + clamp: true + }) + ); + // Defaults (false, false) or no section: the default sampler. + assert_eq!(parse(r#"{"texture":{"blur":false}}"#), None); + assert_eq!(parse(r#"{"animation":{}}"#), None); + assert_eq!(parse("not json"), None); } } From c77863f16314af2f891ee50c770b4ce158197cf4 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 12:08:30 +0200 Subject: [PATCH 05/62] Armour trims on worn armour (player, LAN guests, armour stands) EquipmentLayerRenderer's trim layer: the pattern's textures/trims/entity//.png recoloured from its base palette (palette metadata section) to the material's palette, or to the equipment asset's trim_overrides palette (iron armour with an iron trim uses trim/iron_darker), as PalettedTextureManager does. Each texture is made once, on first use, into one of 32 atlas trim slots (least recently drawn reused), and drawn over the armour layer on the player, on the guests a LAN host sees and on armour stands. Fixes #337 Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 4 + .../horizon-client/src/game/armor_stands.rs | 181 ++++++++- crates/horizon-client/src/game/lan.rs | 7 +- crates/horizon-client/src/game/packs.rs | 1 + crates/horizon-client/src/hud.rs | 15 +- crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/trims.rs | 354 ++++++++++++++++++ 7 files changed, 553 insertions(+), 10 deletions(-) create mode 100644 crates/horizon-client/src/trims.rs diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 2df6aa9b0..e6ccccaab 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1372,6 +1372,8 @@ struct Game<'a> { /// (least recently shown first). skin_downloads: horizon_client::skins::Downloader, skin_slots: Vec<(String, usize)>, + /// Atlas trim slots in use: (sprite name, slot), least recently drawn first. + trim_slots: Vec<(String, usize)>, cart_models: minecarts::CartModels, /// The boat the player rides. riding: Option, @@ -6278,6 +6280,7 @@ impl Game<'_> { mut out: Vec, ) -> Vec { self.prepare_entity_culling(camera); + self.prepare_trims(); let fire_yaw = if self.camera_type == perspective::CameraType::ThirdPersonFront { self.yaw + 180.0 } else { @@ -11439,6 +11442,7 @@ impl<'a> Game<'a> { .join("assets/skins"), ), skin_slots: Vec::new(), + trim_slots: Vec::new(), cart_models: prepared.cart_models, riding: None, ender_items: vec![None; 27], diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs index 9f174c5ef..121287c4c 100644 --- a/crates/horizon-client/src/game/armor_stands.rs +++ b/crates/horizon-client/src/game/armor_stands.rs @@ -8,12 +8,13 @@ use horizon_client::{ items::ItemStack, mesher::Vertex, mobs::{Mob, Part, anim::Poses}, + trims::{TrimOverride, TrimRegistry, TrimTexture}, }; use horizon_core::{ geometry::{Aabb, Vec3}, random::RandomSource, }; -use std::{collections::HashMap, sync::Arc}; +use std::{collections::HashMap, path::PathBuf, sync::Arc}; /// Armor stand models and the humanoid layers of every equipment asset. pub(super) struct ArmorStandAssets { @@ -25,6 +26,11 @@ pub(super) struct ArmorStandAssets { pub player: HashMap<&'static str, Part>, /// asset id -> layer kind (humanoid / humanoid_leggings) -> (texture, undyed colour). pub equipment: HashMap)>>, + /// asset id -> `trim_overrides`. + pub trim_overrides: HashMap>, + pub trims: TrimRegistry, + /// The resources the trim textures are made from. + pub root: PathBuf, } impl ArmorStandAssets { pub fn load( @@ -48,6 +54,7 @@ impl ArmorStandAssets { player.insert("elytra", part); } let mut equipment = HashMap::new(); + let mut trim_overrides = HashMap::new(); if let Ok(entries) = std::fs::read_dir(root.join("assets/minecraft/equipment")) { for e in entries.flatten() { let path = e.path(); @@ -76,6 +83,7 @@ impl ArmorStandAssets { ); } } + trim_overrides.insert(format!("minecraft:{name}"), TrimOverride::list(&v)); equipment.insert(format!("minecraft:{name}"), kinds); } } @@ -85,30 +93,67 @@ impl ArmorStandAssets { layers, player, equipment, + trim_overrides, + trims: TrimRegistry::load(root), + root: root.to_owned(), } } + /// Trim data of reloaded resources (the models stay). + pub fn reload_trims(&mut self, root: &std::path::Path) { + let fresh = Self::load(root, None); + self.trim_overrides = fresh.trim_overrides; + self.trims = fresh.trims; + self.root = fresh.root; + } + /// `TrimTextureKey`: the trim texture of `stack` on its humanoid + /// layer (`humanoid` or `humanoid_leggings`), if it has a trim. + fn trim_texture(&self, asset: &str, kind: &str, stack: &ItemStack) -> Option { + let (material, pattern) = stack.extra.as_ref()?.trim.as_ref()?; + let overrides = self + .trim_overrides + .get(asset) + .map_or(&[][..], Vec::as_slice); + TrimTexture::resolve(&self.trims, overrides, material, pattern, kind) + } } impl Game<'_> { /// `HumanoidArmorLayer` for the player: (model, texture rect, colour) of /// each worn piece, head to feet. pub(super) fn player_armor_layers(&self) -> Vec<(&Part, [f32; 4], u32)> { - self.armor_layers(self.armor.each_ref().map(|s| s.as_ref().map(|s| &*s.item))) + self.stack_armor_layers(&self.armor) + } + /// `HumanoidArmorLayer` for worn stacks (head to feet), trims included. + pub(super) fn stack_armor_layers( + &self, + armor: &[Option; 4], + ) -> Vec<(&Part, [f32; 4], u32)> { + self.armor_layers( + armor + .each_ref() + .map(|s| s.as_ref().map(|s| (&*s.item, Some(s)))), + ) } /// `HumanoidArmorLayer` for another player's model: the armour it wears /// (`extra.head` .. `extra.feet`). pub(super) fn worn_armor_layers(&self, m: &Mob) -> Vec<(&Part, [f32; 4], u32)> { let e = &m.extra; - self.armor_layers([&e.head, &e.chest, &e.legs, &e.feet].map(|s| s.as_deref())) + self.armor_layers( + [&e.head, &e.chest, &e.legs, &e.feet].map(|s| s.as_deref().map(|i| (i, None))), + ) } - /// The layers of the armour items `worn`, head to feet. - fn armor_layers(&self, worn: [Option<&str>; 4]) -> Vec<(&Part, [f32; 4], u32)> { + /// The layers of the armour items `worn` (with their stacks when known, + /// for trims), head to feet. + fn armor_layers( + &self, + worn: [Option<(&str, Option<&ItemStack>)>; 4], + ) -> Vec<(&Part, [f32; 4], u32)> { let assets = &self.armor_stand_assets; let mut out = Vec::new(); for (item, layer) in worn .into_iter() .zip(["helmet", "chestplate", "leggings", "boots"]) { - let Some(item) = item else { + let Some((item, stack)) = item else { continue; }; let Some(asset) = self @@ -138,9 +183,117 @@ impl Game<'_> { 0xFF00_0000 | (c & 0xFF) << 16 | (c & 0xFF00) | (c >> 16) & 0xFF }); out.push((part, [r.u0, r.v0, r.u1, r.v1], color)); + // EquipmentLayerRenderer: the trim layer over the armour. + if let Some(r) = stack + .and_then(|s| assets.trim_texture(&asset, kind, s)) + .and_then(|t| self.gui.atlas.sprites.get(&t.sprite())) + { + out.push((part, [r.u0, r.v0, r.u1, r.v1], 0xFFFF_FFFF)); + } } out } + /// `PalettedTextureManager.getOrPrepare` for the trims drawn this frame + /// (the player's armour and the armour stands'): each generated texture + /// goes into an atlas trim slot, a free one, else the least recently + /// drawn. + pub(super) fn prepare_trims(&mut self) { + use horizon_client::hud::TRIM_SLOTS; + let assets = &self.armor_stand_assets; + let items = self.res.items(); + let mut wanted: Vec = Vec::new(); + let guests = self.lan.iter().flat_map(|host| host.hub.guests.iter()); + let stacks = self + .armor + .iter() + .chain(guests.flat_map(|g| g.armor.iter())) + .zip( + ["helmet", "chestplate", "leggings", "boots"] + .into_iter() + .cycle(), + ) + .chain(self.armor_stands.iter().flat_map(|a| { + [5usize, 4, 3, 2] + .map(|slot| &a.equipment[slot]) + .into_iter() + .zip(["helmet", "chestplate", "leggings", "boots"]) + })); + for (stack, layer) in stacks { + let Some(stack) = stack.as_ref().filter(|s| s.extra.is_some()) else { + continue; + }; + let Some(asset) = items + .get(&stack.item) + .and_then(|i| i.equip_asset.as_deref()) + else { + continue; + }; + let kind = if layer == "leggings" { + "humanoid_leggings" + } else { + "humanoid" + }; + if let Some(t) = assets.trim_texture(asset, kind, stack) + && !wanted.contains(&t) + { + wanted.push(t); + } + } + for t in wanted { + let name = t.sprite(); + // Entries the atlas no longer has (rebuilt by a resource reload) are free. + let sprites = &self.gui.atlas.sprites; + self.trim_slots.retain(|(n, _)| sprites.contains_key(n)); + if let Some(i) = self.trim_slots.iter().position(|e| e.0 == name) { + let e = self.trim_slots.remove(i); + self.trim_slots.push(e); + continue; + } + let Some((w, h, rgba)) = t.generate(&self.armor_stand_assets.root) else { + continue; + }; + let used: Vec = self.trim_slots.iter().map(|e| e.1).collect(); + let slot = match (0..TRIM_SLOTS).find(|i| !used.contains(i)) { + Some(free) => free, + None => { + let (old, slot) = self.trim_slots.remove(0); + self.gui.atlas.sprites.remove(&old); + slot + } + }; + let Some(area) = self + .gui + .atlas + .sprites + .get(&format!("horizon/trim{slot}")) + .copied() + else { + continue; + }; + if w > area.w || h > area.h { + continue; + } + let (aw, ah) = (self.gui.atlas.width as f32, self.gui.atlas.height as f32); + let (x, y) = ((area.u0 * aw).round(), (area.v0 * ah).round()); + self.map_patches.push(horizon_client::font::Patch { + x: x as u32, + y: y as u32, + width: w, + height: h, + rgba, + }); + let rect = horizon_client::hud::Rect { + u0: area.u0, + v0: area.v0, + u1: (x + w as f32) / aw, + v1: (y + h as f32) / ah, + w, + h, + }; + self.gui.atlas.sprites.insert(name.clone(), rect); + self.trim_slots.push((name, slot)); + } + } /// `ArmorStandItem.useOn`. pub(super) fn place_armor_stand(&mut self, hit: &super::Hit, stack: &ItemStack) -> bool { if &*stack.item != "minecraft:armor_stand" || hit.face == [0, -1, 0] { @@ -560,6 +713,22 @@ impl Game<'_> { 0, out, ); + // EquipmentLayerRenderer: the trim layer over the armour. + if let Some(trim) = assets + .trim_texture(&asset, kind, stack) + .and_then(|t| uv_of(&t.sprite())) + { + horizon_client::mobs::render::draw( + part, + base, + &layer_poses, + trim, + 0xFFFF_FFFF, + packed, + 0, + out, + ); + } } self.cull_entity_vertices(out, entity_start); } diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index f9ea1262b..4fb99e2e9 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -1253,7 +1253,7 @@ impl Game<'_> { }; let atlas = &self.gui.atlas; let lookup = |name: &str| atlas.sprites.get(name).map(|r| [r.u0, r.v0, r.u1, r.v1]); - for m in host.models.values() { + for (conn, m) in &host.models { let entity_start = out.len(); let light = self.world.light( m.position.x.floor() as i32, @@ -1268,7 +1268,10 @@ impl Game<'_> { &lookup, packed, self.res.mob_data(), - &self.worn_armor_layers(m), + &host.hub.guest(*conn).map_or_else( + || self.worn_armor_layers(m), + |g| self.stack_armor_layers(&g.armor), + ), out, ); self.held_item_geometry(m, camera, alpha, packed, true, out); diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs index ac08385a0..e635b46d2 100644 --- a/crates/horizon-client/src/game/packs.rs +++ b/crates/horizon-client/src/game/packs.rs @@ -171,6 +171,7 @@ impl Game<'_> { } }; // Everything loaded: switch over. + self.armor_stand_assets.reload_trims(root); self.random_tick_sections.clear(); self.portals.sections.clear(); self.options.resources = root.to_path_buf(); diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 0cc99b07b..69d642246 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -38,6 +38,9 @@ pub const MINIMAP_SPRITE: &str = "horizon/minimap"; pub const SKIN_SLOTS: usize = 32; /// Reused by the visible rows of the classic world selector. pub const WORLD_ICON_SLOTS: usize = 32; +/// Atlas slots for armour trim textures made at run time (`trims`), each the +/// size of the largest trim texture. +pub const TRIM_SLOTS: usize = 32; pub fn decode(path: &Path) -> Result<(u32, u32, Vec)> { decode_bytes(&fs::read(path)?) } @@ -159,7 +162,7 @@ impl HudAtlas { } /// Empty slots written at run time: map textures (game/maps.rs), the /// minimap, downloaded skins, world icons and the Horizon menu text. - fn slots(images: &mut Vec) { + fn slots(images: &mut Vec, trim: (u32, u32)) { for i in 0..MAP_SLOTS { images.push((format!("horizon/map{i}"), 128, 128, vec![0; 128 * 128 * 4])); } @@ -174,6 +177,14 @@ impl HudAtlas { for i in 0..SKIN_SLOTS { images.push((format!("horizon/skin{i}"), 64, 64, vec![0; 64 * 64 * 4])); } + for i in 0..TRIM_SLOTS { + images.push(( + format!("horizon/trim{i}"), + trim.0, + trim.1, + vec![0; (trim.0 * trim.1 * 4) as usize], + )); + } for i in 0..WORLD_ICON_SLOTS { images.push(( format!("horizon/world-icon{i}"), @@ -256,7 +267,7 @@ impl HudAtlas { } images.push(("horizon/white".into(), 4, 4, vec![255; 64])); if full { - Self::slots(&mut images); + Self::slots(&mut images, crate::trims::slot_size(root)); } images.sort_by(|a, b| b.2.cmp(&a.2).then(b.1.cmp(&a.1))); let width = 4096u32; diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 7a69de4aa..b12981533 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -179,6 +179,7 @@ pub mod ticket_levels; pub mod title; pub mod title_edition; pub mod toasts; +pub mod trims; pub mod ui; pub mod ui_theme; pub mod vanillagen; diff --git a/crates/horizon-client/src/trims.rs b/crates/horizon-client/src/trims.rs new file mode 100644 index 000000000..e53aeed72 --- /dev/null +++ b/crates/horizon-client/src/trims.rs @@ -0,0 +1,354 @@ +//! Armour trims on worn armour: `EquipmentLayerRenderer`'s trim layer. A +//! trim's texture is `textures/trims/entity//.png` recoloured +//! by `PalettedTextureManager`: every pixel whose colour is in the texture's +//! base palette (its `palette` metadata section, `trim_base`) takes the colour +//! at the same index of the material's palette (`textures/palettes/trim/*`), +//! unless the equipment asset's `trim_overrides` pick another texture or +//! palette (iron armour with an iron trim uses `trim/iron_darker`). +use horizon_assets::palette::apply_palette; +use serde_json::Value; +use std::{collections::HashMap, fs, path::Path}; + +/// An RGBA image: width, height, pixels. +pub type Image = (u32, u32, Vec); + +/// `minecraft:` added to an identifier without a namespace. +fn qualified(id: &str) -> String { + if id.contains(':') { + id.to_owned() + } else { + format!("minecraft:{id}") + } +} + +/// `assets///` of an identifier. +fn asset_path(root: &Path, folder: &str, id: &str, suffix: &str) -> std::path::PathBuf { + let id = qualified(id); + let (namespace, path) = id.split_once(':').unwrap_or(("minecraft", &id)); + root.join("assets") + .join(namespace) + .join(folder) + .join(format!("{path}{suffix}")) +} + +/// `EquipmentClientInfo.TrimOverride`: when the trim matches (`when`'s +/// material and pattern, each optional), use `texture` instead of the +/// pattern's asset id and `palette` (none when absent) as the palette. +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct TrimOverride { + pub material: Option, + pub pattern: Option, + pub texture: Option, + pub palette: Option, +} +impl TrimOverride { + /// An equipment asset's `trim_overrides` list. + pub fn list(equipment: &Value) -> Vec { + let Some(list) = equipment.get("trim_overrides").and_then(Value::as_array) else { + return Vec::new(); + }; + let id = |v: &Value, key: &str| v.get(key).and_then(Value::as_str).map(qualified); + list.iter() + .filter_map(|o| { + let when = o.get("when")?; + Some(Self { + material: id(when, "material"), + pattern: id(when, "pattern"), + texture: id(o, "texture"), + palette: id(o, "palette"), + }) + }) + .collect() + } + /// `TrimPredicate.matches`. + fn matches(&self, material: &str, pattern: &str) -> bool { + self.material.as_deref().is_none_or(|m| m == material) + && self.pattern.as_deref().is_none_or(|p| p == pattern) + } +} + +/// The `trim_pattern` (asset id) and `trim_material` (palette id) registries. +#[derive(Clone, Debug, Default)] +pub struct TrimRegistry { + patterns: HashMap, + materials: HashMap, +} +impl TrimRegistry { + /// Every `data//trim_pattern` and `trim_material` entry. + pub fn load(root: &Path) -> Self { + let mut out = Self::default(); + let Ok(namespaces) = fs::read_dir(root.join("data")) else { + return out; + }; + for ns in namespaces.flatten() { + let namespace = ns.file_name().to_string_lossy().into_owned(); + for (folder, key, map) in [ + ("trim_pattern", "asset_id", &mut out.patterns), + ("trim_material", "palette_id", &mut out.materials), + ] { + let Ok(files) = fs::read_dir(ns.path().join(folder)) else { + continue; + }; + for f in files.flatten() { + let path = f.path(); + if path.extension().is_none_or(|e| e != "json") { + continue; + } + let Some(value) = fs::read(&path) + .ok() + .and_then(|b| serde_json::from_slice::(&b).ok()) + else { + continue; + }; + if let Some(v) = value.get(key).and_then(Value::as_str) { + let name = path.file_stem().unwrap_or_default().to_string_lossy(); + map.insert(format!("{namespace}:{name}"), qualified(v)); + } + } + } + } + out + } + #[cfg(test)] + fn of(patterns: &[(&str, &str)], materials: &[(&str, &str)]) -> Self { + let map = |l: &[(&str, &str)]| { + l.iter() + .map(|(k, v)| (k.to_string(), v.to_string())) + .collect() + }; + Self { + patterns: map(patterns), + materials: map(materials), + } + } +} + +/// The texture and palette of one trim layer. +#[derive(Clone, Debug, PartialEq, Eq, Hash)] +pub struct TrimTexture { + /// `:trims/entity//`, under `textures/`. + pub texture: String, + /// The target palette under `textures/palettes/`; none draws the + /// texture's own colours. + pub palette: Option, +} +impl TrimTexture { + /// `TrimTextureKey.getOrPrepareTexture`: the trim (`material`, + /// `pattern` registry ids) on the `layer` (`humanoid`, + /// `humanoid_leggings`...) of an equipment asset with `overrides`. + pub fn resolve( + registry: &TrimRegistry, + overrides: &[TrimOverride], + material: &str, + pattern: &str, + layer: &str, + ) -> Option { + let (material, pattern) = (qualified(material), qualified(pattern)); + let mut texture = registry.patterns.get(&pattern)?.clone(); + let mut palette = Some(registry.materials.get(&material)?.clone()); + if let Some(o) = overrides.iter().find(|o| o.matches(&material, &pattern)) { + if let Some(t) = &o.texture { + texture.clone_from(t); + } + palette.clone_from(&o.palette); + } + let (namespace, path) = texture.split_once(':')?; + Some(Self { + texture: format!("{namespace}:trims/entity/{layer}/{path}"), + palette, + }) + } + /// The atlas sprite name the generated texture is stored under. + pub fn sprite(&self) -> String { + format!( + "horizon/trim/{}/{}", + self.texture, + self.palette.as_deref().unwrap_or("-") + ) + } + /// `PalettedTextureManager.prepareSlot`: the texture with its base + /// palette's colours swapped for the target palette's (`PaletteMapping`; + /// unchanged when a palette is missing or the sizes differ). None when + /// the texture itself is missing. + pub fn generate(&self, root: &Path) -> Option { + let path = asset_path(root, "textures", &self.texture, ".png"); + let (w, h, pixels) = crate::hud::decode(&path).ok()?; + let Some(palette) = &self.palette else { + return Some((w, h, pixels)); + }; + let base = fs::read(path.with_extension("png.mcmeta")) + .ok() + .and_then(|b| serde_json::from_slice::(&b).ok()) + .and_then(|m| { + m.get("palette")? + .get("base_palette")? + .as_str() + .map(str::to_owned) + }); + let load = |id: &str| { + crate::hud::decode(&asset_path(root, "textures/palettes", id, ".png")) + .ok() + .map(|(_, _, p)| argb(&p)) + }; + let mut mapped = argb(&pixels); + if let (Some(key), Some(target)) = (base.as_deref().and_then(load), load(palette)) { + // Different sizes: PaletteMapping.NONE, the texture as it is. + let _ = apply_palette(&mut mapped, &key, &target); + } + let out = mapped + .iter() + .flat_map(|p| { + let [a, r, g, b] = p.to_be_bytes(); + [r, g, b, a] + }) + .collect(); + Some((w, h, out)) + } +} + +fn argb(rgba: &[u8]) -> Vec { + rgba.as_chunks::<4>() + .0 + .iter() + .map(|p| u32::from_be_bytes([p[3], p[0], p[1], p[2]])) + .collect() +} + +/// The largest trim texture of the resources (the size of the atlas's trim +/// slots), at least vanilla's 64x32. +pub fn slot_size(root: &Path) -> (u32, u32) { + let mut size = (64, 32); + let Ok(namespaces) = fs::read_dir(root.join("assets")) else { + return size; + }; + for ns in namespaces.flatten() { + let Ok(layers) = fs::read_dir(ns.path().join("textures/trims/entity")) else { + continue; + }; + for layer in layers.flatten() { + for f in fs::read_dir(layer.path()).into_iter().flatten().flatten() { + let path = f.path(); + if path.extension().is_some_and(|e| e == "png") + && let Some((w, h)) = png_size(&path) + { + size = (size.0.max(w.min(512)), size.1.max(h.min(512))); + } + } + } + } + size +} + +/// The width and height in a PNG's IHDR chunk. +fn png_size(path: &Path) -> Option<(u32, u32)> { + use std::io::Read; + let mut head = [0u8; 24]; + fs::File::open(path).ok()?.read_exact(&mut head).ok()?; + let be = |i: usize| u32::from_be_bytes(head[i..i + 4].try_into().unwrap()); + (&head[12..16] == b"IHDR").then(|| (be(16), be(20))) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn registry() -> TrimRegistry { + TrimRegistry::of( + &[("minecraft:coast", "minecraft:coast")], + &[ + ("minecraft:iron", "minecraft:trim/iron"), + ("minecraft:gold", "minecraft:trim/gold"), + ], + ) + } + + #[test] + fn material_palette_and_layer_folder() { + let t = TrimTexture::resolve( + ®istry(), + &[], + "minecraft:gold", + "minecraft:coast", + "humanoid_leggings", + ) + .unwrap(); + assert_eq!(t.texture, "minecraft:trims/entity/humanoid_leggings/coast"); + assert_eq!(t.palette.as_deref(), Some("minecraft:trim/gold")); + // Unknown registry entries draw nothing. + assert!( + TrimTexture::resolve( + ®istry(), + &[], + "minecraft:wood", + "minecraft:coast", + "humanoid" + ) + .is_none() + ); + } + + #[test] + fn equipment_overrides_pick_the_darker_palette() { + let iron = serde_json::json!({"trim_overrides": [ + {"palette": "minecraft:trim/iron_darker", "when": {"material": "minecraft:iron"}}, + ]}); + let overrides = TrimOverride::list(&iron); + let resolve = + |m| TrimTexture::resolve(®istry(), &overrides, m, "coast", "humanoid").unwrap(); + assert_eq!( + resolve("iron").palette.as_deref(), + Some("minecraft:trim/iron_darker") + ); + assert_eq!( + resolve("gold").palette.as_deref(), + Some("minecraft:trim/gold") + ); + // An override without a palette leaves the texture's own colours. + let plain = TrimOverride::list(&serde_json::json!({"trim_overrides": [ + {"texture": "minecraft:other", "when": {"pattern": "minecraft:coast"}}, + ]})); + let t = TrimTexture::resolve(®istry(), &plain, "gold", "coast", "humanoid").unwrap(); + assert_eq!(t.texture, "minecraft:trims/entity/humanoid/other"); + assert_eq!(t.palette, None); + } + + #[test] + fn vanilla_trims_are_recoloured() { + let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3"); + if !root.join("assets/minecraft/textures/trims").is_dir() { + return; + } + let registry = TrimRegistry::load(&root); + let t = TrimTexture::resolve( + ®istry, + &[], + "minecraft:gold", + "minecraft:coast", + "humanoid", + ) + .unwrap(); + let (w, h, gold) = t.generate(&root).unwrap(); + assert_eq!((w, h), (64, 32)); + let plain = TrimTexture { + palette: None, + ..t.clone() + }; + let (_, _, grey) = plain.generate(&root).unwrap(); + // Every opaque pixel of the grey pattern takes a gold palette colour. + let gold_palette = argb( + &crate::hud::decode(&root.join("assets/minecraft/textures/palettes/trim/gold.png")) + .unwrap() + .2, + ); + let mut opaque = 0; + for (g, c) in grey.chunks(4).zip(gold.chunks(4)) { + if g[3] != 0 { + opaque += 1; + let c = u32::from_be_bytes([0xFF, c[0], c[1], c[2]]); + assert!(gold_palette.contains(&c), "{c:08x}"); + } + } + assert!(opaque > 0); + assert_eq!(slot_size(&root), (64, 32)); + } +} From 38276fbc30fee22a46848691522ab1dc2bfe1d7d Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 12:35:27 +0200 Subject: [PATCH 06/62] Locator bar HUD and waypoint styles LocatorBar: when the server tracks waypoints for the player, the bar above the hotbar shows a dot per waypoint within 60 degrees of the view (farthest first), coloured from the waypoint's colour or its id's hash, with the sprite its style picks by distance (assets/*/waypoint_style/*.json, WaypointStyleManager) and the blinking up or down arrow when the waypoint is above or below the screen. The background is nine-sliced. Hud.nextContextualInfoState picks between the jump bar, the experience bar (100 ticks after an experience change) and the locator bar. Waypoints come from ClientboundTrackedWaypointPacket on remote servers and, on a served world, from the host's own connection in lan/waypoints.rs; entity waypoints in view follow the entity's eyes. Fixes #339 Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 62 +- .../horizon-client/src/game/lan_waypoints.rs | 13 +- crates/horizon-client/src/game/locator_bar.rs | 126 +++ crates/horizon-client/src/game/mounts.rs | 29 +- crates/horizon-client/src/game/packs.rs | 1 + crates/horizon-client/src/game/remote.rs | 18 + crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/locator_bar.rs | 742 ++++++++++++++++++ 8 files changed, 978 insertions(+), 14 deletions(-) create mode 100644 crates/horizon-client/src/game/locator_bar.rs create mode 100644 crates/horizon-client/src/locator_bar.rs diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 2df6aa9b0..3b511a7d8 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -80,6 +80,7 @@ mod level_particles; mod levels; mod lightning; mod llamas; +mod locator_bar; mod loom; mod mace; mod machines; @@ -1350,6 +1351,14 @@ struct Game<'a> { /// Entities of types Horizon does not simulate. others: Vec, armor_stand_assets: armor_stands::ArmorStandAssets, + /// `WaypointStyleManager`. + waypoint_styles: horizon_client::locator_bar::WaypointStyles, + /// `ClientWaypointManager`: the locator bar's waypoints. + waypoints: horizon_client::locator_bar::ClientWaypoints, + /// The camera the last frame drew from (position, yaw, pitch, fov), for the locator bar. + locator_camera: Option<([f64; 3], f32, f32, f32)>, + /// `LocalPlayer.experienceDisplayStartTick`: (last progress, seen a change, tick). + experience_display: (f32, bool, u64), boats: Vec, boat_models: boats::BoatModels, /// EndCrystalModel's baked layer. @@ -3865,6 +3874,7 @@ impl Game<'_> { None => 0.0, }; self.ticks += 1; + self.track_experience_display(); // `/tick freeze` stops the world but not the player. let running = self.clock.world_runs(); if running { @@ -4717,12 +4727,41 @@ impl Game<'_> { self.draw_extras(&mut batch); } if show_hud { - // The mount's hearts (and the jump bar that replaces the experience bar). - let (vehicle_hearts, jump_bar) = if spectator { - (0, false) + // Hud.nextContextualInfoState: the jump bar, the experience bar or + // the locator bar above the hotbar. + let has_experience = !self.creative && !spectator; + let contextual = horizon_client::locator_bar::ContextualBar::next( + self.waypoints.has_waypoints(), + !spectator && self.jumpable_mount(), + self.mount_jumping(), + has_experience, + self.experience_recent(), + ); + use horizon_client::locator_bar::ContextualBar; + // The mount's hearts (and the jump bar). + let vehicle_hearts = if spectator { + 0 } else { - self.draw_mount_hud(&mut batch, wi, hi) + self.draw_mount_hud( + &mut batch, + wi, + hi, + contextual == ContextualBar::JumpableVehicle, + ) }; + if contextual == ContextualBar::Locator { + let (sprite, [x, y, w, h]) = horizon_client::locator_bar::background(wi, hi); + horizon_client::ui::nine_slice( + &mut batch, + &self.gui.atlas, + sprite, + x as f32, + y as f32, + w as f32, + h as f32, + u32::MAX, + ); + } if !self.creative && !spectator && let Some(p) = &mut self.player @@ -4734,7 +4773,7 @@ impl Game<'_> { hi, self.experience.progress, self.experience.level, - !jump_bar, + contextual == ContextualBar::Experience, &width, ); hud_layout::paint(&mut batch, atlas, &draws); @@ -4784,6 +4823,10 @@ impl Game<'_> { let draws = self.health_hud.layout(&inputs, wi, hi); hud_layout::paint(&mut batch, atlas, &draws); } + if contextual == ContextualBar::Locator { + let draws = self.locator_bar_draws(wi, hi); + hud_layout::paint(&mut batch, &self.gui.atlas, &draws); + } if !spectator { self.draw_selected_name(&mut batch, !self.creative); } @@ -7554,6 +7597,7 @@ impl Game<'_> { Ok(()) } fn close_world(&mut self) -> Result<()> { + self.clear_waypoints(); self.begin_closing_save(false) } fn finish_close_world(&mut self) -> Result<()> { @@ -9581,6 +9625,8 @@ impl Game<'_> { } else { self.fov_degrees(camera_alpha as f32, camera.to_array()) }; + self.locator_camera = + (!live && !title).then_some((camera.to_array(), view_yaw, view_pitch, fov_degrees)); let bob = if title { glam::Mat4::IDENTITY } else { @@ -11419,6 +11465,10 @@ impl<'a> Game<'a> { armor_stands: Vec::new(), others: Vec::new(), armor_stand_assets: prepared.armor_stand_assets, + waypoint_styles: prepared.waypoint_styles, + waypoints: Default::default(), + locator_camera: None, + experience_display: Default::default(), boats: Vec::new(), boat_models: prepared.boat_models, crystal_model: prepared.crystal_model, @@ -11542,6 +11592,7 @@ struct GameCpuResources { map_frame_model: frames::FrameModel, glow_map_frame_model: frames::FrameModel, armor_stand_assets: armor_stands::ArmorStandAssets, + waypoint_styles: horizon_client::locator_bar::WaypointStyles, boat_models: boats::BoatModels, cart_models: minecarts::CartModels, crystal_model: Option, @@ -11561,6 +11612,7 @@ impl GameCpuResources { map_frame_model: frames::bake_frame(root, "item_frame_map"), glow_map_frame_model: frames::bake_frame(root, "glow_item_frame_map"), armor_stand_assets: armor_stands::ArmorStandAssets::load(root, document.as_ref()), + waypoint_styles: horizon_client::locator_bar::WaypointStyles::load(root), boat_models: boats::BoatModels::load(document.as_ref()), cart_models: minecarts::CartModels::load(document.as_ref()), crystal_model: model("minecraft:end_crystal#main"), diff --git a/crates/horizon-client/src/game/lan_waypoints.rs b/crates/horizon-client/src/game/lan_waypoints.rs index ba1512a00..87476dc46 100644 --- a/crates/horizon-client/src/game/lan_waypoints.rs +++ b/crates/horizon-client/src/game/lan_waypoints.rs @@ -9,6 +9,10 @@ use horizon_client::{ }, }; +/// The host player's connection id in the waypoint managers: its packets +/// go to this client's locator bar rather than to a guest. +const HOST_CONN: u32 = u32::MAX; + /// `waypoint_transmit_range`: hidden by crouching, invisibility or a head worn. fn transmit_range(crouching: bool, invisible: bool, head: Option<&ItemStack>) -> f64 { let hiding_head = head.is_some_and(|s| HIDING_HEADS.contains(&&*s.item)); @@ -47,7 +51,7 @@ impl Game<'_> { self.dim.id(), waypoints::Player { uuid: h.uuid, - conn: None, + conn: Some(HOST_CONN), position: h.position, spectator: self.spectator(), transmit_range: transmit_range( @@ -123,7 +127,12 @@ impl Game<'_> { } } for (conn, packet) in out { - if let Some(g) = host.hub.guest(conn) { + if conn == HOST_CONN { + // The host's own connection: its locator bar. + if let horizon_protocol::packets::play::Clientbound::TrackedWaypoint(w) = &packet { + self.handle_waypoint(w); + } + } else if let Some(g) = host.hub.guest(conn) { g.send(&packet); } } diff --git a/crates/horizon-client/src/game/locator_bar.rs b/crates/horizon-client/src/game/locator_bar.rs new file mode 100644 index 000000000..aa69f7e7d --- /dev/null +++ b/crates/horizon-client/src/game/locator_bar.rs @@ -0,0 +1,126 @@ +//! The locator bar on this client (horizon_client::locator_bar): the +//! waypoints a server tracks for the player (`handleWaypoint`; on a served +//! world the host's own connection in lan/waypoints.rs), the experience +//! bar's priority after a change, and the dots drawn from the last frame's +//! camera. +use super::Game; +use horizon_client::{ + hud_layout::GuiDraw, + locator_bar::{ClientWaypoints, View}, +}; +use horizon_protocol::packets::play::TrackedWaypoint; + +/// `Player.getEyeHeight` while standing. +const PLAYER_EYES: f64 = 1.62; + +fn uuid(ints: [i32; 4]) -> u128 { + ints.iter() + .fold(0u128, |acc, &i| acc << 32 | u128::from(i as u32)) +} + +impl Game<'_> { + /// `ClientPacketListener.handleWaypoint`. + pub(super) fn handle_waypoint(&mut self, packet: &TrackedWaypoint) { + self.waypoints.apply(packet); + } + /// A new connection or world starts with no waypoints. + pub(super) fn clear_waypoints(&mut self) { + self.waypoints = ClientWaypoints::default(); + } + /// `LocalPlayer.setExperienceValues`: a change of progress shows the + /// experience bar for 100 ticks, except the first one + /// (`experienceDisplayStartTick` starts at `Integer.MIN_VALUE`). + pub(super) fn track_experience_display(&mut self) { + let progress = self.experience.progress; + let (last, seen, _) = &mut self.experience_display; + if progress != *last { + *last = progress; + if *seen { + self.experience_display.2 = self.ticks; + } else { + *seen = true; + } + } + // EnchantmentScreen and AnvilScreen.containerTick keep it up. + if self.station.as_ref().is_some_and(|s| { + matches!( + s.kind, + super::stations::Kind::Enchanting | super::stations::Kind::Anvil + ) + }) { + self.experience_display.2 = self.ticks; + } + } + /// `Hud.willPrioritizeExperienceInfo`. + pub(super) fn experience_recent(&self) -> bool { + let (_, _, start) = self.experience_display; + start != 0 && start + 100 > self.ticks + } + /// The local player's UUID, as servers know it. + fn own_uuid(&self) -> u128 { + match &self.remote { + Some(r) => r.profile(), + None => self.level.player_uuid.map_or(0, uuid), + } + } + /// An entity's block position and (interpolated) eyes, by UUID. + fn waypoint_entity(&self, id: u128, alpha: f64) -> Option<([i32; 3], [f64; 3])> { + let at = |p: [f64; 3], q: [f64; 3], eyes: f64| { + let pos: [f64; 3] = std::array::from_fn(|i| q[i] + (p[i] - q[i]) * alpha); + (p.map(|c| c.floor() as i32), [pos[0], pos[1] + eyes, pos[2]]) + }; + if let Some(r) = &self.remote { + let entity = r.player_entity(id)?; + let m = self.mobs.iter().find(|m| m.id == entity)?; + let v = |v: horizon_core::geometry::Vec3| [v.x, v.y, v.z]; + return Some(at(v(m.position), v(m.previous), m.eye_height())); + } + let host = self.lan.as_ref()?; + let g = host.hub.guests.iter().find(|g| g.uuid == id && g.placed)?; + Some(at(g.position, g.previous_position, PLAYER_EYES)) + } + /// `LocatorBar.extractRenderState` from the last frame's camera. + pub(super) fn locator_bar_draws(&self, gui_width: i32, gui_height: i32) -> Vec { + let (Some((camera_pos, yaw, pitch, fov)), Some(p)) = (self.locator_camera, &self.player) + else { + return Vec::new(); + }; + let alpha = self.clock.camera_fraction(); + // Camera.getViewRotationProjectionMatrix, through view space: the + // depth along the look direction and the height on screen. + let (sy, cy) = ( + f64::from(yaw.to_radians()).sin(), + f64::from(yaw.to_radians()).cos(), + ); + let (sp, cp) = ( + f64::from(pitch.to_radians()).sin(), + f64::from(pitch.to_radians()).cos(), + ); + let forward = [-sy * cp, -sp, cy * cp]; + let up = [-sy * sp, cp, cy * sp]; + let focal = 1.0 / f64::from((fov / 2.0).to_radians()).tan(); + let project = |o: [f64; 3]| { + let dot = |a: [f64; 3]| a[0] * o[0] + a[1] * o[1] + a[2] * o[2]; + let depth = dot(forward); + let y = dot(up) * focal / depth; + // Points behind the camera land past the far plane (z > 1). + [0.0, y, if depth < 0.0 { 2.0 } else { 0.5 }] + }; + let entity = |id: u128| self.waypoint_entity(id, alpha); + let view = View { + gui_width, + gui_height, + camera_uuid: self.own_uuid(), + camera_entity_pos: [p.position.x, p.position.y, p.position.z], + camera_pos, + yaw, + pitch, + fov, + project: &project, + entity: &entity, + styles: &self.waypoint_styles, + tick: self.ticks, + }; + self.waypoints.draw(&view) + } +} diff --git a/crates/horizon-client/src/game/mounts.rs b/crates/horizon-client/src/game/mounts.rs index 42eac1e9b..0b25f961b 100644 --- a/crates/horizon-client/src/game/mounts.rs +++ b/crates/horizon-client/src/game/mounts.rs @@ -453,25 +453,40 @@ impl Game<'_> { _ => {} } } - /// `Hud.extractVehicleHealth` and the jump bar that replaces the - /// experience bar on a saddled jumper. Returns the mount's heart count - /// (`getVehicleMaxHearts`) and whether the jump bar shows. - pub(super) fn draw_mount_hud(&self, batch: &mut HudBatch, w: i32, h: i32) -> (i32, bool) { + /// `Player.jumpableVehicle`: a saddled mount that jumps. + pub(super) fn jumpable_mount(&self) -> bool { + self.mount_index() + .is_some_and(|i| self.mobs[i].extra.saddled) + } + /// `willPrioritizeJumpInfo`: charging a jump or recharging. + pub(super) fn mount_jumping(&self) -> bool { + self.mount.jump_scale > 0.0 || self.mount.jump_ticks < 0 + } + /// `Hud.extractVehicleHealth`, and the jump bar when it is the + /// contextual bar (`jump_bar`). Returns the mount's heart count + /// (`getVehicleMaxHearts`). + pub(super) fn draw_mount_hud( + &self, + batch: &mut HudBatch, + w: i32, + h: i32, + jump_bar: bool, + ) -> i32 { let Some(i) = self.mount_index() else { - return (0, false); + return 0; }; let m = &self.mobs[i]; let atlas = &self.gui.atlas; let hearts = horizon_client::hud_layout::vehicle_max_hearts(m.attrs.max_health); let draws = horizon_client::hud_layout::vehicle_health(w, h, hearts, m.health); horizon_client::hud_layout::paint(batch, atlas, &draws); - if m.extra.saddled { + if jump_bar { // JumpableVehicleBar: the cooldown shows while the jump recharges. let cooldown = i32::from(self.mount.jump_ticks < 0); let draws = horizon_client::hud_overlays::jump_bar(w, h, cooldown, self.mount.jump_scale); horizon_client::hud_layout::paint(batch, atlas, &draws); } - (hearts, m.extra.saddled) + hearts } } diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs index ac08385a0..f4f0a760f 100644 --- a/crates/horizon-client/src/game/packs.rs +++ b/crates/horizon-client/src/game/packs.rs @@ -171,6 +171,7 @@ impl Game<'_> { } }; // Everything loaded: switch over. + self.waypoint_styles = horizon_client::locator_bar::WaypointStyles::load(root); self.random_tick_sections.clear(); self.portals.sections.clear(); self.options.resources = root.to_path_buf(); diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 5b8072d7f..9570f8675 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -295,6 +295,7 @@ impl Game<'_> { r.clear_sections(); } self.apply_settings(); + self.clear_waypoints(); self.remote = Some(Remote { session, brand: "unknown".into(), @@ -369,6 +370,7 @@ impl Game<'_> { // Leaving on purpose: nothing for auto-reconnect to retry. self.extras_left(); } + self.clear_waypoints(); if let Some(mut r) = self.remote.take() { r.session.disconnect(); } @@ -1760,6 +1762,7 @@ impl Game<'_> { self.capture(false); } } + C::TrackedWaypoint(p) => self.handle_waypoint(&p), C::SetExperience(p) => { self.experience = Experience { level: p.level, @@ -2520,6 +2523,7 @@ impl Game<'_> { fn tick_remote_level(&mut self) -> Result<()> { self.ticks += 1; + self.track_experience_display(); // Options.broadcastOptions: a changed render distance is sent again. let view = client_view_distance(self.settings.render_distance); if let Some(r) = self.remote.as_mut() @@ -4472,6 +4476,20 @@ impl horizon_client::interaction_input::InteractionWorld for RemoteInputWorld<'_ } } +impl Remote { + /// The local player's profile UUID. + pub(super) fn profile(&self) -> u128 { + self.profile + } + /// The entity id of a player in the level, by profile UUID. + pub(super) fn player_entity(&self, uuid: u128) -> Option { + self.level_players + .iter() + .find(|(_, u)| **u == uuid) + .map(|(id, _)| *id as u32) + } +} + #[cfg(test)] mod tests { use super::Game; diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 7a69de4aa..946be9811 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -102,6 +102,7 @@ pub mod landing; pub mod lang; pub mod level_loading; pub mod light; +pub mod locator_bar; pub mod lod; pub mod logging; pub mod menu; diff --git a/crates/horizon-client/src/locator_bar.rs b/crates/horizon-client/src/locator_bar.rs new file mode 100644 index 000000000..ecead2c52 --- /dev/null +++ b/crates/horizon-client/src/locator_bar.rs @@ -0,0 +1,742 @@ +//! The locator bar: `ClientWaypointManager` (the waypoints the server +//! tracks for this player, from `ClientboundTrackedWaypointPacket`), +//! `WaypointStyleManager` (`waypoint_style/*.json`: near and far distances +//! and the dot sprites between them) and `LocatorBar`, the contextual bar +//! that draws a dot per waypoint within 60 degrees of the view, with an +//! arrow when it is above or below the screen. +use crate::hud_layout::{Blend, GuiDraw}; +use horizon_assets::animation::{AnimationClip, AnimationMetadata}; +use horizon_core::geometry::trig; +use horizon_protocol::packets::play::{ + TrackedWaypoint, WaypointId, WaypointTarget, waypoint_operation, +}; +use std::{borrow::Cow, collections::HashMap, fs, path::Path}; + +/// `WaypointStyle`: the sprites (under `hud/locator_bar_dot/`) from near to far. +#[derive(Clone, Debug, PartialEq)] +pub struct WaypointStyle { + pub near_distance: i32, + pub far_distance: i32, + pub sprites: Vec, +} +impl WaypointStyle { + /// `WaypointStyleManager.MISSING`. + fn missing() -> Self { + Self { + near_distance: 0, + far_distance: 1, + sprites: vec!["hud/locator_bar_dot/missingno".into()], + } + } + /// `WaypointStyle.CODEC` and `validate`: None when the file is invalid. + pub fn parse(json: &str) -> Option { + let v: serde_json::Value = serde_json::from_str(json).ok()?; + let distance = |key: &str, default: i32| match v.get(key) { + None => Some(default), + Some(d) => d + .as_i64() + .filter(|d| (0..=60_000_000).contains(d)) + .map(|d| d as i32), + }; + let near_distance = distance("near_distance", 128)?; + let far_distance = distance("far_distance", 332)?; + let sprites = v + .get("sprites")? + .as_array()? + .iter() + .map(|s| { + let id = s.as_str()?; + let (namespace, path) = id.split_once(':').unwrap_or(("minecraft", id)); + // Sprites of the gui atlas are named by path (minecraft only). + (namespace == "minecraft").then(|| format!("hud/locator_bar_dot/{path}")) + }) + .collect::>>()?; + (!sprites.is_empty() && near_distance > 0 && near_distance < far_distance).then_some(Self { + near_distance, + far_distance, + sprites, + }) + } + /// `WaypointStyle.sprite`. + pub fn sprite(&self, distance: f32) -> &str { + let (first, last) = (&self.sprites[0], &self.sprites[self.sprites.len() - 1]); + if distance < self.near_distance as f32 { + return first; + } + if distance >= self.far_distance as f32 { + return last; + } + match self.sprites.len() { + 1 => first, + 3 => &self.sprites[1], + n => { + let t = (distance - self.near_distance as f32) + / (self.far_distance - self.near_distance) as f32; + // Mth.lerpInt(t, 1, n - 1). + &self.sprites[(1 + (t * (n as f32 - 2.0)).floor() as i32) as usize] + } + } + } +} + +/// An animated GUI sprite (`.png.mcmeta` animation, ticked with the GUI +/// atlas): its image and frame sizes and the frame sequence. +#[derive(Clone, Debug)] +pub struct SpriteFrames { + image: [i32; 2], + frame: [i32; 2], + clip: AnimationClip, +} +impl SpriteFrames { + /// None for a still sprite or invalid metadata. + fn load(png: &Path) -> Option { + let text = fs::read_to_string(png.with_extension("png.mcmeta")).ok()?; + let meta: HashMap> = + serde_json::from_str(&text).ok()?; + let animation = AnimationMetadata::from_json(meta.get("animation")?.get()).ok()?; + // The PNG header: width and height at bytes 16..24 of IHDR. + let mut header = [0u8; 24]; + std::io::Read::read_exact(&mut fs::File::open(png).ok()?, &mut header).ok()?; + let dim = |at: usize| i32::from_be_bytes(header[at..at + 4].try_into().unwrap_or_default()); + let image = [dim(16), dim(20)]; + let frame = animation.frame_size(image[0], image[1]); + if frame[0] <= 0 || frame[1] <= 0 || image[0] % frame[0] != 0 || image[1] % frame[1] != 0 { + return None; + } + let count = (image[0] / frame[0]) * (image[1] / frame[1]); + let clip = animation.clip(count as u32).ok()??; + Some(Self { image, frame, clip }) + } + /// The `region` (image width, height, u, v) of the frame shown at `tick`. + fn region(&self, tick: u64) -> [i32; 4] { + let index = self.clip.sample(tick).frame as i32; + let columns = self.image[0] / self.frame[0]; + [ + self.image[0], + self.image[1], + index % columns * self.frame[0], + index / columns * self.frame[1], + ] + } +} + +/// `WaypointStyleManager`: every `assets//waypoint_style/*.json`, +/// plus the animations of the bar's own sprites (the arrows blink). +#[derive(Clone, Debug, Default)] +pub struct WaypointStyles( + HashMap, + HashMap, +); +impl WaypointStyles { + pub fn load(root: &Path) -> Self { + let mut frames = HashMap::new(); + let hud = root.join("assets/minecraft/textures/gui/sprites/hud"); + let dots = fs::read_dir(hud.join("locator_bar_dot")) + .into_iter() + .flatten() + .flatten() + .map(|e| e.path()); + let arrows = ["locator_bar_arrow_up", "locator_bar_arrow_down"] + .map(|a| hud.join(format!("{a}.png"))); + for png in arrows.into_iter().chain(dots) { + if png.extension().is_none_or(|e| e != "png") { + continue; + } + let Some(f) = SpriteFrames::load(&png) else { + continue; + }; + let name = png + .strip_prefix(hud.parent().unwrap_or(&hud)) + .map(|r| r.with_extension("").to_string_lossy().replace('\\', "/")) + .unwrap_or_default(); + frames.insert(name, f); + } + let mut out = HashMap::new(); + for ns in fs::read_dir(root.join("assets")) + .into_iter() + .flatten() + .flatten() + { + let namespace = ns.file_name().to_string_lossy().into_owned(); + for f in fs::read_dir(ns.path().join("waypoint_style")) + .into_iter() + .flatten() + .flatten() + { + let path = f.path(); + if path.extension().is_none_or(|e| e != "json") { + continue; + } + let name = path.file_stem().unwrap_or_default().to_string_lossy(); + if let Some(style) = fs::read_to_string(&path) + .ok() + .and_then(|t| WaypointStyle::parse(&t)) + { + out.insert(format!("{namespace}:{name}"), style); + } else { + log::warn!("Horizon: invalid waypoint style {}", path.display()); + } + } + } + Self(out, frames) + } + /// The sprite at `tick`, with its animation frame when it has one. + fn sprite(&self, name: &str, x: i32, y: i32, w: i32, h: i32, color: u32, tick: u64) -> GuiDraw { + let mut d = sprite(name, x, y, w, h, color); + if let (Some(f), GuiDraw::Sprite { region, .. }) = (self.1.get(name), &mut d) { + *region = Some(f.region(tick)); + } + d + } + /// `get`: the style, or the missing one. + pub fn get(&self, id: &str) -> Cow<'_, WaypointStyle> { + let id = if id.contains(':') { + Cow::Borrowed(id) + } else { + Cow::Owned(format!("minecraft:{id}")) + }; + self.0 + .get(&*id) + .map_or_else(|| Cow::Owned(WaypointStyle::missing()), Cow::Borrowed) + } +} + +/// `ClientWaypointManager`: the tracked waypoints by identifier. +#[derive(Clone, Debug, Default)] +pub struct ClientWaypoints { + waypoints: Vec, +} +impl ClientWaypoints { + /// `ClientboundTrackedWaypointPacket.apply`. + pub fn apply(&mut self, packet: &TrackedWaypoint) { + let at = self.waypoints.iter().position(|w| w.id == packet.id); + match packet.operation { + waypoint_operation::TRACK => match at { + Some(i) => self.waypoints[i] = packet.clone(), + None => self.waypoints.push(packet.clone()), + }, + waypoint_operation::UNTRACK => { + if let Some(i) = at { + self.waypoints.remove(i); + } + } + // `TrackedWaypoint.update`: only the same kind of waypoint moves. + _ => { + if let Some(w) = at.map(|i| &mut self.waypoints[i]) { + use WaypointTarget as T; + if matches!( + (w.target, packet.target), + (T::Block(_), T::Block(_)) + | (T::Chunk(_), T::Chunk(_)) + | (T::Azimuth(_), T::Azimuth(_)) + ) { + w.target = packet.target; + } + } + } + } + } + pub fn has_waypoints(&self) -> bool { + !self.waypoints.is_empty() + } + pub fn clear(&mut self) { + self.waypoints.clear(); + } +} + +/// What the locator bar needs of the camera and the world this frame. +pub struct View<'a> { + pub gui_width: i32, + pub gui_height: i32, + /// The camera entity's UUID, its block position and its position. + pub camera_uuid: u128, + pub camera_entity_pos: [f64; 3], + /// `Camera.position()` and `yRot()`, `xRot()`, `getFov()` in degrees. + pub camera_pos: [f64; 3], + pub yaw: f32, + pub pitch: f32, + pub fov: f32, + /// `Camera.getViewRotationProjectionMatrix`, applied to a point + /// relative to the camera: normalised device coordinates. + pub project: &'a dyn Fn([f64; 3]) -> [f64; 3], + /// An entity with this UUID in the level: (block position, eye position). + pub entity: &'a dyn Fn(u128) -> Option<([i32; 3], [f64; 3])>, + pub styles: &'a WaypointStyles, + /// Client ticks, for animated sprites. + pub tick: u64, +} + +/// `TrackedWaypoint.PitchDirection`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Pitch { + None, + Up, + Down, +} + +/// `UUID.hashCode`. +fn uuid_hash(uuid: u128) -> i32 { + let hilo = (uuid >> 64) as u64 ^ uuid as u64; + ((hilo >> 32) as i32) ^ (hilo as i32) +} +/// `String.hashCode`. +fn string_hash(s: &str) -> i32 { + s.encode_utf16() + .fold(0i32, |h, c| h.wrapping_mul(31).wrapping_add(i32::from(c))) +} + +/// `ARGB.setBrightness`. +pub fn set_brightness(color: u32, brightness: f32) -> u32 { + let [alpha, r, g, b] = color.to_be_bytes().map(i32::from); + let max = r.max(g).max(b); + let min = r.min(g).min(b); + let range = (max - min) as f32; + let saturation = if max != 0 { range / max as f32 } else { 0.0 }; + let argb = + |r: i32, g: i32, b: i32| u32::from_be_bytes([alpha as u8, r as u8, g as u8, b as u8]); + let round = |v: f32| (v * 255.0).round() as i32; + if saturation == 0.0 { + let v = round(brightness); + return argb(v, v, v); + } + let (cr, cg, cb) = ( + (max - r) as f32 / range, + (max - g) as f32 / range, + (max - b) as f32 / range, + ); + let mut hue = if r == max { + cb - cg + } else if g == max { + 2.0 + cr - cb + } else { + 4.0 + cg - cr + } / 6.0; + if hue < 0.0 { + hue += 1.0; + } + let segment = (hue - hue.floor()) * 6.0; + let offset = segment - segment.floor(); + let primary = brightness * (1.0 - saturation); + let secondary = brightness * (1.0 - saturation * offset); + let tertiary = brightness * (1.0 - saturation * (1.0 - offset)); + let full = round(brightness); + match segment as i32 { + 0 => argb(full, round(tertiary), round(primary)), + 1 => argb(round(secondary), full, round(primary)), + 2 => argb(round(primary), full, round(tertiary)), + 3 => argb(round(primary), round(secondary), full), + 4 => argb(round(tertiary), round(primary), full), + 5 => argb(full, round(primary), round(secondary)), + _ => argb(r, g, b), + } +} + +/// `Mth.wrapDegrees`. +fn wrap_degrees(angle: f32) -> f32 { + let mut a = angle % 360.0; + if a >= 180.0 { + a -= 360.0; + } + if a < -180.0 { + a += 360.0; + } + a +} + +fn centre(v: [i32; 3]) -> [f64; 3] { + v.map(|c| f64::from(c) + 0.5) +} + +impl View<'_> { + /// `Vec3iWaypoint.position`: the tracked entity's eyes when it is within + /// 3 blocks (Manhattan) of the waypoint, else the block's centre. + fn block_position(&self, w: &TrackedWaypoint, v: [i32; 3]) -> [f64; 3] { + if let WaypointId::Uuid(uuid) = w.id + && let Some((block, eyes)) = (self.entity)(uuid) + { + let manhattan: i32 = (0..3).map(|i| (block[i] - v[i]).abs()).sum(); + if manhattan <= 3 { + return eyes; + } + } + centre(v) + } + /// `yawAngleToCamera` of a point: `degreesDifference(camera yaw, the + /// angle of camera - point turned clockwise by 90 degrees)`. + fn yaw_to(&self, p: [f64; 3]) -> f64 { + let c = self.camera_pos; + // Vec3.rotateClockwise90: (-z, y, x). + let (x, z) = (-(c[2] - p[2]), c[0] - p[0]); + let angle = trig::atan2(z, x) as f32 * (180.0 / std::f32::consts::PI); + f64::from(wrap_degrees(angle - self.yaw)) + } + /// `ChunkPos.getMiddleBlockPosition(y)`'s centre. + fn chunk_middle(chunk: [i32; 2], y: i32) -> [f64; 3] { + centre([chunk[0] * 16 + 8, y, chunk[1] * 16 + 8]) + } + fn yaw_angle(&self, w: &TrackedWaypoint) -> f64 { + match w.target { + WaypointTarget::Empty => f64::NAN, + WaypointTarget::Block(v) => self.yaw_to(self.block_position(w, v)), + WaypointTarget::Chunk(c) => { + self.yaw_to(Self::chunk_middle(c, self.camera_pos[1] as i32)) + } + WaypointTarget::Azimuth(a) => { + f64::from(wrap_degrees(a * (180.0 / std::f32::consts::PI) - self.yaw)) + } + } + } + /// `GameRenderer.projectHorizonToScreen`. + fn horizon(&self) -> f64 { + if self.pitch <= -90.0 { + return f64::NEG_INFINITY; + } + if self.pitch >= 90.0 { + return f64::INFINITY; + } + // Math.tan of the float products, in double. + let rad = std::f32::consts::PI / 180.0; + f64::from(self.pitch * rad).tan() / f64::from(self.fov / 2.0 * rad).tan() + } + fn pitch_direction(&self, w: &TrackedWaypoint) -> Pitch { + let by = |y: f64| { + if y < -1.0 { + Pitch::Down + } else if y > 1.0 { + Pitch::Up + } else { + Pitch::None + } + }; + match w.target { + WaypointTarget::Empty => Pitch::None, + WaypointTarget::Chunk(_) | WaypointTarget::Azimuth(_) => by(self.horizon()), + WaypointTarget::Block(v) => { + let p = self.block_position(w, v); + let c = self.camera_pos; + let s = (self.project)([p[0] - c[0], p[1] - c[1], p[2] - c[2]]); + let behind = s[2] > 1.0; + match by(if behind { -s[1] } else { s[1] }) { + Pitch::None if behind && s[1] > 0.0 => Pitch::Up, + Pitch::None if behind && s[1] < 0.0 => Pitch::Down, + p => p, + } + } + } + } + /// `distanceSquared` from the camera entity. + fn distance_sq(&self, w: &TrackedWaypoint) -> f64 { + let e = self.camera_entity_pos; + let d = |p: [f64; 3]| (0..3).map(|i| (p[i] - e[i]).powi(2)).sum::(); + match w.target { + WaypointTarget::Block(v) => d(centre(v)), + WaypointTarget::Chunk(c) => d(Self::chunk_middle(c, e[1].floor() as i32)), + WaypointTarget::Empty | WaypointTarget::Azimuth(_) => f64::INFINITY, + } + } +} + +/// `LocatorBar.extractBackground`: the nine-sliced sprite and its rectangle. +pub fn background(gui_width: i32, gui_height: i32) -> (&'static str, [i32; 4]) { + ( + "gui/sprites/hud/locator_bar_background", + [gui_width / 2 - 91, gui_height - 32 + 3, 182, 5], + ) +} + +fn sprite(name: &str, x: i32, y: i32, w: i32, h: i32, color: u32) -> GuiDraw { + GuiDraw::Sprite { + sprite: Cow::Owned(name.to_owned()), + x, + y, + w, + h, + region: None, + color, + blend: Blend::Textured, + } +} + +impl ClientWaypoints { + /// `LocatorBar.extractRenderState`: the farthest waypoint first. + pub fn draw(&self, view: &View) -> Vec { + let top = view.gui_height - 32 + 3; + let mut sorted: Vec<(f64, &TrackedWaypoint)> = self + .waypoints + .iter() + .map(|w| (view.distance_sq(w), w)) + .collect(); + sorted.sort_by(|a, b| b.0.total_cmp(&a.0)); + let mut out = Vec::new(); + for (distance_sq, w) in sorted { + if w.id == WaypointId::Uuid(view.camera_uuid) { + continue; + } + let angle = view.yaw_angle(w); + // `!(angle <= -60) && !(angle > 60)`: NaN draws, at the centre. + if angle <= -60.0 || angle > 60.0 { + continue; + } + let middle = ((view.gui_width - 9) as f32 / 2.0).ceil() as i32; + let style = view.styles.get(&w.style); + let distance = (distance_sq as f32).sqrt(); + let color = w.color.map_or_else( + || { + let hash = match &w.id { + WaypointId::Uuid(u) => uuid_hash(*u), + WaypointId::Name(n) => string_hash(n), + }; + set_brightness(0xFF00_0000 | hash as u32, 0.9) + }, + |c| c as u32, + ); + let dot = (angle * 173.0 / 2.0 / 60.0).floor() as i32; + out.push(view.styles.sprite( + style.sprite(distance), + middle + dot, + top - 2, + 9, + 9, + color, + view.tick, + )); + let arrow = match view.pitch_direction(w) { + Pitch::None => continue, + Pitch::Down => (6, "hud/locator_bar_arrow_down"), + Pitch::Up => (-6, "hud/locator_bar_arrow_up"), + }; + out.push(view.styles.sprite( + arrow.1, + middle + dot + 1, + top + arrow.0, + 7, + 5, + u32::MAX, + view.tick, + )); + } + out + } +} + +/// `Hud.ContextualInfo`: which bar sits above the hotbar. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ContextualBar { + Empty, + Experience, + Locator, + JumpableVehicle, +} +impl ContextualBar { + /// `Hud.nextContextualInfoState`: `recent_experience` is + /// `willPrioritizeExperienceInfo` (experience changed in the last 100 + /// ticks), `jumping` is `willPrioritizeJumpInfo`. + pub fn next( + waypoints: bool, + jumpable_vehicle: bool, + jumping: bool, + has_experience: bool, + recent_experience: bool, + ) -> Self { + if waypoints { + if jumpable_vehicle && jumping { + Self::JumpableVehicle + } else if has_experience && recent_experience { + Self::Experience + } else { + Self::Locator + } + } else if jumpable_vehicle { + Self::JumpableVehicle + } else if has_experience { + Self::Experience + } else { + Self::Empty + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn tracked(operation: i32, id: u128, target: WaypointTarget) -> TrackedWaypoint { + TrackedWaypoint { + operation, + id: WaypointId::Uuid(id), + style: "minecraft:default".into(), + color: None, + target, + } + } + + #[test] + fn styles_pick_sprites_by_distance() { + let default = WaypointStyle::parse( + r#"{"sprites":["minecraft:default_0","minecraft:default_1","minecraft:default_2","minecraft:default_3"]}"#, + ) + .unwrap(); + assert_eq!((default.near_distance, default.far_distance), (128, 332)); + assert_eq!(default.sprite(10.0), "hud/locator_bar_dot/default_0"); + assert_eq!(default.sprite(128.0), "hud/locator_bar_dot/default_1"); + // lerpInt((d - 128) / 204, 1, 3): halfway is the third sprite. + assert_eq!(default.sprite(229.0), "hud/locator_bar_dot/default_1"); + assert_eq!(default.sprite(230.0), "hud/locator_bar_dot/default_2"); + assert_eq!(default.sprite(332.0), "hud/locator_bar_dot/default_3"); + let bowtie = WaypointStyle::parse( + r#"{"near_distance":64,"sprites":["minecraft:bowtie","minecraft:default_0","minecraft:default_1","minecraft:default_2","minecraft:default_3"]}"#, + ) + .unwrap(); + assert_eq!(bowtie.sprite(63.0), "hud/locator_bar_dot/bowtie"); + // lerpInt((d - 64) / 268, 1, 4). + assert_eq!(bowtie.sprite(64.0), "hud/locator_bar_dot/default_0"); + assert_eq!(bowtie.sprite(200.0), "hud/locator_bar_dot/default_1"); + assert_eq!(bowtie.sprite(300.0), "hud/locator_bar_dot/default_2"); + // Three sprites: the middle one between near and far. + let three = WaypointStyle::parse(r#"{"sprites":["a","b","c"]}"#).unwrap(); + assert_eq!(three.sprite(200.0), "hud/locator_bar_dot/b"); + // validate: sprites, near > 0, far > near. + assert!(WaypointStyle::parse(r#"{"sprites":[]}"#).is_none()); + assert!(WaypointStyle::parse(r#"{"near_distance":0,"sprites":["a"]}"#).is_none()); + assert!(WaypointStyle::parse(r#"{"near_distance":400,"sprites":["a"]}"#).is_none()); + assert_eq!( + WaypointStyles::default().get("minecraft:none").sprite(5.0), + "hud/locator_bar_dot/missingno" + ); + } + + #[test] + fn packets_track_update_and_untrack() { + let mut w = ClientWaypoints::default(); + w.apply(&tracked( + waypoint_operation::TRACK, + 1, + WaypointTarget::Block([1, 2, 3]), + )); + assert!(w.has_waypoints()); + w.apply(&tracked( + waypoint_operation::UPDATE, + 1, + WaypointTarget::Block([4, 5, 6]), + )); + assert_eq!(w.waypoints[0].target, WaypointTarget::Block([4, 5, 6])); + // Another kind of waypoint doesn't update it. + w.apply(&tracked( + waypoint_operation::UPDATE, + 1, + WaypointTarget::Azimuth(1.0), + )); + assert_eq!(w.waypoints[0].target, WaypointTarget::Block([4, 5, 6])); + w.apply(&tracked( + waypoint_operation::UNTRACK, + 1, + WaypointTarget::Empty, + )); + assert!(!w.has_waypoints()); + } + + #[test] + fn brightness_like_argb() { + // Pure red at 0.9: Math.round(0.9 * 255) = 230. + assert_eq!(set_brightness(0xFFFF_0000, 0.9), 0xFFE6_0000); + assert_eq!(set_brightness(0xFF80_8080, 0.9), 0xFFE6_E6E6); + assert_eq!(uuid_hash(0x0000_0001_0000_0000_0000_0000_0000_0002), 3); + assert_eq!(string_hash("ab"), 97 * 31 + 98); + } + + #[test] + fn arrows_blink_through_their_frames() { + // locator_bar_arrow_up.png.mcmeta: 7x10, two 5-pixel frames. + let meta = r#"{"frames":[{"index":0,"time":10},{"index":1,"time":4}],"height":5}"#; + let animation = AnimationMetadata::from_json(meta).unwrap(); + let frames = SpriteFrames { + image: [7, 10], + frame: animation.frame_size(7, 10), + clip: animation.clip(2).unwrap().unwrap(), + }; + assert_eq!(frames.region(0), [7, 10, 0, 0]); + assert_eq!(frames.region(9), [7, 10, 0, 0]); + assert_eq!(frames.region(10), [7, 10, 0, 5]); + assert_eq!(frames.region(14), [7, 10, 0, 0]); + } + + #[test] + fn dots_sit_on_the_bar_by_angle() { + let styles = WaypointStyles( + [( + "minecraft:default".to_owned(), + WaypointStyle { + near_distance: 128, + far_distance: 332, + sprites: vec!["hud/locator_bar_dot/default_0".into()], + }, + )] + .into(), + HashMap::new(), + ); + let project = |p: [f64; 3]| [p[0], p[1], 0.5]; + let entity = |_: u128| None; + let view = View { + gui_width: 427, + gui_height: 240, + camera_uuid: 9, + camera_entity_pos: [0.5, 64.0, 0.5], + camera_pos: [0.5, 65.62, 0.5], + yaw: 0.0, + pitch: 0.0, + fov: 70.0, + project: &project, + entity: &entity, + styles: &styles, + tick: 0, + }; + let mut w = ClientWaypoints::default(); + // Yaw 0 looks towards +z: a waypoint straight ahead sits in the middle. + w.apply(&tracked( + waypoint_operation::TRACK, + 1, + WaypointTarget::Block([0, 65, 40]), + )); + // One behind the camera and the camera's own waypoint are not drawn. + w.apply(&tracked( + waypoint_operation::TRACK, + 2, + WaypointTarget::Block([0, 65, -40]), + )); + w.apply(&tracked( + waypoint_operation::TRACK, + 9, + WaypointTarget::Block([0, 65, 40]), + )); + let draws = w.draw(&view); + assert_eq!(draws.len(), 1); + let GuiDraw::Sprite { x, y, .. } = draws[0] else { + panic!("{draws:?}"); + }; + assert_eq!((x, y), (209, 209)); + // 30 degrees to the right: floor(30 * 173 / 120) = 43 pixels. + let east = ClientWaypoints { + waypoints: vec![tracked( + waypoint_operation::TRACK, + 3, + WaypointTarget::Azimuth(30f32.to_radians()), + )], + }; + let GuiDraw::Sprite { x, .. } = east.draw(&view)[0] else { + panic!(); + }; + assert_eq!(x, 209 + 43); + } + + #[test] + fn contextual_bar_priorities() { + use ContextualBar as B; + assert_eq!(B::next(true, false, false, true, false), B::Locator); + assert_eq!(B::next(true, false, false, true, true), B::Experience); + assert_eq!(B::next(true, true, true, true, true), B::JumpableVehicle); + assert_eq!(B::next(false, false, false, true, true), B::Experience); + assert_eq!(B::next(false, false, false, false, false), B::Empty); + // Creative players see the bar too. + assert_eq!(B::next(true, false, false, false, false), B::Locator); + } +} From 9d58d6f525babf5a1478d98cab34cb9cc73f268a Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 13:31:27 +0200 Subject: [PATCH 07/62] Random ticks: a section ticks while it holds a randomly ticking block, as in vanilla Vanilla random-ticks a section while its count of randomly ticking blocks and fluids is above zero (LevelChunkSection.isRandomlyTicking), and asks as it reaches each section. Horizon ticked every section whose palette listed such a state, even after the last one was gone, and decided before the tick's scheduled ticks, which drew positions vanilla doesn't and shifted its position sequence. RandomTickSections now reads each section's blocks (PalettedContainer::has), again only for the sections that changed, and tick_chunk_random asks for each section when it reaches it; the game reads a chunk's sections again only after a block changed. New harness random_tick_sections compares the sections and positions with vanilla's real section counts. Co-Authored-By: Claude Opus 5.5 --- .../examples/random_tick_sections_probe.rs | 132 ++++++++++++++++ crates/horizon-client/src/game.rs | 48 +++--- .../src/random_tick_sections.rs | 149 +++++++++++------- crates/horizon-core/src/paletted.rs | 57 +++++++ crates/horizon-world/src/level/mod.rs | 8 +- crates/horizon-world/src/level/tick.rs | 17 +- .../VanillaRandomTickSectionsOracle.java | 102 ++++++++++++ tools/test_random_tick_sections_parity.py | 73 +++++++++ 8 files changed, 504 insertions(+), 82 deletions(-) create mode 100644 crates/horizon-client/examples/random_tick_sections_probe.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRandomTickSectionsOracle.java create mode 100644 tools/test_random_tick_sections_parity.py diff --git a/crates/horizon-client/examples/random_tick_sections_probe.rs b/crates/horizon-client/examples/random_tick_sections_probe.rs new file mode 100644 index 000000000..cb8a8b742 --- /dev/null +++ b/crates/horizon-client/examples/random_tick_sections_probe.rs @@ -0,0 +1,132 @@ +//! Random-tick sections companion for tools/test_random_tick_sections_parity.py: +//! the game's `RandomTickSections` choosing the sections of a chunk that +//! `Behaviours::tick_chunk_random` ticks, after the case's edits (see +//! VanillaRandomTickSectionsOracle for the format; the `#resources` line names +//! the prepared resources). The level the ticks run against reads as air +//! everywhere, so nothing ticks for real: its reads are the drawn positions. +use horizon_client::{ + blocks::BlockFacts, + chunk::{Chunk, MIN_Y, Section}, + random_tick_sections::RandomTickSections, +}; +use horizon_core::{ + position::{BlockPos, ChunkPos}, + random::LegacyRandom, +}; +use horizon_world::{ + fluid::FluidKind, + level::{GameRules, LevelAccess, LevelEvent, Ticks, data}, + registry::BlockStateId, +}; +use std::{cell::RefCell, error::Error, fmt::Write, path::PathBuf, sync::Arc}; + +struct Air { + reads: RefCell>, + random: LegacyRandom, + speed: i32, +} +impl LevelAccess for Air { + fn block_state(&self, pos: BlockPos) -> BlockStateId { + self.reads.borrow_mut().push(pos); + BlockStateId(0) + } + fn set_raw(&mut self, _: BlockPos, _: BlockStateId) -> Option { + None + } + fn is_loaded(&self, _: BlockPos) -> bool { + true + } + fn random(&mut self) -> &mut LegacyRandom { + &mut self.random + } + fn game_time(&self) -> i64 { + 0 + } + fn game_rules(&self) -> GameRules { + GameRules { + random_tick_speed: self.speed, + ..Default::default() + } + } + fn emit(&mut self, _: LevelEvent) {} +} + +fn main() -> Result<(), Box> { + let args: Vec = std::env::args().collect(); + let input = std::fs::read_to_string(&args[1])?; + let root = input + .lines() + .find_map(|l| l.strip_prefix("#resources ")) + .map(PathBuf::from) + .ok_or("no #resources line")?; + let registry = data::load_registry(&root)?; + let (facts, behaviours) = BlockFacts::load_pair(&root, ®istry)?; + let mut output = String::new(); + for line in input.lines().filter(|l| !l.starts_with('#')) { + let mut words = line.split(' '); + let mut ticks = Ticks::new(0); + ticks.random_tick_value = words.next().ok_or("no randValue")?.parse()?; + let mut level = Air { + reads: RefCell::default(), + random: LegacyRandom::new(0), + speed: words.next().ok_or("no speed")?.parse()?, + }; + let mut chunk = Arc::new(Chunk::empty(0, 0)); + let mut cache = RandomTickSections::default(); + for word in words { + let op: Vec<&str> = word.split(':').collect(); + let int = |i: usize| -> Result> { Ok(op[i].parse()?) }; + match op[0] { + "s" => { + let (section, index) = (int(1)?, int(2)?); + Arc::make_mut(&mut chunk).set( + index & 15, + MIN_Y + section * 16 + (index >> 8), + index >> 4 & 15, + int(3)? as u32, + ); + } + "f" => { + let (a, b, m) = (int(2)? as u32, int(3)? as u32, int(4)? as usize); + let values = std::array::from_fn(|i| if i % m == m - 1 { b } else { a }); + Arc::make_mut(&mut Arc::make_mut(&mut chunk).sections[int(1)? as usize]) + .blocks = Section::from_blocks(&values); + } + "t" => { + output.push('|'); + level.reads.borrow_mut().clear(); + behaviours.tick_chunk_random( + &mut level, + &mut ticks, + ChunkPos::new(0, 0), + |_, min_y| cache.get((0, 0), &chunk, &facts).contains(min_y), + ); + for pos in level.reads.borrow().iter() { + let state = chunk.block(pos.x, pos.y, pos.z); + let fluid = matches!( + behaviours.fluid(state).kind(), + FluidKind::Lava | FluidKind::FlowingLava + ); + write!( + output, + " {},{},{},{}{}", + pos.x, + pos.y, + pos.z, + if behaviours.is_randomly_ticking(state) { + 'B' + } else { + '-' + }, + if fluid { 'F' } else { '-' }, + )?; + } + } + other => return Err(format!("unknown op {other}").into()), + } + } + writeln!(output, " | {}", ticks.random_tick_value)?; + } + std::fs::write(&args[2], output)?; + Ok(()) +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index bad635c5c..afdb2ee37 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -515,6 +515,7 @@ struct GameLevel<'w> { spill: &'w mut spill::Spill, /// Where the chunk tickets let blocks tick. tickets: horizon_client::ticket_levels::Levels, + random_tick_sections: &'w mut horizon_client::random_tick_sections::RandomTickSections, } struct PlayerCollision { y: f64, @@ -2276,6 +2277,7 @@ impl Game<'_> { pending: &mut self.pending, spill: &mut self.spill, tickets: self.tickets.levels(), + random_tick_sections: &mut self.random_tick_sections, }; let result = f(self.res.behaviours(), &mut level, &mut self.block_ticks); self.flush_spill(); @@ -2370,18 +2372,15 @@ impl Game<'_> { self.sync_tick_chunks(); self.start_ticking_chunks(); let levels = self.tickets.levels(); - let mut ticking = Vec::new(); - let facts = self.res.facts(); - for (&(x, z), chunk) in &self.world.chunks { - if !levels.random_ticking(x, z) || !ticking_chunk(&self.world, x, z) { - continue; - } - // Capture eligibility before inside-block and scheduled updates, as - // before. Keep the world map's chunk order, including empty chunks - // (tick_chunk_random still draws for precipitation in those). - let sections = self.random_tick_sections.get((x, z), chunk, facts); - ticking.push((x, z, sections)); - } + // Keep the world map's chunk order, including empty chunks + // (tick_chunk_random still draws for precipitation in those). + let ticking: Vec<_> = self + .world + .chunks + .keys() + .copied() + .filter(|&(x, z)| levels.random_ticking(x, z) && ticking_chunk(&self.world, x, z)) + .collect(); // Entity.checkInsideBlocks for the plates, tripwires and detector rails // under the players (the host and the LAN guests) and the minecarts. let mut inside = Vec::new(); @@ -2423,13 +2422,24 @@ impl Game<'_> { self.process_level_events()?; self.tick_scheduled()?; self.with_level(|b, level, ticks| { - for (x, z, sections) in ticking { - b.tick_chunk_random( - level, - ticks, - horizon_core::position::ChunkPos::new(x, z), - sections, - ); + for (x, z) in ticking { + // The sections are read again only after a block changed. + let mut read = None; + let mut sections = Default::default(); + let pos = horizon_core::position::ChunkPos::new(x, z); + b.tick_chunk_random(level, ticks, pos, |level, min_y| { + if read != Some(level.world.revision) { + read = Some(level.world.revision); + sections = level + .world + .chunks + .get(&(x, z)) + .map_or_else(Default::default, |chunk| { + level.random_tick_sections.get((x, z), chunk, level.facts) + }); + } + sections.contains(min_y) + }); } b.run_block_events(level, ticks); b.tick_block_entities(level, ticks); diff --git a/crates/horizon-client/src/random_tick_sections.rs b/crates/horizon-client/src/random_tick_sections.rs index ce5da051b..23d6a3dbe 100644 --- a/crates/horizon-client/src/random_tick_sections.rs +++ b/crates/horizon-client/src/random_tick_sections.rs @@ -1,7 +1,8 @@ -//! Memoized palette eligibility for the game thread's random-tick snapshot. +//! Which sections of the game thread's chunks random-tick +//! (`LevelChunkSection.isRandomlyTicking`), memoized per section. use crate::{ blocks::BlockFacts, - chunk::{Chunk, MIN_Y, SECTIONS}, + chunk::{Chunk, MIN_Y, SECTIONS, Section}, fast_hash::FxHashMap, }; use horizon_world::registry::BlockStateId; @@ -10,6 +11,13 @@ use std::sync::{Arc, Weak}; /// A value snapshot, in ascending section order, with no per-chunk allocation. #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub struct Sections(u32); +impl Sections { + /// Whether the section starting at block `min_y` is in the set. + pub fn contains(self, min_y: i32) -> bool { + let index = (min_y - MIN_Y) >> 4; + (0..SECTIONS as i32).contains(&index) && self.0 >> index & 1 != 0 + } +} impl Iterator for Sections { type Item = i32; fn next(&mut self) -> Option { @@ -29,12 +37,20 @@ impl ExactSizeIterator for Sections {} struct Cached { chunk: Weak, + /// The section each bit of `sections` was read from. + read: [Weak
; SECTIONS], sections: Sections, } -/// Resident chunks are immutable behind `Arc`; edits use `Arc::make_mut`. -/// A weak reference detects both edits and replacement, without retaining block -/// data or forcing a deep copy on the next edit. It also prevents address reuse. -/// Clear this cache whenever the gameplay facts change (including resource reload). +/// Vanilla keeps a count of randomly ticking blocks and fluids per section, +/// updated by every `setBlockState`, and ticks the sections where it is above +/// zero. Here a section's answer is read from its blocks after any edit: +/// resident chunks and sections are immutable behind `Arc` and edited through +/// `Arc::make_mut`, so a weak reference tells an edited or replaced one from +/// the one read, without retaining block data or forcing a deep copy on the +/// next edit, and prevents address reuse. An unchanged chunk costs one +/// pointer comparison; a changed one, a comparison per section and a read of +/// the sections that changed. Clear this cache whenever the gameplay facts +/// change (including resource reload). #[derive(Default)] pub struct RandomTickSections { chunks: FxHashMap<(i32, i32), Cached>, @@ -46,6 +62,7 @@ impl RandomTickSections { pub fn remove(&mut self, key: &(i32, i32)) { self.chunks.remove(key); } + /// The sections of `chunk` holding a randomly ticking block or fluid. pub fn get(&mut self, key: (i32, i32), chunk: &Arc, facts: &BlockFacts) -> Sections { self.get_with(key, chunk, |id| facts.get(BlockStateId(id)).random_ticks) } @@ -60,17 +77,23 @@ impl RandomTickSections { } let cached = self.chunks.entry(key).or_insert_with(|| Cached { chunk: Weak::new(), + read: std::array::from_fn(|_| Weak::new()), sections: Sections::default(), }); if cached.chunk.as_ptr() != Arc::as_ptr(chunk) { - let mut mask = 0; - for (i, section) in chunk.sections.iter().enumerate() { - // Preserve maybe_has, including unused entries and global palettes. - if section.blocks.maybe_has(&mut random) { - mask |= 1 << i; + for (i, (section, read)) in chunk.sections.iter().zip(&mut cached.read).enumerate() { + if read.as_ptr() == Arc::as_ptr(section) { + continue; } + // `isRandomlyTicking`: the blocks themselves, not the palette, + // which keeps the states no block uses any more. + if section.blocks.has(&mut random) { + cached.sections.0 |= 1 << i; + } else { + cached.sections.0 &= !(1 << i); + } + *read = Arc::downgrade(section); } - cached.sections = Sections(mask); cached.chunk = Arc::downgrade(chunk); } cached.sections @@ -97,10 +120,24 @@ mod tests { [MIN_Y] ); assert_eq!(worker.get(0, MIN_Y, 0), 0); - // Even after the last ticking block is removed, its unused palette entry counts. + // Once the last ticking block is gone the section stops ticking, as + // vanilla's count drops to zero, though its palette still lists it. Arc::make_mut(&mut chunk).set(0, MIN_Y, 0, 0); - assert_eq!(cache.get_with((0, 0), &chunk, |id| id == 1).len(), 1); - Arc::make_mut(&mut Arc::make_mut(&mut chunk).sections[0]).compact(); + assert!(chunk.sections[0].blocks.maybe_has(|id| id == 1)); + assert_eq!(cache.get_with((0, 0), &chunk, |id| id == 1).len(), 0); + // Only the edited section is read again (its palette: air, then 1). + Arc::make_mut(&mut chunk).set(0, MIN_Y + 16, 0, 1); + let mut asked = Vec::new(); + let sections = cache.get_with((0, 0), &chunk, |id| { + asked.push(id); + id == 1 + }); + assert_eq!( + (sections.collect::>(), asked), + (vec![MIN_Y + 16], vec![0, 1]) + ); + Arc::make_mut(&mut chunk).set(0, MIN_Y + 16, 0, 0); + Arc::make_mut(&mut Arc::make_mut(&mut chunk).sections[1]).compact(); assert_eq!(cache.get_with((0, 0), &chunk, |id| id == 1).len(), 0); Arc::make_mut(&mut chunk).sections[SECTIONS - 1] = Arc::new(Section::default()); cache.clear(); // resource reload, with changed facts for the same state IDs @@ -138,10 +175,12 @@ mod tests { } let chunk = Arc::new(chunk); let mut cache = RandomTickSections::default(); - // Global maybe_has considers the entire ID range, including absent states. + // Global palettes: the states the blocks hold, not the whole ID range. + assert_eq!(cache.get_with((0, 0), &chunk, |id| id == 40000).len(), 0); + cache.clear(); assert_eq!( cache - .get_with((0, 0), &chunk, |id| id == 40000) + .get_with((0, 0), &chunk, |id| id == 299) .collect::>(), [MIN_Y, MIN_Y + 9 * 16, MIN_Y + (SECTIONS as i32 - 1) * 16] ); @@ -201,7 +240,7 @@ mod tick_parity { } #[test] - fn actual_random_ticks_match_original_scan() { + fn actual_random_ticks_match_a_block_scan() { let root = std::env::var_os("HORIZON_RESOURCES") .map(PathBuf::from) .unwrap_or_else(|| { @@ -228,6 +267,7 @@ mod tick_parity { let registry = data::load_registry(&root).unwrap(); let (mut facts, behaviours) = BlockFacts::load_pair(&root, ®istry).unwrap(); let grass = registry.default_state("minecraft:grass_block").unwrap(); + let stone = registry.default_state("minecraft:stone").unwrap(); let chunk = |x| { let mut c = Chunk::empty(x, 0); c.lit = true; @@ -280,6 +320,15 @@ mod tick_parity { 40 | 41 => { Arc::make_mut(level.chunks.get_mut(&(0, 0)).unwrap()).lit = step == 41; } + 70 => { + // Every block of a ticking section replaced: its + // palette still lists grass, but nothing ticks there. + let c = Arc::make_mut(level.chunks.get_mut(&(-1, 0)).unwrap()); + for i in 0..4096 { + c.set(i & 15, MIN_Y + 4 * 16 + (i >> 8), i >> 4 & 15, stone.0); + } + assert!(c.sections[4].blocks.maybe_has(|id| id == grass.0)); + } _ => {} } } @@ -290,47 +339,41 @@ mod tick_parity { facts.states[grass.0 as usize].random_ticks = step == 60; cache.clear(); } - let old: Vec<_> = original - .chunks - .iter() - .filter(|(_, c)| c.lit) - .map(|(&key, c)| { - let sections: Vec<_> = c - .sections - .iter() - .enumerate() - .filter(|(_, s)| { - s.blocks - .maybe_has(|id| facts.get(BlockStateId(id)).random_ticks) - }) - .map(|(i, _)| MIN_Y + i as i32 * 16) - .collect(); - (key, sections) - }) - .collect(); - let new: Vec<_> = cached - .chunks - .iter() - .filter(|(_, c)| c.lit) - .map(|(&key, c)| (key, cache.get(key, c, &facts))) - .collect(); - assert_eq!( - old, - new.iter() - .map(|(k, s)| (*k, s.collect::>())) - .collect::>() - ); - // Stand in for an inside-block/scheduled write AFTER eligibility capture. + // A write between ticks. if step == 20 { for level in [&mut original, &mut cached] { level.set_raw(BlockPos::new(0, MIN_Y + 16, 0), grass); } } - for ((x, z), sections) in old { - behaviours.tick_chunk_random(&mut original, &mut a, ChunkPos::new(x, z), sections); + let lit = |level: &Level| { + let mut keys: Vec<_> = level + .chunks + .iter() + .filter(|(_, c)| c.lit) + .map(|(&key, _)| key) + .collect(); + keys.sort(); + keys + }; + let random = |id| facts.get(BlockStateId(id)).random_ticks; + for (x, z) in lit(&original) { + // Vanilla's rule, asked as each section is reached: any of its + // 4,096 blocks ticks randomly. + let reference = |level: &mut Level, min_y: i32| { + let chunk = &level.chunks[&(x, z)]; + (0..16).any(|y| { + (0..16).any(|z| (0..16).any(|x| random(chunk.get(x, min_y + y, z)))) + }) + }; + behaviours.tick_chunk_random(&mut original, &mut a, ChunkPos::new(x, z), reference); } - for ((x, z), sections) in new { - behaviours.tick_chunk_random(&mut cached, &mut b, ChunkPos::new(x, z), sections); + for (x, z) in lit(&cached) { + let memoized = |level: &mut Level, min_y| { + cache + .get((x, z), &level.chunks[&(x, z)], &facts) + .contains(min_y) + }; + behaviours.tick_chunk_random(&mut cached, &mut b, ChunkPos::new(x, z), memoized); } assert_eq!(original.reads, cached.reads, "ordered reads at tick {step}"); assert_eq!(original.events, cached.events, "events at tick {step}"); diff --git a/crates/horizon-core/src/paletted.rs b/crates/horizon-core/src/paletted.rs index 3d56bb987..dad7f76a0 100644 --- a/crates/horizon-core/src/paletted.rs +++ b/crates/horizon-core/src/paletted.rs @@ -674,6 +674,41 @@ impl PalettedContainer { Palette::Global => (0..1u32 << self.bits.min(31)).any(predicate), } } + /// Whether any entry satisfies `predicate`. Unlike [`Self::maybe_has`], + /// palette entries no entry uses any more don't count. + pub fn has(&self, mut predicate: impl FnMut(u32) -> bool) -> bool { + let matching: Vec = match &self.palette { + Palette::Single(value) => return predicate(*value), + Palette::List(list) => list.iter().map(|&v| predicate(v)).collect(), + Palette::Global => Vec::new(), + }; + if matches!(self.palette, Palette::List(_)) { + if !matching.contains(&true) { + return false; + } + if !matching.contains(&false) { + return true; + } + } + let bits = usize::from(self.bits); + let per = 64 / bits; + let m = mask(self.bits); + let mut left = self.strategy.entries(); + for &word in &self.words { + for slot in 0..per.min(left) { + let id = ((word >> (slot * bits)) & m) as usize; + let hit = match self.palette { + Palette::Global => predicate(id as u32), + _ => matching[id], + }; + if hit { + return true; + } + } + left = left.saturating_sub(per); + } + false + } /// Heap bytes held by the palette and the storage. pub fn heap_bytes(&self) -> usize { self.words.capacity() * 8 @@ -771,9 +806,31 @@ mod tests { let wire = PalettedContainer::from_wire(strategy, bits, palette, words.to_vec()).unwrap(); assert_eq!(wire, c); + for wanted in [0, 7, 14, 35, 7 * 699, 5] { + assert_eq!( + c.has(|v| v == wanted || v == wanted + 7), + plain.iter().any(|&v| v == wanted || v == wanted + 7), + "has {wanted} in {distinct} values" + ); + } } } #[test] + fn has_ignores_stale_palette_entries() { + let mut c = PalettedContainer::new(BLOCKS, 0); + assert!(c.has(|v| v == 0) && !c.has(|v| v == 3)); + c.set(4095, 3); + assert!(c.has(|v| v == 3)); + c.set(4095, 0); + assert!(c.maybe_has(|v| v == 3) && !c.has(|v| v == 3)); + for v in 1..=300 { + c.set(v as usize, v); + } + assert!(c.is_global() && c.has(|v| v == 300)); + c.set(300, 0); + assert!(c.maybe_has(|v| v == 300) && !c.has(|v| v == 300)); + } + #[test] fn uniform_detection_ignores_stale_palette_entries() { let mut c = PalettedContainer::new(BLOCKS, 0); c.set(10, 3); diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs index de7312cb1..1c338f2ed 100644 --- a/crates/horizon-world/src/level/mod.rs +++ b/crates/horizon-world/src/level/mod.rs @@ -19,9 +19,9 @@ //! `ServerLevel.tickChunk`'s random ticks: for each non-empty section, //! `randomTickSpeed` (game rule, default 3) positions are drawn with //! `Level.getBlockRandomPos` and randomly-ticking block and fluid states are -//! ticked. The caller decides which sections are randomly ticking (vanilla -//! counts randomly-ticking states per section); [`Behaviours::random_tick`] -//! ticks a single position. +//! ticked. The caller says which sections are randomly ticking when each is +//! reached (vanilla counts randomly-ticking states per section); +//! [`Behaviours::random_tick`] ticks a single position. //! 3. [`Behaviours::run_block_events`] runs queued block events (pistons), //! then (after entities) [`Behaviours::tick_block_entities`] advances //! moving pistons ([`Ticks::moving_pistons`]). @@ -69,7 +69,7 @@ //! level.time += 1; //! behaviours.tick_scheduled(&mut level, &mut ticks); //! for chunk in ticking_chunks { -//! behaviours.tick_chunk_random(&mut level, &mut ticks, chunk, randomly_ticking_section_min_ys(chunk)); +//! behaviours.tick_chunk_random(&mut level, &mut ticks, chunk, |level, min_y| level.randomly_ticking(chunk, min_y)); //! } //! behaviours.run_block_events(&mut level, &mut ticks); //! /* tick entities */ diff --git a/crates/horizon-world/src/level/tick.rs b/crates/horizon-world/src/level/tick.rs index 1c45990a0..e9e4f6791 100644 --- a/crates/horizon-world/src/level/tick.rs +++ b/crates/horizon-world/src/level/tick.rs @@ -1615,16 +1615,18 @@ impl Behaviours { }; ticks.handling_tick = false; } - /// Random-tick one chunk (`ServerLevel.tickChunk` block part). `sections` - /// yields the minimum block Y of every section the caller considers - /// randomly ticking (vanilla: sections containing randomly-ticking states), - /// in ascending order. Draws `randomTickSpeed` positions per section. + /// Random-tick one chunk (`ServerLevel.tickChunk` block part). Visits the + /// sections from the bottom up and draws `randomTickSpeed` positions in + /// each one `ticking(level, min_y)` reports randomly ticking + /// (`LevelChunkSection.isRandomlyTicking`: it holds a randomly ticking + /// block or fluid). Vanilla asks as it reaches each section, so the ticks + /// of the sections below count. pub fn tick_chunk_random( &self, level: &mut L, ticks: &mut Ticks, chunk: ChunkPos, - sections: impl IntoIterator, + mut ticking: impl FnMut(&mut L, i32) -> bool, ) { let speed = level.game_rules().random_tick_speed; if speed <= 0 { @@ -1639,7 +1641,10 @@ impl Behaviours { } } } - for min_y in sections { + for min_y in (level.min_y()..level.max_y()).step_by(16) { + if !ticking(level, min_y) { + continue; + } for _ in 0..speed { let pos = ticks.block_random_pos(min_x, min_y, min_z, 15); self.sim(level, ticks).random_tick_at(pos); diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRandomTickSectionsOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRandomTickSectionsOracle.java new file mode 100644 index 000000000..a0dc5d914 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRandomTickSectionsOracle.java @@ -0,0 +1,102 @@ +package dev.horizonlab.parity; + +import java.io.*; +import java.lang.reflect.Field; +import java.nio.charset.StandardCharsets; +import java.nio.file.*; +import net.minecraft.core.BlockPos; +import net.minecraft.util.RandomSource; +import net.minecraft.world.level.Level; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.level.chunk.LevelChunkSection; +import net.minecraft.world.level.chunk.PalettedContainerFactory; + +/** + * Original oracle for which sections of a chunk random-tick and where: the + * real LevelChunkSection block counts (setBlockState, and recalcBlockCounts + * for a section built from a filled container, as a loaded one is) and + * isRandomlyTicking, with the block part of ServerLevel.tickChunk's section + * loop around them (the precipitation draws included, on a level random + * seeded 0) and the real Level.getBlockRandomPos drawing the positions. + * + * Each case line is "randValue speed op...", ops being "s:section:index:state" + * (setBlockState, index y << 8 | z << 4 | x), "f:section:a:b:m" (a section + * loaded from a container holding b where index % m == m - 1, a elsewhere) and + * "t" (one tick). Prints, per tick, every drawn position with whether its + * block and its fluid tick randomly, then the final randValue. + */ +public final class VanillaRandomTickSectionsOracle { + static final int SECTIONS = 24; + static final int MIN_Y = -64; + + public static void main(String[] args) throws Exception { + ParityData.init(); + var factory = PalettedContainerFactory.create(ParityData.access); + Level level = ParityData.level; + Field randValue = Level.class.getDeclaredField("randValue"); + randValue.setAccessible(true); + try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8)); + var lines = Files.lines(Path.of(args[0]))) { + for (var line : (Iterable) lines::iterator) { + if (line.startsWith("#")) continue; + String[] words = line.trim().split(" "); + randValue.setInt(level, Integer.parseInt(words[0])); + int speed = Integer.parseInt(words[1]); + RandomSource random = RandomSource.create(0); + LevelChunkSection[] sections = new LevelChunkSection[SECTIONS]; + for (int i = 0; i < SECTIONS; i++) sections[i] = new LevelChunkSection(factory); + StringBuilder result = new StringBuilder(); + for (int w = 2; w < words.length; w++) { + String[] op = words[w].split(":"); + switch (op[0]) { + case "s" -> { + int index = Integer.parseInt(op[2]); + sections[Integer.parseInt(op[1])].setBlockState(index & 15, index >> 8, index >> 4 & 15, + state(op[3])); + } + case "f" -> { + BlockState a = state(op[2]), b = state(op[3]); + int m = Integer.parseInt(op[4]); + var states = factory.createForBlockStates(); + for (int index = 0; index < 4096; index++) { + states.getAndSetUnchecked(index & 15, index >> 8, index >> 4 & 15, + index % m == m - 1 ? b : a); + } + sections[Integer.parseInt(op[1])] = new LevelChunkSection(states, factory.createForBiomes()); + } + case "t" -> { + result.append('|'); + // ServerLevel.tickChunk, for a chunk at 0, 0. Its + // precipitation positions use randValue too. + for (int i = 0; i < speed; i++) { + if (random.nextInt(48) == 0) level.getBlockRandomPos(0, 0, 0, 15); + } + if (speed <= 0) continue; + for (int s = 0; s < SECTIONS; s++) { + LevelChunkSection section = sections[s]; + if (!section.isRandomlyTicking()) continue; + int minY = MIN_Y + s * 16; + for (int i = 0; i < speed; i++) { + BlockPos pos = level.getBlockRandomPos(0, minY, 0, 15); + BlockState state = section.getBlockState(pos.getX(), pos.getY() - minY, pos.getZ()); + result.append(' ').append(pos.getX()).append(',').append(pos.getY()).append(',') + .append(pos.getZ()).append(',') + .append(state.isRandomlyTicking() ? 'B' : '-') + .append(state.getFluidState().isRandomlyTicking() ? 'F' : '-'); + } + } + } + default -> throw new IllegalArgumentException(words[w]); + } + } + out.println(result.append(" | ").append(randValue.getInt(level))); + } + } + System.exit(0); + } + + static BlockState state(String id) { + return Block.BLOCK_STATE_REGISTRY.byId(Integer.parseInt(id)); + } +} diff --git a/tools/test_random_tick_sections_parity.py b/tools/test_random_tick_sections_parity.py new file mode 100644 index 000000000..632808523 --- /dev/null +++ b/tools/test_random_tick_sections_parity.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python3 +"""Compare which sections of a chunk random-tick, and the positions drawn in them, with the pinned client. + +Vanilla random-ticks a section while its count of randomly ticking blocks and fluids is above zero +(LevelChunkSection.isRandomlyTicking, counted by setBlockState and recalcBlockCounts), whatever its palette still lists. +Each case loads sections (every block state fills one, alone, so each state's own answer is compared; others mix a +ticking and a non-ticking state), ticks, sets and removes randomly ticking blocks (leaving them in the palette), and +ticks again. Vanilla runs ServerLevel.tickChunk's section loop on real sections with the real getBlockRandomPos +(VanillaRandomTickSectionsOracle); Horizon runs Behaviours::tick_chunk_random with the game's RandomTickSections +(examples/random_tick_sections_probe). Both print every drawn position, whether its block and its fluid tick +randomly, and the final randValue. +""" +import itertools +import json +import random + +try: + from . import lab, oracle_harness as harness +except ImportError: + import lab, oracle_harness as harness + +COUNT = 3000 +SECTIONS = 24 + + +def make_cases(build): + resources = lab.LOCAL / 'horizon-client' / '26.3' + states = json.loads((resources / 'gameplay-facts.json').read_text())['states'] + ticking = [s['id'] for s in states if s['random_ticks']] + still = [s['id'] for s in states if not s['random_ticks']] + sweep = itertools.cycle(range(len(states))) + rng = random.Random(0x5449434B) + lines = [f'#resources {resources}'] + for _ in range(COUNT): + ops = [] + loaded = rng.sample(range(SECTIONS), 14) + for section in loaded[:12]: + state = next(sweep) + ops.append(f'f:{section}:{state}:{state}:1') + mixed = loaded[12:] + for section in mixed: + ops.append(f'f:{section}:{rng.choice(still)}:{rng.choice(ticking)}:{rng.choice([1, 2, 7, 64, 4096])}') + ops.append('t') + placed = [] + for _ in range(rng.randrange(1, 6)): + section, index = rng.randrange(SECTIONS), rng.randrange(4096) + ops.append(f's:{section}:{index}:{rng.choice(ticking)}') + placed.append((section, index)) + ops.append('t') + # Take them away again, and the lone ticking block of the mixed sections: + # their palettes keep the states. + for section, index in placed + [(section, 4095) for section in mixed]: + ops.append(f's:{section}:{index}:{rng.choice([0, 0, rng.choice(still)])}') + ops.append('t') + ops.append('t') + lines.append(f'{rng.randrange(-2**31, 2**31)} {rng.choice([0, 1, 2, 3, 3, 3, 4])} {" ".join(ops)}') + path = build / 'cases.txt' + path.write_text('\n'.join(lines) + '\n') + return path, COUNT + + +if __name__ == '__main__': + harness.differential( + 'random-tick-sections-parity', 'VanillaRandomTickSectionsOracle', 'random_tick_sections_probe', make_cases, + 'Which sections of a chunk random-tick (block and fluid counts over loads, sets and removals, not the palette) ' + 'and the positions tickChunk draws in them, with each position\'s block and fluid random-tick flags. The ' + 'blocks\' random-tick behaviour itself is test_random_tick_parity\'s.', + sources=[lab.ROOT / 'crates/horizon-client/src/random_tick_sections.rs', + lab.ROOT / 'crates/horizon-client/src/chunk.rs', + lab.ROOT / 'crates/horizon-core/src/paletted.rs', + lab.ROOT / 'crates/horizon-world/src/level/tick.rs', + lab.ROOT / 'crates/horizon-world/src/level/ticks.rs'], + expected_lines=COUNT) From 4e45a3bddfd2f0a3090d729ac95a02ab9d11a43e Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 12:36:09 +0200 Subject: [PATCH 08/62] Credits and end poem (WinScreen) Leaving the End through the exit portal for the first time now rolls the end poem, the credits and the post-credits text (WinScreen), as does a server's WIN_GAME event; Options -> Credits & Attribution -> Credits rolls the credits alone. The texts come from the resource root (texts/end.txt, credits.json, postcredits.txt), so packs can replace them. - win_screen.rs: vanilla's line building (PLAYERNAME, the obfuscated names from LegacyRandom(8124371), wrapping at 256), scroll speeds and keys (Space, Ctrl, Up, Escape), the last line pinned mid-screen, the logo, the vignette and the backgrounds. - HUD: Blend::Vignette (RenderPipelines.VIGNETTE) and Blend::EndPortal (the End portal effect as a GUI fill, the poem's background). - Obfuscated text draws a random glyph of the same width each frame. - seenCredits is read and saved; the player stays out of the world while the poem rolls and arrives in the Overworld after it. - horizon-ctl `credits [poem] [SCROLL]` and `options credits`. Fixes #338 Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/font.rs | 71 +++ crates/horizon-client/src/game.rs | 27 +- crates/horizon-client/src/game/agent.rs | 1 + crates/horizon-client/src/game/control.rs | 25 + crates/horizon-client/src/game/end.rs | 5 +- crates/horizon-client/src/game/music.rs | 8 +- crates/horizon-client/src/game/options.rs | 1 + crates/horizon-client/src/game/remote.rs | 4 + .../horizon-client/src/game/startup_menu.rs | 40 ++ crates/horizon-client/src/game/win.rs | 150 ++++++ crates/horizon-client/src/hud.rs | 108 ++++- crates/horizon-client/src/hud.wgsl | 51 +- crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/options_ui.rs | 52 +- crates/horizon-client/src/save.rs | 4 + crates/horizon-client/src/win_screen.rs | 452 ++++++++++++++++++ 16 files changed, 982 insertions(+), 18 deletions(-) create mode 100644 crates/horizon-client/src/game/win.rs create mode 100644 crates/horizon-client/src/win_screen.rs diff --git a/crates/horizon-client/src/font.rs b/crates/horizon-client/src/font.rs index aeedb92bd..3039fdb40 100644 --- a/crates/horizon-client/src/font.rs +++ b/crates/horizon-client/src/font.rs @@ -52,6 +52,10 @@ struct Cache { cursor: (u32, u32), pending: Vec, hex: Option>, + /// `FontSet.glyphsByWidth` for obfuscated text (built on first use). + by_width: Option>>, + /// `Font.random`: picks obfuscated glyphs. + random: horizon_core::random::LegacyRandom, } pub struct Font { bitmap: HashMap, @@ -285,6 +289,12 @@ impl Font { cursor: (0, 0), pending: Vec::new(), hex: None, + by_width: None, + random: horizon_core::random::LegacyRandom::new( + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_or(0, |d| d.as_nanos() as i64), + ), }), uniform: false, japanese: false, @@ -353,6 +363,7 @@ impl Font { cache.glyphs.clear(); cache.cursor = (0, 0); cache.hex = None; + cache.by_width = None; } /// The glyph for a character (FontSet.getGlyph). pub fn glyph(&self, c: char) -> Glyph { @@ -427,6 +438,66 @@ impl Font { offset: 0.5, }) } + /// `FontSet.getRandomGlyph`: what an obfuscated character draws, a random + /// glyph as wide as `advance` (rounded up), else the missing glyph. + /// + /// Vanilla picks among every glyph of the font set, Unifont's included. + /// Those are rasterized into a fixed atlas region on demand, which a + /// line of obfuscated text would fill in seconds, so the candidates are + /// the glyphs already in the atlas (the bitmap sheets and spaces), or with + /// "Force Unicode Font" the Unifont glyphs below U+0250. + pub fn random_glyph(&self, advance: f32) -> Glyph { + use horizon_core::random::RandomSource; + let width = advance.ceil() as u32; + let pick = { + let mut cache = self.cache.borrow_mut(); + if cache.by_width.is_none() { + let by_width = self.glyphs_by_width(&mut cache); + cache.by_width = Some(by_width); + } + let Cache { + by_width, random, .. + } = &mut *cache; + by_width + .as_ref() + .and_then(|m| m.get(&width)) + .and_then(|chars| { + let i = random.next_int_bound(chars.len() as i32).ok()?; + chars.get(i as usize).copied() + }) + }; + pick.map_or(self.missing, |c| self.glyph(c)) + } + fn glyphs_by_width(&self, cache: &mut Cache) -> HashMap> { + let mut chars: Vec<(char, f32)> = self.space.iter().map(|(c, a)| (*c, *a)).collect(); + if self.uniform { + if cache.hex.is_none() { + cache.hex = Some(self.load_hex()); + } + for code in 0..0x250u32 { + let hex = cache.hex.iter().flatten().find_map(|p| p.glyphs.get(&code)); + if let (Some(c), Some(h)) = (char::from_u32(code), hex) + && !self.space.contains_key(&c) + { + let width = h.right.saturating_sub(h.left) + 1; + chars.push((c, (width / 2 + 1) as f32)); + } + } + } else { + chars.extend( + self.bitmap + .iter() + .filter(|(c, _)| !self.space.contains_key(c)) + .map(|(c, g)| (*c, g.advance)), + ); + } + chars.sort_by_key(|(c, _)| *c); + let mut out: HashMap> = HashMap::new(); + for (c, advance) in chars { + out.entry(advance.ceil() as u32).or_default().push(c); + } + out + } /// Atlas pixels rasterized since the last call. pub fn take_patches(&self) -> Vec { std::mem::take(&mut self.cache.borrow_mut().pending) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index bad635c5c..02d31b494 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -155,6 +155,7 @@ mod ui_control; mod vault; mod villagers; mod wandering_trader; +mod win; mod wind; mod wither; mod world_loading; @@ -453,6 +454,8 @@ enum Screen { WorldOptions, /// CommandBlockEditScreen (game/command_blocks.rs). CommandBlock, + /// WinScreen: the end poem and the credits (game/win.rs). + Win, } struct Mining { pos: [i32; 3], @@ -1341,6 +1344,8 @@ struct Game<'a> { respawn_travel: Option, /// The next enter_dimension call comes from an End portal. end_portal_travel: bool, + /// The open WinScreen (game/win.rs). + win: Option, end: end::EndState, block_ticks: Ticks, tick_chunks: horizon_client::tick_chunk_membership::TickChunkMembership, @@ -3748,6 +3753,9 @@ impl Game<'_> { return Ok(()); } if let Some((_, target)) = &self.travelling { + if self.win_screen_holds_arrival() { + return Ok(()); + } let (cx, cz) = ( (target.x.floor() as i32) >> 4, (target.z.floor() as i32) >> 4, @@ -4429,7 +4437,8 @@ impl Game<'_> { | Screen::Advancements | Screen::WorldOptions | Screen::CommandBlock - ) || self.book.is_some()) + ) || self.book.is_some() + || self.win_screen_pauses()) } /// `MouseHandler.grabMouse` / `releaseMouse`. Both put the pointer at /// the window's centre, so a screen opened from gameplay (inventory, @@ -4637,6 +4646,10 @@ impl Game<'_> { fn hud_layers(&mut self, size: [u32; 2]) -> HudBatch { let mut batch = HudBatch::new(size); let (w, h) = (batch.width, batch.height); + if self.screen == Screen::Win { + self.draw_win_screen(&mut batch); + return batch; + } if self.screen == Screen::Options { self.draw_options(&mut batch); return batch; @@ -4846,7 +4859,7 @@ impl Game<'_> { self.draw_creative(&mut batch); } Screen::Chat => self.draw_chat_screen(&mut batch), - Screen::Playing | Screen::Options => {} + Screen::Playing | Screen::Options | Screen::Win => {} } self.draw_toasts(&mut batch); self.remote_hud(&mut batch); @@ -9846,7 +9859,7 @@ impl Game<'_> { let blurred = !horizon_client::ui_theme::horizon() && (loading || self.title.as_ref().is_some_and(|t| { - self.screen == Screen::Options + matches!(self.screen, Screen::Options | Screen::Win) || !matches!(t.mode, horizon_client::title::Mode::Main) })); let radius = self.settings.menu_blur as f32; @@ -9932,6 +9945,7 @@ impl Game<'_> { Screen::WorldOptions => self.world_options_escape(), Screen::CommandBlock => self.close_command_block(), Screen::Chat => self.close_chat(), + Screen::Win => self.close_win_screen()?, }, KeyCode::Digit1 | KeyCode::Digit2 @@ -10539,6 +10553,7 @@ impl ApplicationHandler for Game<'_> { let d = scaled(raw_y) as f32; if let Some(title) = &mut self.title && !horizon_client::ui_theme::horizon() + && self.screen != Screen::Win { let size = self .window @@ -10597,6 +10612,7 @@ impl ApplicationHandler for Game<'_> { self.advancements_scroll(scaled(raw_x) as f32, d); } } + WindowEvent::MouseInput { .. } if self.screen == Screen::Win => {} WindowEvent::MouseInput { state, button, .. } if self.screen == Screen::Options => { if self.options_waiting_for_key() && state == ElementState::Pressed { self.options_bind_mouse(button)?; @@ -10858,6 +10874,9 @@ impl ApplicationHandler for Game<'_> { { self.world_options_key(&event) } + WindowEvent::KeyboardInput { event, .. } if self.screen == Screen::Win => { + self.win_key(&event)? + } WindowEvent::KeyboardInput { event, .. } if self.screen == Screen::CommandBlock => { self.command_block_key(&event) } @@ -10994,6 +11013,7 @@ impl ApplicationHandler for Game<'_> { } else if self.title.is_some() { self.tick_backdrop(); } + self.tick_win_screen()?; self.tick_music(); self.tick_sound_engine(); self.clock.record(started.elapsed()); @@ -11420,6 +11440,7 @@ impl<'a> Game<'a> { respawn_config: None, respawn_travel: None, end_portal_travel: false, + win: None, end: Default::default(), block_ticks: Ticks::new(0), tick_chunks: Default::default(), diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index 9a5cd6a58..1fa422f92 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -404,6 +404,7 @@ impl Game<'_> { Screen::Advancements => "advancements", Screen::WorldOptions => "world-options", Screen::CommandBlock => "command-block", + Screen::Win => "win", } } pub(super) fn inventory_counts(&self) -> BTreeMap { diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index 6cbbf5007..6a79419a1 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -42,6 +42,7 @@ const HELP: &[&str] = &[ "chat MESSAGE send chat or a /command to the server", "disconnect leave the server for the server list", "respawn respawn after death on a server", + "credits [poem] [SCROLL] roll the credits (with the end poem), or hold them SCROLL pixels in", "quit save and exit", ]; @@ -555,6 +556,7 @@ impl Game<'_> { "graphics" => Page::Graphics, "graphics-advanced" => Page::GraphicsAdvanced, "extras" => Page::Extras, + "credits" => Page::Credits, other => return Err(format!("unknown options page {other}").into()), }; if self.screen == Screen::Playing && self.title.is_none() { @@ -630,6 +632,25 @@ impl Game<'_> { self.connect_server(arg(1)?, &name)?; ok() } + "credits" => { + let poem = words.get(1) == Some(&"poem"); + let hold = words + .get(1 + usize::from(poem)) + .map(|s| s.parse::()) + .transpose()?; + if self.screen != Screen::Win { + let finish = if self.screen == Screen::Options { + super::win::Finish::Options + } else { + super::win::Finish::Closed + }; + self.open_win_screen(poem, finish); + } + if let Some(scroll) = hold { + self.hold_win_screen(scroll); + } + ok() + } "respawn" => { if self.remote.is_none() || self.screen != Screen::Dead { return Err("respawn needs the death screen on a server".into()); @@ -712,6 +733,9 @@ impl Game<'_> { } fn screen_name(&self) -> &'static str { + if self.screen == Screen::Win { + return "win"; + } if self.title.is_some() { return "title"; } @@ -728,6 +752,7 @@ impl Game<'_> { Screen::Advancements => "advancements", Screen::WorldOptions => "world-options", Screen::CommandBlock => "command-block", + Screen::Win => "win", } } diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs index a7813c767..f5ddf537b 100644 --- a/crates/horizon-client/src/game/end.rs +++ b/crates/horizon-client/src/game/end.rs @@ -377,7 +377,10 @@ impl Game<'_> { f64::from(p.dimensions.width), f64::from(p.dimensions.height), ); - if portal { + if portal && self.dim == Dim::End && !self.level.seen_credits { + // EndPortalBlock.entityInside: the first exit shows the credits. + self.show_end_credits()?; + } else if portal { if self.portals.player.cooldown == 0 { let target = if self.dim == Dim::End { Dim::Overworld diff --git a/crates/horizon-client/src/game/music.rs b/crates/horizon-client/src/game/music.rs index 9198a78a1..6f8b5e7ae 100644 --- a/crates/horizon-client/src/game/music.rs +++ b/crates/horizon-client/src/game/music.rs @@ -12,7 +12,7 @@ impl Game<'_> { pub(super) fn tick_music(&mut self) { let (music, volume) = self.situational_music(); // LevelLoadingScreen: no new track before the player is in the world. - let loading = self.title.is_none() && self.player.is_none(); + let loading = self.title.is_none() && self.player.is_none() && self.win.is_none(); self.music .tick(music.as_ref(), volume, loading, &mut self.audio); } @@ -59,7 +59,11 @@ impl Game<'_> { None => (empty, 1.0), }; let situation = Situation { - screen_music: None, + // WinScreen.getBackgroundMusic. + screen_music: self + .win + .is_some() + .then(horizon_client::music::Music::credits), in_world: eye.is_some(), in_end: self.dim == super::Dim::End, boss_music: self.boss_music(), diff --git a/crates/horizon-client/src/game/options.rs b/crates/horizon-client/src/game/options.rs index 61036d18c..ff9e4f28f 100644 --- a/crates/horizon-client/src/game/options.rs +++ b/crates/horizon-client/src/game/options.rs @@ -235,6 +235,7 @@ impl Game<'_> { let _ = std::fs::create_dir_all(&dir); super::packs::open_folder(&dir); } + Event::Credits => self.open_win_screen(false, super::win::Finish::Options), } } Ok(()) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 09e03e719..fcc7bee08 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -1840,6 +1840,10 @@ impl Game<'_> { ); } } + // WIN_GAME: the poem and credits, then PERFORM_RESPAWN. + 4 if self.screen != Screen::Win => { + self.open_win_screen(true, super::win::Finish::RemoteRespawn); + } 1 => { self.world.weather.raining = true; self.world.weather.rain_level = (0.0, 0.0); diff --git a/crates/horizon-client/src/game/startup_menu.rs b/crates/horizon-client/src/game/startup_menu.rs index ffbbe7193..4253cbe65 100644 --- a/crates/horizon-client/src/game/startup_menu.rs +++ b/crates/horizon-client/src/game/startup_menu.rs @@ -12,6 +12,8 @@ pub(super) struct StartupMenu { title: Option, options: OptionsUi, options_open: bool, + /// The credits from Credits & Attribution, and their last frame. + win: Option<(horizon_client::win_screen::WinScreen, Instant)>, root: PathBuf, cursor: (f32, f32), pointer: (f64, f64), @@ -378,6 +380,21 @@ impl Loading { let _ = std::fs::create_dir_all(&dir); packs::open_folder(&dir); } + Event::Credits => { + if let Some(gui) = &self.gui { + let name = self.options.as_ref().map_or_else( + || horizon_client::offline_name::generate(0), + Options::player_name, + ); + let screen = horizon_client::win_screen::WinScreen::new( + false, + &self.menu.root, + &name, + &gui.atlas.font, + ); + self.menu.win = Some((screen, Instant::now())); + } + } Event::ButtonClick => {} } } @@ -473,6 +490,20 @@ impl Loading { } } _ if self.gui.is_none() || self.menu.pending.is_some() => {} + WindowEvent::KeyboardInput { event, .. } if self.menu.win.is_some() => { + if let PhysicalKey::Code(code) = event.physical_key { + let pressed = event.state == ElementState::Pressed; + if code == KeyCode::Escape && pressed { + self.menu.win = None; + } else if let Some(key) = horizon_client::win_screen::Key::from_code(code) + && let Some((win, _)) = &mut self.menu.win + { + win.key(key, pressed); + } + } + } + WindowEvent::MouseInput { .. } | WindowEvent::MouseWheel { .. } + if self.menu.win.is_some() => {} WindowEvent::CursorMoved { position, .. } => { self.menu.pointer = (position.x, position.y); self.update_menu_cursor(); @@ -610,6 +641,15 @@ impl Loading { self.progress.line(), self.progress.fraction(), ); + } else if let Some((win, frame)) = &mut self.menu.win { + let now = Instant::now(); + // 20 ticks a second: the startup menu runs no tick rate. + let delta_ticks = now.duration_since(*frame).as_secs_f32() * 20.0; + *frame = now; + win.draw(batch, &gui.atlas, delta_ticks, Default::default()); + if win.finished(batch.height) { + self.menu.win = None; + } } else if self.menu.options_open { self.menu .options diff --git a/crates/horizon-client/src/game/win.rs b/crates/horizon-client/src/game/win.rs new file mode 100644 index 000000000..a9cf6379a --- /dev/null +++ b/crates/horizon-client/src/game/win.rs @@ -0,0 +1,150 @@ +//! `WinScreen` in the game: the poem and credits after leaving the End for +//! the first time (`EndPortalBlock.entityInside` -> `ServerPlayer.showEndCredits`, +//! or a server's `WIN_GAME` event), and the credits from Credits & +//! Attribution. +use super::{Game, Screen}; +use horizon_client::{ + Result, + hud::{EndPortalFill, HudBatch}, + win_screen::{Key, WinScreen}, +}; +use std::time::Instant; +use winit::{ + event::{ElementState, KeyEvent}, + keyboard::{KeyCode, PhysicalKey}, +}; + +/// What closing the screen does (`WinScreen.onFinished`). +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(super) enum Finish { + /// `PERFORM_RESPAWN` in single player: the player, out of the End since + /// the credits began, arrives in the Overworld. + Respawn, + /// `PERFORM_RESPAWN` sent to the server. + RemoteRespawn, + /// Back to Credits & Attribution. + Options, + /// Back to the game (`horizon-ctl credits`). + Closed, +} +pub(super) struct Win { + screen: WinScreen, + finish: Finish, + /// The last drawn frame, for the scroll's game-time delta. + frame: Instant, +} +impl Game<'_> { + pub(super) fn open_win_screen(&mut self, poem: bool, finish: Finish) { + let screen = WinScreen::new( + poem, + &self.options.resources, + &self.options.player_name(), + &self.gui.atlas.font, + ); + self.win = Some(Win { + screen, + finish, + frame: Instant::now(), + }); + self.keys.clear(); + self.screen = Screen::Win; + self.capture(false); + } + /// `ServerPlayer.showEndCredits`: the player leaves the End now (no + /// longer in any level until the credits end) and has seen the credits. + pub(super) fn show_end_credits(&mut self) -> Result<()> { + self.level.seen_credits = true; + self.open_win_screen(true, Finish::Respawn); + self.end_portal_travel = true; + let result = self.enter_dimension(super::Dim::Overworld); + self.end_portal_travel = false; + result + } + /// Stop the scroll `scroll` pixels in (`horizon-ctl credits ... SCROLL`). + pub(super) fn hold_win_screen(&mut self, scroll: f32) { + if let Some(win) = self.win.as_mut() { + win.screen.hold(scroll); + } + } + /// `WinScreen.isPauseScreen`: only the credits without the poem pause. + pub(super) fn win_screen_pauses(&self) -> bool { + self.win.as_ref().is_some_and(|w| !w.screen.poem) + } + /// The player waits out of the world while the poem rolls. + pub(super) fn win_screen_holds_arrival(&self) -> bool { + self.win + .as_ref() + .is_some_and(|w| w.finish == Finish::Respawn) + } + pub(super) fn draw_win_screen(&mut self, batch: &mut HudBatch) { + let Some(win) = self.win.as_mut() else { + return; + }; + let now = Instant::now(); + // DeltaTracker.getGameTimeDeltaTicks: the frame's length in ticks. + let delta_ticks = + now.duration_since(win.frame).as_secs_f32() / self.clock.tick_duration().as_secs_f32(); + win.frame = now; + let sprite = |n: &str| { + self.gui + .atlas + .sprites + .get(n) + .map_or([0.0; 4], |r| [r.u0, r.v0, r.u1 - r.u0, r.v1 - r.v0]) + }; + let fill = EndPortalFill { + sprites: [ + sprite("environment/end_sky"), + sprite("entity/end_portal/end_portal"), + ], + game_time: (self.world.game_time % 24000) as f32 / 24000.0, + }; + win.screen.draw(batch, &self.gui.atlas, delta_ticks, fill); + } + /// `WinScreen.keyPressed` / `keyReleased`; Escape closes it (`onClose`). + pub(super) fn win_key(&mut self, event: &KeyEvent) -> Result<()> { + let PhysicalKey::Code(code) = event.physical_key else { + return Ok(()); + }; + let pressed = event.state == ElementState::Pressed; + if code == KeyCode::Escape && pressed { + return self.close_win_screen(); + } + let Some(key) = Key::from_code(code) else { + return Ok(()); + }; + if let Some(win) = self.win.as_mut() { + win.screen.key(key, pressed); + } + Ok(()) + } + /// `WinScreen.tick`: done once everything has rolled past the top. + pub(super) fn tick_win_screen(&mut self) -> Result<()> { + let height = self.gui_size().1; + if self.win.as_ref().is_some_and(|w| w.screen.finished(height)) { + self.close_win_screen()?; + } + Ok(()) + } + /// `WinScreen.respawn` (`onFinished`) and `removed`: the credits music stops. + pub(super) fn close_win_screen(&mut self) -> Result<()> { + let Some(win) = self.win.take() else { + return Ok(()); + }; + let credits = horizon_client::music::Music::credits(); + self.music + .stop_playing_music(&credits, None, &mut self.audio); + match win.finish { + Finish::Options => self.screen = Screen::Options, + Finish::Closed if self.title.is_some() => self.screen = Screen::Playing, + Finish::Respawn | Finish::RemoteRespawn | Finish::Closed => { + if win.finish == Finish::RemoteRespawn { + self.remote_respawn(); + } + self.screen = Screen::Playing; + self.capture(true); + } + } + Ok(()) + } +} diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 0cc99b07b..29faf5a2a 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -363,6 +363,8 @@ pub struct HudBatch { pub patches: Vec<crate::font::Patch>, /// Vertex ranges with another blend or depth/scissor state, in order. pub blends: Vec<(std::ops::Range<u32>, Blend)>, + /// The textures and time of the `Blend::EndPortal` runs. + pub end_portal: EndPortalFill, } /// How a run of HUD vertices blends and tests depth. #[derive(Clone, Copy, PartialEq, Eq, Debug)] @@ -375,6 +377,19 @@ pub enum Blend { Additive, /// Alpha blending with an isolated depth buffer and a pixel scissor. Depth([u32; 4]), + /// `RenderPipelines.VIGNETTE`: the destination darkened by the texture + /// (`ZERO, ONE_MINUS_SRC_COLOR`). + Vignette, + /// `RenderPipelines.END_PORTAL` as a GUI fill: the End portal's layers + /// projected from the screen (`HudBatch::end_portal` sets the textures). + EndPortal, +} +/// What a `Blend::EndPortal` fill samples: the atlas rects (u0, v0, width, +/// height) of `end_sky.png` and `end_portal.png`, and the `GameTime` uniform. +#[derive(Clone, Copy, Debug, Default, PartialEq)] +pub struct EndPortalFill { + pub sprites: [[f32; 4]; 2], + pub game_time: f32, } pub fn rgba(r: u8, g: u8, b: u8, a: u8) -> u32 { u32::from(a) << 24 | u32::from(b) << 16 | u32::from(g) << 8 | u32::from(r) @@ -398,6 +413,7 @@ impl HudBatch { height: (window[1] as f32 / scale as f32).ceil(), patches: Vec::new(), blends: Vec::new(), + end_portal: EndPortalFill::default(), } } /// Draw the vertices added since `start` with the inverting blend. @@ -695,7 +711,12 @@ impl HudBatch { let mut glyphs = Vec::new(); let mut cursor = x; for (i, (ch, style)) in text.chars().enumerate() { - let g = font.glyph(ch); + let mut g = font.glyph(ch); + // Font.StringRenderOutput.accept: obfuscated characters draw a + // random glyph of the same width each frame. + if style.obfuscated == Some(true) && ch != ' ' { + g = font.random_glyph(g.advance); + } let c = style.color.map_or(color, |rgb| { rgba((rgb >> 16) as u8, (rgb >> 8) as u8, rgb as u8, alpha) }); @@ -789,6 +810,20 @@ impl HudBatch { #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)] struct HudUniform { size: [f32; 4], + /// `EndPortalFill`: the two sprites, then the game time in x. + end_portal: [[f32; 4]; 3], +} +impl HudUniform { + fn new(size: [f32; 4], fill: EndPortalFill) -> Self { + Self { + size, + end_portal: [ + fill.sprites[0], + fill.sprites[1], + [fill.game_time, 0.0, 0.0, 0.0], + ], + } + } } pub struct HudRenderer { pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation, usize)>, @@ -799,6 +834,8 @@ pub struct HudRenderer { invert_pipeline: wgpu::RenderPipeline, additive_pipeline: wgpu::RenderPipeline, depth_pipeline: wgpu::RenderPipeline, + vignette_pipeline: wgpu::RenderPipeline, + end_portal_pipeline: wgpu::RenderPipeline, group: wgpu::BindGroup, uniform: wgpu::Buffer, buffer: wgpu::Buffer, @@ -821,7 +858,7 @@ impl HudRenderer { }); let uniform = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { label: Some("HUD size"), - contents: bytemuck::bytes_of(&HudUniform { size: [1.0; 4] }), + contents: bytemuck::bytes_of(&HudUniform::new([1.0; 4], EndPortalFill::default())), usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, }); let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { @@ -829,7 +866,7 @@ impl HudRenderer { entries: &[ wgpu::BindGroupLayoutEntry { binding: 0, - visibility: wgpu::ShaderStages::VERTEX, + visibility: wgpu::ShaderStages::VERTEX_FRAGMENT, ty: wgpu::BindingType::Buffer { ty: wgpu::BufferBindingType::Uniform, has_dynamic_offset: false, @@ -957,6 +994,31 @@ impl HudRenderer { "fs_main", false, ); + // RenderPipelines.VIGNETTE: ZERO, ONE_MINUS_SRC_COLOR, ZERO, ONE. + let vignette_pipeline = create( + "HUD vignette", + wgpu::BlendState { + color: wgpu::BlendComponent { + src_factor: wgpu::BlendFactor::Zero, + dst_factor: wgpu::BlendFactor::OneMinusSrc, + operation: wgpu::BlendOperation::Add, + }, + alpha: wgpu::BlendComponent { + src_factor: wgpu::BlendFactor::Zero, + dst_factor: wgpu::BlendFactor::One, + operation: wgpu::BlendOperation::Add, + }, + }, + "fs_main", + false, + ); + // RenderPipelines.END_PORTAL: opaque. + let end_portal_pipeline = create( + "HUD end portal", + wgpu::BlendState::REPLACE, + "fs_end_portal", + false, + ); let capacity = 1 << 16; let buffer = device.create_buffer(&wgpu::BufferDescriptor { label: Some("HUD vertices"), @@ -971,6 +1033,8 @@ impl HudRenderer { invert_pipeline, additive_pipeline, depth_pipeline, + vignette_pipeline, + end_portal_pipeline, group, uniform, buffer, @@ -1064,9 +1128,10 @@ impl HudRenderer { encoder, &self.uniform, 0, - bytemuck::bytes_of(&HudUniform { - size: [size[0] as f32, size[1] as f32, batch.scale, 0.0], - }), + bytemuck::bytes_of(&HudUniform::new( + [size[0] as f32, size[1] as f32, batch.scale, 0.0], + batch.end_portal, + )), ); } /// Draw the batch `prepare` staged. @@ -1135,6 +1200,8 @@ impl HudRenderer { Blend::Invert => &self.invert_pipeline, Blend::Additive => &self.additive_pipeline, Blend::Depth(_) => &self.depth_pipeline, + Blend::Vignette => &self.vignette_pipeline, + Blend::EndPortal => &self.end_portal_pipeline, }); pass.draw(range.clone(), 0..1); } @@ -1147,10 +1214,10 @@ impl HudRenderer { mod tests { use super::*; - #[test] - fn the_fonts_only_atlas_measures_text_like_the_full_one() { - // A synthetic default font: two 8x8 glyphs, 3 and 5 pixels wide. - let root = std::env::temp_dir().join(format!("horizon-fonts-atlas-{}", std::process::id())); + /// A synthetic default font: two 8x8 glyphs, 3 and 5 pixels wide. + fn two_glyph_font(name: &str) -> std::path::PathBuf { + let root = + std::env::temp_dir().join(format!("horizon-fonts-{name}-{}", std::process::id())); let font = root.join("assets/minecraft/font"); let textures = root.join("assets/minecraft/textures/font"); fs::create_dir_all(&font).unwrap(); @@ -1175,6 +1242,11 @@ mod tests { .unwrap() .write_image_data(&pixels) .unwrap(); + root + } + #[test] + fn the_fonts_only_atlas_measures_text_like_the_full_one() { + let root = two_glyph_font("atlas"); let full = HudAtlas::build(&root).unwrap(); let fonts = HudAtlas::fonts(&root).unwrap(); let _ = fs::remove_dir_all(&root); @@ -1183,6 +1255,21 @@ mod tests { assert!(width > 0.0); assert_eq!(fonts.font.width("abba"), width); } + #[test] + fn obfuscated_glyphs_keep_the_width() { + let root = two_glyph_font("obfuscated"); + let fonts = HudAtlas::fonts(&root).unwrap(); + let _ = fs::remove_dir_all(&root); + let (a, b) = (fonts.font.glyph('a').advance, fonts.font.glyph('b').advance); + assert_ne!(a, b); + for _ in 0..20 { + assert_eq!(fonts.font.random_glyph(a).advance, a); + assert_eq!(fonts.font.random_glyph(b).advance, b); + } + // No glyph that wide: FontSet's missing glyph. + let missing = fonts.font.random_glyph(30.0); + assert!(missing.rect.is_none() && missing.right == 5.0); + } #[test] fn effect_icons_are_painted_from_the_mob_effect_directory() { @@ -1340,6 +1427,7 @@ mod tests { height: height as f32, patches: Vec::new(), blends: Vec::new(), + end_portal: EndPortalFill::default(), }; for (image_width, image_height) in [(195, 136), (176, 166), (176, 222)] { assert_eq!( diff --git a/crates/horizon-client/src/hud.wgsl b/crates/horizon-client/src/hud.wgsl index 17d50d51a..ebb6dc2cb 100644 --- a/crates/horizon-client/src/hud.wgsl +++ b/crates/horizon-client/src/hud.wgsl @@ -1,4 +1,9 @@ -struct Hud { size: vec4<f32> } +struct Hud { + size: vec4<f32>, + // Blend::EndPortal: atlas rects (u0, v0, width, height) of end_sky.png and + // end_portal.png, then vanilla's GameTime in x. + end_portal: array<vec4<f32>, 3>, +} @group(0) @binding(0) var<uniform> hud: Hud; @group(0) @binding(1) var atlas: texture_2d<f32>; @group(0) @binding(2) var atlas_sampler: sampler; @@ -6,6 +11,8 @@ struct Out { @builtin(position) clip: vec4<f32>, @location(0) uv: vec2<f32>, @location(1) color: vec4<f32>, + // projection_from_position(gl_Position): the End portal's texProj0. + @location(2) proj: vec4<f32>, } @vertex fn vs_main(@location(0) pos: vec2<f32>, @location(1) uv: vec2<f32>, @location(2) color: vec4<f32>, @location(3) depth: f32) -> Out { let pixels = pos * hud.size.z; @@ -13,6 +20,7 @@ struct Out { out.clip = vec4(pixels.x / hud.size.x * 2.0 - 1.0, 1.0 - pixels.y / hud.size.y * 2.0, depth, 1.0); out.uv = uv; out.color = color; + out.proj = vec4(out.clip.xy * 0.5 + 0.5, out.clip.zw); return out; } @fragment fn fs_main(in: Out) -> @location(0) vec4<f32> { @@ -31,3 +39,44 @@ struct Out { if c.a == 0.0 { discard; } return c; } +// rendertype_end_portal.fsh (entity.wgsl has the same for portal blocks). +const PORTAL_COLORS = array<vec3<f32>, 16>( + vec3(0.022087, 0.098399, 0.110818), + vec3(0.011892, 0.095924, 0.089485), + vec3(0.027636, 0.101689, 0.100326), + vec3(0.046564, 0.109883, 0.114838), + vec3(0.064901, 0.117696, 0.097189), + vec3(0.063761, 0.086895, 0.123646), + vec3(0.084817, 0.111994, 0.166380), + vec3(0.097489, 0.154120, 0.091064), + vec3(0.106152, 0.131144, 0.195191), + vec3(0.097721, 0.110188, 0.187229), + vec3(0.133516, 0.138278, 0.148582), + vec3(0.070006, 0.243332, 0.235792), + vec3(0.196766, 0.142899, 0.214696), + vec3(0.047281, 0.315338, 0.321970), + vec3(0.204675, 0.390010, 0.302066), + vec3(0.080955, 0.314821, 0.661491), +); +fn portal_sample(rect: vec4<f32>, p: vec4<f32>) -> vec3<f32> { + let st = fract(p.xy / p.w); + return textureSampleLevel(atlas, atlas_sampler, rect.xy + st * rect.zw, 0.0).rgb; +} +fn portal_layer(p: vec4<f32>, layer: f32) -> vec4<f32> { + let a = radians((layer * layer * 4321.0 + layer * 9.0) * 2.0); + let c = cos(a); + let s = sin(a); + let k = (4.5 - layer / 4.0) * 2.0; + var v = vec4(k * (c * p.x - s * p.y), k * (s * p.x + c * p.y), p.z, p.w); + v = vec4(v.x + 17.0 / layer * v.w, v.y + (2.0 + layer / 1.5) * (hud.end_portal[2].x * 1.5) * v.w, v.z, v.w); + return vec4(0.5 * v.x + 0.25 * v.w, 0.5 * v.y + 0.25 * v.w, v.z, v.w); +} +// RenderPipelines.END_PORTAL (WinScreen's poem background): end_sky and 15 +// layers of end_portal.png. +@fragment fn fs_end_portal(in: Out) -> @location(0) vec4<f32> { + var c = portal_sample(hud.end_portal[0], in.proj) * PORTAL_COLORS[0]; + for (var i = 0; i < 15; i++) { + c += portal_sample(hud.end_portal[1], portal_layer(in.proj, f32(i + 1))) * PORTAL_COLORS[i]; + } + return vec4(c, 1.0); +} diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 4cf0c5c48..25be4a0c4 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -186,6 +186,7 @@ pub mod vanillagen; pub mod vault; pub mod weather; pub mod widgets; +pub mod win_screen; pub mod window; pub mod world; pub mod world_spawn; diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 7d86263df..2290e9632 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -871,6 +871,8 @@ pub enum Page { Controller, PadBinds, Extras, + /// CreditsAndAttributionScreen. + Credits, } #[derive(Clone, Debug, PartialEq)] enum Act { @@ -893,6 +895,8 @@ enum Act { /// Pick shader pack `i` of `OptionsUi::shader_packs` (again: off). ToggleShaderPack(usize), OpenShaderPackFolder, + /// Credits & Attribution's Credits button (WinScreen without the poem). + Credits, } enum WKind { Button { @@ -942,6 +946,8 @@ pub enum Event { OpenModFolder, /// Create `shaderpacks/` if needed and open it. OpenShaderPackFolder, + /// Roll the credits (`CreditsAndAttributionScreen.openCreditsScreen`). + Credits, } /// `SliderableValueSet.applyValueImmediately`: these apply 600 ms after /// the last change (`OptionInstanceSliderButton.delayedApplyAt`). @@ -1200,6 +1206,7 @@ impl OptionsUi { Page::Controller => "Controller Settings", Page::PadBinds => "Controller Binds", Page::Extras => "Horizon Extras", + Page::Credits => "credits_and_attribution.screen.title", } } fn scrollbar_x(&self, width: f32) -> f32 { @@ -1580,8 +1587,10 @@ impl OptionsUi { ("options.accessibility", Some(Page::Accessibility)), ("Mods...", Some(Page::Mods)), ("Horizon Extras...", Some(Page::Extras)), + ("options.credits_and_attribution", Some(Page::Credits)), ]; - let gy = (61.0 + 30.0f32).min(h - 33.0 - 120.0); + let rows = entries.len().div_ceil(2) as f32; + let gy = (61.0 + 30.0f32).min(h - 33.0 - rows * 24.0); for (i, (key, page)) in entries.iter().enumerate() { let x = cx - 158.0 + 4.0 + (i % 2) as f32 * 158.0; let y = gy + (i / 2) as f32 * 24.0; @@ -1592,6 +1601,46 @@ impl OptionsUi { top = 0.0; bottom = 0.0; } + Page::Credits => { + // CreditsAndAttributionScreen: the title header, three 210-wide + // buttons 8 apart (HeaderAndFooterLayout: 30 below the header + // unless the footer is closer), Done. + out.push(Widget { + x: 0.0, + y: 12.0, + w, + h: 9.0, + kind: WKind::Text { + text: tr(Self::title(page)), + color: u32::MAX, + centered: true, + }, + list: false, + }); + let y = (33.0 + 30.0f32).min(h - 33.0 - 76.0); + let x = cx - 105.0; + out.push(button( + x, + y, + 210.0, + tr("credits_and_attribution.button.credits"), + Act::Credits, + )); + // ConfirmLinkScreen to minecraft.net: Horizon opens no links. + for (i, key) in [ + "credits_and_attribution.button.attribution", + "credits_and_attribution.button.licenses", + ] + .into_iter() + .enumerate() + { + let y = y + 28.0 * (i + 1) as f32; + out.push(inactive(button(x, y, 210.0, tr(key), Act::None))); + } + out.push(done(h - 27.0)); + top = 0.0; + bottom = 0.0; + } Page::KeyBinds => { top = 38.0; out.push(Widget { @@ -2487,6 +2536,7 @@ impl OptionsUi { events.push(Event::Changed); } Act::OpenShaderPackFolder => events.push(Event::OpenShaderPackFolder), + Act::Credits => events.push(Event::Credits), Act::None => {} } } diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 2e1eb8455..0428670f4 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -2209,6 +2209,8 @@ pub struct Level { pub inventory_components: HashMap<u8, Box<crate::item_data::StackData>>, /// Player.XpSeed: the enchanting table seed. pub xp_seed: i32, + /// ServerPlayer.seenCredits: the end poem has been shown. + pub seen_credits: bool, /// Player.active_effects: (id, duration, amplifier, ambient, show_icon). pub active_effects: Vec<(String, i32, i32, bool, bool)>, /// Player.EnderItems: the ender chest inventory (27 slots). @@ -2400,6 +2402,7 @@ impl Level { self.selected_slot = n("SelectedItemSlot").unwrap_or(0) as i32; self.fall_distance = f("fall_distance").unwrap_or(0.0); self.on_ground = n("OnGround").unwrap_or(0) != 0; + self.seen_credits = n("seenCredits").unwrap_or(0) != 0; if let Some(mode) = n("playerGameType") { self.creative = mode == 1; self.game_mode = mode as i32; @@ -2621,6 +2624,7 @@ impl Level { if let Some(pos) = self.position { entries.push(("Pos", doubles(&pos))); } + entries.push(("seenCredits", Tag::Byte(i8::from(self.seen_credits)))); // A respawn point other than the world spawn: an anchor elsewhere, or a bed. if let Some((dimension, block, yaw, forced)) = &self.respawn_elsewhere { let mut respawn = vec![ diff --git a/crates/horizon-client/src/win_screen.rs b/crates/horizon-client/src/win_screen.rs new file mode 100644 index 000000000..8d2a1c145 --- /dev/null +++ b/crates/horizon-client/src/win_screen.rs @@ -0,0 +1,452 @@ +//! `WinScreen`: the end poem, the credits and the post-credits text rolling up +//! under the logo, after the player leaves the End for the first time (with +//! the poem) or from Credits & Attribution (the credits alone). The texts come +//! from the resource root, so resource packs can replace them. +use crate::{ + font::Font, + hud::{Blend, EndPortalFill, HudAtlas, HudBatch}, + text::{self, Style, Text}, +}; +use horizon_core::random::{LegacyRandom, RandomSource}; +use std::{collections::HashSet, path::Path}; + +/// `WinScreen.OBFUSCATE_TOKEN`: `§f§k§a§b` marks where the poem hides a name. +const OBFUSCATE_TOKEN: &str = "\u{a7}f\u{a7}k\u{a7}a\u{a7}b"; +/// `WinScreen.NAME_PREFIX`. +const NAME_PREFIX: &str = " "; +/// `WinScreen.SECTION_HEADING`. +const SECTION_HEADING: &str = "============"; +/// A key the screen reacts to (`keyPressed` / `keyReleased`). +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum Key { + /// `KeyEvent.isUp`: the up arrow scrolls back. + Up, + /// Space speeds the scroll up. + Space, + /// Each held Control key speeds it up more. + LeftControl, + RightControl, +} +impl Key { + pub fn from_code(code: winit::keyboard::KeyCode) -> Option<Self> { + use winit::keyboard::KeyCode; + match code { + KeyCode::ArrowUp => Some(Self::Up), + KeyCode::Space => Some(Self::Space), + KeyCode::ControlLeft => Some(Self::LeftControl), + KeyCode::ControlRight => Some(Self::RightControl), + _ => None, + } + } +} +pub struct WinScreen { + pub poem: bool, + lines: Vec<Text>, + centered: HashSet<usize>, + total_scroll_length: i32, + scroll: f32, + speedup_active: bool, + speedup_modifiers: HashSet<Key>, + unmodified_scroll_speed: f32, + scroll_speed: f32, + direction: i32, +} +impl WinScreen { + /// `WinScreen.<init>` and `init`: the poem (`texts/end.txt`) when `poem`, + /// the credits (`texts/credits.json`), then `texts/postcredits.txt`. + pub fn new(poem: bool, root: &Path, player: &str, font: &Font) -> Self { + let speed = if poem { 0.5 } else { 0.75 }; + let mut screen = Self { + poem, + lines: Vec::new(), + centered: HashSet::new(), + total_scroll_length: 0, + scroll: 0.0, + speedup_active: false, + speedup_modifiers: HashSet::new(), + unmodified_scroll_speed: speed, + scroll_speed: speed, + direction: 1, + }; + let texts = root.join("assets/minecraft/texts"); + let read = |name: &str| match std::fs::read_to_string(texts.join(name)) { + Ok(s) => Some(s), + Err(e) => { + log::error!("Couldn't load credits from file minecraft:texts/{name}: {e}"); + None + } + }; + if poem && let Some(s) = read("end.txt") { + screen.add_poem_file(&s, player, font); + } + if let Some(s) = read("credits.json") { + match serde_json::from_str(&s) { + Ok(json) => screen.add_credits_file(&json), + Err(e) => { + log::error!("Couldn't load credits from file minecraft:texts/credits.json: {e}") + } + } + } + if poem && let Some(s) = read("postcredits.txt") { + screen.add_poem_file(&s, player, font); + } + screen.total_scroll_length = screen.lines.len() as i32 * 12; + screen + } + /// `addPoemFile`: each line with the player's name in, its obfuscated + /// spans turned into 3 to 6 scrambled characters, wrapped at 256 pixels + /// and followed by an empty line; 8 more empty lines at the end. + fn add_poem_file(&mut self, file: &str, player: &str, font: &Font) { + let mut random = LegacyRandom::new(8124371); + // BufferedReader.readLine: \n, \r or \r\n end a line; no empty last line. + let mut lines: Vec<&str> = file + .split('\n') + .map(|l| l.strip_suffix('\r').unwrap_or(l)) + .collect(); + if file.ends_with('\n') { + lines.pop(); + } + for line in lines.iter().flat_map(|l| l.split('\r')) { + let mut line = line.replace("PLAYERNAME", player); + while let Some(pos) = line.find(OBFUSCATE_TOKEN) { + let n = random.next_int_bound(4).unwrap_or(0) as usize + 3; + line = format!( + "{}\u{a7}f\u{a7}k{}{}", + &line[..pos], + &"XXXXXXXX"[..n], + &line[pos + OBFUSCATE_TOKEN.len()..] + ); + } + let text = Text::legacy(&line); + self.lines + .extend(font.split_lines(&text, 256.0).into_iter().map(|(t, _)| t)); + self.add_empty_line(); + } + for _ in 0..8 { + self.add_empty_line(); + } + } + /// `addCreditsFile`: each section's heading, then each discipline's name + /// and its titles with the names under them. + fn add_credits_file(&mut self, json: &serde_json::Value) { + let colored = |s: &str, color: u32| Text::styled(s, Style::color(color)); + let heading = || colored(SECTION_HEADING, text::WHITE); + for section in json.as_array().into_iter().flatten() { + let name = section["section"].as_str().unwrap_or_default(); + self.add_credits_line(heading(), true); + self.add_credits_line(colored(name, text::YELLOW), true); + self.add_credits_line(heading(), true); + self.add_empty_line(); + self.add_empty_line(); + for discipline in section["disciplines"].as_array().into_iter().flatten() { + let name = discipline["discipline"].as_str().unwrap_or_default(); + if !name.is_empty() { + self.add_credits_line(colored(name, text::YELLOW), true); + self.add_empty_line(); + self.add_empty_line(); + } + for title in discipline["titles"].as_array().into_iter().flatten() { + let name = title["title"].as_str().unwrap_or_default(); + self.add_credits_line(colored(name, text::GRAY), false); + for name in title["names"].as_array().into_iter().flatten() { + let line = format!("{NAME_PREFIX}{}", name.as_str().unwrap_or_default()); + self.add_credits_line(colored(&line, text::WHITE), false); + } + self.add_empty_line(); + self.add_empty_line(); + } + } + } + } + fn add_empty_line(&mut self) { + self.lines.push(Text::empty()); + } + fn add_credits_line(&mut self, line: Text, centered: bool) { + if centered { + self.centered.insert(self.lines.len()); + } + self.lines.push(line); + } + /// The lines in order and whether each is centred. + pub fn lines(&self) -> impl Iterator<Item = (&Text, bool)> { + self.lines + .iter() + .enumerate() + .map(|(i, l)| (l, self.centered.contains(&i))) + } + fn calculate_scroll_speed(&self) -> f32 { + let speed = if self.speedup_active { + self.unmodified_scroll_speed * (5.0 + self.speedup_modifiers.len() as f32 * 15.0) + } else { + self.unmodified_scroll_speed + }; + speed * self.direction as f32 + } + /// `keyPressed` / `keyReleased` (Escape closes the screen: `onClose`). + pub fn key(&mut self, key: Key, pressed: bool) { + match (key, pressed) { + (Key::Up, _) => self.direction = if pressed { -1 } else { 1 }, + (Key::Space, _) => self.speedup_active = pressed, + (_, true) => { + self.speedup_modifiers.insert(key); + } + (_, false) => { + self.speedup_modifiers.remove(&key); + } + } + self.scroll_speed = self.calculate_scroll_speed(); + } + /// `tick`: once the text has rolled past the top, the screen is done + /// (`respawn`, or back to the screen that opened it). + pub fn finished(&self, height: f32) -> bool { + let height = height as i32; + self.scroll > (self.total_scroll_length + height + height + 24) as f32 + } + pub fn scroll(&self) -> f32 { + self.scroll + } + /// Stay `scroll` pixels in (until a key changes the speed), for + /// screenshots. + pub fn hold(&mut self, scroll: f32) { + self.scroll = scroll; + self.scroll_speed = 0.0; + } + /// `extractRenderState` after a frame of `delta_ticks` game ticks: + /// `extractBackground`, the vignette, then the logo and the lines + /// scrolled up. The poem's End portal background samples `end_portal`; + /// the credits draw the scrolling menu background (over the blurred + /// panorama on the title screen). + pub fn draw( + &mut self, + batch: &mut HudBatch, + atlas: &HudAtlas, + delta_ticks: f32, + end_portal: EndPortalFill, + ) { + let (w, h) = (batch.width, batch.height); + if self.poem { + let start = batch.vertices.len(); + batch.fill(atlas, 0.0, 0.0, w, h, u32::MAX); + batch.blend_since(start, Blend::EndPortal); + batch.end_portal = end_portal; + } else { + self.menu_background(batch, atlas, w, h); + } + // extractVignette: credits_vignette.png stretched over the screen. + if let Some(r) = atlas.sprites.get("misc/credits_vignette").copied() { + let start = batch.vertices.len(); + batch.rect_uv(0.0, 0.0, w, h, r, u32::MAX); + batch.blend_since(start, Blend::Vignette); + } + self.scroll = (self.scroll + delta_ticks * self.scroll_speed).max(0.0); + let logo_x = (w / 2.0).floor() - 128.0; + let logo_y = h + 50.0; + // Everything below is drawn translated by `y_offs`. + let y_offs = -self.scroll; + // LogoRenderer(false) at full alpha. + let edition_x = (w / 2.0).floor() - 64.0; + batch.sprite_region( + atlas, + "gui/title/minecraft", + [logo_x, logo_y + y_offs, 256.0, 44.0], + 256.0, + 64.0, + ); + batch.sprite_region( + atlas, + crate::title_edition::SPRITE, + [edition_x, logo_y + 44.0 - 7.0 + y_offs, 128.0, 14.0], + 128.0, + 16.0, + ); + let mut y_pos = logo_y + 100.0; + let last = self.lines.len().saturating_sub(1); + for (i, line) in self.lines.iter().enumerate() { + let mut shift = y_offs; + if i == last { + // The last line stops in the middle of the screen. + let diff = y_pos + y_offs - ((h as i32 / 2) as f32 - 6.0); + if diff < 0.0 { + shift -= diff; + } + } + if y_pos + y_offs + 12.0 + 8.0 > 0.0 && y_pos + y_offs < h { + let x = if self.centered.contains(&i) { + // GuiGraphicsExtractor.centeredText: x - width / 2. + logo_x + 128.0 - (atlas.font.width_text(line) as i32 / 2) as f32 + } else { + logo_x + }; + batch.text_styled(atlas, line, x, y_pos + shift, u32::MAX, true); + } + y_pos += 12.0; + } + } + /// `extractMenuBackground`: `menu_background.png` tiled at 32 pixels, + /// scrolled by half the text's scroll. + fn menu_background(&self, batch: &mut HudBatch, atlas: &HudAtlas, w: f32, h: f32) { + let v = (self.scroll * 0.5).rem_euclid(32.0); + let start = batch.vertices.len(); + crate::ui::tiled( + batch, + atlas, + "gui/menu_background", + 0.0, + -v, + w, + h + 32.0, + 32.0, + u32::MAX, + ); + batch.clip_since(start, 0.0, 0.0, w, h); + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// A resource root with only the credits texts: every glyph is the + /// missing one, 6 pixels wide. + fn screen(poem: bool, end: &str, credits: &str, post: &str) -> WinScreen { + let root = std::env::temp_dir().join(format!( + "horizon-win-screen-{}-{poem}-{}", + std::process::id(), + end.len() + )); + let texts = root.join("assets/minecraft/texts"); + std::fs::create_dir_all(&texts).unwrap(); + std::fs::write(texts.join("end.txt"), end).unwrap(); + std::fs::write(texts.join("credits.json"), credits).unwrap(); + std::fs::write(texts.join("postcredits.txt"), post).unwrap(); + let atlas = HudAtlas::fonts(&root).unwrap(); + let screen = WinScreen::new(poem, &root, "Steve", &atlas.font); + let _ = std::fs::remove_dir_all(&root); + screen + } + const CREDITS: &str = r#"[{"section":"Studio","disciplines":[ + {"discipline":"","titles":[{"title":"Head","names":["Ada","Bo"]}]}, + {"discipline":"Art","titles":[{"title":"Artist","names":[]}]}]}]"#; + + #[test] + fn the_poem_names_the_player_and_scrambles_its_hidden_names() { + let s = screen( + true, + "\u{a7}3Hello PLAYERNAME.\r\n\n\u{a7}2\u{a7}f\u{a7}k\u{a7}a\u{a7}bkey\n", + "[]", + "End.", + ); + let lines: Vec<(String, bool)> = s.lines().map(|(t, c)| (t.plain(), c)).collect(); + // Each line then an empty one; the empty line adds no text line; 8 + // empty lines after each file. + let mut want = vec!["Hello Steve.", ""]; + want.push(""); + // LegacyRandom(8124371).nextInt(4) + 3 scrambled characters. + let n = LegacyRandom::new(8124371).next_int_bound(4).unwrap() as usize + 3; + let hidden = format!("{}key", &"XXXXXXXX"[..n]); + want.extend([hidden.as_str(), ""]); + want.extend([""; 8]); + want.extend(["End.", ""]); + want.extend([""; 8]); + assert_eq!( + lines, + want.iter() + .map(|l| (l.to_string(), false)) + .collect::<Vec<_>>() + ); + let hidden_line = s.lines().nth(3).unwrap().0; + let styles: Vec<_> = hidden_line.chars().map(|(_, s)| s.obfuscated).collect(); + assert!(styles[..n].iter().all(|o| *o == Some(true))); + assert_eq!(s.total_scroll_length, lines.len() as i32 * 12); + } + + #[test] + fn long_poem_lines_wrap_at_256_pixels() { + // 6-pixel glyphs: 42 fit a line, and the space at each break goes. + let line = vec!["a"; 50].join(" "); + let s = screen(true, &line, "[]", ""); + let lines: Vec<String> = s.lines().take(4).map(|(t, _)| t.plain()).collect(); + assert_eq!( + lines.iter().map(|l| l.chars().count()).collect::<Vec<_>>(), + [41, 41, 15, 0] + ); + assert!(lines.iter().all(|l| !l.starts_with(' '))); + } + #[test] + fn credits_centre_the_headings_and_list_the_names() { + let s = screen(false, "ignored", CREDITS, "ignored"); + let lines: Vec<(String, bool)> = s.lines().map(|(t, c)| (t.plain(), c)).collect(); + let l = |s: &str, c| (s.to_string(), c); + let names = |n: &str| l(&format!("{NAME_PREFIX}{n}"), false); + assert_eq!( + lines, + vec![ + l(SECTION_HEADING, true), + l("Studio", true), + l(SECTION_HEADING, true), + l("", false), + l("", false), + l("Head", false), + names("Ada"), + names("Bo"), + l("", false), + l("", false), + l("Art", true), + l("", false), + l("", false), + l("Artist", false), + l("", false), + l("", false), + ] + ); + let color = |i: usize| s.lines().nth(i).unwrap().0.chars().next().unwrap().1.color; + assert_eq!( + [color(0), color(1), color(5), color(6), color(10)], + [ + Some(text::WHITE), + Some(text::YELLOW), + Some(text::GRAY), + Some(text::WHITE), + Some(text::YELLOW) + ] + ); + } + + #[test] + fn keys_set_the_scroll_speed_and_direction() { + let mut s = screen(false, "", CREDITS, ""); + assert_eq!(s.scroll_speed, 0.75); + s.key(Key::Space, true); + assert_eq!(s.scroll_speed, 0.75 * 5.0); + s.key(Key::LeftControl, true); + s.key(Key::RightControl, true); + assert_eq!(s.scroll_speed, 0.75 * 35.0); + s.key(Key::Up, true); + assert_eq!(s.scroll_speed, -0.75 * 35.0); + s.key(Key::Space, false); + assert_eq!(s.scroll_speed, -0.75); + s.key(Key::Up, false); + s.key(Key::LeftControl, false); + assert_eq!(s.scroll_speed, 0.75); + // The poem rolls at 0.5 pixels a tick. + assert_eq!(screen(true, "", CREDITS, "").scroll_speed, 0.5); + } + + #[test] + fn the_screen_ends_once_everything_rolled_past() { + let mut s = screen(false, "", CREDITS, ""); + let atlas = HudAtlas::fonts(Path::new("/nonexistent")).unwrap(); + let mut batch = HudBatch::new([640, 480]); + let h = batch.height; + let end = (s.total_scroll_length as f32 + 2.0 * h + 24.0) / 0.75; + s.draw(&mut batch, &atlas, end - 1.0, EndPortalFill::default()); + assert!(!s.finished(h)); + // Scrolling back never goes above the start. + s.key(Key::Up, true); + s.draw(&mut batch, &atlas, end * 2.0, EndPortalFill::default()); + assert_eq!(s.scroll(), 0.0); + s.key(Key::Up, false); + s.draw(&mut batch, &atlas, end + 1.0, EndPortalFill::default()); + assert!(s.finished(h)); + } +} From 7e410d93b3f38dd92b349c1608fb5eb5ad85479a Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 14:27:47 +0200 Subject: [PATCH 09/62] Fonts: TrueType providers and the font picked by text components Every font definition of the resources (and packs) is now loaded, not just font/default.json, and a text component's "font" field picks one: "minecraft:alt" draws the enchanting table's Galactic alphabet, "minecraft:illageralt" the illager runes, a pack's own font its glyphs, and a font that doesn't exist draws every character as the missing glyph (FontManager.getFontSetRaw). - font.rs: one FontSet per font id with its providers in order (space, bitmap, unihex, ttf) and their filters ("uniform", "jp"). Bitmap sheets outside the atlas (another namespace or folder) are copied into the glyph region when first drawn. - TrueTypeGlyphProvider: "ttf" providers (file under font/, size, oversample, shift, skip; CFF fonts refused) rasterized with ab_glyph into the glyph region as rrrr coverage (text_intensity), metrics as GlyphBitmap (bearings over the oversampling, whole-pixel advances). - text::Style gains the font id; it is parsed from JSON and SNBT components, pack descriptions and scoreboard number formats, inherited by children and written back. - Obfuscated text picks its random glyph in the style's font. Fixes #336 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/component.rs | 23 + crates/horizon-client/src/font.rs | 1053 +++++++++++++++++------ crates/horizon-client/src/hud.rs | 11 +- crates/horizon-client/src/packs.rs | 1 + crates/horizon-client/src/scoreboard.rs | 1 + crates/horizon-client/src/text.rs | 16 +- 6 files changed, 835 insertions(+), 270 deletions(-) diff --git a/crates/horizon-client/src/component.rs b/crates/horizon-client/src/component.rs index 0e04eab5e..68460054b 100644 --- a/crates/horizon-client/src/component.rs +++ b/crates/horizon-client/src/component.rs @@ -167,6 +167,7 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style { style.underlined = flag("underlined"); style.strikethrough = flag("strikethrough"); style.obfuscated = flag("obfuscated"); + style.font = o.get("font").and_then(crate::text::font_id); style } /// `ComponentSerialization.CODEC` decoding into text. `selector` components @@ -266,4 +267,26 @@ mod tests { let (v, _) = parse_snbt("[\"a\",{\"text\":\"b\"}]").unwrap(); assert_eq!(to_text(&v, &mut |_| Text::empty()).plain(), "ab"); } + + #[test] + fn the_font_is_inherited_and_kept() { + let (v, _) = + parse_snbt(r#"{text:"a",font:"alt",extra:["b",{text:"c",font:"minecraft:uniform"}]}"#) + .unwrap(); + let t = to_text(&v, &mut |_| Text::empty()); + let fonts: Vec<_> = t.chars().map(|(_, s)| s.font.clone()).collect(); + let (alt, uniform) = ( + Some("minecraft:alt".into()), + Some("minecraft:uniform".into()), + ); + assert_eq!(fonts, [alt.clone(), alt, uniform]); + // Back to JSON with the field, which a re-read keeps. + let again = to_text(&t.component(), &mut |_| Text::empty()); + let kept: Vec<_> = again.chars().map(|(_, s)| s.font.clone()).collect(); + assert_eq!(kept, fonts); + // Not an identifier: no font. + let (v, _) = parse_snbt(r#"{text:"a",font:"Bad Font"}"#).unwrap(); + let t = to_text(&v, &mut |_| Text::empty()); + assert_eq!(t.spans[0].style.font, None); + } } diff --git a/crates/horizon-client/src/font.rs b/crates/horizon-client/src/font.rs index 3039fdb40..c5e5760f3 100644 --- a/crates/horizon-client/src/font.rs +++ b/crates/horizon-client/src/font.rs @@ -1,19 +1,27 @@ -//! The default font (FontSet over `font/default.json`): space and bitmap -//! providers from the shared atlas, the unihex (GNU Unifont) fallback whose -//! glyphs are rasterized on demand into a reserved atlas region, vanilla -//! glyph metrics (ascent, oversampling, advances, bold/shadow offsets), -//! styled drawing and StringSplitter-style line wrapping. +//! Fonts (FontManager / FontSet): `font/default.json` and every other font a +//! text component names (`minecraft:alt`, `minecraft:uniform`, a pack's own), +//! each a list of providers tried in order: `space`, `bitmap` (sheets in the +//! shared atlas, or rasterized on demand when a pack's sheet is not in it), +//! `unihex` (GNU Unifont) and `ttf` (TrueTypeGlyphProvider, rasterized with +//! ab_glyph). Glyphs drawn at run time go into a reserved atlas region. +//! Vanilla glyph metrics (ascent, oversampling, advances, bold/shadow +//! offsets), styled drawing and StringSplitter-style line wrapping. use crate::{ hud::Rect, text::{Style, Text}, zip::Zip, }; +use ab_glyph::{Font as _, ScaleFont as _}; use std::{ cell::RefCell, collections::HashMap, path::{Path, PathBuf}, + sync::Arc, }; +/// `FontDescription.DEFAULT`. +pub const DEFAULT: &str = "minecraft:default"; + /// A glyph ready to draw: atlas UVs and its box relative to the pen /// position (GlyphBitmap left/top/right/bottom), in GUI pixels. #[derive(Clone, Copy, Debug)] @@ -24,7 +32,7 @@ pub struct Glyph { pub right: f32, pub bottom: f32, pub advance: f32, - /// Shadow and bold offset (1 for bitmap glyphs, 0.5 for unihex). + /// Shadow and bold offset (1 for bitmap and TrueType glyphs, 0.5 for unihex). pub offset: f32, } /// Pixels to copy into the shared atlas before the next HUD draw. @@ -43,23 +51,77 @@ struct HexGlyph { left: u32, right: u32, } -#[derive(Default)] -struct HexProvider { - glyphs: HashMap<u32, HexGlyph>, +/// A provider's `filter` (`FontOption.Filter`): the options it needs. +#[derive(Clone, Copy, Default)] +struct Filter { + uniform: Option<bool>, + jp: Option<bool>, +} +impl Filter { + fn of(provider: &serde_json::Value) -> Self { + let f = &provider["filter"]; + Self { + uniform: f["uniform"].as_bool(), + jp: f["jp"].as_bool(), + } + } + fn passes(self, uniform: bool, japanese: bool) -> bool { + self.uniform.is_none_or(|v| v == uniform) && self.jp.is_none_or(|v| v == japanese) + } +} +/// A bitmap glyph whose sheet is not in the atlas: the cell to copy. +struct SheetCell { + sheet: Arc<(u32, Vec<u8>)>, + x: u32, + y: u32, + w: u32, + h: u32, + glyph: Glyph, +} +enum BitmapGlyph { + Atlas(Glyph), + Sheet(SheetCell), +} +/// `TrueTypeGlyphProvider`. +struct TrueType { + font: ab_glyph::FontVec, + ids: HashMap<char, ab_glyph::GlyphId>, + /// FT_Set_Pixel_Sizes: `size * oversample` pixels to the em. + scale: ab_glyph::PxScale, + oversample: f32, + /// FT_Set_Transform's delta, in oversampled pixels (y down). + shift: (f32, f32), +} +enum Provider { + Space(HashMap<char, f32>), + Bitmap(Filter, HashMap<char, BitmapGlyph>), + /// The definition, and its glyphs once read. + Unihex(Filter, serde_json::Value, Option<HashMap<u32, HexGlyph>>), + TrueType(Filter, Box<TrueType>), +} +/// One font (`FontSet`): its providers and the glyphs resolved so far. +struct FontSet { + providers: Vec<Provider>, + glyphs: HashMap<char, Glyph>, + /// `glyphsByWidth` for obfuscated text (built on first use). + by_width: Option<HashMap<u32, Vec<char>>>, +} +/// The atlas region glyphs are rasterized into, filled in rows. +struct Region { + cursor: (u32, u32), + row: u32, + pending: Vec<Patch>, } struct Cache { - glyphs: HashMap<char, Glyph>, - cursor: (u32, u32), - pending: Vec<Patch>, - hex: Option<Vec<HexProvider>>, - /// `FontSet.glyphsByWidth` for obfuscated text (built on first use). - by_width: Option<HashMap<u32, Vec<char>>>, + /// Every font by id, the default one first (the common lookup). + sets: Vec<(String, FontSet)>, + region: Region, /// `Font.random`: picks obfuscated glyphs. random: horizon_core::random::LegacyRandom, } pub struct Font { - bitmap: HashMap<char, Glyph>, - space: HashMap<char, f32>, + /// The atlas rects of the sheets under `textures/font`. + sheets: HashMap<String, Rect>, missing: Glyph, white: Rect, root: PathBuf, @@ -67,9 +129,9 @@ pub struct Font { atlas: (u32, u32), region: (u32, u32), cache: RefCell<Cache>, - /// "Force Unicode Font": skip the bitmap providers (font/uniform.json). + /// "Force Unicode Font": the `uniform` filter option. pub uniform: bool, - /// "Japanese Glyph Variants": enable providers filtered on `jp`. + /// "Japanese Glyph Variants": the `jp` filter option. pub japanese: bool, } fn parse_hex_digit(b: u8) -> Option<u32> { @@ -178,9 +240,324 @@ fn glyph_rect(x: u32, y: u32, w: u32, h: u32, atlas: (u32, u32)) -> Rect { h, } } +/// The unscaled pixel width of a bitmap cell (`BitmapProvider.getActualGlyphWidth`). +fn used_width(pixels: &[u8], stride: u32, (cx, cy, cw, ch): (u32, u32, u32, u32)) -> u32 { + (0..cw) + .rev() + .find(|&x| { + (0..ch).any(|y| { + pixels + .get((((cy + y) * stride + cx + x) * 4 + 3) as usize) + .is_some_and(|a| *a != 0) + }) + }) + .map_or(0, |x| x + 1) +} +/// `BitmapProvider.Definition.load`: each character's glyph, from the atlas +/// when the sheet is in it (`pixels` its RGBA), else from the sheet's own +/// pixels, copied into the atlas when first drawn. +fn load_bitmap( + root: &Path, + p: &serde_json::Value, + sheets: &HashMap<String, Rect>, + pixels: &[u8], + atlas: (u32, u32), +) -> HashMap<char, BitmapGlyph> { + let mut out = HashMap::new(); + let file = p["file"].as_str().unwrap_or(""); + let (ns, name) = file.split_once(':').unwrap_or(("minecraft", file)); + let in_atlas = (ns == "minecraft") + .then(|| sheets.get(name.trim_end_matches(".png")).copied()) + .flatten(); + // The sheet: its size, and its pixels when they are not in the atlas. + let (sw, sh, sheet) = match in_atlas { + Some(rect) => (rect.w, rect.h, None), + None => match crate::hud::decode(&root.join(resource_path(file, "textures", ""))) { + Ok((w, h, rgba)) => (w, h, Some(Arc::new((w, rgba)))), + Err(_) => { + log::warn!("font sheet {file} could not be read"); + return out; + } + }, + }; + let rows: Vec<Vec<char>> = p["chars"] + .as_array() + .into_iter() + .flatten() + .filter_map(|r| r.as_str().map(|s| s.chars().collect())) + .collect(); + if rows.is_empty() || rows[0].is_empty() { + return out; + } + let cell_w = sw / rows[0].len() as u32; + let cell_h = sh / rows.len() as u32; + let height = p["height"].as_f64().unwrap_or(8.0) as f32; + let ascent = p["ascent"].as_f64().unwrap_or(7.0) as f32; + let scale = height / cell_h as f32; + let origin = in_atlas.map_or((0, 0), |rect| { + ( + (rect.u0 * atlas.0 as f32).round() as u32, + (rect.v0 * atlas.1 as f32).round() as u32, + ) + }); + for (r, row) in rows.iter().enumerate() { + for (c, ch) in row.iter().enumerate() { + if *ch == '\0' || out.contains_key(ch) { + continue; + } + let (x, y) = (c as u32 * cell_w, r as u32 * cell_h); + let used = match &sheet { + Some(s) => used_width(&s.1, s.0, (x, y, cell_w, cell_h)), + None => used_width( + pixels, + atlas.0, + (origin.0 + x, origin.1 + y, cell_w, cell_h), + ), + }; + let top = 7.0 - ascent; + let glyph = Glyph { + rect: None, + left: 0.0, + top, + right: cell_w as f32 * scale, + bottom: top + cell_h as f32 * scale, + advance: (0.5 + used as f32 * scale).floor() + 1.0, + offset: 1.0, + }; + let glyph = match &sheet { + None => BitmapGlyph::Atlas(Glyph { + rect: Some(glyph_rect( + origin.0 + x, + origin.1 + y, + cell_w, + cell_h, + atlas, + )), + ..glyph + }), + Some(s) => BitmapGlyph::Sheet(SheetCell { + sheet: s.clone(), + x, + y, + w: cell_w, + h: cell_h, + glyph, + }), + }; + out.insert(*ch, glyph); + } + } + out +} +/// `TrueTypeGlyphProviderDefinition.load`: a TrueType file (not CFF) under +/// `font/`, its Unicode characters but the `skip` ones. +fn load_true_type(root: &Path, p: &serde_json::Value) -> Option<TrueType> { + let file = p["file"].as_str()?; + let data = std::fs::read(root.join(resource_path(file, "font", ""))) + .map_err(|e| log::warn!("font file {file}: {e}")) + .ok()?; + // FT_Get_Font_Format must say TrueType: CFF outlines ("OTTO") are refused. + if data.starts_with(b"OTTO") { + log::warn!("font file {file} is not in TTF format"); + return None; + } + let font = ab_glyph::FontVec::try_from_vec(data) + .map_err(|e| log::warn!("font file {file}: {e}")) + .ok()?; + let size = p["size"].as_f64().unwrap_or(11.0) as f32; + let oversample = p["oversample"].as_f64().unwrap_or(1.0) as f32; + let shift = p["shift"].as_array().map_or((0.0, 0.0), |s| { + let f = |i: usize| s.get(i).and_then(|v| v.as_f64()).unwrap_or(0.0) as f32; + (f(0), f(1)) + }); + let skip: Vec<char> = match &p["skip"] { + serde_json::Value::String(s) => s.chars().collect(), + serde_json::Value::Array(a) => a + .iter() + .filter_map(|v| v.as_str()) + .flat_map(str::chars) + .collect(), + _ => Vec::new(), + }; + let ids = font + .codepoint_ids() + .filter(|(id, c)| id.0 != 0 && !skip.contains(c)) + .map(|(id, c)| (c, id)) + .collect(); + let pixels_per_em = (size * oversample).round(); + // ab_glyph scales by the font's height; FreeType by its em. + let units = font.units_per_em().unwrap_or(1000.0); + let scale = ab_glyph::PxScale::from(pixels_per_em * font.height_unscaled() / units); + Some(TrueType { + font, + ids, + scale, + oversample, + shift: (shift.0 * oversample, shift.1 * oversample), + }) +} +impl TrueType { + /// The advance in GUI pixels: hinted FreeType advances are whole + /// oversampled pixels. + fn advance(&self, id: ab_glyph::GlyphId) -> f32 { + self.font.as_scaled(self.scale).h_advance(id).round() / self.oversample + } + /// `loadGlyph` and its bitmap: the grey coverage as `rrrr` texels + /// (`text_intensity`), below 0.1 cut (its discard). + fn glyph(&self, id: ab_glyph::GlyphId) -> (Glyph, Option<(u32, u32, Vec<u8>)>) { + let advance = self.advance(id); + let glyph = + id.with_scale_and_position(self.scale, ab_glyph::point(self.shift.0, self.shift.1)); + let empty = Glyph { + rect: None, + left: 0.0, + top: 0.0, + right: 0.0, + bottom: 0.0, + advance, + offset: 1.0, + }; + let Some(outline) = self.font.outline_glyph(glyph) else { + return (empty, None); + }; + let bounds = outline.px_bounds(); + let (w, h) = (bounds.width() as u32, bounds.height() as u32); + if w == 0 || h == 0 { + return (empty, None); + } + let mut rgba = vec![0u8; (w * h * 4) as usize]; + outline.draw(|x, y, coverage| { + let v = if coverage < 0.1 { + 0 + } else { + (coverage.min(1.0) * 255.0).round() as u8 + }; + let i = ((y * w + x) * 4) as usize; + if let Some(px) = rgba.get_mut(i..i + 4) { + px.copy_from_slice(&[v; 4]); + } + }); + let os = self.oversample; + // GlyphBitmap: bitmap_left / bitmap_top over the oversampling, and + // top = 7 - bearingTop. + let (left, top) = (bounds.min.x / os, 7.0 + bounds.min.y / os); + ( + Glyph { + rect: None, + left, + top, + right: left + w as f32 / os, + bottom: top + h as f32 / os, + advance, + offset: 1.0, + }, + Some((w, h, rgba)), + ) + } +} +fn load_hex(root: &Path, p: &serde_json::Value) -> HashMap<u32, HexGlyph> { + let mut glyphs = HashMap::new(); + let Some(file) = p["hex_file"].as_str() else { + return glyphs; + }; + let path = root.join(resource_path(file, "", "").replace("//", "/")); + let Ok(zip) = Zip::open(&path) else { + return glyphs; + }; + let names: Vec<String> = zip + .names() + .filter(|n| n.ends_with(".hex")) + .map(str::to_owned) + .collect(); + for name in names { + if let Ok(bytes) = zip.read(&name) { + parse_hex(&bytes, &mut glyphs); + } + } + for o in p["size_overrides"].as_array().into_iter().flatten() { + let bound = |k: &str| { + o[k].as_str() + .and_then(|s| s.chars().next()) + .map_or(0, u32::from) + }; + let (left, right) = ( + o["left"].as_u64().unwrap_or(0) as u32, + o["right"].as_u64().unwrap_or(15) as u32, + ); + for c in bound("from")..=bound("to") { + if let Some(g) = glyphs.get_mut(&c) { + g.left = left; + g.right = right; + } + } + } + glyphs +} +/// The ids of every font definition (`font/**/*.json` of each namespace). +fn font_ids(root: &Path) -> Vec<String> { + fn walk(dir: &Path, prefix: &str, out: &mut Vec<String>) { + for entry in std::fs::read_dir(dir).into_iter().flatten().flatten() { + let path = entry.path(); + let name = entry.file_name().to_string_lossy().into_owned(); + if path.is_dir() { + walk(&path, &format!("{prefix}{name}/"), out); + } else if let Some(stem) = name.strip_suffix(".json") { + out.push(format!("{prefix}{stem}")); + } + } + } + let mut ids = Vec::new(); + for ns in std::fs::read_dir(root.join("assets")) + .into_iter() + .flatten() + .flatten() + { + let ns = ns.file_name().to_string_lossy().into_owned(); + walk( + &root.join("assets").join(&ns).join("font"), + &format!("{ns}:"), + &mut ids, + ); + } + ids.sort(); + ids +} +impl Region { + /// Place `w x h` pixels in the region (rows left to right); their atlas + /// position, or none when it is full. + fn place( + &mut self, + w: u32, + h: u32, + rgba: Vec<u8>, + atlas: (u32, u32), + region: (u32, u32), + ) -> Option<(u32, u32)> { + let (mut x, mut y) = self.cursor; + if x + w + 1 > atlas.0 { + x = 0; + y += self.row + 1; + self.row = 0; + } + if y + h > region.1 { + return None; + } + let (ax, ay) = (x, region.0 + y); + self.pending.push(Patch { + x: ax, + y: ay, + width: w, + height: h, + rgba, + }); + self.cursor = (x + w + 1, y); + self.row = self.row.max(h); + Some((ax, ay)) + } +} impl Font { - /// Build from the atlas holding the bitmap font sheets. `pixels` is the - /// RGBA atlas (for glyph widths) and `region` the reserved rows. + /// Build from the atlas holding the bitmap font sheets (`sprites`, of + /// `atlas` size) with `region` the reserved rows. pub fn load( root: &Path, sprites: &HashMap<String, Rect>, @@ -189,107 +566,33 @@ impl Font { region: (u32, u32), white: Rect, ) -> Self { - let mut bitmap = HashMap::new(); - let mut space = HashMap::new(); - let mut all = Vec::new(); - providers(root, "minecraft:default", 0, &mut all); - for provider in &all { - match provider["type"].as_str() { - Some("space") => { - for (k, v) in provider["advances"].as_object().into_iter().flatten() { - if let (Some(c), Some(a)) = (k.chars().next(), v.as_f64()) { - space.entry(c).or_insert(a as f32); - } - } - } - Some("bitmap") => { - // Only non-uniform bitmap sheets exist in the default font. - let file = provider["file"].as_str().unwrap_or(""); - let name = file - .trim_start_matches("minecraft:") - .trim_end_matches(".png"); - let name = name.to_string(); - let Some(rect) = sprites.get(&name).copied() else { - continue; - }; - let rows: Vec<Vec<char>> = provider["chars"] - .as_array() - .into_iter() - .flatten() - .filter_map(|r| r.as_str().map(|s| s.chars().collect())) - .collect(); - if rows.is_empty() || rows[0].is_empty() { - continue; - } - let cell_w = rect.w / rows[0].len() as u32; - let cell_h = rect.h / rows.len() as u32; - let height = provider["height"].as_f64().unwrap_or(8.0) as f32; - let ascent = provider["ascent"].as_f64().unwrap_or(7.0) as f32; - let scale = height / cell_h as f32; - let (ax, ay) = ( - (rect.u0 * atlas.0 as f32).round() as u32, - (rect.v0 * atlas.1 as f32).round() as u32, - ); - for (r, row) in rows.iter().enumerate() { - for (c, ch) in row.iter().enumerate() { - if *ch == '\0' || bitmap.contains_key(ch) { - continue; - } - let (cx, cy) = (ax + c as u32 * cell_w, ay + r as u32 * cell_h); - // BitmapProvider.getActualGlyphWidth. - let mut used = 0; - for x in (0..cell_w).rev() { - if (0..cell_h).any(|y| { - pixels - .get((((cy + y) * atlas.0 + cx + x) * 4 + 3) as usize) - .is_some_and(|a| *a != 0) - }) { - used = x + 1; - break; - } - } - let top = 7.0 - ascent; - bitmap.insert( - *ch, - Glyph { - rect: Some(glyph_rect(cx, cy, cell_w, cell_h, atlas)), - left: 0.0, - top, - right: cell_w as f32 * scale, - bottom: top + cell_h as f32 * scale, - advance: (0.5 + used as f32 * scale).floor() + 1.0, - offset: 1.0, - }, - ); - } - } - } - _ => {} - } - } - let missing = Glyph { - rect: None, - left: 0.0, - top: 0.0, - right: 5.0, - bottom: 8.0, - advance: 6.0, - offset: 1.0, - }; - Self { - bitmap, - space, - missing, + let sheets = sprites + .iter() + .filter(|(k, _)| k.starts_with("font/")) + .map(|(k, v)| (k.clone(), *v)) + .collect(); + let font = Self { + sheets, + missing: Glyph { + rect: None, + left: 0.0, + top: 0.0, + right: 5.0, + bottom: 8.0, + advance: 6.0, + offset: 1.0, + }, white, root: root.to_owned(), atlas, region, cache: RefCell::new(Cache { - glyphs: HashMap::new(), - cursor: (0, 0), - pending: Vec::new(), - hex: None, - by_width: None, + sets: Vec::new(), + region: Region { + cursor: (0, 0), + row: 0, + pending: Vec::new(), + }, random: horizon_core::random::LegacyRandom::new( std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) @@ -298,120 +601,161 @@ impl Font { }), uniform: false, japanese: false, - } + }; + // FontManager.prepare: every font definition of the resources. + let mut ids = font_ids(root); + ids.sort_by_key(|id| id != DEFAULT); + let sets = ids + .into_iter() + .map(|id| { + let set = font.load_set(&id, pixels); + (id, set) + }) + .collect(); + font.cache.borrow_mut().sets = sets; + font } - fn load_hex(&self) -> Vec<HexProvider> { + /// `FontManager`: a font's providers with references expanded. + fn load_set(&self, id: &str, pixels: &[u8]) -> FontSet { let mut all = Vec::new(); - providers(&self.root, "minecraft:default", 0, &mut all); - let mut out = Vec::new(); - for p in all.iter().filter(|p| p["type"] == "unihex") { - if let Some(filter) = p["filter"].as_object() { - let pass = filter.iter().all(|(k, v)| match k.as_str() { - "jp" => v.as_bool() == Some(self.japanese), - "uniform" => v.as_bool() == Some(self.uniform), - _ => true, - }); - if !pass { - continue; - } - } - let Some(file) = p["hex_file"].as_str() else { - continue; - }; - let path = self - .root - .join(resource_path(file, "", "").replace("//", "/")); - let Ok(zip) = Zip::open(&path) else { continue }; - let mut provider = HexProvider::default(); - let names: Vec<String> = zip - .names() - .filter(|n| n.ends_with(".hex")) - .map(str::to_owned) - .collect(); - for name in names { - if let Ok(bytes) = zip.read(&name) { - parse_hex(&bytes, &mut provider.glyphs); - } - } - for o in p["size_overrides"].as_array().into_iter().flatten() { - let from = o["from"] - .as_str() - .and_then(|s| s.chars().next()) - .map_or(0, u32::from); - let to = o["to"] - .as_str() - .and_then(|s| s.chars().next()) - .map_or(0, u32::from); - let (left, right) = ( - o["left"].as_u64().unwrap_or(0) as u32, - o["right"].as_u64().unwrap_or(15) as u32, - ); - for c in from..=to { - if let Some(g) = provider.glyphs.get_mut(&c) { - g.left = left; - g.right = right; - } - } - } - out.push(provider); + providers(&self.root, id, 0, &mut all); + let providers = all + .iter() + .filter_map(|p| match p["type"].as_str()? { + "space" => Some(Provider::Space( + p["advances"] + .as_object() + .into_iter() + .flatten() + .filter_map(|(k, v)| Some((k.chars().next()?, v.as_f64()? as f32))) + .collect(), + )), + "bitmap" => Some(Provider::Bitmap( + Filter::of(p), + load_bitmap(&self.root, p, &self.sheets, pixels, self.atlas), + )), + "unihex" => Some(Provider::Unihex(Filter::of(p), p.clone(), None)), + "ttf" => Some(Provider::TrueType( + Filter::of(p), + Box::new(load_true_type(&self.root, p)?), + )), + _ => None, + }) + .collect(); + FontSet { + providers, + glyphs: HashMap::new(), + by_width: None, } - out } - /// Forget rasterized fallback glyphs (after changing font options). + /// Forget rasterized glyphs (after changing font options). pub fn reset_cache(&self) { let mut cache = self.cache.borrow_mut(); - cache.glyphs.clear(); - cache.cursor = (0, 0); - cache.hex = None; - cache.by_width = None; + for (_, set) in &mut cache.sets { + set.glyphs.clear(); + set.by_width = None; + } + cache.region.cursor = (0, 0); + cache.region.row = 0; } - /// The glyph for a character (FontSet.getGlyph). + /// The glyph for a character in the default font (FontSet.getGlyph). pub fn glyph(&self, c: char) -> Glyph { - if let Some(a) = self.space.get(&c) { - return Glyph { - rect: None, - left: 0.0, - top: 0.0, - right: 0.0, - bottom: 0.0, - advance: *a, - offset: 1.0, - }; - } - if !self.uniform - && let Some(g) = self.bitmap.get(&c) - { - return *g; - } - if let Some(g) = self.cache.borrow().glyphs.get(&c) { - return *g; + self.glyph_of(DEFAULT, c) + } + /// The glyph for a character drawn in `style`'s font (its id is + /// already complete, see `text::font_id`). + pub fn glyph_styled(&self, c: char, style: &Style) -> Glyph { + self.glyph_of(style.font.as_deref().unwrap_or(DEFAULT), c) + } + /// The glyph for a character in the font `id` (`alt` is `minecraft:alt`). + pub fn glyph_in(&self, id: &str, c: char) -> Glyph { + if id.contains(':') { + self.glyph_of(id, c) + } else { + self.glyph_of(&format!("minecraft:{id}"), c) } + } + /// The first active provider's glyph, else the missing glyph. + fn glyph_of(&self, id: &str, c: char) -> Glyph { let mut cache = self.cache.borrow_mut(); - if cache.hex.is_none() { - cache.hex = Some(self.load_hex()); - } - let hex = cache.hex.as_ref().and_then(|providers| { - providers - .iter() - .find_map(|p| p.glyphs.get(&u32::from(c)).copied()) - }); - let glyph = match hex { - Some(h) => self.rasterize(&mut cache, h).unwrap_or(self.missing), - None => self.missing, + let Cache { sets, region, .. } = &mut *cache; + // FontManager.getFontSetRaw: a font that doesn't exist draws every + // character as the missing glyph. + let Some((_, set)) = sets.iter_mut().find(|(k, _)| k == id) else { + return self.missing; }; - cache.glyphs.insert(c, glyph); + if let Some(g) = set.glyphs.get(&c) { + return *g; + } + let glyph = self.resolve(set, region, c).unwrap_or(self.missing); + set.glyphs.insert(c, glyph); glyph } - fn rasterize(&self, cache: &mut Cache, h: HexGlyph) -> Option<Glyph> { + fn resolve(&self, set: &mut FontSet, region: &mut Region, c: char) -> Option<Glyph> { + let (uniform, japanese) = (self.uniform, self.japanese); + for provider in &mut set.providers { + match provider { + Provider::Space(advances) => { + if let Some(a) = advances.get(&c) { + return Some(Glyph { + rect: None, + left: 0.0, + top: 0.0, + right: 0.0, + bottom: 0.0, + advance: *a, + offset: 1.0, + }); + } + } + Provider::Bitmap(filter, glyphs) if filter.passes(uniform, japanese) => { + match glyphs.get(&c) { + Some(BitmapGlyph::Atlas(g)) => return Some(*g), + Some(BitmapGlyph::Sheet(cell)) => { + let (stride, pixels) = (&cell.sheet.0, &cell.sheet.1); + let mut rgba = Vec::with_capacity((cell.w * cell.h * 4) as usize); + for y in cell.y..cell.y + cell.h { + let at = ((y * stride + cell.x) * 4) as usize; + rgba.extend_from_slice(&pixels[at..at + (cell.w * 4) as usize]); + } + let (x, y) = + region.place(cell.w, cell.h, rgba, self.atlas, self.region)?; + return Some(Glyph { + rect: Some(glyph_rect(x, y, cell.w, cell.h, self.atlas)), + ..cell.glyph + }); + } + None => {} + } + } + Provider::Unihex(filter, def, glyphs) if filter.passes(uniform, japanese) => { + let glyphs = glyphs.get_or_insert_with(|| load_hex(&self.root, def)); + if let Some(h) = glyphs.get(&u32::from(c)).copied() { + return self.rasterize_hex(region, h); + } + } + Provider::TrueType(filter, ttf) if filter.passes(uniform, japanese) => { + if let Some(id) = ttf.ids.get(&c) { + let (glyph, bitmap) = ttf.glyph(*id); + return match bitmap { + Some((w, h, rgba)) => { + let (x, y) = region.place(w, h, rgba, self.atlas, self.region)?; + Some(Glyph { + rect: Some(glyph_rect(x, y, w, h, self.atlas)), + ..glyph + }) + } + None => Some(glyph), + }; + } + } + _ => {} + } + } + None + } + fn rasterize_hex(&self, region: &mut Region, h: HexGlyph) -> Option<Glyph> { let width = h.right.saturating_sub(h.left) + 1; - let (mut x, mut y) = cache.cursor; - if x + width + 1 > self.atlas.0 { - x = 0; - y += 17; - } - if y + 16 > self.region.1 { - return None; - } let mut rgba = Vec::with_capacity((width * 16 * 4) as usize); for row in h.rows { for bit in h.left..=h.right { @@ -419,17 +763,9 @@ impl Font { rgba.extend(if set { [255; 4] } else { [0; 4] }); } } - let (ax, ay) = (x, self.region.0 + y); - cache.pending.push(Patch { - x: ax, - y: ay, - width, - height: 16, - rgba, - }); - cache.cursor = (x + width + 1, y); + let (x, y) = region.place(width, 16, rgba, self.atlas, self.region)?; Some(Glyph { - rect: Some(glyph_rect(ax, ay, width, 16, self.atlas)), + rect: Some(glyph_rect(x, y, width, 16, self.atlas)), left: 0.0, top: 0.0, right: width as f32 / 2.0, @@ -439,26 +775,29 @@ impl Font { }) } /// `FontSet.getRandomGlyph`: what an obfuscated character draws, a random - /// glyph as wide as `advance` (rounded up), else the missing glyph. + /// glyph of the font as wide as `advance` (rounded up), else the missing + /// glyph. /// /// Vanilla picks among every glyph of the font set, Unifont's included. /// Those are rasterized into a fixed atlas region on demand, which a /// line of obfuscated text would fill in seconds, so the candidates are - /// the glyphs already in the atlas (the bitmap sheets and spaces), or with - /// "Force Unicode Font" the Unifont glyphs below U+0250. - pub fn random_glyph(&self, advance: f32) -> Glyph { + /// the glyphs already in the atlas (the bitmap sheets there and spaces), + /// or for a font without any (Force Unicode Font, a TrueType font) its + /// glyphs below U+0250. + pub fn random_glyph(&self, style: &Style, advance: f32) -> Glyph { use horizon_core::random::RandomSource; + let id = style.font.as_deref().unwrap_or(DEFAULT); let width = advance.ceil() as u32; let pick = { let mut cache = self.cache.borrow_mut(); - if cache.by_width.is_none() { - let by_width = self.glyphs_by_width(&mut cache); - cache.by_width = Some(by_width); + let Cache { sets, random, .. } = &mut *cache; + let Some((_, set)) = sets.iter_mut().find(|(k, _)| k == id) else { + return self.missing; + }; + if set.by_width.is_none() { + set.by_width = Some(self.glyphs_by_width(set)); } - let Cache { - by_width, random, .. - } = &mut *cache; - by_width + set.by_width .as_ref() .and_then(|m| m.get(&width)) .and_then(|chars| { @@ -466,44 +805,79 @@ impl Font { chars.get(i as usize).copied() }) }; - pick.map_or(self.missing, |c| self.glyph(c)) + pick.map_or(self.missing, |c| self.glyph_of(id, c)) } - fn glyphs_by_width(&self, cache: &mut Cache) -> HashMap<u32, Vec<char>> { - let mut chars: Vec<(char, f32)> = self.space.iter().map(|(c, a)| (*c, *a)).collect(); - if self.uniform { - if cache.hex.is_none() { - cache.hex = Some(self.load_hex()); - } - for code in 0..0x250u32 { - let hex = cache.hex.iter().flatten().find_map(|p| p.glyphs.get(&code)); - if let (Some(c), Some(h)) = (char::from_u32(code), hex) - && !self.space.contains_key(&c) - { - let width = h.right.saturating_sub(h.left) + 1; - chars.push((c, (width / 2 + 1) as f32)); + fn glyphs_by_width(&self, set: &mut FontSet) -> HashMap<u32, Vec<char>> { + let (uniform, japanese) = (self.uniform, self.japanese); + let mut chars = std::collections::BTreeSet::new(); + let mut in_atlas = false; + for provider in &set.providers { + match provider { + Provider::Space(advances) => chars.extend(advances.keys().copied()), + Provider::Bitmap(filter, glyphs) if filter.passes(uniform, japanese) => { + for (c, g) in glyphs { + if matches!(g, BitmapGlyph::Atlas(_)) { + in_atlas = true; + chars.insert(*c); + } + } } + _ => {} } - } else { - chars.extend( - self.bitmap - .iter() - .filter(|(c, _)| !self.space.contains_key(c)) - .map(|(c, g)| (*c, g.advance)), - ); } - chars.sort_by_key(|(c, _)| *c); + if !in_atlas { + // Nothing in the atlas: the glyphs below U+0250, rasterized as used. + chars.extend((0..0x250u32).filter_map(char::from_u32)); + } let mut out: HashMap<u32, Vec<char>> = HashMap::new(); - for (c, advance) in chars { - out.entry(advance.ceil() as u32).or_default().push(c); + for c in chars { + if let Some(advance) = self.provider_advance(set, c) { + out.entry(advance.ceil() as u32).or_default().push(c); + } } out } + /// A character's advance in `set` (its first provider that has it), + /// without rasterizing it. + fn provider_advance(&self, set: &mut FontSet, c: char) -> Option<f32> { + let (uniform, japanese) = (self.uniform, self.japanese); + for provider in &mut set.providers { + match provider { + Provider::Space(advances) => { + if let Some(a) = advances.get(&c) { + return Some(*a); + } + } + Provider::Bitmap(filter, glyphs) if filter.passes(uniform, japanese) => { + match glyphs.get(&c) { + Some(BitmapGlyph::Atlas(g)) => return Some(g.advance), + Some(BitmapGlyph::Sheet(cell)) => return Some(cell.glyph.advance), + None => {} + } + } + Provider::Unihex(filter, def, glyphs) if filter.passes(uniform, japanese) => { + let glyphs = glyphs.get_or_insert_with(|| load_hex(&self.root, def)); + if let Some(h) = glyphs.get(&u32::from(c)) { + let width = h.right.saturating_sub(h.left) + 1; + return Some((width / 2 + 1) as f32); + } + } + Provider::TrueType(filter, ttf) if filter.passes(uniform, japanese) => { + if let Some(id) = ttf.ids.get(&c) { + return Some(ttf.advance(*id)); + } + } + _ => {} + } + } + None + } /// Atlas pixels rasterized since the last call. pub fn take_patches(&self) -> Vec<Patch> { - std::mem::take(&mut self.cache.borrow_mut().pending) + std::mem::take(&mut self.cache.borrow_mut().region.pending) } pub fn advance(&self, c: char, style: &Style) -> f32 { - let g = self.glyph(c); + let g = self.glyph_styled(c, style); g.advance + if style.is_bold() { g.offset } else { 0.0 } } /// Font.width of plain text (legacy codes are formatting, not glyphs). @@ -689,4 +1063,155 @@ mod tests { assert_eq!(r.v1, ((y + h) as f32 - 0.01) / 4096.0); } } + + /// A resource root with these font definitions and files. + fn root(name: &str, files: &[(&str, &[u8])]) -> PathBuf { + let root = std::env::temp_dir().join(format!("horizon-font-{name}-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&root); + for (path, bytes) in files { + let path = root.join(path); + std::fs::create_dir_all(path.parent().unwrap()).unwrap(); + std::fs::write(path, bytes).unwrap(); + } + root + } + fn white() -> Rect { + Rect { + u0: 0.0, + v0: 0.0, + u1: 0.0, + v1: 0.0, + w: 1, + h: 1, + } + } + fn load(root: &Path) -> Font { + Font::load( + root, + &HashMap::new(), + &[], + (4096, 1024), + (512, 512), + white(), + ) + } + fn png(width: u32, height: u32, opaque: impl Fn(u32, u32) -> bool) -> Vec<u8> { + let mut pixels = Vec::new(); + for y in 0..height { + for x in 0..width { + pixels.extend(if opaque(x, y) { [255; 4] } else { [0; 4] }); + } + } + let mut out = Vec::new(); + let mut encoder = png::Encoder::new(&mut out, width, height); + encoder.set_color(png::ColorType::Rgba); + encoder.set_depth(png::BitDepth::Eight); + encoder + .write_header() + .unwrap() + .write_image_data(&pixels) + .unwrap(); + out + } + + #[test] + fn true_type_glyphs_are_rasterized_at_the_provider_size() { + let def = br#"{"providers":[{"type":"ttf","file":"minecraft:mono.ttf","size":11,"oversample":2,"shift":[0.5,1],"skip":["B"]}]}"#; + let root = root( + "ttf", + &[ + ("assets/minecraft/font/default.json", def), + ( + "assets/minecraft/font/mono.ttf", + horizon_theme::fonts::GEIST_MONO, + ), + ], + ); + let font = load(&root); + let _ = std::fs::remove_dir_all(&root); + let a = font.glyph('A'); + let rect = a.rect.expect("A is drawn"); + // Oversampled 2x: the bitmap is twice the glyph's GUI size. + assert_eq!(rect.w as f32 / 2.0, a.right - a.left); + assert_eq!(rect.h as f32 / 2.0, a.bottom - a.top); + // A monospaced font: every advance is the same, in half pixels. + assert_eq!(a.advance, font.glyph('i').advance); + assert_eq!((a.advance * 2.0).fract(), 0.0); + assert!(a.advance > 4.0 && a.advance < 9.0, "{}", a.advance); + // Capitals sit on the baseline at y = 7, shifted down a pixel. + assert!((a.bottom - 8.0).abs() <= 0.5, "{}", a.bottom); + assert_eq!(a.offset, 1.0); + // The space has an advance and nothing to draw. + let space = font.glyph(' '); + assert!(space.rect.is_none() && space.advance > 0.0); + // Skipped characters fall through to the missing glyph. + assert_eq!(font.glyph('B').advance, 6.0); + // Coverage as `rrrr` texels, faint coverage cut. + let patches = font.take_patches(); + assert_eq!(patches.len(), 2); + let texels: Vec<&[u8]> = patches.iter().flat_map(|p| p.rgba.chunks(4)).collect(); + assert!(texels.iter().all(|t| t.iter().all(|v| *v == t[0]))); + assert!(texels.iter().all(|t| t[0] == 0 || t[0] >= 25)); + assert!(texels.iter().any(|t| t[0] == 255)); + } + + #[test] + fn styles_pick_their_font_and_unknown_fonts_draw_missing_glyphs() { + let sheet = png(16, 8, |x, _| x < 2 || (8..14).contains(&x)); + let default = br#"{"providers":[{"type":"space","advances":{" ":4}},{"type":"bitmap","file":"minecraft:font/a.png","ascent":7,"chars":["ab"]}]}"#; + let alt = br#"{"providers":[{"type":"bitmap","file":"minecraft:font/a.png","ascent":7,"chars":["ba"]}]}"#; + let root = root( + "styles", + &[ + ("assets/minecraft/font/default.json", default), + ("assets/minecraft/font/alt.json", alt), + ("assets/minecraft/textures/font/a.png", &sheet), + ], + ); + let font = load(&root); + let _ = std::fs::remove_dir_all(&root); + // The sheet is not in this atlas: glyphs are copied in when first drawn. + assert_eq!(font.glyph('a').advance, 3.0); + assert_eq!(font.glyph('b').advance, 7.0); + let alt = Style { + font: Some("minecraft:alt".into()), + ..Style::default() + }; + assert_eq!(font.glyph_styled('a', &alt).advance, 7.0); + assert_eq!(font.glyph_in("alt", 'b').advance, 3.0); + assert!(font.glyph_styled('a', &alt).rect.is_some()); + // Not in alt (no space provider there), or no such font at all. + assert_eq!(font.glyph_styled(' ', &alt).advance, 6.0); + let missing = Style { + font: Some("minecraft:nope".into()), + ..Style::default() + }; + assert_eq!(font.glyph_styled(' ', &missing).advance, 6.0); + assert_eq!(font.advance('a', &alt), 7.0); + let text = Text::literal("ab").with_style(&alt); + assert_eq!(font.width_text(&text), 10.0); + assert_eq!(font.random_glyph(&alt, 7.0).advance, 7.0); + assert!(!font.take_patches().is_empty()); + } + + #[test] + fn provider_filters_follow_the_font_options() { + let sheet = png(8, 8, |x, _| x < 4); + let default = br#"{"providers":[{"type":"reference","id":"minecraft:include/sheet","filter":{"uniform":false}},{"type":"space","advances":{"a":2}}]}"#; + let sheet_def = br#"{"providers":[{"type":"bitmap","file":"minecraft:font/s.png","ascent":7,"chars":["a"]}]}"#; + let root = root( + "filters", + &[ + ("assets/minecraft/font/default.json", default), + ("assets/minecraft/font/include/sheet.json", sheet_def), + ("assets/minecraft/textures/font/s.png", &sheet), + ], + ); + let mut font = load(&root); + let _ = std::fs::remove_dir_all(&root); + assert_eq!(font.glyph('a').advance, 5.0); + font.uniform = true; + font.reset_cache(); + assert_eq!(font.glyph('a').advance, 2.0); + } } diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 29faf5a2a..3c33ecb18 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -711,11 +711,12 @@ impl HudBatch { let mut glyphs = Vec::new(); let mut cursor = x; for (i, (ch, style)) in text.chars().enumerate() { - let mut g = font.glyph(ch); + // The style's font (`Style.getFont`), the default one unless set. + let mut g = font.glyph_styled(ch, style); // Font.StringRenderOutput.accept: obfuscated characters draw a // random glyph of the same width each frame. if style.obfuscated == Some(true) && ch != ' ' { - g = font.random_glyph(g.advance); + g = font.random_glyph(style, g.advance); } let c = style.color.map_or(color, |rgb| { rgba((rgb >> 16) as u8, (rgb >> 8) as u8, rgb as u8, alpha) @@ -1263,11 +1264,11 @@ mod tests { let (a, b) = (fonts.font.glyph('a').advance, fonts.font.glyph('b').advance); assert_ne!(a, b); for _ in 0..20 { - assert_eq!(fonts.font.random_glyph(a).advance, a); - assert_eq!(fonts.font.random_glyph(b).advance, b); + assert_eq!(fonts.font.random_glyph(&Default::default(), a).advance, a); + assert_eq!(fonts.font.random_glyph(&Default::default(), b).advance, b); } // No glyph that wide: FontSet's missing glyph. - let missing = fonts.font.random_glyph(30.0); + let missing = fonts.font.random_glyph(&Default::default(), 30.0); assert!(missing.rect.is_none() && missing.right == 5.0); } diff --git a/crates/horizon-client/src/packs.rs b/crates/horizon-client/src/packs.rs index 7af7518f8..7bd4fd782 100644 --- a/crates/horizon-client/src/packs.rs +++ b/crates/horizon-client/src/packs.rs @@ -87,6 +87,7 @@ fn style_of(o: &serde_json::Map<String, serde_json::Value>) -> Style { underlined: flag("underlined"), strikethrough: flag("strikethrough"), obfuscated: flag("obfuscated"), + font: o.get("font").and_then(crate::text::font_id), ..Style::default() } } diff --git a/crates/horizon-client/src/scoreboard.rs b/crates/horizon-client/src/scoreboard.rs index e063c6f09..4796be51a 100644 --- a/crates/horizon-client/src/scoreboard.rs +++ b/crates/horizon-client/src/scoreboard.rs @@ -118,6 +118,7 @@ pub fn style_from_json(v: &Value) -> Style { s.underlined = flag("underlined"); s.strikethrough = flag("strikethrough"); s.obfuscated = flag("obfuscated"); + s.font = o.get("font").and_then(text::font_id); s } impl NumberFormat { diff --git a/crates/horizon-client/src/text.rs b/crates/horizon-client/src/text.rs index 3874efd17..9f39155d1 100644 --- a/crates/horizon-client/src/text.rs +++ b/crates/horizon-client/src/text.rs @@ -61,6 +61,13 @@ pub struct Style { pub click: Option<ClickEvent>, /// Hover text. pub hover: Option<Box<Text>>, + /// The font (`FontDescription.Resource`), a full id like + /// `minecraft:alt`; the default font when unset. + pub font: Option<String>, +} +/// A style's `font` field: an identifier (`alt` is `minecraft:alt`). +pub fn font_id(v: &Value) -> Option<String> { + crate::command::args::parse_identifier(v.as_str()?) } impl Style { pub fn color(c: u32) -> Self { @@ -83,6 +90,9 @@ impl Style { if self.hover.is_none() { self.hover.clone_from(&base.hover); } + if self.font.is_none() { + self.font.clone_from(&base.font); + } } pub fn is_bold(&self) -> bool { self.bold == Some(true) @@ -451,7 +461,7 @@ impl Text { } /// The style fields of a component's JSON. -const STYLE_KEYS: [&str; 8] = [ +const STYLE_KEYS: [&str; 9] = [ "color", "bold", "italic", @@ -460,6 +470,7 @@ const STYLE_KEYS: [&str; 8] = [ "obfuscated", "click_event", "hover_event", + "font", ]; /// Style.Serializer: the fields a style sets. fn style_json(style: &Style) -> Vec<(String, Value)> { @@ -500,6 +511,9 @@ fn style_json(style: &Style) -> Vec<(String, Value)> { json!({ "action": "show_text", "value": hover.component() }), )); } + if let Some(font) = &style.font { + out.push(("font".to_owned(), font.clone().into())); + } out } From a069c2716f9a2bcf394859a53e44e0538825f9ad Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:24:07 +0200 Subject: [PATCH 10/62] Random ticks: ask for the next ticking section, and read a section's blocks faster tick_chunk_random asks for the lowest randomly ticking section from a height up, instead of asking about every section: a chunk costs one question per section that ticks, not 24. PalettedContainer::has tests whole words for the few matching palette indices (a field-wise zero test) instead of reading every entry, so a section read again after an edit costs a few hundred word operations. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- .../examples/random_tick_sections_probe.rs | 2 +- crates/horizon-client/src/game.rs | 4 +- .../src/random_tick_sections.rs | 47 ++++++-- crates/horizon-core/src/paletted.rs | 105 +++++++++++++----- crates/horizon-world/src/level/mod.rs | 2 +- crates/horizon-world/src/level/tick.rs | 18 +-- 6 files changed, 127 insertions(+), 51 deletions(-) diff --git a/crates/horizon-client/examples/random_tick_sections_probe.rs b/crates/horizon-client/examples/random_tick_sections_probe.rs index cb8a8b742..91c861f45 100644 --- a/crates/horizon-client/examples/random_tick_sections_probe.rs +++ b/crates/horizon-client/examples/random_tick_sections_probe.rs @@ -99,7 +99,7 @@ fn main() -> Result<(), Box<dyn Error>> { &mut level, &mut ticks, ChunkPos::new(0, 0), - |_, min_y| cache.get((0, 0), &chunk, &facts).contains(min_y), + |_, from| cache.get((0, 0), &chunk, &facts).from(from), ); for pos in level.reads.borrow().iter() { let state = chunk.block(pos.x, pos.y, pos.z); diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index afdb2ee37..20e75fcdf 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -2427,7 +2427,7 @@ impl Game<'_> { let mut read = None; let mut sections = Default::default(); let pos = horizon_core::position::ChunkPos::new(x, z); - b.tick_chunk_random(level, ticks, pos, |level, min_y| { + b.tick_chunk_random(level, ticks, pos, |level, from| { if read != Some(level.world.revision) { read = Some(level.world.revision); sections = level @@ -2438,7 +2438,7 @@ impl Game<'_> { level.random_tick_sections.get((x, z), chunk, level.facts) }); } - sections.contains(min_y) + sections.from(from) }); } b.run_block_events(level, ticks); diff --git a/crates/horizon-client/src/random_tick_sections.rs b/crates/horizon-client/src/random_tick_sections.rs index 23d6a3dbe..ebab40a7b 100644 --- a/crates/horizon-client/src/random_tick_sections.rs +++ b/crates/horizon-client/src/random_tick_sections.rs @@ -12,10 +12,10 @@ use std::sync::{Arc, Weak}; #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub struct Sections(u32); impl Sections { - /// Whether the section starting at block `min_y` is in the set. - pub fn contains(self, min_y: i32) -> bool { - let index = (min_y - MIN_Y) >> 4; - (0..SECTIONS as i32).contains(&index) && self.0 >> index & 1 != 0 + /// The minimum Y of the lowest section in the set from block `min_y` up. + pub fn from(self, min_y: i32) -> Option<i32> { + let index = ((min_y - MIN_Y) >> 4).max(0) as u32; + Sections(self.0 & u32::MAX.checked_shl(index).unwrap_or(0)).next() } } impl Iterator for Sections { @@ -184,6 +184,27 @@ mod tests { .collect::<Vec<_>>(), [MIN_Y, MIN_Y + 9 * 16, MIN_Y + (SECTIONS as i32 - 1) * 16] ); + let sections = cache.get_with((0, 0), &chunk, |id| id == 299); + let top = MIN_Y + (SECTIONS as i32 - 1) * 16; + let from = |y| sections.from(y); + assert_eq!( + [ + from(MIN_Y - 16), + from(MIN_Y), + from(MIN_Y + 16), + from(MIN_Y + 9 * 16) + ], + [ + Some(MIN_Y), + Some(MIN_Y), + Some(MIN_Y + 9 * 16), + Some(MIN_Y + 9 * 16) + ] + ); + assert_eq!( + [from(top), from(top + 16), from(top + 1000)], + [Some(top), None, None] + ); } } @@ -359,19 +380,21 @@ mod tick_parity { for (x, z) in lit(&original) { // Vanilla's rule, asked as each section is reached: any of its // 4,096 blocks ticks randomly. - let reference = |level: &mut Level, min_y: i32| { + let reference = |level: &mut Level, from: i32| { let chunk = &level.chunks[&(x, z)]; - (0..16).any(|y| { - (0..16).any(|z| (0..16).any(|x| random(chunk.get(x, min_y + y, z)))) - }) + (from..MIN_Y + SECTIONS as i32 * 16) + .step_by(16) + .find(|&min_y| { + (0..16).any(|y| { + (0..16).any(|z| (0..16).any(|x| random(chunk.get(x, min_y + y, z)))) + }) + }) }; behaviours.tick_chunk_random(&mut original, &mut a, ChunkPos::new(x, z), reference); } for (x, z) in lit(&cached) { - let memoized = |level: &mut Level, min_y| { - cache - .get((x, z), &level.chunks[&(x, z)], &facts) - .contains(min_y) + let memoized = |level: &mut Level, from| { + cache.get((x, z), &level.chunks[&(x, z)], &facts).from(from) }; behaviours.tick_chunk_random(&mut cached, &mut b, ChunkPos::new(x, z), memoized); } diff --git a/crates/horizon-core/src/paletted.rs b/crates/horizon-core/src/paletted.rs index dad7f76a0..43189f425 100644 --- a/crates/horizon-core/src/paletted.rs +++ b/crates/horizon-core/src/paletted.rs @@ -677,37 +677,43 @@ impl PalettedContainer { /// Whether any entry satisfies `predicate`. Unlike [`Self::maybe_has`], /// palette entries no entry uses any more don't count. pub fn has(&self, mut predicate: impl FnMut(u32) -> bool) -> bool { - let matching: Vec<bool> = match &self.palette { + let list = match &self.palette { Palette::Single(value) => return predicate(*value), - Palette::List(list) => list.iter().map(|&v| predicate(v)).collect(), - Palette::Global => Vec::new(), + Palette::List(list) => list, + Palette::Global => { + return (0..self.strategy.entries()).any(|i| predicate(self.raw(i) as u32)); + } }; - if matches!(self.palette, Palette::List(_)) { - if !matching.contains(&true) { - return false; - } - if !matching.contains(&false) { - return true; - } + let matching: Vec<bool> = list.iter().map(|&v| predicate(v)).collect(); + let count = matching.iter().filter(|&&m| m).count(); + if count == 0 || count == list.len() { + return count != 0; } - let bits = usize::from(self.bits); + let (bits, entries) = (usize::from(self.bits), self.strategy.entries()); let per = 64 / bits; - let m = mask(self.bits); - let mut left = self.strategy.entries(); - for &word in &self.words { - for slot in 0..per.min(left) { - let id = ((word >> (slot * bits)) & m) as usize; - let hit = match self.palette { - Palette::Global => predicate(id as u32), - _ => matching[id], - }; - if hit { - return true; - } - } - left = left.saturating_sub(per); + // The words whose fields all hold entries; the last may be partial. + let full = entries / per; + if count <= 4 { + // A field-wise zero test of each word XORed with the matching + // index in every field: `(v - lo) & !v & hi` is non-zero exactly + // when some field of `v` is zero. + let lo = (0..per).fold(0u64, |a, f| a | 1 << (f * bits)); + let hi = lo << (bits - 1); + let words = &self.words[..full]; + let found = matching + .iter() + .enumerate() + .filter(|(_, m)| **m) + .any(|(i, _)| { + let pattern = lo * i as u64; + words.iter().any(|&w| { + let v = w ^ pattern; + v.wrapping_sub(lo) & !v & hi != 0 + }) + }); + return found || (full * per..entries).any(|i| matching[self.raw(i)]); } - false + (0..entries).any(|i| matching[self.raw(i)]) } /// Heap bytes held by the palette and the storage. pub fn heap_bytes(&self) -> usize { @@ -816,6 +822,53 @@ mod tests { } } #[test] + fn has_matches_a_scan_at_every_width() { + let mut state = 0x9E37_79B9_7F4A_7C15u64; + for (strategy, distinct) in [ + (BLOCKS, 2u32), + (BLOCKS, 3), + (BLOCKS, 17), + (BLOCKS, 33), + (BLOCKS, 65), + (BLOCKS, 129), + (BIOMES, 2), + (BIOMES, 3), + (BIOMES, 5), + ] { + let entries = strategy.entries(); + let mut c = PalettedContainer::new(strategy, 0); + let mut plain = vec![0u32; entries]; + for i in 0..entries { + let v = (rng(&mut state) % u64::from(distinct)) as u32; + c.set(i, v); + plain[i] = v; + } + // Take some values away again (stale entries), the last index too. + for gone in [0, 1, distinct - 1] { + for i in 0..entries { + if plain[i] == gone { + c.set(i, distinct); + plain[i] = distinct; + } + } + for m in [3, 5, 7] { + let hit = |v: u32| v % m == gone % m; + assert_eq!(c.has(hit), plain.iter().any(|&v| hit(v))); + } + for wanted in 0..=distinct { + for other in [wanted, wanted + 1, wanted + 2, wanted + 3, wanted + 4] { + let hit = |v: u32| v == wanted || v == other; + assert_eq!( + c.has(hit), + plain.iter().any(|&v| hit(v)), + "{distinct} values, {wanted}/{other}, without {gone}" + ); + } + } + } + } + } + #[test] fn has_ignores_stale_palette_entries() { let mut c = PalettedContainer::new(BLOCKS, 0); assert!(c.has(|v| v == 0) && !c.has(|v| v == 3)); diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs index 1c338f2ed..e343e06a7 100644 --- a/crates/horizon-world/src/level/mod.rs +++ b/crates/horizon-world/src/level/mod.rs @@ -69,7 +69,7 @@ //! level.time += 1; //! behaviours.tick_scheduled(&mut level, &mut ticks); //! for chunk in ticking_chunks { -//! behaviours.tick_chunk_random(&mut level, &mut ticks, chunk, |level, min_y| level.randomly_ticking(chunk, min_y)); +//! behaviours.tick_chunk_random(&mut level, &mut ticks, chunk, |level, from| level.next_ticking_section(chunk, from)); //! } //! behaviours.run_block_events(&mut level, &mut ticks); //! /* tick entities */ diff --git a/crates/horizon-world/src/level/tick.rs b/crates/horizon-world/src/level/tick.rs index e9e4f6791..0f640ef3a 100644 --- a/crates/horizon-world/src/level/tick.rs +++ b/crates/horizon-world/src/level/tick.rs @@ -1617,16 +1617,17 @@ impl Behaviours { } /// Random-tick one chunk (`ServerLevel.tickChunk` block part). Visits the /// sections from the bottom up and draws `randomTickSpeed` positions in - /// each one `ticking(level, min_y)` reports randomly ticking - /// (`LevelChunkSection.isRandomlyTicking`: it holds a randomly ticking - /// block or fluid). Vanilla asks as it reaches each section, so the ticks - /// of the sections below count. + /// each randomly ticking one (`LevelChunkSection.isRandomlyTicking`: it + /// holds a randomly ticking block or fluid). `next_ticking(level, min_y)` + /// is the minimum Y of the lowest such section from `min_y` up, as the + /// chunk is now: vanilla asks as it reaches each section, so the ticks of + /// the sections below count. pub fn tick_chunk_random<L: LevelAccess + ?Sized>( &self, level: &mut L, ticks: &mut Ticks, chunk: ChunkPos, - mut ticking: impl FnMut(&mut L, i32) -> bool, + mut next_ticking: impl FnMut(&mut L, i32) -> Option<i32>, ) { let speed = level.game_rules().random_tick_speed; if speed <= 0 { @@ -1641,14 +1642,13 @@ impl Behaviours { } } } - for min_y in (level.min_y()..level.max_y()).step_by(16) { - if !ticking(level, min_y) { - continue; - } + let mut from = level.min_y(); + while let Some(min_y) = next_ticking(level, from).filter(|&y| y < level.max_y()) { for _ in 0..speed { let pos = ticks.block_random_pos(min_x, min_y, min_z, 15); self.sim(level, ticks).random_tick_at(pos); } + from = min_y + 16; } } /// Random-tick a single position (block then fluid), as `tickChunk` does. From bd36508c298cfee286986088a1b30ecdac68d34b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 12:34:20 +0200 Subject: [PATCH 11/62] lan_e2e levels: players in their own levels on the server thread; design note A new `levels` check (--server-thread) runs the host and a guest in different dimensions: execute in ... tp, mobs ticking in two levels at once with unique ids, rejoin and save/reload with the guest in the Nether, death there, the host through a Nether portal alone, the guest through an End portal and the exit portal alone. All of it already works on the server thread. docs/server-levels.md says how the server's levels map onto vanilla's, what the dedicated server and the server thread share, the cost of an extra level and what's left. docs/server.md no longer says players can't change dimension. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- docs/server-levels.md | 90 ++++++++++++++++++ docs/server.md | 2 +- tools/lan_e2e.py | 212 +++++++++++++++++++++++++++++++++++++++++- 3 files changed, 301 insertions(+), 3 deletions(-) create mode 100644 docs/server-levels.md diff --git a/docs/server-levels.md b/docs/server-levels.md new file mode 100644 index 000000000..0190c0c03 --- /dev/null +++ b/docs/server-levels.md @@ -0,0 +1,90 @@ +# A server's levels: one per dimension + +Vanilla's `MinecraftServer` holds a `ServerLevel` per dimension, and each player is in one of them. +Horizon's server does the same. That covers the dedicated server and single player's server thread +(`Game::serving`, the default since #1114). So a LAN world's host and each guest can be in different +dimensions at the same time. + +## How the single-level `Game` maps onto vanilla's levels + +The game's tick code reads one level: the one held in `Game`'s own fields (the world, its streaming +and save, block ticks, entities, block entities and their per-level queues). `game/levels.rs` keeps +the other dimensions' levels as `Parked` values and swaps one into place (`enter_level`). The swap is +`mem::swap` of each per-level field, so the tick code runs unchanged, one level at a time. + +| Vanilla | Horizon | +| --- | --- | +| `MinecraftServer.levels` | the level in place plus `Levels::parked` | +| `MinecraftServer.tickChildren`, every level | `tick_server`: each level with a player in it, in Overworld, Nether, End order. The first pass reads the network and runs the shared parts (clock, weather, functions, autosave). | +| `ServerLevel.players` | `Hub::here`: the guests whose `dimension` is the level in place | +| `ServerPlayer.teleport` into another level | `server_travel.rs`: a Respawn packet, then the teleport once the destination has loaded (portals and `execute in … tp`) | +| `PlayerList.respawn` | `guest_respawn`: back into the Overworld's level | +| `ServerLevel.noPlayersEmptyTime`, chunk unloading | `close_idle_levels`: a level other than the Overworld with nobody in it for 300 ticks is saved and closed | +| the levels' shared `LevelData` | not swapped: game time, day time, weather, game rules, scoreboard, maps, entity ids (`next_entity`, unique across levels) | + +The packets of a guest are read in its own level's pass (`Hub::tick_level`), so its actions and +commands run with its level in place. + +The window's own game (`--no-server-thread`, `HORIZON_SERVER_THREAD=0`, and the command harness) keeps +one level, which follows its player (`enter_dimension`). LAN guests of a world run that way stay in the +host's dimension. That mode is the escape hatch now, so it gets no multi-level work. + +## One code path for both + +The dedicated server and the server thread are the same code. The server thread runs a `Game` with +`options.dedicated` set and a hub without a host player. The window joins it through memory as one +more player. Everything above serves both, and `server_dimension_players` (vanilla clients on Horizon's +dedicated server) and `lan_e2e --server-thread` (Horizon clients on the server thread) check it from +the two sides. + +## Cost of an extra level + +Measured on the Mac mini (M4 Pro) at render distance 12, on 2026-10-22. The host and a guest each +played a fresh world on the server thread. RSS is the host's whole process, window included. Tick time +is `/tick query`'s average over 100 ticks. + +| Where the players are | Average tick | P95 | Host RSS | +| --- | --- | --- | --- | +| both in the Overworld | 1.0 ms | 1.3 ms | 1194 MB | +| guest in the Nether (two levels tick) | 2.2 ms | 2.9 ms | 1238 MB | +| guest in the End (the Nether still parked) | 0.9 ms | 1.1 ms | 1324 MB | +| both back, the Nether and End closed after 300 idle ticks | 0.8 ms | 0.9 ms | 1335 MB | + +- A level costs only while a player is in it: its chunks around that player, their entities, and the + tick. With nobody outside the Overworld, `tick_server` runs one pass, as before. +- A closed level's memory goes back to the allocator, not always to the system. +- Entering a level the first time opens its region files and streaming (`open_level`). That cost + comes once, before the player's chunks load. + +## Saving + +`save_game` saves the level in place, then every parked level (`save_parked_levels`). Each level has +its own region folder, as in vanilla (`DIM-1`, `DIM1`). A level closed for being idle is saved first. +Each player's saved data holds its dimension (`Dimension`). A guest who leaves in +the Nether, or whose host saves and quits, joins again in the Nether where it was. + +## What's checked + +`python3 tools/lan_e2e.py --server-thread --check portals --check levels`: + +- `portals`: the guest goes to the Nether through a portal while the host stays. The host then goes + to the End while the guest is in the Nether, so three levels run at once, and both come back. +- `levels`, with the host and the guest each in a level of its own: + - `execute in the_nether run tp` moves the guest alone. + - Mobs and armour stands fall in two levels at once, and every entity id is unique across the + levels. + - The guest leaves in the Nether and joins again there. + - The guest dies in the Nether and respawns in the Overworld. + - The host takes a Nether portal alone. + - The guest takes an End portal and then the exit portal alone. + - The host saves, quits and opens the world again with the guest in the Nether, and the guest + joins again there. + +## Not done yet + +- **End credits for server players.** The first exit from the End should show a player the credits + (`EndPortalBlock.entityInside`, `seenCredits`). The client's WinScreen is #338. +- **Entities through portals between levels.** Mobs, items and minecarts that enter a portal on a + server, and portal tickets (`TeleportTransition.PLACE_PORTAL_TICKET`), are not handled. +- **Unlimited selectors.** `@e` without a distance or volume reads only the source's level. Vanilla's + reads every level. diff --git a/docs/server.md b/docs/server.md index d7959aed0..6a73e768f 100644 --- a/docs/server.md +++ b/docs/server.md @@ -90,7 +90,7 @@ not tick cost, so it is in scope here (see section 9). |---|---| | `online-mode=true` | **Works** (ServerLoginPacketListenerImpl): a 1024-bit RSA key pair at start ("Generating keypair"), the encryption request, the shared secret and challenge, AES/CFB8, and the session service's `hasJoined` check (with the address when `prevent-proxy-connections` is on), with vanilla's log lines and messages. `test_online_mode_parity.py` runs the same logins against vanilla's server and Horizon's with a mock session service. | | Secure chat | **Works** (`SignedMessageChain`, `LastSeenMessagesValidator`, `MessageSignatureCache`): the chat session update and its profile key, checked against the services' `playerCertificateKeys`; signed chat, `say`, `me` and `msg`, relayed with their signatures and last-seen lists; `enforce-secure-profile` (with `online-mode`) refuses unsigned chat; and vanilla's log lines (`[Not Secure]`, the decoder's warnings, the kicks). Offline servers and players without a chat session chat unsigned, as on vanilla. `test_secure_chat_parity.py` runs the same signed and unsigned players against vanilla's server and Horizon's, with test keys and a mock services server. | -| Nether and End | **Players can't change dimension.** The engine keeps one dimension loaded (`Game::enter_dimension` moves only the local single-player player), and the hub serves one `dimension` to everyone. | +| Nether and End | **Works**: the server holds a level per dimension, and each player is in its own (portals, `execute in … tp`, respawn). `test_server_dimension_players_parity.py` checks it against vanilla. How it works, its cost and what's left: [server-levels.md](server-levels.md). | | Refused logins | Logged as vanilla does: `Disconnecting <name> (/address): <reason>`, then `<name> (/address) lost connection: <reason>`, and the session errors (`Username '<name>' tried to join with an invalid session`, `Couldn't verify username because servers are unavailable`). | | Gameplay for remote players | Checked against vanilla's server with a vanilla-codec client (#484, `tools/test_dedicated_server_parity.py`): a right click with an item on a block uses it once, a dead player's commands run, players on a team without friendly fire don't hurt each other, and a player's projectiles are theirs (their ender pearl takes them). The recipe book, status effects and block sync while digging (#500) work. Left: a player's projectiles don't hit other players (no bow PvP between guests), and a mob a guest kills counts in the host's statistics and advancements, not the guest's (`mob_died` runs as the host). | | Defaults that surprise owners | `white-list=true` is vanilla 26.3's default, so a fresh server refuses everyone until they are added. That matches vanilla, so the first-run flow (section 3) asks about the whitelist up front. | diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 9b883b163..304668322 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -67,6 +67,10 @@ address. The script then checks, from both sides, what a guest's game used to ge - portals: (--server-thread) the server holds a level per dimension: the guest goes to the Nether through a portal while the host stays, then the host goes to the End while the guest is in the Nether, and both come back. +- levels: (--server-thread) the host and the guest each in a level of their own: `execute in` builds + and teleports into another level, mobs fall in two levels at once with ids unique across + them, the guest rejoins in the Nether, dies there and respawns in the Overworld, the host + takes a Nether portal alone, the guest takes an End portal and the exit portal alone, and the host saves, quits and reopens with the guest in the Nether. - commands: the guest's chat completes commands and their arguments over the server's command tree (Tab), and runs what it completed; - recipes: the guest's recipe book lists the planks recipe the logs unlock, and clicking it @@ -155,7 +159,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'levels'] class Game: @@ -525,6 +529,209 @@ def portals(host, guest, out, x, y, z, hx, hy, hz): return {'guest_nether': arrived, 'host_end': [ex, ey, ez], 'back': pos_of(guest)} +NETHER, END, OVERWORLD = 'minecraft:the_nether', 'minecraft:the_end', 'minecraft:overworld' + + +def check_levels(host, guest, out): + """(--server-thread) Each player in its own level (MinecraftServer.levels), the host and the guest + apart: the steps run in order, each reported, and the check fails if any did.""" + if not SERVER_THREAD: + return 'skipped (needs --server-thread)' + start = {g.name: pos_of(g) for g in (host, guest)} + steps, failed = {}, [] + guest('command', command='gamemode creative') + try: + for name, step in LEVEL_STEPS: + try: + steps[name] = step(host, guest, out) + except (Failed, AssertionError, StopIteration, KeyError) as e: + steps[name], failed = repr(e), failed + [name] + for g in (host, guest): + back_to_game(g) + print(f'[lan] levels {name}: {"FAIL" if name in failed else "PASS"} {steps[name]}') + finally: + for g in (host, guest): + back_to_game(g) + if g('state').get('screen') == 'dead': + g.raw('respawn') + g.wait(20) + x, y, z = start[g.name] + g('command', command=f'execute in {OVERWORLD} run tp @s {x:.2f} {y:.2f} {z:.2f}') + guest('command', command='gamemode survival') + guest.wait(40) + assert not failed, f'failed: {failed}; {steps}' + return steps + + +def level_floor(game, x, y, z): + """An obsidian floor under x y z with air above it, in the level `game` is in (fill needs the + chunks loaded: ServerLevel.hasChunksAt).""" + game('command', command=f'fill {x - 4} {y - 1} {z - 4} {x + 4} {y - 1} {z + 4} minecraft:obsidian') + game('command', command=f'fill {x - 4} {y} {z - 4} {x + 4} {y + 4} {z + 4} minecraft:air') + + +def into_level(game, dimension, x, y, z): + """`execute in DIMENSION run tp` to x y z, onto a floor built once the level has loaded around it.""" + game('command', command=f'execute in {dimension} run tp @s {x + 0.5} {y} {z + 0.5}') + state = wait_dimension(game, dimension, 400) + game.wait(20) + level_floor(game, x, y, z) + game('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + game.wait(20) + return state + + +def dims(host, guest): + return host('state').get('dimension'), guest('state').get('dimension') + + +def level_execute(host, guest, out): + """`execute in the_nether run tp` takes the guest alone.""" + x, z = (int(v // 1) for v in pos_of(guest)[::2]) + there = into_level(guest, NETHER, x, 100, z) + below = guest.raw('block', x, 99, z) + assert dims(host, guest) == (OVERWORLD, NETHER), f'host, guest in {dims(host, guest)}' + assert there.get('dimension') == NETHER and below.get('block') == 'minecraft:obsidian', f'{there} on {below}' + return {'guest': pos_of(guest)} + + +def level_ticking(host, guest, out): + """Mobs and objects fall in both levels at once (each level with a player ticks); every entity + has its own id across the levels.""" + gx, gy, gz = pos_of(guest) + hx, hy, hz = pos_of(host) + # A floor of its own beside the host (earlier checks may have broken the open one there). + bx, by, bz = int(hx // 1), int(hy // 1), int(hz // 1) + host('command', command=f'fill {bx - 4} {by - 1} {bz - 4} {bx + 4} {by - 1} {bz - 2} minecraft:stone') + host('command', command=f'fill {bx - 4} {by} {bz - 4} {bx + 4} {by + 4} {bz - 2} minecraft:air') + guest('command', command=f'summon minecraft:pig {gx + 2.5:.2f} {gy + 3:.2f} {gz:.2f}') + guest('command', command=f'summon minecraft:armor_stand {gx - 2.5:.2f} {gy + 3:.2f} {gz:.2f}') + host('command', command=f'summon minecraft:pig {hx + 2.5:.2f} {hy + 3:.2f} {hz - 3:.2f}') + host('command', command=f'summon minecraft:armor_stand {hx - 2.5:.2f} {hy + 3:.2f} {hz - 3:.2f}') + try: + guest.wait(60) + seen = {} + for name, g, floor in (('guest', guest, gy), ('host', host, hy)): + mobs = [m for m in g.raw('mobs', 8)['near'] if m['kind'] == 'minecraft:pig'] + stands = [o for o in g('status')['objects'] if o['kind'] == 'minecraft:armor_stand'] + seen[name] = {'pigs': [(m['id'], round(m['pos'][1], 2)) for m in mobs], + 'stands': [(o['id'], round(o['position'][1], 2)) for o in stands], 'floor': floor} + finally: + guest('command', command='kill @e[type=!minecraft:player,distance=..8]') + host('command', command='kill @e[type=!minecraft:player,distance=..8]') + for name, s in seen.items(): + heights = [y for _, y in s['pigs'] + s['stands']] + assert len(s['pigs']) == 1 and len(s['stands']) == 1, f'{name} sees {s}' + assert all(abs(y - s['floor']) < 0.1 for y in heights), f"{name}'s did not fall to the floor: {seen}" + ids = [i for s in seen.values() for i, _ in s['pigs'] + s['stands']] + assert len(set(ids)) == len(ids), f'ids shared across the levels: {seen}' + return seen + + +def level_rejoin(host, guest, out): + """The guest leaves in the Nether and joins again there (its player data keeps its level).""" + before = pos_of(guest) + port = host.raw('lan', 'status')['port'] + guest.raw('disconnect') + time.sleep(2) + guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME) + guest.raw('wait-for', 'loaded', '--timeout', 300) + guest.wait(20) + after = pos_of(guest) + assert dims(host, guest) == (OVERWORLD, NETHER), f'host, guest in {dims(host, guest)}' + assert all(abs(a - b) < 1 for a, b in zip(before, after)), f'left at {before}, back at {after}' + return {'at': after} + + +def level_death(host, guest, out): + """The guest dies in the Nether and respawns in the Overworld; the host stays where it is.""" + guest('command', command='kill @s') + guest.wait(20) + guest.raw('respawn') + back = wait_dimension(guest, OVERWORLD, 400) + guest.wait(20) + assert back.get('dimension') == OVERWORLD, f'the guest respawned in {back.get("dimension")}' + assert dims(host, guest) == (OVERWORLD, OVERWORLD), f'host, guest in {dims(host, guest)}' + return {'respawned': back['player']['position']} + + +def level_host_nether(host, guest, out): + """The host goes through a Nether portal while the guest stays in the Overworld.""" + hx, hy, hz = (int(v // 1) for v in pos_of(host)) + nether_portal(host, hx, hy, hz - 3) + try: + host('command', command=f'tp @s {hx + 0.5} {hy} {hz - 2.5}') + there = wait_dimension(host, NETHER, 600) + host.wait(20) + result = dims(host, guest) + assert there.get('dimension') == NETHER, f'the host is in {there.get("dimension")}' + assert result == (NETHER, OVERWORLD), f'host, guest in {result}' + return {'host': there['player']['position']} + finally: + host('command', command=f'execute in {OVERWORLD} run fill {hx - 1} {hy} {hz - 3} {hx + 2} {hy + 3} {hz - 3} ' + 'minecraft:air') + host('command', command=f'execute in {OVERWORLD} run tp @s {hx + 0.5} {hy} {hz + 0.5}') + wait_dimension(host, OVERWORLD, 400) + + +def level_guest_end(host, guest, out): + """The guest steps into an End portal alone and lands on the obsidian platform; an exit portal + takes it back to the Overworld.""" + x, y, z = (int(v // 1) for v in pos_of(guest)) + guest('command', command=f'setblock {x + 2} {y} {z} minecraft:end_portal') + try: + guest('command', command=f'tp @s {x + 2.5} {y} {z + 0.5}') + wait_dimension(guest, END, 600) + # The arrival waits for the platform's chunks; its portal cooldown (10 ticks) runs out after, + # and a player who stands in a portal while it runs stays (Entity.setAsInsidePortal). + guest.wait(60) + landed = pos_of(guest) + assert dims(host, guest) == (OVERWORLD, END), f'host, guest in {dims(host, guest)}' + assert [int(v // 1) for v in landed] == [100, 49, 0], f'the guest landed at {landed}' + finally: + guest('command', command=f'execute in {OVERWORLD} run setblock {x + 2} {y} {z} minecraft:air') + ex, ey, ez = (int(v // 1) for v in landed) + guest('command', command=f'setblock {ex + 2} {ey} {ez} minecraft:end_portal') + guest('command', command=f'tp @s {ex + 2.5} {ey} {ez + 0.5}') + home = wait_dimension(guest, OVERWORLD, 600) + guest.wait(20) + assert dims(host, guest) == (OVERWORLD, OVERWORLD), f'host, guest in {dims(host, guest)}' + return {'landed': landed, 'home': home['player']['position']} + + +def level_reload(host, guest, out): + """The host saves and quits with the guest in the Nether, opens the world again and opens it to the + LAN; the guest joins again where it was, in the Nether.""" + x, z = (int(v // 1) for v in pos_of(guest)[::2]) + into_level(guest, NETHER, x, 100, z) + before = pos_of(guest) + host.raw('disconnect') + # The world saves on its server thread before the title screen shows. + for attempt in range(60): + time.sleep(1) + try: + host.raw('open', 'Lan') + break + except Failed: + if attempt == 59: + raise + host('wait_ready', seconds=400) + port = host.raw('lan', 'open', 0, 'commands')['port'] + back_to_game(guest) + guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME) + guest.raw('wait-for', 'loaded', '--timeout', 300) + guest.wait(20) + after = pos_of(guest) + assert dims(host, guest) == (OVERWORLD, NETHER), f'host, guest in {dims(host, guest)}' + assert all(abs(a - b) < 1 for a, b in zip(before, after)), f'left at {before}, back at {after}' + return {'at': after} + + +LEVEL_STEPS = [('execute', level_execute), ('ticking', level_ticking), ('rejoin', level_rejoin), + ('death', level_death), ('host_nether', level_host_nether), + ('guest_end', level_guest_end), ('reload', level_reload)] + + def check_damage(host, guest, out): guest('command', command='gamemode survival') guest.wait(10) @@ -2591,7 +2798,8 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name 'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast, 'light': check_light, 'plates': check_plates, 'swings': check_swings, 'cracks': check_cracks, - 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict} + 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, + 'levels': check_levels} def run(ctl, out, resources, checks): From 84171cfc94c048807520c426cf9a4af05aaf289f Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:19:17 +0200 Subject: [PATCH 12/62] lan_e2e portals: wait for the guest to be placed in its Nether portal On a server the guest is held where it entered the Nether until the chunks around the destination are lit, then placed in its portal. The check read the guest's position 40 ticks after the dimension changed, which on a busy machine was still the held spot, and then stepped the guest out of a portal that wasn't there. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- tools/lan_e2e.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 304668322..e781cdea6 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -496,12 +496,17 @@ def portals(host, guest, out, x, y, z, hx, hy, hz): guest('command', command=f'tp @s {x + 0.5} {y} {z + 3.5}') # players_nether_portal_default_delay: 80 ticks in survival. there = wait_dimension(guest, 'minecraft:the_nether', 600) - guest.wait(40) + # On a server the guest is held where it entered until the chunks around the destination are + # lit, then placed in its portal: wait for that before reading where it arrived. + for _ in range(30): + guest.wait(20) + arrived = [int(v // 1) for v in pos_of(guest)] + if guest.raw('block', *arrived).get('block') == 'minecraft:nether_portal': + break guest.shot(out, 'portals-nether') host_dim = host('state').get('dimension') assert there.get('dimension') == 'minecraft:the_nether', f'the guest is in {there.get("dimension")}' assert host_dim == 'minecraft:overworld', f'the host went to {host_dim} with the guest' - arrived = [int(v // 1) for v in pos_of(guest)] below = guest.raw('block', arrived[0], arrived[1] - 1, arrived[2]) assert below.get('loaded') and below.get('block') != 'minecraft:air', f'under the guest in the Nether: {below}' # The host takes an End portal while the guest is in the Nether: three levels at once. From 9fe228cd1e2753e252f40a2f49150779316423cf Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 12:51:16 +0200 Subject: [PATCH 13/62] Server commands run in their source's level (execute in, execute at) On a server (dedicated, or single player's server thread) each dimension is its own level, but a command ran in whichever level was in place. So a guest in the Nether running `execute in minecraft:overworld run setblock ...` got "That position is not loaded", and `execute at <a player in another level>` used the wrong level's blocks. with_source now puts the source's level in place for the command (CommandSourceStack.getLevel), as as_target already does for a player in another level, and puts the old one back after. `execute at` takes the entity's level (withLevel(entity.level())), and a player's level is the guest's own (target_level) even while another level is in place. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game/commands.rs | 32 +++++++++++-------- .../src/game/commands/execute.rs | 14 ++++++-- crates/horizon-client/src/game/levels.rs | 18 +++++++++++ docs/server-levels.md | 4 ++- tools/lan_e2e.py | 29 ++++++++++++++--- 5 files changed, 74 insertions(+), 23 deletions(-) diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index f174f98c1..570a64c09 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -294,6 +294,18 @@ impl Game<'_> { } // ---- entities ------------------------------------------------------- + /// The level `t` is in (`Entity.level`): a server's players have their + /// own, which need not be the one in place; everything else is in the + /// level in place. + pub(super) fn target_level(&self, t: Target) -> Dim { + let conn = match t { + Target::Player => self.lan_acting, + Target::Guest(conn) => Some(conn), + _ => None, + }; + conn.and_then(|c| self.command_guest(c)) + .map_or(self.dim, |g| Dim::from_id(&g.dimension)) + } pub(super) fn target_position(&self, t: Target) -> Option<[f64; 3]> { match t { Target::Player => self @@ -1191,15 +1203,12 @@ impl Game<'_> { pos: [f64; 3], rotation: Option<[f32; 2]>, ) -> bool { - let (conn, at) = match t { - Target::Player => (self.lan_acting, self.dim), - Target::Guest(conn) => ( - Some(conn), - self.command_guest(conn) - .map_or(self.dim, |g| super::Dim::from_id(&g.dimension)), - ), - _ => (None, self.dim), + let conn = match t { + Target::Player => self.lan_acting, + Target::Guest(conn) => Some(conn), + _ => None, }; + let at = self.target_level(t); let Some(conn) = conn.filter(|_| at != level && self.options.dedicated.is_some()) else { return false; }; @@ -1222,12 +1231,7 @@ impl Game<'_> { let dest = self.entities(ctx, "destination", false)?[0]; let pos = self.target_position(dest).unwrap_or(self.source_position()); // Into the destination's level. - let level = match dest { - Target::Guest(conn) => self - .command_guest(conn) - .map_or(self.dim, |g| super::Dim::from_id(&g.dimension)), - _ => self.dim, - }; + let level = self.target_level(dest); // TeleportCommand.teleportToEntity: the destination's rotation too. let rotation = Some(self.target_rotation(dest)); for &t in &targets { diff --git a/crates/horizon-client/src/game/commands/execute.rs b/crates/horizon-client/src/game/commands/execute.rs index 221ebb238..463cd542e 100644 --- a/crates/horizon-client/src/game/commands/execute.rs +++ b/crates/horizon-client/src/game/commands/execute.rs @@ -155,14 +155,20 @@ impl Game<'_> { _ => s.pos, } } - /// Evaluate `f` with `source` as the command source. + /// Evaluate `f` with `source` as the command source, in the source's + /// level (`CommandSourceStack.getLevel`): a server puts that level in + /// place for it. pub(in crate::game) fn with_source<T>( &mut self, source: Source, f: impl FnOnce(&mut Self) -> T, ) -> T { let previous = self.command_source.replace(source); + let back = self.enter_command_level(source.dimension); let out = f(self); + if let Some(back) = back { + self.enter_command_level(back); + } self.command_source = previous; out } @@ -447,11 +453,13 @@ impl Game<'_> { "at" => targets(self)? .into_iter() .filter_map(|t| { + // CommandSourceStack.withLevel(entity.level()). + let level = self.target_level(t); Some(Source { pos: self.target_position(t)?, rot: self.target_rotation(t), - dimension: self.dim, - level: None, + dimension: level, + level: (level != self.dim).then_some(level), ..s }) }) diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs index 7df5541b4..3b73a2e20 100644 --- a/crates/horizon-client/src/game/levels.rs +++ b/crates/horizon-client/src/game/levels.rs @@ -253,6 +253,24 @@ impl Game<'_> { Ok(()) } + /// Put `dim`'s level in place for a command whose source is there + /// (`execute in`, `execute at` a player in another level), opening it if + /// nobody is in it; returns the level to put back afterwards. Only a + /// server holds other levels. + pub(super) fn enter_command_level(&mut self, dim: Dim) -> Option<Dim> { + if self.options.dedicated.is_none() || dim == self.dim { + return None; + } + let back = self.dim; + match self.enter_level(None, dim) { + Ok(()) => Some(back), + Err(e) => { + log::error!("could not open {}: {e}", dim.id()); + None + } + } + } + /// One server tick (`MinecraftServer.tickServer`): each level with /// players in turn (`tickChildren`), its chunks streamed and loaded and /// its world ticked. The first pass reads the network and runs the diff --git a/docs/server-levels.md b/docs/server-levels.md index 0190c0c03..45fbf03e3 100644 --- a/docs/server-levels.md +++ b/docs/server-levels.md @@ -20,6 +20,7 @@ the other dimensions' levels as `Parked` values and swaps one into place (`enter | `ServerPlayer.teleport` into another level | `server_travel.rs`: a Respawn packet, then the teleport once the destination has loaded (portals and `execute in … tp`) | | `PlayerList.respawn` | `guest_respawn`: back into the Overworld's level | | `ServerLevel.noPlayersEmptyTime`, chunk unloading | `close_idle_levels`: a level other than the Overworld with nobody in it for 300 ticks is saved and closed | +| `CommandSourceStack.getLevel` | `with_source` puts the source's level in place for a command (`execute in`, `execute at` a player in another level) | | the levels' shared `LevelData` | not swapped: game time, day time, weather, game rules, scoreboard, maps, entity ids (`next_entity`, unique across levels) | The packets of a guest are read in its own level's pass (`Hub::tick_level`), so its actions and @@ -70,7 +71,8 @@ the Nether, or whose host saves and quits, joins again in the Nether where it wa - `portals`: the guest goes to the Nether through a portal while the host stays. The host then goes to the End while the guest is in the Nether, so three levels run at once, and both come back. - `levels`, with the host and the guest each in a level of its own: - - `execute in the_nether run tp` moves the guest alone. + - `execute in the_nether run tp` moves the guest alone. From the Nether, `execute in overworld` and + `execute at` the host change and test blocks in the host's level. - Mobs and armour stands fall in two levels at once, and every entity id is unique across the levels. - The guest leaves in the Nether and joins again there. diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index e781cdea6..66297b909 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -67,10 +67,12 @@ address. The script then checks, from both sides, what a guest's game used to ge - portals: (--server-thread) the server holds a level per dimension: the guest goes to the Nether through a portal while the host stays, then the host goes to the End while the guest is in the Nether, and both come back. -- levels: (--server-thread) the host and the guest each in a level of their own: `execute in` builds - and teleports into another level, mobs fall in two levels at once with ids unique across - them, the guest rejoins in the Nether, dies there and respawns in the Overworld, the host - takes a Nether portal alone, the guest takes an End portal and the exit portal alone, and the host saves, quits and reopens with the guest in the Nether. +- levels: (--server-thread) the host and the guest each in a level of their own: `execute in` + teleports into another level, and `execute in` and `at` change and test blocks there; + mobs fall in two levels at once, with ids unique across them; the guest rejoins in the + Nether, dies there and respawns in the Overworld; the host takes a Nether portal alone; + the guest takes an End portal and the exit portal alone; and the host saves, quits and + reopens with the guest in the Nether. - commands: the guest's chat completes commands and their arguments over the server's command tree (Tab), and runs what it completed; - recipes: the guest's recipe book lists the planks recipe the logs unlock, and clicking it @@ -591,12 +593,29 @@ def dims(host, guest): def level_execute(host, guest, out): - """`execute in the_nether run tp` takes the guest alone.""" + """`execute in the_nether run tp` takes the guest alone. From the Nether, the guest's commands + reach the host's level (CommandSourceStack.getLevel): `execute in overworld` and `execute at` + the host put a block beside the host, and `execute if block` reads it.""" x, z = (int(v // 1) for v in pos_of(guest)[::2]) + hx, hy, hz = (int(v // 1) for v in pos_of(host)) there = into_level(guest, NETHER, x, 100, z) below = guest.raw('block', x, 99, z) + gold = f'{hx} {hy} {hz + 2} minecraft:gold_block' + try: + guest('command', command=f'execute in {OVERWORLD} run setblock {gold}') + guest('command', command=f'execute at {host.player} run setblock ~ ~ ~-2 minecraft:diamond_block') + guest('command', command=f'execute in {OVERWORLD} if block {gold} in {NETHER} ' + f'run setblock {x} 99 {z} minecraft:gold_block') + host.wait(10) + placed = [host.raw('block', hx, hy, hz + 2), host.raw('block', hx, hy, hz - 2)] + found = guest.raw('block', x, 99, z) + finally: + host('command', command=f'fill {hx} {hy} {hz - 2} {hx} {hy} {hz + 2} minecraft:air') assert dims(host, guest) == (OVERWORLD, NETHER), f'host, guest in {dims(host, guest)}' assert there.get('dimension') == NETHER and below.get('block') == 'minecraft:obsidian', f'{there} on {below}' + assert [p.get('block') for p in placed] == ['minecraft:gold_block', 'minecraft:diamond_block'], \ + f'beside the host: {placed}' + assert found.get('block') == 'minecraft:gold_block', f'execute in overworld if block: {found}' return {'guest': pos_of(guest)} From 86fdc720696f99f591b8f1519aedbab56340577d Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 12:51:16 +0200 Subject: [PATCH 14/62] Server players go through End gateways handle_server_portal ignored End gateways, so on a server (dedicated, or single player's server thread) no player could use one: the in-frame game's gateway code moved only its own player. A gateway that is not cooling down now takes a server player at once (EndGatewayBlock.entityInside, triggerCooldown, setAsInsidePortal), within the End, keeping its motion and look (Relative.DELTA and ROTATION). An exact exit is reached straight away; otherwise the player waits at the destination while it loads, and the exit is found or built there (the in-frame resolve_gateway, shared through gateway_job). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game/end.rs | 26 ++++++--- .../horizon-client/src/game/server_travel.rs | 57 ++++++++++++++++++- crates/horizon-client/src/lan/hub.rs | 21 ++++++- docs/server-levels.md | 4 +- tools/lan_e2e.py | 31 ++++++++-- 5 files changed, 117 insertions(+), 22 deletions(-) diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs index a7813c767..08eb8ad33 100644 --- a/crates/horizon-client/src/game/end.rs +++ b/crates/horizon-client/src/game/end.rs @@ -23,7 +23,7 @@ const GATEWAY_FILE: &str = "horizon-end-gateways.json"; /// A gateway teleport waiting for its destination chunks. #[derive(Clone, Copy, Debug)] -enum GatewayJob { +pub(super) enum GatewayJob { /// TheEndGatewayBlockEntity.findOrCreateValidTeleportPos from this gateway. Find { gateway: [i32; 3] }, /// A known exit (exact, or findExitPosition around it). @@ -735,6 +735,20 @@ impl Game<'_> { fn enter_gateway(&mut self, gateway: [i32; 3]) -> Result<()> { // TheEndGatewayBlockEntity.triggerCooldown: 40 ticks. self.end.gateway_cooldown = 40; + let (job, destination) = self.gateway_job(gateway); + let Some(player) = self.player.take() else { + return Ok(()); + }; + self.end.job = Some(job); + self.end_travel = true; + self.travelling = Some((player, destination)); + Ok(()) + } + + /// Where `gateway` leads (TheEndGatewayBlockEntity.getPortalPosition): + /// its exit, or the search for one, and the spot to load before either + /// is resolved ([`Game::resolve_gateway`]). + pub(super) fn gateway_job(&mut self, gateway: [i32; 3]) -> (GatewayJob, Vec3) { let known = self.gateway_exits().get(&gateway).copied(); let job = match known { Some((exit, exact)) => GatewayJob::Known { exit, exact }, @@ -760,13 +774,7 @@ impl Game<'_> { Vec3::new(d.x, 75.0, d.y) } }; - let Some(player) = self.player.take() else { - return Ok(()); - }; - self.end.job = Some(job); - self.end_travel = true; - self.travelling = Some((player, destination)); - Ok(()) + (job, destination) } fn chunk_empty(&self, x: f64, z: f64) -> Option<bool> { @@ -803,7 +811,7 @@ impl Game<'_> { /// The teleport position of a gateway job, creating the exit gateway (and /// an island when the chunk has no landing spot) for new destinations. - fn resolve_gateway(&mut self, job: GatewayJob, target: Vec3) -> Result<Vec3> { + pub(super) fn resolve_gateway(&mut self, job: GatewayJob, target: Vec3) -> Result<Vec3> { let bottom_center = |p: [i32; 3]| { Vec3::new( f64::from(p[0]) + 0.5, diff --git a/crates/horizon-client/src/game/server_travel.rs b/crates/horizon-client/src/game/server_travel.rs index 1d857c1fe..b7462baa8 100644 --- a/crates/horizon-client/src/game/server_travel.rs +++ b/crates/horizon-client/src/game/server_travel.rs @@ -7,6 +7,7 @@ //! another level: a Respawn packet keeping all data, then a teleport to the //! exit once the destination has loaded around them. +use super::end::GatewayJob; use super::nether_portal::{PLAYER_DELAY, Plan}; use super::{Dim, Game, lan::LanHost}; use horizon_client::lan::hub::TickCtx; @@ -22,6 +23,9 @@ pub(super) struct Trip { end: bool, /// The Nether portal plan, whose exit is found or built on arrival. plan: Option<Plan>, + /// Through an End gateway, within the level: its exit, found or built + /// on arrival. + gateway: Option<GatewayJob>, /// Sent by a command: the player is already where it goes. placed: bool, } @@ -95,7 +99,7 @@ impl Game<'_> { if let Some(pos) = self.nether_portal_inside(at) { self.portals.player.set_inside(pos, PLAYER_DELAY); } - let (end_portal, _) = self.inside_end_portals(at, WIDTH, HEIGHT); + let (end_portal, gateway) = self.inside_end_portals(at, WIDTH, HEIGHT); if end_portal { if self.portals.player.cooldown == 0 { let target = if self.dim == Dim::End { @@ -109,6 +113,19 @@ impl Game<'_> { self.portals.player.cooldown = 10; return; } + // EndGatewayBlock.entityInside: a gateway that is not cooling down + // takes the player at once (no transition time) and cools down + // (triggerCooldown), even for a player still on its own cooldown. + if let Some(g) = gateway + && self.gateway_enter(g) + { + if self.portals.player.cooldown == 0 { + self.start_gateway_trip(host, conn, g); + } + // setPortalCooldown: after the trip, or again while cooling down. + self.portals.player.cooldown = 10; + return; + } let rule = if invulnerable { "players_nether_portal_creative_delay" } else { @@ -197,6 +214,7 @@ impl Game<'_> { target: destination, end, plan, + gateway: None, placed: false, }); if let Err(e) = self.enter_level(Some(host), source) { @@ -204,6 +222,32 @@ impl Game<'_> { } } + /// `TheEndGatewayBlockEntity.getPortalPosition` and the teleport within + /// the End (keeping the player's motion and look): straight to an exact + /// exit, else once the destination has loaded around the player, who + /// waits there (its exit is found among those blocks, or built). + fn start_gateway_trip(&mut self, host: &mut LanHost, conn: u32, gateway: [i32; 3]) { + let Some(i) = host.hub.guests.iter().position(|g| g.conn == conn) else { + return; + }; + let (job, destination) = self.gateway_job(gateway); + let at = [destination.x, destination.y, destination.z]; + // Relative.union(DELTA, ROTATION). + host.hub.teleport_keeping_motion(i, at); + if let GatewayJob::Known { exact: true, .. } = job { + return; + } + self.server_trips.push(Trip { + conn, + dim: self.dim, + target: destination, + end: false, + plan: None, + gateway: Some(job), + placed: false, + }); + } + /// The trips into the level in place whose destination has loaded /// around their target: the exit (the Nether portal found or built, the /// End platform, the Overworld's spawn column) and the teleport there. @@ -232,7 +276,15 @@ impl Game<'_> { } self.resolve_arrivals(); let yaw = host.hub.guests[i].yaw; - let (position, yaw) = if trip.end { + let (position, yaw) = if let Some(job) = trip.gateway { + match self.resolve_gateway(job, trip.target) { + Ok(at) => (at, yaw), + Err(e) => { + log::error!("End gateway exit: {e}"); + (trip.target, yaw) + } + } + } else if trip.end { match self.end_arrival(trip.target) { Ok((at, turned)) => (at, turned.unwrap_or(yaw)), Err(e) => { @@ -293,6 +345,7 @@ impl Game<'_> { target: Vec3::new(t.at[0], t.at[1], t.at[2]), end: false, plan: None, + gateway: None, placed: true, }); if let Err(e) = self.enter_level(Some(host), source) { diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index af0c1ac83..5be044e5d 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -818,6 +818,20 @@ impl Hub { /// ServerGamePacketListenerImpl.teleport: move the client and wait for its confirmation. pub fn teleport(&mut self, i: usize, position: Option<[f64; 3]>) { + self.teleport_relative(i, position, 0); + } + + /// A teleport to `position` that keeps the player's motion and look + /// (`Relative.DELTA` and `Relative.ROTATION`: an End gateway's). + pub fn teleport_keeping_motion(&mut self, i: usize, position: [f64; 3]) { + use play::relative::{DELTA_X, DELTA_Y, DELTA_Z, ROTATE_DELTA, X_ROT, Y_ROT}; + let relatives = Y_ROT | X_ROT | DELTA_X | DELTA_Y | DELTA_Z | ROTATE_DELTA; + self.teleport_relative(i, Some(position), relatives); + } + + /// ServerGamePacketListenerImpl.teleport with `relatives`: the rotation + /// and motion they name are sent as zero changes. + fn teleport_relative(&mut self, i: usize, position: Option<[f64; 3]>, relatives: i32) { let ticks = self.ticks; let g = &mut self.guests[i]; g.teleport_tick = ticks; @@ -828,13 +842,14 @@ impl Hub { g.teleport_counter = (g.teleport_counter + 1) & 0x7FFF_FFFF; let id = g.teleport_counter; g.awaiting_teleport = Some((id, g.position)); + let turn = relatives & (play::relative::Y_ROT | play::relative::X_ROT) != 0; g.send(&C::PlayerPosition(play::PlayerPosition { teleport: id, position: g.position, delta: [0.0; 3], - yaw: g.yaw, - pitch: g.pitch, - relatives: 0, + yaw: if turn { 0.0 } else { g.yaw }, + pitch: if turn { 0.0 } else { g.pitch }, + relatives, })); } diff --git a/docs/server-levels.md b/docs/server-levels.md index 45fbf03e3..eee730f89 100644 --- a/docs/server-levels.md +++ b/docs/server-levels.md @@ -17,7 +17,7 @@ the other dimensions' levels as `Parked` values and swaps one into place (`enter | `MinecraftServer.levels` | the level in place plus `Levels::parked` | | `MinecraftServer.tickChildren`, every level | `tick_server`: each level with a player in it, in Overworld, Nether, End order. The first pass reads the network and runs the shared parts (clock, weather, functions, autosave). | | `ServerLevel.players` | `Hub::here`: the guests whose `dimension` is the level in place | -| `ServerPlayer.teleport` into another level | `server_travel.rs`: a Respawn packet, then the teleport once the destination has loaded (portals and `execute in … tp`) | +| `ServerPlayer.teleport` into another level | `server_travel.rs`: a Respawn packet, then the teleport once the destination has loaded (portals and `execute in … tp`). An End gateway teleports within the End. | | `PlayerList.respawn` | `guest_respawn`: back into the Overworld's level | | `ServerLevel.noPlayersEmptyTime`, chunk unloading | `close_idle_levels`: a level other than the Overworld with nobody in it for 300 ticks is saved and closed | | `CommandSourceStack.getLevel` | `with_source` puts the source's level in place for a command (`execute in`, `execute at` a player in another level) | @@ -78,7 +78,7 @@ the Nether, or whose host saves and quits, joins again in the Nether where it wa - The guest leaves in the Nether and joins again there. - The guest dies in the Nether and respawns in the Overworld. - The host takes a Nether portal alone. - - The guest takes an End portal and then the exit portal alone. + - The guest takes an End portal, an End gateway and then the exit portal alone. - The host saves, quits and opens the world again with the guest in the Nether, and the guest joins again there. diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 66297b909..ddbec78af 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -71,8 +71,8 @@ address. The script then checks, from both sides, what a guest's game used to ge teleports into another level, and `execute in` and `at` change and test blocks there; mobs fall in two levels at once, with ids unique across them; the guest rejoins in the Nether, dies there and respawns in the Overworld; the host takes a Nether portal alone; - the guest takes an End portal and the exit portal alone; and the host saves, quits and - reopens with the guest in the Nether. + the guest takes an End portal, an End gateway and the exit portal alone; and the host + saves, quits and reopens with the guest in the Nether. - commands: the guest's chat completes commands and their arguments over the server's command tree (Tab), and runs what it completed; - recipes: the guest's recipe book lists the planks recipe the logs unlock, and clicking it @@ -699,8 +699,8 @@ def level_host_nether(host, guest, out): def level_guest_end(host, guest, out): - """The guest steps into an End portal alone and lands on the obsidian platform; an exit portal - takes it back to the Overworld.""" + """The guest steps into an End portal alone and lands on the obsidian platform, an End gateway + takes it across the End, and an exit portal takes it back to the Overworld.""" x, y, z = (int(v // 1) for v in pos_of(guest)) guest('command', command=f'setblock {x + 2} {y} {z} minecraft:end_portal') try: @@ -714,13 +714,32 @@ def level_guest_end(host, guest, out): assert [int(v // 1) for v in landed] == [100, 49, 0], f'the guest landed at {landed}' finally: guest('command', command=f'execute in {OVERWORLD} run setblock {x + 2} {y} {z} minecraft:air') - ex, ey, ez = (int(v // 1) for v in landed) + # A gateway far out with an exact exit at the End spawn, as end_gateway_return's + # (TheEndGatewayBlockEntity.getPortalPosition), takes the guest back there within the End. + guest('command', command='tp @s 700.5 80 0.5') + guest.wait(60) + level_floor(guest, 700, 80, 0) + guest('command', command='tp @s 700.5 80 0.5') + guest.wait(20) + guest('command', command='setblock 702 80 0 minecraft:end_gateway{exit_portal:[I;100,50,0],exact_teleport:1b}') + guest('command', command='tp @s 702.5 80 0.5') + gateway = None + for _ in range(20): + guest.wait(10) + gateway = pos_of(guest) + if abs(gateway[0] - 702.5) > 50: + break + assert dims(host, guest) == (OVERWORLD, END), f'host, guest in {dims(host, guest)}' + assert abs(gateway[0] - 100.5) < 1 and abs(gateway[2] - 0.5) < 1 and 49 <= gateway[1] <= 50, \ + f'the gateway left the guest at {gateway}' + guest.wait(40) + ex, ey, ez = (int(v // 1) for v in pos_of(guest)) guest('command', command=f'setblock {ex + 2} {ey} {ez} minecraft:end_portal') guest('command', command=f'tp @s {ex + 2.5} {ey} {ez + 0.5}') home = wait_dimension(guest, OVERWORLD, 600) guest.wait(20) assert dims(host, guest) == (OVERWORLD, OVERWORLD), f'host, guest in {dims(host, guest)}' - return {'landed': landed, 'home': home['player']['position']} + return {'landed': landed, 'gateway': gateway, 'home': home['player']['position']} def level_reload(host, guest, out): From 2ced9a451dcb900d73719308e86d740fd923306f Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 12:51:16 +0200 Subject: [PATCH 15/62] Server players respawn at their point in the Nether (anchors, spawnpoint) A server's player (a LAN guest, and since the server thread the single player too) always respawned in the Overworld. Its respawn anchor was dropped when its action ended, and its save kept only an Overworld point. - The guest keeps a respawn point outside the Overworld (respawn_elsewhere, saved as the player's `respawn`) and has it in place while it acts, so an anchor it uses is its own. - guest_respawn respawns it in that point's level, waits there for the chunks, then resolves the point through its block (findRespawnAndUseSpawnBlock): beside the anchor, using a charge, or the world spawn and block.minecraft.spawn.not_valid when the block is gone. - `spawnpoint` in another level than the Overworld sets a forced point there (SetSpawnCommand) instead of Overworld coordinates, and a forced point that is no anchor holds where a player fits (isPossibleToRespawnInThis), in the window's own game too. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game.rs | 19 ++--- crates/horizon-client/src/game/commands.rs | 23 ++++-- crates/horizon-client/src/game/lan_actions.rs | 43 ++++++++--- .../horizon-client/src/game/respawn_anchor.rs | 41 +++++++++- .../horizon-client/src/game/server_travel.rs | 77 ++++++++++++++++++- crates/horizon-client/src/lan/guest.rs | 5 ++ crates/horizon-client/src/lan/playerdata.rs | 2 + docs/server-levels.md | 5 +- tools/lan_e2e.py | 48 +++++++++++- 9 files changed, 224 insertions(+), 39 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f706e9348..04c8d5ed1 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -7437,16 +7437,11 @@ impl Game<'_> { self.sleep_timer = 0; self.spawn = None; self.respawn_travel = None; - self.respawn_config = - self.level - .respawn_elsewhere - .as_ref() - .map(|(dim, pos, yaw, forced)| respawn_anchor::RespawnConfig { - dim: Dim::from_id(dim), - pos: *pos, - yaw: *yaw, - forced: *forced, - }); + self.respawn_config = self + .level + .respawn_elsewhere + .as_ref() + .map(respawn_anchor::RespawnConfig::from_saved); self.spawn_origin = None; self.spawn_spiral = Default::default(); self.player_spawn = None; @@ -9424,9 +9419,7 @@ impl Game<'_> { level.weather = self.world.weather; level.day_time = self.world.day_time; level.spawn = self.spawn.map(|s| [s.x, s.y, s.z]); - level.respawn_elsewhere = self - .respawn_config - .map(|c| (c.dim.id().to_owned(), c.pos, c.yaw, c.forced)); + level.respawn_elsewhere = self.respawn_config.map(|c| c.saved()); level.rotation = [self.yaw, self.pitch]; level.xp_level = self.experience.level; level.xp_progress = self.experience.progress; diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index 570a64c09..c6877a839 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -2285,12 +2285,23 @@ impl Game<'_> { }; let yaw = ((rot[0] + 180.0).rem_euclid(360.0)) - 180.0; let pitch = rot[1].clamp(-90.0, 90.0); - self.spawn = Some(Vec3::new( - f64::from(pos[0]) + 0.5, - f64::from(pos[1]), - f64::from(pos[2]) + 0.5, - )); - self.respawn_config = None; + // SetSpawnCommand: a forced point in the source's level. + if self.dim == Dim::Overworld { + self.spawn = Some(Vec3::new( + f64::from(pos[0]) + 0.5, + f64::from(pos[1]), + f64::from(pos[2]) + 0.5, + )); + self.respawn_config = None; + } else { + self.spawn = None; + self.respawn_config = Some(super::respawn_anchor::RespawnConfig { + dim: self.dim, + pos, + yaw, + forced: true, + }); + } let dim = Text::literal(self.dim.id()); let p = pos.map(|v| Text::literal(v.to_string())); let mut args = vec![ diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index bc224da9e..60a403871 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -5,7 +5,7 @@ //! blocks, attacking and the commands all behave exactly as they do for the //! host, and every world change they cause reaches all players through the //! block log, the level events and the entity tracker. -use super::{Game, GuestUse, Hit, Mining, Screen, lan::LanHost}; +use super::{Game, GuestUse, Hit, Mining, Screen, lan::LanHost, respawn_anchor::RespawnConfig}; use horizon_client::{ command::vanilla, containers::BlockEntity, @@ -303,6 +303,7 @@ impl Game<'_> { g.spawn.map(|s| Vec3::new(s[0], s[1], s[2])), ); let respawn = (self.respawn_config.take(), self.level.spawn); + self.respawn_config = g.respawn_elsewhere.as_ref().map(RespawnConfig::from_saved); let message = self.message.take(); // The guest's own ender inventory; one the host has open goes back // into the host's while the guest acts. @@ -464,7 +465,8 @@ impl Game<'_> { let bed = std::mem::replace(&mut self.sleeping, sleeping); let guest_sleep_timer = std::mem::replace(&mut self.sleep_timer, sleep_timer); let guest_spawn = std::mem::replace(&mut self.spawn, spawn).map(|s| [s.x, s.y, s.z]); - (self.respawn_config, self.level.spawn) = respawn; + let guest_respawn = std::mem::replace(&mut self.respawn_config, respawn.0); + self.level.spawn = respawn.1; // ServerPlayer.displayClientMessage(_, true): the guest's action bar. let guest_message = std::mem::replace(&mut self.message, message); self.riding = riding; @@ -493,6 +495,7 @@ impl Game<'_> { let g = &mut host.hub.guests[i]; let fell_asleep = bed.is_some() && g.bed.is_none(); (g.bed, g.sleep_timer, g.spawn) = (bed, guest_sleep_timer, guest_spawn); + g.respawn_elsewhere = guest_respawn.map(|c| c.saved()); g.sleeping = g.bed.is_some(); if let Some((text, _)) = guest_message { g.send(&C::SystemChat(play::SystemChat { @@ -1417,17 +1420,32 @@ impl Game<'_> { if !host.hub.guests[i].dead { return; } - // PlayerList.respawn: a server's player comes back in the Overworld, - // where the world spawn is (respawn anchors and beds aside). + // PlayerList.respawn: a server's player comes back in its respawn + // point's level: the Overworld, where the world spawn and beds are, + // or another one's anchor or forced point, which its block resolves + // once the level has loaded around it. + let server = self.options.dedicated.is_some(); + let elsewhere = host.hub.guests[i] + .respawn_elsewhere + .as_ref() + .filter(|_| server) + .map(RespawnConfig::from_saved); + let level = elsewhere.map_or(super::Dim::Overworld, |c| c.dim); + let spawn = elsewhere.map_or(spawn, |c| { + [ + f64::from(c.pos[0]) + 0.5, + f64::from(c.pos[1]), + f64::from(c.pos[2]) + 0.5, + ] + }); let back = self.dim; - let away = self.options.dedicated.is_some() - && host.hub.guests[i].dimension != super::Dim::Overworld.id(); - if away { + let away = server && host.hub.guests[i].dimension != level.id(); + if server { self.server_trips.retain(|t| !t.is(conn)); - if let Err(e) = self.enter_level(Some(host), super::Dim::Overworld) { - log::error!("could not open the Overworld: {e}"); - return; - } + } + if away && let Err(e) = self.enter_level(Some(host), level) { + log::error!("could not open {}: {e}", level.id()); + return; } let g = &mut host.hub.guests[i]; g.dead = false; @@ -1466,6 +1484,9 @@ impl Game<'_> { collision: Some(self.collision), }; host.hub.respawn(i, spawn, &ctx); + if let Some(config) = elsewhere { + self.respawn_trip(conn, config); + } if away && let Err(e) = self.enter_level(Some(host), back) { log::error!("could not reopen {}: {e}", back.id()); } diff --git a/crates/horizon-client/src/game/respawn_anchor.rs b/crates/horizon-client/src/game/respawn_anchor.rs index 4604c076f..9b6ecc203 100644 --- a/crates/horizon-client/src/game/respawn_anchor.rs +++ b/crates/horizon-client/src/game/respawn_anchor.rs @@ -31,6 +31,24 @@ pub(super) struct RespawnConfig { pub forced: bool, } +/// A respawn point as a player's save keeps it (`respawn`): dimension, +/// block, yaw and whether it is forced. +pub(super) type SavedRespawn = (String, [i32; 3], f32, bool); + +impl RespawnConfig { + pub(super) fn from_saved((dim, pos, yaw, forced): &SavedRespawn) -> Self { + Self { + dim: Dim::from_id(dim), + pos: *pos, + yaw: *yaw, + forced: *forced, + } + } + pub(super) fn saved(&self) -> SavedRespawn { + (self.dim.id().to_owned(), self.pos, self.yaw, self.forced) + } +} + /// `RespawnAnchorBlock.RESPAWN_HORIZONTAL_OFFSETS`, then the same a block /// below, a block above, and straight above. const HORIZONTAL: [[i32; 3]; 8] = [ @@ -415,6 +433,16 @@ impl Game<'_> { let (lz, hz) = (bounds.min(Axis::Z), bounds.max(Axis::Z) - 1.0e-5); (self.border.contains(lo, lz) && self.border.contains(hi, hz)).then_some(position) } + /// `Block.isPossibleToRespawnInThis`: neither solid nor liquid; banners, + /// signs and pressure plates override it to always. + fn possible_to_respawn_in(&self, state: BlockStateId) -> bool { + let f = self.res.facts().get(state); + let name = &*f.name; + name.ends_with("_banner") + || name.ends_with("_sign") + || name.ends_with("_pressure_plate") + || !(f.legacy_solid || matches!(name, "minecraft:water" | "minecraft:lava")) + } /// `RespawnAnchorBlock.findStandUpPosition`: a safe spot around the /// anchor, else any spot. pub(super) fn anchor_stand_up(&self, pos: [i32; 3]) -> Option<Vec3> { @@ -428,8 +456,9 @@ impl Game<'_> { } None } - /// `ServerPlayer.findRespawnAndUseSpawnBlock` for an anchor config in the - /// loaded dimension: the position and yaw, using a charge. + /// `ServerPlayer.findRespawnAndUseSpawnBlock` for a config in the loaded + /// dimension: the position and yaw, using an anchor's charge. A forced + /// point (`spawnpoint`) that is no anchor holds if a player fits in it. pub(super) fn find_respawn_and_use( &mut self, c: RespawnConfig, @@ -440,7 +469,13 @@ impl Game<'_> { && (c.forced || self.anchor_charges(state) > 0) && self.anchor_works()) { - return Ok(None); + let [x, y, z] = c.pos; + let free = c.forced + && !self.is_anchor(state) + && self.possible_to_respawn_in(state) + && self.possible_to_respawn_in(self.world.block(x, y + 1, z)); + let at = Vec3::new(f64::from(x) + 0.5, f64::from(y) + 0.1, f64::from(z) + 0.5); + return Ok(free.then_some((at, c.yaw))); } let stand = self.anchor_stand_up(c.pos); if !c.forced diff --git a/crates/horizon-client/src/game/server_travel.rs b/crates/horizon-client/src/game/server_travel.rs index b7462baa8..1b1ec3a6d 100644 --- a/crates/horizon-client/src/game/server_travel.rs +++ b/crates/horizon-client/src/game/server_travel.rs @@ -9,8 +9,9 @@ use super::end::GatewayJob; use super::nether_portal::{PLAYER_DELAY, Plan}; +use super::respawn_anchor::RespawnConfig; use super::{Dim, Game, lan::LanHost}; -use horizon_client::lan::hub::TickCtx; +use horizon_client::{lan::hub::TickCtx, text::Text}; use horizon_core::{geometry::Vec3, position::BlockPos}; /// A trip under way: the player is in the destination's level, whose @@ -26,6 +27,9 @@ pub(super) struct Trip { /// Through an End gateway, within the level: its exit, found or built /// on arrival. gateway: Option<GatewayJob>, + /// A respawn at this point outside the Overworld, resolved through its + /// block on arrival. + respawn: Option<RespawnConfig>, /// Sent by a command: the player is already where it goes. placed: bool, } @@ -215,6 +219,7 @@ impl Game<'_> { end, plan, gateway: None, + respawn: None, placed: false, }); if let Err(e) = self.enter_level(Some(host), source) { @@ -222,6 +227,64 @@ impl Game<'_> { } } + /// A respawned player waits at its point outside the Overworld for the + /// level to load around it. + pub(super) fn respawn_trip(&mut self, conn: u32, config: RespawnConfig) { + let [x, y, z] = config.pos; + self.server_trips.push(Trip { + conn, + dim: config.dim, + target: Vec3::new(f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5), + end: false, + plan: None, + gateway: None, + respawn: Some(config), + placed: false, + }); + } + + /// `findRespawnAndUseSpawnBlock` for the player in place, at its point + /// in the level in place: where it stands up, facing the anchor, with + /// the deplete sound; else the point is forgotten + /// (`block.minecraft.spawn.not_valid`). + fn resolve_server_respawn(&mut self, config: RespawnConfig) -> Option<(Vec3, f32)> { + match self.find_respawn_and_use(config, true) { + Ok(Some((at, yaw))) => { + if !config.forced { + let [x, y, z] = config.pos.map(f64::from); + self.audio.play( + "minecraft:block.respawn_anchor.deplete", + Some([x, y, z]), + 1.0, + 1.0, + ); + } + Some((at, yaw)) + } + Ok(None) | Err(_) => { + self.respawn_config = None; + self.system_message(Text::translate("block.minecraft.spawn.not_valid", &[])); + None + } + } + } + + /// TeleportTransition.missingRespawnBlock: the world spawn, in the + /// Overworld. + fn respawn_at_world_spawn(&mut self, host: &mut LanHost, conn: u32) { + let at = self.level.world_spawn.map_or( + self.spawn.map_or([0.5, 80.0, 0.5], |s| [s.x, s.y, s.z]), + |[x, y, z]| [f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5], + ); + self.level_teleports.push(LevelTeleport { + conn, + dim: Dim::Overworld, + at, + rotation: None, + }); + self.run_level_teleports(host); + } + /// `TheEndGatewayBlockEntity.getPortalPosition` and the teleport within /// the End (keeping the player's motion and look): straight to an exact /// exit, else once the destination has loaded around the player, who @@ -244,6 +307,7 @@ impl Game<'_> { end: false, plan: None, gateway: Some(job), + respawn: None, placed: false, }); } @@ -276,7 +340,15 @@ impl Game<'_> { } self.resolve_arrivals(); let yaw = host.hub.guests[i].yaw; - let (position, yaw) = if let Some(job) = trip.gateway { + let (position, yaw) = if let Some(config) = trip.respawn { + match self.as_guest(host, trip.conn, |g| g.resolve_server_respawn(config)) { + Some(Some(found)) => found, + _ => { + self.respawn_at_world_spawn(host, trip.conn); + continue; + } + } + } else if let Some(job) = trip.gateway { match self.resolve_gateway(job, trip.target) { Ok(at) => (at, yaw), Err(e) => { @@ -346,6 +418,7 @@ impl Game<'_> { end: false, plan: None, gateway: None, + respawn: None, placed: true, }); if let Err(e) = self.enter_level(Some(host), source) { diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs index 4be5aa29f..6f939ac9d 100644 --- a/crates/horizon-client/src/lan/guest.rs +++ b/crates/horizon-client/src/lan/guest.rs @@ -86,6 +86,10 @@ pub struct Guest { /// Where the player respawns (a bed's spot; `ServerPlayer.respawnConfig`), /// None for the world spawn. pub spawn: Option<[f64; 3]>, + /// A respawn point outside the Overworld (a respawn anchor, or one + /// `spawnpoint` set there): its dimension, block, yaw and whether it is + /// forced, as the player's save keeps it (`respawn`). + pub respawn_elsewhere: Option<(String, [i32; 3], f32, bool)>, /// Pending ClientboundPlayerPositionPacket id; movement is ignored until /// the client accepts it (ServerGamePacketListenerImpl.awaitingPositionFromClient). pub awaiting_teleport: Option<(i32, [f64; 3])>, @@ -242,6 +246,7 @@ impl Guest { sleep_timer: 0, sent_bed: None, spawn: None, + respawn_elsewhere: None, awaiting_teleport: None, teleport_counter: 0, teleport_tick: 0, diff --git a/crates/horizon-client/src/lan/playerdata.rs b/crates/horizon-client/src/lan/playerdata.rs index 8797f25a2..24a4a9d65 100644 --- a/crates/horizon-client/src/lan/playerdata.rs +++ b/crates/horizon-client/src/lan/playerdata.rs @@ -72,6 +72,7 @@ pub fn apply(guest: &mut Guest, level: &Level) { guest.flying = level.flying; guest.selected = (level.selected_slot.max(0) as usize).min(8); guest.spawn = level.spawn.map(|s| [s[0] + 0.5, s[1], s[2] + 0.5]); + guest.respawn_elsewhere = level.respawn_elsewhere.clone(); guest.saved = level.player_extra.clone(); guest.recipe_book = level.recipe_book.clone(); guest.dimension = match level.dimension.as_str() { @@ -135,6 +136,7 @@ pub fn store(guest: &Guest, level: &mut Level) { level.flying = guest.flying; level.selected_slot = guest.selected as i32; level.spawn = guest.spawn.map(|s| [s[0] - 0.5, s[1], s[2] - 0.5]); + level.respawn_elsewhere = guest.respawn_elsewhere.clone(); level.on_ground = guest.on_ground; level.player_extra = guest.saved.clone(); level.recipe_book = guest.recipe_book.clone(); diff --git a/docs/server-levels.md b/docs/server-levels.md index eee730f89..a44f290c4 100644 --- a/docs/server-levels.md +++ b/docs/server-levels.md @@ -18,7 +18,7 @@ the other dimensions' levels as `Parked` values and swaps one into place (`enter | `MinecraftServer.tickChildren`, every level | `tick_server`: each level with a player in it, in Overworld, Nether, End order. The first pass reads the network and runs the shared parts (clock, weather, functions, autosave). | | `ServerLevel.players` | `Hub::here`: the guests whose `dimension` is the level in place | | `ServerPlayer.teleport` into another level | `server_travel.rs`: a Respawn packet, then the teleport once the destination has loaded (portals and `execute in … tp`). An End gateway teleports within the End. | -| `PlayerList.respawn` | `guest_respawn`: back into the Overworld's level | +| `PlayerList.respawn` | `guest_respawn`: into the respawn point's level, the Overworld unless the player has an anchor or a `spawnpoint` elsewhere (`Guest::respawn_elsewhere`), resolved through its block once that level has loaded | | `ServerLevel.noPlayersEmptyTime`, chunk unloading | `close_idle_levels`: a level other than the Overworld with nobody in it for 300 ticks is saved and closed | | `CommandSourceStack.getLevel` | `with_source` puts the source's level in place for a command (`execute in`, `execute at` a player in another level) | | the levels' shared `LevelData` | not swapped: game time, day time, weather, game rules, scoreboard, maps, entity ids (`next_entity`, unique across levels) | @@ -76,7 +76,8 @@ the Nether, or whose host saves and quits, joins again in the Nether where it wa - Mobs and armour stands fall in two levels at once, and every entity id is unique across the levels. - The guest leaves in the Nether and joins again there. - - The guest dies in the Nether and respawns in the Overworld. + - The guest dies in the Nether and respawns in the Overworld. With a `spawnpoint` and then a + respawn anchor set in the Nether, it respawns there, and the anchor loses a charge. - The host takes a Nether portal alone. - The guest takes an End portal, an End gateway and then the exit portal alone. - The host saves, quits and opens the world again with the guest in the Nether, and the guest diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index ddbec78af..dffa2bde0 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -70,7 +70,8 @@ address. The script then checks, from both sides, what a guest's game used to ge - levels: (--server-thread) the host and the guest each in a level of their own: `execute in` teleports into another level, and `execute in` and `at` change and test blocks there; mobs fall in two levels at once, with ids unique across them; the guest rejoins in the - Nether, dies there and respawns in the Overworld; the host takes a Nether portal alone; + Nether, dies there and respawns in the Overworld, then in the Nether at a `spawnpoint` + and at a respawn anchor set there; the host takes a Nether portal alone; the guest takes an End portal, an End gateway and the exit portal alone; and the host saves, quits and reopens with the guest in the Nether. - commands: the guest's chat completes commands and their arguments over the server's command @@ -679,6 +680,48 @@ def level_death(host, guest, out): return {'respawned': back['player']['position']} +def level_respawn_points(host, guest, out): + """Respawn points outside the Overworld (ServerPlayer.findRespawnAndUseSpawnBlock): a point + `spawnpoint` sets in the Nether (forced), then a charged respawn anchor the guest uses there, + each bring the guest back in the Nether; the anchor loses a charge.""" + home = pos_of(guest) + x, z = (int(v // 1) for v in home[::2]) + into_level(guest, NETHER, x, 100, z) + results = {} + try: + guest('command', command=f'spawnpoint @s {x} 100 {z}') + results['spawnpoint'] = die_and_respawn(guest) + guest('command', command=f'setblock {x + 2} 100 {z} minecraft:respawn_anchor[charges=2]') + guest.wait(10) + guest.raw('interact', x + 2, 100, z) + guest.wait(10) + results['anchor'] = die_and_respawn(guest) + results['charges'] = guest.raw('block', x + 2, 100, z).get('state') + finally: + sx, sy, sz = (int(v // 1) for v in pos_of(host)) + guest('command', command=f'execute in {OVERWORLD} run spawnpoint @s {sx} {sy} {sz}') + guest('command', command=f'execute in {NETHER} run setblock {x + 2} 100 {z} minecraft:air') + guest('command', command=f'execute in {OVERWORLD} run tp @s {home[0]:.2f} {home[1]:.2f} {home[2]:.2f}') + wait_dimension(guest, OVERWORLD, 400) + point, anchor = results['spawnpoint'], results['anchor'] + assert point[0] == NETHER and abs(point[1][0] - x - 0.5) < 0.6 and abs(point[1][2] - z - 0.5) < 0.6, \ + f'the spawnpoint brought the guest to {point}' + assert anchor[0] == NETHER and abs(anchor[1][0] - x - 2.5) < 2 and abs(anchor[1][2] - z - 0.5) < 2, \ + f'the anchor brought the guest to {anchor}' + assert 'charges=1' in (results['charges'] or ''), f'the anchor after the respawn: {results["charges"]}' + return results + + +def die_and_respawn(guest): + """Kill the guest and respawn it: the dimension and position it comes back at, once settled.""" + guest('command', command='kill @s') + guest.wait(20) + guest.raw('respawn') + guest.wait(80) + state = guest('state') + return state.get('dimension'), state['player']['position'] + + def level_host_nether(host, guest, out): """The host goes through a Nether portal while the guest stays in the Overworld.""" hx, hy, hz = (int(v // 1) for v in pos_of(host)) @@ -771,7 +814,8 @@ def level_reload(host, guest, out): LEVEL_STEPS = [('execute', level_execute), ('ticking', level_ticking), ('rejoin', level_rejoin), - ('death', level_death), ('host_nether', level_host_nether), + ('death', level_death), ('respawn_points', level_respawn_points), + ('host_nether', level_host_nether), ('guest_end', level_guest_end), ('reload', level_reload)] From 4ad6bb18efe9a08c02504f382502a578510dc19e Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:26:45 +0200 Subject: [PATCH 16/62] Natural spawning: resolve the entry's type once, skip the mobsAt recheck where it was picked, measure only nearby players spawn_category_for_position looked up the picked entry's type twice per attempt and asked mobsAt again at the position it had just picked the entry from. The type is now resolved when the entry is picked, and the recheck is skipped at that position (the list there holds the entry). The nearest player distance only feeds comparisons with 24 and the despawn distances (128 at most), so an attempt near its start measures only the players that can be within 128 blocks of it; farther ones read as infinitely far, which every check answers the same. The water-ambient biome tag is read only for that category. Same lists, same random draws. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- .../examples/natural_spawn_fixture.rs | 22 ++- .../src/game/natural_spawning.rs | 21 +-- .../src/mobs/spawn_selection.rs | 127 ++++++++++++++---- 3 files changed, 119 insertions(+), 51 deletions(-) diff --git a/crates/horizon-client/examples/natural_spawn_fixture.rs b/crates/horizon-client/examples/natural_spawn_fixture.rs index 528f8195d..e4c9b1ce6 100644 --- a/crates/horizon-client/examples/natural_spawn_fixture.rs +++ b/crates/horizon-client/examples/natural_spawn_fixture.rs @@ -111,6 +111,8 @@ struct World<'a> { slime: f32, starts: Vec<Start>, players: Vec<([f64; 3], String)>, + /// Where the non-spectators among them are. + nearest: Vec<[f64; 3]>, respawn: Option<[i32; 3]>, unloaded: HashSet<(i32, i32)>, spawn_mobs: bool, @@ -302,19 +304,8 @@ impl NaturalLevel for World<'_> { fn structure_spawns(&self) -> &StructureSpawns { self.s.structures } - fn nearest_player_distance_sqr(&self, x: f64, y: f64, z: f64) -> Option<f64> { - let mut best: Option<f64> = None; - for (p, mode) in &self.players { - if mode == "spectator" { - continue; - } - let d = [p[0] - x, p[1] - y, p[2] - z]; - let d = d[0] * d[0] + d[1] * d[1] + d[2] * d[2]; - if best.is_none_or(|b| d < b) { - best = Some(d); - } - } - best + fn nearest_player_positions(&self) -> &[[f64; 3]] { + &self.nearest } fn respawn(&self) -> Option<[i32; 3]> { self.respawn @@ -730,6 +721,11 @@ fn main() -> horizon_client::Result<()> { dimension_id: dimension_id.clone(), slime: get("slime", "0.0").parse()?, starts, + nearest: players + .iter() + .filter(|(_, mode)| mode != "spectator") + .map(|(p, _)| *p) + .collect(), players, respawn, unloaded, diff --git a/crates/horizon-client/src/game/natural_spawning.rs b/crates/horizon-client/src/game/natural_spawning.rs index 68aabbbc6..334e9bd7e 100644 --- a/crates/horizon-client/src/game/natural_spawning.rs +++ b/crates/horizon-client/src/game/natural_spawning.rs @@ -71,6 +71,8 @@ pub(super) struct GameLevel<'g, 'a> { pub(super) w: MobWorld<'g>, /// Every player in the level ([`Game::level_players`]). pub(super) players: Vec<LevelPlayer>, + /// Where the non-spectators among them are (`getNearestPlayer`). + pub(super) nearest: Vec<[f64; 3]>, /// Boxes of the mobs this pass created, not yet in the game's list. pub(super) pending: std::cell::RefCell<Vec<Aabb>>, /// The types and boxes of what a spawner created this tick. @@ -190,14 +192,8 @@ impl NaturalLevel for GameLevel<'_, '_> { fn structure_spawns(&self) -> &StructureSpawns { StructureSpawns::shared(&self.game.options.resources) } - fn nearest_player_distance_sqr(&self, x: f64, y: f64, z: f64) -> Option<f64> { - // The nearest player's distance (`nearest_player`), without finding - // which player it is: every spawn attempt asks. - self.players - .iter() - .filter(|p| !p.spectator) - .map(|p| p.distance_sqr(x, y, z)) - .reduce(f64::min) + fn nearest_player_positions(&self) -> &[[f64; 3]] { + &self.nearest } fn respawn(&self) -> Option<[i32; 3]> { // The world spawn point lives in the overworld. @@ -305,10 +301,17 @@ impl horizon_client::mobs::spawner::SpawnerLevel for GameLevel<'_, '_> { } impl<'a> Game<'a> { pub(super) fn natural_level(&self) -> GameLevel<'_, 'a> { + let players = self.level_players(); + let nearest = players + .iter() + .filter(|p| !p.spectator) + .map(|p| [p.position.x, p.position.y, p.position.z]) + .collect(); GameLevel { game: self, w: self.mob_world_base(&[]), - players: self.level_players(), + players, + nearest, pending: Default::default(), pending_ids: Default::default(), } diff --git a/crates/horizon-client/src/mobs/spawn_selection.rs b/crates/horizon-client/src/mobs/spawn_selection.rs index 614a2b2b5..046583a1f 100644 --- a/crates/horizon-client/src/mobs/spawn_selection.rs +++ b/crates/horizon-client/src/mobs/spawn_selection.rs @@ -351,6 +351,9 @@ fn spawns_far_from_player(s: Species, category: Category) -> bool { } /// What natural spawning reads from a level beyond the spawn rules. +/// An entity type's species, width, height and category. +pub type MobType = (Species, f32, f32, Category); + pub trait NaturalLevel: SpawnLevel { fn min_y(&self) -> i32; /// `getMaxY()`: the highest buildable block. @@ -359,7 +362,7 @@ pub trait NaturalLevel: SpawnLevel { fn ambient_light(&self) -> f32; fn has_ceiling(&self) -> bool; /// The entity type's species, width, height and category. - fn mob_type(&self, entity: &str) -> Option<(Species, f32, f32, Category)>; + fn mob_type(&self, entity: &str) -> Option<MobType>; /// The `natural_mob_spawns` lists by category at a position. fn biome_spawns(&self, x: i32, y: i32, z: i32) -> Option<&HashMap<String, Vec<SpawnEntry>>>; /// The `natural_mob_spawns` spawn cost of a type at a position. @@ -376,9 +379,9 @@ pub trait NaturalLevel: SpawnLevel { wanted: &dyn Fn(&str) -> bool, ) -> Vec<StructureAt>; fn structure_spawns(&self) -> &StructureSpawns; - /// `getNearestPlayer(x, y, z, -1, false)`: the squared distance to the - /// nearest player that is not a spectator. - fn nearest_player_distance_sqr(&self, x: f64, y: f64, z: f64) -> Option<f64>; + /// Where the players `getNearestPlayer(x, y, z, -1, false)` measures to + /// are: every one that is not a spectator. + fn nearest_player_positions(&self) -> &[[f64; 3]]; /// The world spawn point, when it is in this dimension. fn respawn(&self) -> Option<[i32; 3]>; /// `ServerLevel.canSpawnEntitiesInChunk`. @@ -870,9 +873,13 @@ impl SpawnState { /// `ChunkMap.getPlayersCloseForSpawning`: none past the natural spawn /// chunk tracker's range of 8 chunks from every player, else the /// non-spectators within 128 blocks of the chunk's centre. - fn players_near(&mut self, cx: i32, cz: i32) -> &[usize] { - let players = &self.players; - self.players_near.entry((cx, cz)).or_insert_with(|| { + fn players_near<'a>( + near: &'a mut FxHashMap<(i32, i32), Vec<usize>>, + players: &[SpawnPlayer], + cx: i32, + cz: i32, + ) -> &'a [usize] { + near.entry((cx, cz)).or_insert_with(|| { let tracked = players.iter().any(|p| { let (px, pz) = ( (p.position[0].floor() as i32) >> 4, @@ -896,8 +903,7 @@ impl SpawnState { }) } fn add_local(&mut self, cx: i32, cz: i32, category: Category) { - let near = self.players_near(cx, cz).to_vec(); - for p in near { + for &p in Self::players_near(&mut self.players_near, &self.players, cx, cz) { self.player_counts.entry(p).or_insert([0; 8])[category.index()] += 1; } } @@ -908,10 +914,10 @@ impl SpawnState { } /// `canSpawnForCategoryLocal` (`LocalMobCapCalculator.canSpawn`). pub fn can_spawn_local(&mut self, category: Category, cx: i32, cz: i32) -> bool { - let near = self.players_near(cx, cz).to_vec(); - near.into_iter().any(|p| { + let near = Self::players_near(&mut self.players_near, &self.players, cx, cz); + near.iter().any(|p| { self.player_counts - .get(&p) + .get(p) .is_none_or(|c| c[category.index()] < category.max()) }) } @@ -1080,9 +1086,11 @@ pub fn spawn_category_for_position<L: NaturalLevel, R: RandomSource>( } let mut spawned: Vec<Aabb> = Vec::new(); let mut cluster = 0u32; + let mut nearest = Nearest::new(start); for _ in 0..3 { let (mut x, mut z) = (x0, z0); - let mut current: Option<SpawnEntry> = None; + // The group's entry, its type and where it was picked. + let mut current: Option<(SpawnEntry, Option<MobType>, [i32; 3])> = None; let mut group_index = 0u32; let mut max = (random.next_float() * 4.0).ceil() as i32; let mut ll = 0; @@ -1092,16 +1100,15 @@ pub fn spawn_category_for_position<L: NaturalLevel, R: RandomSource>( z += random.next_int_bound(6).unwrap_or(0) - random.next_int_bound(6).unwrap_or(0); let (xx, zz) = (f64::from(x) + 0.5, f64::from(z) + 0.5); trace(Event::Try(x, z)); - let Some(distance) = l.nearest_player_distance_sqr(xx, f64::from(y), zz) else { + let Some(distance) = nearest.distance_sqr(l, xx, f64::from(y), zz) else { continue; }; if !right_distance(l, chunk, [x, y, z], distance) { continue; } if current.is_none() { - let reduced = l.biome_tag("minecraft:reduce_water_ambient_spawns", x, y, z); let list = if category == Category::WaterAmbient - && reduced + && l.biome_tag("minecraft:reduce_water_ambient_spawns", x, y, z) && random.next_float() < 0.98 { None @@ -1112,21 +1119,32 @@ pub fn spawn_category_for_position<L: NaturalLevel, R: RandomSource>( break; }; max = sample_count(&entry, random) as i32; - current = Some(entry); + let kind = l.mob_type(&entry.entity); + current = Some((entry, kind, [x, y, z])); } - let entry = current.as_ref().unwrap_or_else(|| unreachable!()); - if !valid_position_for_type(l, random, category, entry, [x, y, z], distance) { + let (entry, kind, picked_at) = current.as_ref().unwrap_or_else(|| unreachable!()); + // The list the entry was picked from holds it where it was picked. + let listed = *picked_at == [x, y, z]; + let valid = valid_position_for_type( + l, + random, + category, + entry, + *kind, + listed, + [x, y, z], + distance, + ); + let Some((species, width, height, type_category)) = (*kind).filter(|_| valid) else { continue; - } + }; let passed = state.can_spawn(l, &entry.entity, [x, y, z]); trace(Event::Test(entry.entity.clone(), [x, y, z], passed)); if !passed { continue; } - // getMobForSpawn: a type the game cannot create ends the pass. - let Some((species, width, height, type_category)) = l.mob_type(&entry.entity) else { - return; - }; + // getMobForSpawn (a type the game cannot create, which would end + // the pass, never passes isValidSpawnPostitionForType). let yaw = random.next_float() * 360.0; let bounds = spawn_box(xx, f64::from(y), zz, width, height); let despawn = f64::from(type_category.despawn_distance().pow(2)); @@ -1167,6 +1185,52 @@ pub fn spawn_category_for_position<L: NaturalLevel, R: RandomSource>( } } } +/// `getNearestPlayer(x, y, z, -1, false)`'s squared distance for the +/// attempts of one start. The spawn checks only compare it with 24² and the +/// despawn distances (128² at most), so it is measured only to the players +/// that can be within 128 blocks of an attempt near the start: when none is, +/// the nearest reads as infinitely far, which every check answers as it +/// answers the real distance. An attempt that wanders farther than +/// `MARGIN` from the start measures every player. +struct Nearest { + /// The players that can be within 128 blocks, once an attempt asked. + nearby: Option<Vec<[f64; 3]>>, + start: (f64, f64), +} +impl Nearest { + const REACH: f64 = 128.0; + const MARGIN: f64 = 64.0; + fn new(start: [i32; 3]) -> Self { + Self { + nearby: None, + start: (f64::from(start[0]) + 0.5, f64::from(start[2]) + 0.5), + } + } + fn distance_sqr<L: NaturalLevel>(&mut self, l: &L, x: f64, y: f64, z: f64) -> Option<f64> { + let all = l.nearest_player_positions(); + if all.is_empty() { + return None; + } + let distance = |p: &[f64; 3]| (p[0] - x).powi(2) + (p[1] - y).powi(2) + (p[2] - z).powi(2); + let (sx, sz) = self.start; + if (x - sx).abs() > Self::MARGIN || (z - sz).abs() > Self::MARGIN { + return all.iter().map(distance).reduce(f64::min); + } + // The others are farther than REACH, across, from every point within + // MARGIN of the start. + let nearby = self.nearby.get_or_insert_with(|| { + all.iter() + .filter(|p| { + let dx = ((p[0] - sx).abs() - Self::MARGIN).max(0.0); + let dz = ((p[2] - sz).abs() - Self::MARGIN).max(0.0); + dx * dx + dz * dz <= Self::REACH * Self::REACH + }) + .copied() + .collect() + }); + Some(nearby.iter().map(distance).fold(f64::INFINITY, f64::min)) + } +} /// `isRightDistanceToPlayerAndSpawnPoint`. fn right_distance<L: NaturalLevel>(l: &L, chunk: (i32, i32), pos: [i32; 3], distance: f64) -> bool { if distance <= 576.0 { @@ -1185,16 +1249,20 @@ fn right_distance<L: NaturalLevel>(l: &L, chunk: (i32, i32), pos: [i32; 3], dist let (cx, cz) = (pos[0] >> 4, pos[2] >> 4); (cx, cz) == chunk || l.can_spawn_in_chunk(cx, cz) } -/// `isValidSpawnPostitionForType`. +/// `isValidSpawnPostitionForType`, for the entry's type (`mob_type`). +/// `listed`: the position is where the entry was picked from `mobsAt`. +#[allow(clippy::too_many_arguments)] fn valid_position_for_type<L: NaturalLevel, R: RandomSource>( l: &L, random: &mut R, category: Category, entry: &SpawnEntry, + kind: Option<MobType>, + listed: bool, pos: [i32; 3], distance: f64, ) -> bool { - let Some((species, width, height, type_category)) = l.mob_type(&entry.entity) else { + let Some((species, width, height, type_category)) = kind else { return false; }; if type_category == Category::Misc { @@ -1205,9 +1273,10 @@ fn valid_position_for_type<L: NaturalLevel, R: RandomSource>( return false; } let [x, y, z] = pos; - if !mobs_at(l, category, x, y, z) - .iter() - .any(|e| same_spawner(e, entry)) + if !listed + && !mobs_at(l, category, x, y, z) + .iter() + .any(|e| same_spawner(e, entry)) { return false; } From abb7a971363bf2244b63585a8daf9a9d7c620744 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 13:45:18 +0200 Subject: [PATCH 17/62] Animated sprites on the GPU: frames uploaded once, one dispatch per mip level Every animation frame's mip chain goes to video memory once, at the sprite's own size, as vanilla keeps its animated sprites' frames on the GPU. A tick that changes sprites writes one 20-byte job per changed sprite, and a compute dispatch per mip level repeats the chain into the array's larger layers and mixes interpolated frames (animate_sprite_interpolate), instead of blending on the CPU at the array's size and copying each sprite level by level. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/gfx.rs | 365 +------------ crates/horizon-client/src/gfx/animate.rs | 590 +++++++++++++++++++++ crates/horizon-client/src/gfx/animate.wgsl | 48 ++ crates/horizon-client/src/sprites.rs | 13 +- 4 files changed, 663 insertions(+), 353 deletions(-) create mode 100644 crates/horizon-client/src/gfx/animate.rs create mode 100644 crates/horizon-client/src/gfx/animate.wgsl diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 14c040c5c..7298d4292 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -59,6 +59,7 @@ pub fn outline_vertices(edges: &[[f64; 6]], camera: glam::DVec3) -> Vec<[f32; 6] .collect() } +mod animate; mod arena; mod cull; mod flat; @@ -363,8 +364,6 @@ pub struct Renderer { sprite_textures: Vec<wgpu::Texture>, /// A 1-layer array bound where a pack needs fewer arrays. sprite_unused: wgpu::TextureView, - /// Layers per sprite array ([`SPRITE_SPLIT`] but in tests). - sprite_split: u32, mip_levels: u32, /// The mipmap levels sampled (the Mipmap Levels option), at most `mip_levels - 1`. mipmaps: u32, @@ -372,7 +371,7 @@ pub struct Renderer { sprite_sampler: wgpu::Sampler, lightmap_view: wgpu::TextureView, lightmap_sampler: wgpu::Sampler, - animations: AnimatedSprites, + animations: animate::SpriteAnimator, uploads: upload::Uploads, /// Section meshes are staged through their own belt into /// `section_copies`, which the next frame records its commands after: @@ -1274,7 +1273,9 @@ impl Renderer { sample_count: 1, dimension: wgpu::TextureDimension::D2, format: wgpu::TextureFormat::Rgba8Unorm, - usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, + usage: wgpu::TextureUsages::TEXTURE_BINDING + | wgpu::TextureUsages::COPY_DST + | wgpu::TextureUsages::STORAGE_BINDING, view_formats: &[], }, wgpu::util::TextureDataOrder::LayerMajor, @@ -1282,6 +1283,14 @@ impl Renderer { ) }) .collect(); + let animations = animate::SpriteAnimator::new( + &device, + animations, + sprite_size, + sprite_mips, + &sprite_textures, + split, + ); let sprite_unused = device .create_texture(&wgpu::TextureDescriptor { label: Some("Block sprites (unused)"), @@ -2133,14 +2142,13 @@ impl Renderer { lightmap, sprite_textures, sprite_unused, - sprite_split: split, mip_levels, mipmaps: mip_levels - 1, terrain_layout: bindings, sprite_sampler, lightmap_view, lightmap_sampler, - animations: AnimatedSprites::new(animations, sprite_size, sprite_mips), + animations, uploads, section_uploads, section_copies: None, @@ -2733,29 +2741,7 @@ impl Renderer { self.lightmap_uploaded = true; } fn animate(&mut self, encoder: &mut wgpu::CommandEncoder, tick: u64) { - animate_sprites( - &mut self.animations, - tick, - self.mip_levels, - |layer, level, size, pixels| { - self.uploads.texture( - encoder, - wgpu::TexelCopyTextureInfo { - texture: &self.sprite_textures[(layer / self.sprite_split) as usize], - mip_level: level, - origin: wgpu::Origin3d { - x: 0, - y: 0, - z: layer % self.sprite_split, - }, - aspect: wgpu::TextureAspect::All, - }, - size, - size, - pixels, - ); - }, - ); + self.animations.animate(encoder, &mut self.uploads, tick); } pub fn render(&mut self, frame: &Frame) -> Result<bool> { let rendered = self.draw_frame(frame); @@ -4427,171 +4413,10 @@ pub(crate) fn sprite_mipmap_limit(requested: u32, size: u32, minimum: u32, avail let upscale = (size / minimum.max(1)).max(1).ilog2(); requested.saturating_add(upscale).min(available - 1) } -/// Room for every frame of the vanilla animations (594 frames, 13 MB of mip -/// chains in 64-pixel layers), so no frame's chain is rebuilt on the render -/// thread when its animation comes back to it; larger packs stay bounded. -const ANIMATION_MIP_BUDGET: usize = 32 << 20; -const ANIMATION_MIP_ENTRIES: usize = 4096; - -/// One immutable resource snapshot and its lazily generated frame mips. A new -/// renderer on resource reload drops this entire snapshot, including its cache: -/// frame indices can never alias another resource's pixels, size or settings. -struct AnimatedSprites { - /// Each animated sprite and what its layer holds (`None`: not uploaded yet). - animations: Vec<(SpriteAnimation, Option<crate::sprites::FrameBlend>)>, - size: u32, - settings: Vec<crate::mipmap::Settings>, - // Cache bookkeeping must not consume randomness or affect other maps' seeding. - cache: crate::fast_hash::FxHashMap<(usize, usize), Vec<u8>>, - /// Retained pixel-buffer capacities, not just their initialized lengths. - cache_bytes: usize, - budget: usize, -} -impl AnimatedSprites { - fn new( - animations: &[SpriteAnimation], - size: u32, - settings: &[crate::mipmap::Settings], - ) -> Self { - Self { - animations: animations.iter().cloned().map(|a| (a, None)).collect(), - size, - settings: settings.to_vec(), - cache: Default::default(), - cache_bytes: 0, - budget: ANIMATION_MIP_BUDGET, - } - } -} -fn animate_sprites( - state: &mut AnimatedSprites, - tick: u64, - max_levels: u32, - mut write: impl FnMut(u32, u32, u32, &[u8]), -) { - let size = state.size; - let levels = size.trailing_zeros() + 1; - let AnimatedSprites { - animations, - settings, - cache, - cache_bytes, - budget, - .. - } = state; - for (index, (animation, previous)) in animations.iter_mut().enumerate() { - let blend = animation.blend(tick); - if *previous == Some(blend) { - continue; - } - *previous = Some(blend); - let (animation, settings) = (&*animation, &**settings); - let chain = |frame: usize| { - move || mip_chain(animation.pixels(frame), size, settings, animation.layer, 1).0 - }; - let (current, mixed); - let mips: &[u8] = if blend.millis > 0 { - let mut mix = frame_mips( - cache, - cache_bytes, - *budget, - (index, blend.frame), - chain(blend.frame), - ) - .into_owned(); - let next = frame_mips( - cache, - cache_bytes, - *budget, - (index, blend.next), - chain(blend.next), - ); - mix_frames(&mut mix, &next, blend.millis); - mixed = mix; - &mixed - } else { - current = frame_mips( - cache, - cache_bytes, - *budget, - (index, blend.frame), - chain(blend.frame), - ); - ¤t - }; - let mut offset = 0; - for level in 0..levels.min(max_levels) { - let edge = size >> level; - let bytes = (edge * edge * 4) as usize; - write(animation.layer, level, edge, &mips[offset..offset + bytes]); - offset += bytes; - } - } -} -/// `animate_sprite_interpolate.fsh`: `mix(current, next, millis / 1000)` per -/// channel of every mipmap level, stored as 8-bit unorm. -/// One frame's mip chain: from the cache, or generated and kept while the budget has room. -/// Frames that do not fit still go through the same generation path. -fn frame_mips<'a>( - cache: &'a mut crate::fast_hash::FxHashMap<(usize, usize), Vec<u8>>, - cache_bytes: &mut usize, - budget: usize, - key: (usize, usize), - generate: impl FnOnce() -> Vec<u8>, -) -> std::borrow::Cow<'a, [u8]> { - let room = cache.len() < ANIMATION_MIP_ENTRIES; - match cache.entry(key) { - std::collections::hash_map::Entry::Occupied(entry) => entry.into_mut().as_slice().into(), - std::collections::hash_map::Entry::Vacant(entry) => { - let pixels = generate(); - // Bound both pixel storage and map metadata. Keep admitted frames - // rather than churning them on large/unique workloads. - if room && pixels.capacity() <= budget - *cache_bytes { - *cache_bytes += pixels.capacity(); - entry.insert(pixels).as_slice().into() - } else { - pixels.into() - } - } - } -} -fn mix_frames(current: &mut [u8], next: &[u8], millis: u32) { - let t = millis as f32 / 1000.0; - for (c, n) in current.iter_mut().zip(next) { - let (a, b) = (f32::from(*c) / 255.0, f32::from(*n) / 255.0); - *c = round_unorm8((a * (1.0 - t) + b * t) * 255.0); - } -} -/// `x.round() as u8` for `x >= 0`, without the `roundf` library call that -/// x86-64 makes for every `f32::round` (it has no rounding instruction before -/// SSE4.1): the fraction `x - trunc(x)` is exact below 2^23, so rounding half -/// away from zero is adding one when it is at least a half. -#[inline] -fn round_unorm8(x: f32) -> u8 { - let whole = x as u8; - whole.saturating_add(u8::from(x - f32::from(whole) >= 0.5)) -} #[cfg(test)] mod sprite_upload_tests { use super::*; #[test] - fn blended_frames_round_like_f32_round() { - for millis in (0..1000).step_by(7).chain([999]) { - let t = millis as f32 / 1000.0; - for a in 0..=255u8 { - for b in 0..=255u8 { - let x = (f32::from(a) / 255.0 * (1.0 - t) + f32::from(b) / 255.0 * t) * 255.0; - assert_eq!(round_unorm8(x), x.round() as u8, "{a} {b} {millis}"); - } - } - } - for x in [ - 0.0, 0.49999997, 0.5, 1.5, 2.5, 254.49998, 254.5, 255.0, 255.00002, 300.0, - ] { - assert_eq!(round_unorm8(x), x.round() as u8, "{x}"); - } - } - #[test] fn real_rail_mips_do_not_change_with_larger_array_layers() { let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .join("../../.local/horizon-client") @@ -4654,84 +4479,6 @@ mod sprite_upload_tests { assert_eq!(sprite_mipmap_limit(levels, 16, 16, 5), levels); } } - #[test] - fn animation_updates_entire_layer_every_mip_once() { - for size in [16, 32] { - let animation = crate::sprites::test_animation(size, 7); - let pixels = animation.pixels(animation.frame(1)).to_vec(); - let settings = []; - let (expected, levels) = mip_chain(&pixels, size, &settings, 7, 1); - let mut animations = AnimatedSprites::new(&[animation], size, &settings); - animations.animations[0].1 = Some(animations.animations[0].0.blend(0)); - let mut writes = Vec::new(); - let mut record = |layer, level, edge, data: &[u8]| { - assert_eq!(layer, 7); - assert_eq!(edge, size >> level); - assert_eq!(data.len(), (edge * edge * 4) as usize); - writes.push(data.to_vec()); - }; - animate_sprites(&mut animations, 0, levels, &mut record); - animate_sprites(&mut animations, 1, levels, &mut record); - animate_sprites(&mut animations, 1, levels, &mut record); - assert_eq!(writes.len(), levels as usize); - assert_eq!(writes[0], pixels); - assert_eq!(writes.concat(), expected); - } - } - - #[test] - fn cached_and_uncached_uploads_match_through_loops_and_mip_changes() { - for size in [16, 32] { - let animations = [crate::sprites::test_animation(size, 7)]; - let settings = vec![ - crate::mipmap::Settings { - strategy: crate::mipmap::Strategy::StrictCutout, - alpha_cutoff_bias: -0.2, - ..Default::default() - }; - 8 - ]; - let mut cached = AnimatedSprites::new(&animations, size, &settings); - let mut uncached = AnimatedSprites::new(&animations, size, &settings); - uncached.budget = 0; - for tick in [0, 0, 1, 2, 3, 33, 32, 32, 1, 0] { - let levels = (tick % 7) as u32; - let mut expected = Vec::new(); - let mut actual = Vec::new(); - animate_sprites(&mut uncached, tick, levels, |layer, level, edge, bytes| { - expected.push((layer, level, edge, bytes.to_vec())); - }); - animate_sprites(&mut cached, tick, levels, |layer, level, edge, bytes| { - actual.push((layer, level, edge, bytes.to_vec())); - }); - assert_eq!(actual, expected); - } - assert_eq!(cached.cache.len(), 2); - assert_eq!(uncached.cache_bytes, 0); - assert_eq!( - cached.cache_bytes, - cached.cache.values().map(Vec::capacity).sum::<usize>() - ); - } - } - - #[test] - fn budget_exhaustion_keeps_admitted_frames_and_uploads_misses() { - let size = 16; - let animation = crate::sprites::test_animation(size, 0); - let bytes = mip_chain(animation.pixels(0), size, &[], 0, 1).0.capacity(); - let mut state = AnimatedSprites::new(&[animation], size, &[]); - state.budget = bytes; - for tick in 0..8 { - let mut writes = 0; - animate_sprites(&mut state, tick, 5, |_, _, _, _| writes += 1); - assert_eq!(writes, 5); - assert_eq!(state.cache_bytes, bytes); - assert_eq!(state.cache.len(), 1); - assert!(state.cache.contains_key(&(0, 0))); - } - } - #[test] fn prepared_texture_uploads_preserve_layer_order_and_settings() { let size = 4; @@ -4784,86 +4531,4 @@ mod sprite_upload_tests { assert_eq!(chain.capacity(), chain.len()); } } - - #[test] - fn every_vanilla_animation_frame_stays_cached() { - // Vanilla's 594 animation frames in 64-pixel layers: 297 two-frame clips. - let animations: Vec<_> = (0..297) - .map(|layer| crate::sprites::test_animation(64, layer)) - .collect(); - let mut state = AnimatedSprites::new(&animations, 64, &[]); - for tick in 0..4 { - animate_sprites(&mut state, tick, 7, |_, _, _, _| {}); - } - assert_eq!(state.cache.len(), 594); - assert!(state.cache_bytes <= ANIMATION_MIP_BUDGET); - } - - #[test] - fn entry_limit_also_bounds_metadata_for_tiny_frames() { - let animation = crate::sprites::test_animation(1, 0); - let animations = vec![animation; ANIMATION_MIP_ENTRIES + 1]; - let mut state = AnimatedSprites::new(&animations, 1, &[]); - for tick in 0..2 { - let mut writes = 0; - animate_sprites(&mut state, tick, 1, |_, _, _, _| writes += 1); - assert_eq!(writes, animations.len()); - assert_eq!(state.cache.len(), ANIMATION_MIP_ENTRIES); - assert!(state.cache_bytes <= ANIMATION_MIP_BUDGET); - } - } - - #[test] - fn resource_snapshot_replacement_discards_pixels_size_and_settings() { - let old = crate::sprites::test_animation(16, 0); - let mut state = AnimatedSprites::new(&[old], 16, &[]); - animate_sprites(&mut state, 0, 5, |_, _, _, _| {}); - assert!(!state.cache.is_empty()); - let animation = crate::sprites::test_animation(32, 0); - let settings = [crate::mipmap::Settings { - strategy: crate::mipmap::Strategy::StrictCutout, - alpha_cutoff_bias: -0.4, - ..Default::default() - }]; - let expected = mip_chain(animation.pixels(0), 32, &settings, 0, 1).0; - state = AnimatedSprites::new(&[animation], 32, &settings); - assert_eq!(state.cache_bytes, 0); - assert!(state.cache.is_empty()); - let mut actual = Vec::new(); - animate_sprites(&mut state, 0, 6, |_, _, _, bytes| { - actual.extend_from_slice(bytes) - }); - assert_eq!(actual, expected); - } - - #[test] - fn interpolated_animation_uploads_the_mix_every_tick() { - let animation = crate::sprites::test_clip(16, 3, r#"{"frametime":4,"interpolate":true}"#); - let settings = []; - let (_, levels) = mip_chain(animation.pixels(0), 16, &settings, 3, 1); - let mut cached = AnimatedSprites::new(std::slice::from_ref(&animation), 16, &settings); - let mut uncached = AnimatedSprites::new(std::slice::from_ref(&animation), 16, &settings); - uncached.budget = 0; - for state in [&mut cached, &mut uncached] { - state.animations[0].1 = Some(animation.blend(0)); - } - let mut blues = Vec::new(); - let mut uncached_blues = Vec::new(); - let mut record = |_, level, _, data: &[u8]| { - if level == 0 { - blues.push(data[2]); - } - }; - for tick in [0, 1, 1, 2, 4] { - animate_sprites(&mut cached, tick, levels, &mut record); - animate_sprites(&mut uncached, tick, levels, |_, level, _, data: &[u8]| { - if level == 0 { - uncached_blues.push(data[2]); - } - }); - } - // Frame 0 is blue 0, frame 1 blue 99: a quarter, a half, then frame 1. - assert_eq!(blues, [25, 50, 99]); - assert_eq!(uncached_blues, blues); - } } diff --git a/crates/horizon-client/src/gfx/animate.rs b/crates/horizon-client/src/gfx/animate.rs new file mode 100644 index 000000000..f4528902b --- /dev/null +++ b/crates/horizon-client/src/gfx/animate.rs @@ -0,0 +1,590 @@ +//! Animated block sprites, drawn on the GPU as vanilla 26.3 draws them: +//! `SpriteContents.AnimatedTexture` keeps every frame in video memory, and +//! each tick `animate_sprite_blit` or `animate_sprite_interpolate` draws the +//! frame shown (mixed with the next one for `interpolate`) into the atlas. +//! +//! Every frame's mip chain is uploaded once, at the sprite's own size. A tick +//! that changes sprites writes one small job per changed sprite and runs one +//! compute dispatch per mip level (`animate.wgsl`), which repeats the chain +//! into the array's larger layers by whole pixels and mixes interpolated +//! frames. Blending on the CPU at the array's size and copying every changed +//! sprite level by level (a copy command each, a blit each in Mesa) was about +//! a fifth of the render thread on an integrated GPU. +use super::upload::Uploads; +use crate::mipmap::Settings; +use crate::sprites::{FrameBlend, SpriteAnimation}; +use wgpu::util::DeviceExt; + +/// Bytes of `animate.wgsl`'s `Job`. +const JOB_BYTES: usize = 20; +/// `animate.wgsl`'s workgroup edge. +const WORKGROUP: u32 = 8; + +struct Sprite { + animation: SpriteAnimation, + /// What its layer shows (`None`: the frame the array was created with, + /// rewritten on the first tick). + shown: Option<FrameBlend>, + /// Its layer in its sprite array. + layer: u32, + /// Each frame's mip chain: its offset in words in the group's frames. + frames: Vec<u32>, + /// Edge of the chains' first level. + edge: u32, + group: usize, +} + +/// The animated sprites of one sprite array whose frames share one buffer. +struct Group { + /// Where its jobs start in `SpriteAnimator::jobs`, in bytes. + offset: u64, + /// One bind group per mip level of the array. + levels: Vec<wgpu::BindGroup>, + /// This tick's jobs. + jobs: Vec<u8>, +} + +pub(super) struct SpriteAnimator { + sprites: Vec<Sprite>, + groups: Vec<Group>, + jobs: wgpu::Buffer, + pipeline: wgpu::ComputePipeline, + /// Edge of the arrays' layers. + size: u32, +} + +impl SpriteAnimator { + /// `textures` are the sprite arrays, `split` layers each, `size` pixels + /// wide; `animations` hold their frames at that size. + pub fn new( + device: &wgpu::Device, + animations: &[SpriteAnimation], + size: u32, + settings: &[Settings], + textures: &[wgpu::Texture], + split: u32, + ) -> Self { + let limits = device.limits(); + let limit = limits + .max_storage_buffer_binding_size + .min(limits.max_buffer_size); + let mut frames: Vec<Vec<u8>> = Vec::new(); + // Each group's sprite array and frames buffer. + let mut keys: Vec<(u32, usize)> = Vec::new(); + let mut counts: Vec<usize> = Vec::new(); + let mut sprites = Vec::with_capacity(animations.len()); + for animation in animations { + let chains: Vec<_> = (0..animation.frame_count()) + .map(|frame| source_chain(animation.pixels(frame), size, settings, animation.layer)) + .collect(); + let bytes: u64 = chains.iter().map(|(chain, _)| chain.len() as u64).sum(); + if bytes > limit { + log::warn!( + "Horizon: layer {}'s animation ({bytes} bytes) does not fit in a storage buffer; it stays still", + animation.layer + ); + continue; + } + if frames + .last() + .is_none_or(|data| data.len() as u64 + bytes > limit) + { + frames.push(Vec::new()); + } + let buffer = frames.len() - 1; + let data = &mut frames[buffer]; + let offsets = chains + .iter() + .map(|(chain, _)| { + let offset = (data.len() / 4) as u32; + data.extend_from_slice(chain); + offset + }) + .collect(); + let key = (animation.layer / split, buffer); + let group = keys.iter().position(|&k| k == key).unwrap_or_else(|| { + keys.push(key); + counts.push(0); + keys.len() - 1 + }); + counts[group] += 1; + sprites.push(Sprite { + animation: animation.clone(), + shown: None, + layer: animation.layer % split, + frames: offsets, + edge: chains[0].1, + group, + }); + } + let frames: Vec<_> = frames + .iter() + .map(|data| { + device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: Some("Animated sprite frames"), + contents: data, + usage: wgpu::BufferUsages::STORAGE, + }) + }) + .collect(); + let align = u64::from(limits.min_storage_buffer_offset_alignment); + let mut offsets = Vec::with_capacity(counts.len()); + let mut total = 0; + for &count in &counts { + offsets.push(total); + total = (total + (count * JOB_BYTES) as u64).next_multiple_of(align); + } + let jobs = device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Animated sprite jobs"), + size: total.max(align), + usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some("Animated sprites"), + source: wgpu::ShaderSource::Wgsl(include_str!("animate.wgsl").into()), + }); + let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { + label: Some("Animated sprites"), + layout: None, + module: &module, + entry_point: Some("animate"), + compilation_options: Default::default(), + cache: None, + }); + let layout = pipeline.get_bind_group_layout(0); + let groups = keys + .iter() + .zip(&counts) + .zip(offsets) + .map(|((&(array, buffer), &count), offset)| { + let texture = &textures[array as usize]; + let levels = (0..texture.mip_level_count()) + .map(|level| { + let view = texture.create_view(&wgpu::TextureViewDescriptor { + label: Some("Animated sprites"), + dimension: Some(wgpu::TextureViewDimension::D2Array), + base_mip_level: level, + mip_level_count: Some(1), + ..Default::default() + }); + device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("Animated sprites"), + layout: &layout, + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: frames[buffer].as_entire_binding(), + }, + wgpu::BindGroupEntry { + binding: 1, + resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding { + buffer: &jobs, + offset, + size: wgpu::BufferSize::new((count * JOB_BYTES) as u64), + }), + }, + wgpu::BindGroupEntry { + binding: 2, + resource: wgpu::BindingResource::TextureView(&view), + }, + ], + }) + }) + .collect(); + Group { + offset, + levels, + jobs: Vec::with_capacity(count * JOB_BYTES), + } + }) + .collect(); + Self { + sprites, + groups, + jobs, + pipeline, + size, + } + } + + /// Show every sprite's frame at `tick`, rewriting only the sprites whose + /// frame or mix changed (`SpriteContents.AnimationState.tick`). + pub fn animate( + &mut self, + encoder: &mut wgpu::CommandEncoder, + uploads: &mut Uploads, + tick: u64, + ) { + if self.collect(tick) == 0 { + return; + } + for group in &self.groups { + uploads.buffer(encoder, &self.jobs, group.offset, &group.jobs); + } + let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { + label: Some("Animated sprites"), + timestamp_writes: None, + }); + pass.set_pipeline(&self.pipeline); + for group in &mut self.groups { + let count = (group.jobs.len() / JOB_BYTES) as u32; + if count == 0 { + continue; + } + for (level, bind) in group.levels.iter().enumerate() { + let groups = (self.size >> level).div_ceil(WORKGROUP); + pass.set_bind_group(0, bind, &[]); + pass.dispatch_workgroups(groups, groups, count); + } + group.jobs.clear(); + } + } + + /// Queue a job for every sprite whose blend at `tick` differs from what + /// its layer shows; the number of jobs. + fn collect(&mut self, tick: u64) -> usize { + let mut count = 0; + for sprite in &mut self.sprites { + let blend = sprite.animation.blend(tick); + if sprite.shown == Some(blend) { + continue; + } + sprite.shown = Some(blend); + let job = [ + sprite.layer, + sprite.frames[blend.frame], + sprite.frames[blend.next], + blend.millis, + sprite.edge, + ]; + let jobs = &mut self.groups[sprite.group].jobs; + for word in job { + jobs.extend_from_slice(&word.to_le_bytes()); + } + count += 1; + } + count + } +} + +/// The mip chain a frame's layer is made of, and its first level's edge. +/// `mipmap::generate` makes a sprite scaled up by whole pixels to the +/// array's size from its own size's chain, its first level repeated into the +/// larger levels: that chain, which the shader repeats. Any other sprite: its +/// chain at the array's size. +fn source_chain(pixels: &[u8], size: u32, settings: &[Settings], layer: u32) -> (Vec<u8>, u32) { + let native = settings.get(layer as usize).map_or(0, |s| s.native_size); + let edge = if native.is_power_of_two() && native < size { + native + } else { + size + }; + let frame = crate::sprites::resample(pixels, size, edge); + (super::mip_chain(&frame, edge, settings, layer, 1).0, edge) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::mipmap::Strategy; + + /// `animate.wgsl` on the CPU: `chain` (first level `edge` wide) as the + /// full chain of a `size` layer, mixed `millis` thousandths of the way + /// towards `next`. + fn reference(chain: &[u8], next: &[u8], millis: u32, edge: u32, size: u32) -> Vec<u8> { + let levels = size.trailing_zeros() + 1; + let mut out = Vec::new(); + for level in 0..levels { + let width = size >> level; + for y in 0..width { + for x in 0..width { + let texel = if width >= edge { + let scale = width / edge; + y / scale * edge + x / scale + } else { + 4 * (edge * edge - width * width) / 3 + y * width + x + } as usize; + for c in 0..4 { + let (a, b) = ( + u32::from(chain[texel * 4 + c]), + u32::from(next[texel * 4 + c]), + ); + out.push(((a * (1000 - millis) + b * millis + 500) / 1000) as u8); + } + } + } + } + out + } + + fn frame(size: u32, seed: u32) -> Vec<u8> { + (0..size * size) + .flat_map(|i| { + let v = i + .wrapping_mul(2654435761) + .wrapping_add(seed.wrapping_mul(40503)); + let alpha = match v >> 29 { + 0 => 0, + 1 => 77, + _ => 255, + }; + [(v >> 3) as u8, (v >> 11) as u8, (v >> 19) as u8, alpha] + }) + .collect() + } + + fn settings(native: u32, strategy: Strategy) -> Settings { + Settings { + native_size: native, + strategy, + alpha_cutoff_bias: -0.1, + ..Default::default() + } + } + + #[test] + fn source_chains_repeat_into_the_array_chain() { + // Sprites scaled up by whole pixels, at the array's size, and of a + // size that is not a power of two (scaled up to the next one). + for (native, size) in [(16, 16), (16, 64), (8, 32), (32, 64), (1, 16), (24, 32)] { + for strategy in [ + Strategy::Auto, + Strategy::Mean, + Strategy::Cutout, + Strategy::StrictCutout, + Strategy::DarkCutout, + ] { + for item in [false, true] { + let settings = [ + Settings::default(), + Settings { + item, + ..settings(native, strategy) + }, + ]; + let pixels = crate::sprites::resample(&frame(native, 3), native, size); + let (expected, _) = super::super::mip_chain(&pixels, size, &settings, 1, 1); + let (chain, edge) = source_chain(&pixels, size, &settings, 1); + let fits = native.is_power_of_two() && native < size; + assert_eq!(edge, if fits { native } else { size }); + assert_eq!( + reference(&chain, &chain, 0, edge, size), + expected, + "{native} in {size}, {strategy:?}, item {item}" + ); + } + } + } + } + + #[test] + fn real_animation_chains_repeat_into_the_array_chain() { + let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client") + .join(horizon_core::VANILLA_VERSION); + if !root + .join("assets/minecraft/textures/block/water_still.png") + .exists() + { + return; + } + let mut sprites = crate::sprites::Sprites::default(); + for name in [ + "water_still", + "water_flow", + "lava_still", + "fire_0", + "nether_portal", + "sea_lantern", + "prismarine", + "magma", + "kelp", + "straw_bed", + ] { + sprites + .insert(&root, &format!("minecraft:block/{name}")) + .unwrap(); + } + sprites.finish(); + assert_eq!(sprites.size, 64); + assert_eq!(sprites.animations.len(), 9); + for animation in &sprites.animations { + for frame in 0..animation.frame_count() { + let pixels = animation.pixels(frame); + let (expected, _) = + super::super::mip_chain(pixels, 64, &sprites.mips, animation.layer, 1); + let (chain, edge) = source_chain(pixels, 64, &sprites.mips, animation.layer); + assert!(edge < 64, "layer {}", animation.layer); + assert_eq!(reference(&chain, &chain, 0, edge, 64), expected); + } + } + } + + #[test] + fn rounding_matches_f32_mix_but_for_exact_halves() { + // The CPU blend this replaced: f32 mix, then rounded. They differ + // only where the exact mix is a half, which f32 rounded either way. + for millis in 1..1000u32 { + let t = millis as f32 / 1000.0; + for a in 0..=255u32 { + for b in (0..=255u32).step_by(3) { + let f = ((a as f32 / 255.0) * (1.0 - t) + (b as f32 / 255.0) * t) * 255.0; + let exact = a * (1000 - millis) + b * millis; + let ours = (exact + 500) / 1000; + if exact % 1000 != 500 { + assert_eq!(ours, f.round() as u32, "{a} {b} {millis}"); + } + } + } + } + } + + fn device() -> Option<(wgpu::Device, wgpu::Queue)> { + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); + let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?; + pollster::block_on(adapter.request_device(&Default::default())).ok() + } + + /// Every layer's full mip chain, layer major. + fn read_back( + device: &wgpu::Device, + queue: &wgpu::Queue, + texture: &wgpu::Texture, + ) -> Vec<Vec<u8>> { + let layers = texture.depth_or_array_layers(); + let mut out = vec![Vec::new(); layers as usize]; + for level in 0..texture.mip_level_count() { + let edge = texture.width() >> level; + let padded = (edge * 4).next_multiple_of(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT); + let buffer = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: u64::from(padded * edge * layers), + usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let mut encoder = device.create_command_encoder(&Default::default()); + encoder.copy_texture_to_buffer( + wgpu::TexelCopyTextureInfo { + texture, + mip_level: level, + origin: wgpu::Origin3d::ZERO, + aspect: wgpu::TextureAspect::All, + }, + wgpu::TexelCopyBufferInfo { + buffer: &buffer, + layout: wgpu::TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(padded), + rows_per_image: Some(edge), + }, + }, + wgpu::Extent3d { + width: edge, + height: edge, + depth_or_array_layers: layers, + }, + ); + queue.submit([encoder.finish()]); + buffer + .slice(..) + .map_async(wgpu::MapMode::Read, |r| r.unwrap()); + device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); + let data = buffer.slice(..).get_mapped_range().unwrap(); + for (layer, image) in data.chunks((padded * edge) as usize).enumerate() { + for row in image.chunks(padded as usize) { + out[layer].extend_from_slice(&row[..edge as usize * 4]); + } + } + } + out + } + + #[test] + fn gpu_layers_match_the_cpu_chains_every_tick() { + let Some((device, queue)) = device() else { + return; + }; + let size = 32; + // Layers 1 and 3: 8-pixel sprites with and without interpolation; + // layer 4: one at the array's size. Two layers per array. + let clips = [ + ( + 1, + 8, + r#"{"frametime":3,"interpolate":true,"frames":[0,2,1]}"#, + ), + (3, 8, r#"{"frametime":2}"#), + (4, 32, r#"{"frametime":5,"interpolate":true}"#), + ]; + let mut mips = vec![Settings::default(); 6]; + let animations: Vec<_> = clips + .iter() + .map(|&(layer, native, metadata)| { + mips[layer as usize] = settings(native, Strategy::Cutout); + let frames = (0..3) + .map(|f| crate::sprites::resample(&frame(native, layer * 7 + f), native, size)) + .collect(); + crate::sprites::test_frames(layer, frames, metadata) + }) + .collect(); + let split = 2; + let textures: Vec<_> = (0..3) + .map(|_| { + device.create_texture(&wgpu::TextureDescriptor { + label: None, + size: wgpu::Extent3d { + width: size, + height: size, + depth_or_array_layers: split, + }, + mip_level_count: size.trailing_zeros() + 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::STORAGE_BINDING | wgpu::TextureUsages::COPY_SRC, + view_formats: &[], + }) + }) + .collect(); + let mut animator = SpriteAnimator::new(&device, &animations, size, &mips, &textures, split); + let mut uploads = Uploads::new(&device); + let mut writes = Vec::new(); + for tick in [0, 0, 1, 2, 3, 4, 7, 7, 12, 30] { + let mut encoder = device.create_command_encoder(&Default::default()); + let shown: Vec<_> = animator.sprites.iter().map(|s| s.shown).collect(); + animator.animate(&mut encoder, &mut uploads, tick); + writes.push( + animator + .sprites + .iter() + .zip(shown) + .filter(|(s, shown)| s.shown != *shown) + .count(), + ); + uploads.finish(&encoder); + queue.submit([encoder.finish()]); + for animation in &animations { + let blend = animation.blend(tick); + let chain = |f| source_chain(animation.pixels(f), size, &mips, animation.layer); + let ((current, edge), (next, _)) = (chain(blend.frame), chain(blend.next)); + let layers = read_back( + &device, + &queue, + &textures[(animation.layer / split) as usize], + ); + assert_eq!( + layers[(animation.layer % split) as usize], + reference(¤t, &next, blend.millis, edge, size), + "layer {} at tick {tick}", + animation.layer + ); + } + } + // Every sprite on the first tick, then only those whose frame or mix + // changed since they were written: the interpolated ones every tick + // but layer 1 at tick 30 (two 9-tick loops after 12), layer 3 when + // its frame turns over (every 2 ticks, but 12 shows 7's frame). + assert_eq!(writes, [3, 0, 2, 3, 2, 3, 3, 0, 2, 1]); + } +} diff --git a/crates/horizon-client/src/gfx/animate.wgsl b/crates/horizon-client/src/gfx/animate.wgsl new file mode 100644 index 000000000..8998a1aa1 --- /dev/null +++ b/crates/horizon-client/src/gfx/animate.wgsl @@ -0,0 +1,48 @@ +// Animated block sprites (gfx/animate.rs), as vanilla's animate_sprite_blit +// and animate_sprite_interpolate shaders draw them: each job writes its +// frame, or the frame mixed with the next one, into one mip level of its +// sprite array layer. One invocation per texel; the job is the z coordinate. +struct Job { + layer: u32, + // Word offsets of the two frames' mip chains in `frames`. + current: u32, + next: u32, + // Thousandths of the way from `current` to `next` (0: `current` alone). + millis: u32, + // Edge of the chains' first level. + edge: u32, +} +@group(0) @binding(0) var<storage, read> frames: array<u32>; +@group(0) @binding(1) var<storage, read> jobs: array<Job>; +@group(0) @binding(2) var level: texture_storage_2d_array<rgba8unorm, write>; + +fn channels(rgba: u32) -> vec4<u32> { + return vec4(rgba & 0xffu, (rgba >> 8u) & 0xffu, (rgba >> 16u) & 0xffu, rgba >> 24u); +} + +@compute @workgroup_size(8, 8) +fn animate(@builtin(global_invocation_id) id: vec3<u32>) { + let size = textureDimensions(level).x; + if id.x >= size || id.y >= size { + return; + } + let job = jobs[id.z]; + // mipmap::generate: the levels at least as large as the chain's first + // repeat it by whole pixels, the smaller ones are the chain's own. + var texel: u32; + if size >= job.edge { + let scale = size / job.edge; + texel = id.y / scale * job.edge + id.x / scale; + } else { + // Every level above this one, each a quarter of the one before. + texel = 4u * (job.edge * job.edge - size * size) / 3u + id.y * size + id.x; + } + var color = channels(frames[job.current + texel]); + if job.millis > 0u { + // mix(current, next, millis / 1000), rounded to the nearest 8-bit + // value (halves up) in integers: the same on every GPU. + let next = channels(frames[job.next + texel]); + color = (color * (1000u - job.millis) + next * job.millis + 500u) / 1000u; + } + textureStore(level, id.xy, job.layer, vec4<f32>(color) / 255.0); +} diff --git a/crates/horizon-client/src/sprites.rs b/crates/horizon-client/src/sprites.rs index b89983966..6d754894a 100644 --- a/crates/horizon-client/src/sprites.rs +++ b/crates/horizon-client/src/sprites.rs @@ -63,6 +63,9 @@ impl SpriteAnimation { pub fn pixels(&self, frame: usize) -> &[u8] { &self.frames[frame] } + pub fn frame_count(&self) -> usize { + self.frames.len() + } } #[derive(Default)] @@ -93,7 +96,7 @@ pub const SPRITE_SIZE: u32 = 16; /// with bigger textures are sampled down to fit. const MAX_ARRAY_BYTES: u64 = 256 << 20; /// Nearest-resample a square RGBA frame to another square size. -fn resample(frame: &[u8], from: u32, to: u32) -> Vec<u8> { +pub(crate) fn resample(frame: &[u8], from: u32, to: u32) -> Vec<u8> { if from == to { return frame.to_vec(); } @@ -327,11 +330,15 @@ pub(crate) fn test_clip(size: u32, layer: u32, metadata: &str) -> SpriteAnimatio .flat_map(|i| [(i % size) as u8, (i / size) as u8, blue, 255]) .collect() }; + test_frames(layer, vec![frame(0), frame(99)], metadata) +} +#[cfg(test)] +pub(crate) fn test_frames(layer: u32, frames: Vec<Vec<u8>>, metadata: &str) -> SpriteAnimation { let metadata = AnimationMetadata::from_json(metadata).unwrap(); SpriteAnimation { layer, - frames: Arc::new(vec![frame(0), frame(99)]), - clip: Arc::new(metadata.clip(2).unwrap().unwrap()), + clip: Arc::new(metadata.clip(frames.len() as u32).unwrap().unwrap()), + frames: Arc::new(frames), } } From 8b16f76b3c1f17d12c1b2bd5e1ed85c44a10e361 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:39:28 +0200 Subject: [PATCH 18/62] Section walk: no per-section frustum test in columns entirely inside A column whose box lies entirely inside the frustum holds no section the frustum would reject (plane distances only grow from its nearest corner to a section's farthest, and rounding keeps the order), so its sections skip the test. At render distance 32 most columns are past the distance where the vertical field of view takes in their whole height. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/gfx.rs | 14 +++++ crates/horizon-client/src/gfx/resident.rs | 70 ++++++++++++++++++++--- 2 files changed, 75 insertions(+), 9 deletions(-) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 14c040c5c..d75a1144f 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -4059,6 +4059,20 @@ impl Frustum { p.truncate().dot(v) + p.w < 0.0 }) } + /// Whether the camera-relative box `min..max` is entirely inside. Then + /// `intersects` accepts every box within it: each plane's distance only + /// grows from this box's nearest corner to the inner box's farthest, and + /// rounding keeps that order. + pub fn contains(&self, min: Vec3, max: Vec3) -> bool { + self.planes.iter().all(|p| { + let v = Vec3::new( + if p.x >= 0.0 { min.x } else { max.x }, + if p.y >= 0.0 { min.y } else { max.y }, + if p.z >= 0.0 { min.z } else { max.z }, + ); + p.truncate().dot(v) + p.w >= 0.0 + }) + } } /// Vanilla's `Projection`: reversed depth (near maps to 1, far to 0, tests /// are GREATER_THAN_OR_EQUAL), which keeps far faces a hair apart, like diff --git a/crates/horizon-client/src/gfx/resident.rs b/crates/horizon-client/src/gfx/resident.rs index 49407e77a..51e5d8176 100644 --- a/crates/horizon-client/src/gfx/resident.rs +++ b/crates/horizon-client/src/gfx/resident.rs @@ -169,14 +169,20 @@ fn in_view(key: SectionKey, camera: DVec3, radius: i32, frustum: &Frustum) -> Op if !in_view_distance(camera_column(camera), radius, key.0, key.2) { return None; } - in_frustum(key, camera, frustum) + in_frustum(key, camera, frustum, false) } -/// `in_view` without the distance test. -fn in_frustum(key: SectionKey, camera: DVec3, frustum: &Frustum) -> Option<(f64, Vec3)> { +/// `in_view` without the distance test; `inside`: the section's column is +/// entirely inside the frustum, so the section is too. +fn in_frustum( + key: SectionKey, + camera: DVec3, + frustum: &Frustum, + inside: bool, +) -> Option<(f64, Vec3)> { let origin = origin(key, camera); let min = origin.as_vec3(); - if !frustum.intersects(min, min + Vec3::splat(16.0)) { + if !inside && !frustum.intersects(min, min + Vec3::splat(16.0)) { return None; } Some(((origin + DVec3::splat(8.0)).length_squared(), min)) @@ -192,8 +198,9 @@ impl<T> Resident<T> { /// Columns are tested first, with the same distance test (it depends /// only on x and z) and a box spanning their sections: every section box /// lies inside it and the frustum test rounds monotonically, so a column - /// the frustum rejects holds no section it would accept. `radius` is the - /// render distance in chunks. + /// the frustum rejects holds no section it would accept, and one + /// entirely inside holds none it would reject (its sections skip the + /// test). `radius` is the render distance in chunks. pub fn visible( &self, camera: DVec3, @@ -211,7 +218,9 @@ impl<T> Resident<T> { } let min = origin((column.x, column.low, column.z), camera).as_vec3(); let top = origin((column.x, column.high, column.z), camera).as_vec3(); - if !frustum.intersects(min, top + Vec3::splat(16.0)) { + let max = top + Vec3::splat(16.0); + let inside = frustum.contains(min, max); + if !inside && !frustum.intersects(min, max) { continue; } for &(y, slot) in &column.sections { @@ -219,7 +228,7 @@ impl<T> Resident<T> { if near && !reachable(key) { continue; } - if let Some((d, o)) = in_frustum(key, camera, frustum) { + if let Some((d, o)) = in_frustum(key, camera, frustum, inside) { out.push(Visible { distance: d.to_bits(), key, @@ -277,7 +286,7 @@ mod tests { if near { in_view(k, camera, radius, &frustum).filter(|_| reachable(k)) } else if beyond(k.0, k.2) { - in_frustum(k, camera, &frustum) + in_frustum(k, camera, &frustum, false) } else { None } @@ -298,6 +307,49 @@ mod tests { } } + #[test] + fn columns_entirely_inside_skip_no_section() { + // Short columns ahead of the camera: most lie entirely inside. + let mut r = Resident::default(); + for x in -12i32..=12 { + for z in 1..=12 { + for y in 3..6 { + if (x + y + z).rem_euclid(3) != 0 { + r.insert((x, y, z), ()); + } + } + } + } + let camera = DVec3::new(0.5, -8.0, 0.5); + let projection = super::super::world_projection(70.0, 16.0 / 9.0, 512.0); + let frustum = Frustum { + planes: super::super::frustum(projection * crate::camera::view_matrix(0.0, 5.0)), + }; + let inside = r + .columns + .iter() + .filter(|c| { + let min = origin((c.x, c.low, c.z), camera).as_vec3(); + let top = origin((c.x, c.high, c.z), camera).as_vec3(); + frustum.contains(min, top + Vec3::splat(16.0)) + }) + .count(); + assert!(inside > 50 && inside < r.columns.len(), "{inside}"); + let mut fast = Vec::new(); + r.visible(camera, 12, &frustum, |_| true, |_, _| false, &mut fast); + let mut slow: Vec<_> = r + .items + .iter() + .filter_map(|&(k, _)| in_view(k, camera, 12, &frustum).map(|(d, _)| (d, k))) + .collect(); + slow.sort_unstable_by(|a, b| a.0.total_cmp(&b.0).then(a.1.cmp(&b.1))); + let fast: Vec<_> = fast + .iter() + .map(|v| (f64::from_bits(v.distance), v.key)) + .collect(); + assert_eq!(fast, slow); + } + /// Every key reaches its value through its slot and column, and every /// column's bounds and sections match the keys. fn check(r: &Resident<u32>, model: &HashMap<SectionKey, u32>) { From 7eded537d6b69c98e4f8476360feaa3359395b74 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 21:45:57 +0200 Subject: [PATCH 19/62] perf_bench: wait for Horizon to actually load before timing a scene Right after a teleport, and at spawn, Horizon v2026.10.22.04 reports nothing queued and steady chunk counts for over a second before it starts loading. wait_loaded() took that for "loaded" and stopped the clock with 0 to 3 sections meshed (load 0.1 s), so the flights ran over empty terrain and the frame rates meant nothing. Now the counts must change once since the wait began (or stay at the full view for 5 s), and the resident chunks must reach 80% of the view circle (pi x RD^2), before a steady second counts as loaded. Measured with it on the Mac mini and the ThinkPad for the website's Benchmarks page (#1274). At RD 32 a 4-thread laptop needs --timeout above the default 300 s. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- tools/perf_bench.py | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/tools/perf_bench.py b/tools/perf_bench.py index eb6b3fda2..bf5ee5582 100644 --- a/tools/perf_bench.py +++ b/tools/perf_bench.py @@ -307,7 +307,12 @@ def poll(control, check, limit, interval=0.05): QUIET_MESHES_PER_S = 100 -def wait_loaded(control, near, limit): +def view_chunks(distance): + """80% of the view circle (pi x RD^2): Horizon keeps 637 columns at RD 12 and 3725 at RD 32.""" + return int(0.8 * math.pi * distance ** 2) + + +def wait_loaded(control, near, limit, min_chunks=0): """Waits until the player is spawned (near(position)), nothing is queued, the resident and generated chunk counts have not changed for a second, as the vanilla driver does, and the last sections are drawn; returns when the last @@ -320,6 +325,10 @@ def wait_loaded(control, near, limit): already taken, and sections waiting for their neighbours' light.)""" deadline = time.time() + limit last, changed, previous, meshing = None, time.time(), None, time.time() + # Right after a teleport (and at spawn) Horizon reports nothing queued and steady counts for over a second + # before it starts loading: the counts must change once, or stay full for 5 s, and the resident chunks reach + # min_chunks, before "steady" means loaded. + first, moved, began = None, False, time.time() while time.time() < deadline: try: s = control("status", timeout=10) @@ -331,6 +340,12 @@ def wait_loaded(control, near, limit): last, changed, previous, meshing = None, now, None, now else: counts = (s["chunks"], s["generated_chunks"]) + first = first or counts + moved = moved or counts != first or (s["chunks"] >= min_chunks > 0 and now - began > 5) + if not moved or s["chunks"] < min_chunks: + last, changed, previous, meshing = None, now, None, now + time.sleep(0.05) + continue if counts != last: last, changed = counts, now stages = s.get("streaming") @@ -392,7 +407,7 @@ def run_horizon(args, distance): result["renderer"] = title["renderer"] result["startup"] = {"title_s": at - started} control(f"open {WORLD} {SEED} creative") - result["startup"]["world_s"] = wait_loaded(control, lambda p: True, args.timeout) - started + result["startup"]["world_s"] = wait_loaded(control, lambda p: True, args.timeout, view_chunks(distance)) - started for name, start, end, pitch in scene_list(args): control("time 6000") meshed = control("status")["meshed_sections"] @@ -402,7 +417,7 @@ def run_horizon(args, distance): control("fly {0} {1} {2} {0} {1} {2} 0.1 {3}".format(*start, pitch)) control(f"look {yaw(start, end):.3f} {pitch}") near = lambda p: sum((a - b) ** 2 for a, b in zip(p, start)) < 4.0 - scene = {"load_s": wait_loaded(control, near, args.timeout) - tp} + scene = {"load_s": wait_loaded(control, near, args.timeout, view_chunks(distance)) - tp} # Section meshes built while loading and while flying (Horizon only). loaded_meshes = control("status")["meshed_sections"] scene["meshes_load"] = loaded_meshes - meshed From 9e1c3ec860c0961385a2f2b77d13d4627b9ea833 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 21:51:16 +0200 Subject: [PATCH 20/62] perf_bench: the readiness gate only with a chunk target; a test for the quiet start Without min_chunks (the old call) wait_loaded behaves as before, which tests/test_perf_bench.py's old-builds case relies on. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- tests/test_perf_bench.py | 16 ++++++++++++++-- tools/perf_bench.py | 2 +- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/tests/test_perf_bench.py b/tests/test_perf_bench.py index 4729c5e20..ea074442e 100644 --- a/tests/test_perf_bench.py +++ b/tests/test_perf_bench.py @@ -50,7 +50,7 @@ if __name__ == "__main__": class WaitLoadedTests(unittest.TestCase): """wait_loaded on a scripted game with a fake clock: one status per 50 ms poll.""" - def run_script(self, statuses): + def run_script(self, statuses, min_chunks=0): import tools.perf_bench as pb clock = [0.0] it = iter(statuses) @@ -62,7 +62,7 @@ class WaitLoadedTests(unittest.TestCase): pb.time.time = lambda: clock[0] pb.time.sleep = lambda s: clock.__setitem__(0, clock[0] + s) try: - return pb.wait_loaded(control, lambda p: True, 60) + return pb.wait_loaded(control, lambda p: True, 60, min_chunks) finally: pb.time.time, pb.time.sleep = real_time, real_sleep @@ -86,3 +86,15 @@ class WaitLoadedTests(unittest.TestCase): busy = [self.status(901, 1000 * i) for i in range(20)] quiet = [self.status(901, 20000 + i) for i in range(40)] self.assertAlmostEqual(self.run_script(busy + quiet), 1.0, places=6) + + def test_a_quiet_start_is_not_a_load(self): + # Right after a teleport Horizon reports steady counts and nothing queued for 1.5 s before it loads: + # with a target the clock runs on until the chunks are there and the meshing has gone quiet. + idle = [self.status(3, 0, stages=0) for _ in range(30)] + loading = [self.status(30 * (i + 1), 500 * i, stages=500) for i in range(20)] + tail = [self.status(600, 10000, stages=0) for _ in range(60)] + took = self.run_script(idle + loading + tail, min_chunks=500) + self.assertGreater(took, 2.4) + self.assertLess(took, 4.0) + # Without one (the old call), the quiet start ends the wait at once. + self.assertLess(self.run_script(idle + loading + tail), 1.6) diff --git a/tools/perf_bench.py b/tools/perf_bench.py index bf5ee5582..6ff6b8052 100644 --- a/tools/perf_bench.py +++ b/tools/perf_bench.py @@ -342,7 +342,7 @@ def wait_loaded(control, near, limit, min_chunks=0): counts = (s["chunks"], s["generated_chunks"]) first = first or counts moved = moved or counts != first or (s["chunks"] >= min_chunks > 0 and now - began > 5) - if not moved or s["chunks"] < min_chunks: + if min_chunks and (not moved or s["chunks"] < min_chunks): last, changed, previous, meshing = None, now, None, now time.sleep(0.05) continue From 9f54087a8694a4d9b620240a93b29bad14020ef4 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 23:04:29 +0200 Subject: [PATCH 21/62] Win screen: cover main's menu-blur match (Screen::Win) Main's Screen::blurs_background (in-world menu blur) has no arm for the new Screen::Win. WinScreen.extractBackground fills the screen with the End portal while the poem rolls and falls back to Screen.extractBackground (blurred) for the credits alone, so Game::menu_blur blurs only for the credits without the poem. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game.rs | 3 ++- crates/horizon-client/src/game/screens.rs | 4 ++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 9e06e12bb..8e4f96d46 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -10061,7 +10061,8 @@ impl Game<'_> { }) || (self.title.is_none() && self.player.is_some() - && self.screen.blurs_background(self.pause_menu))); + && (self.screen.blurs_background(self.pause_menu) + || (self.screen == Screen::Win && self.win_screen_pauses())))); let radius = self.settings.menu_blur as f32; (blurred && radius >= 1.0).then_some(radius) } diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs index 07eacfb49..b2b869340 100644 --- a/crates/horizon-client/src/game/screens.rs +++ b/crates/horizon-client/src/game/screens.rs @@ -21,6 +21,9 @@ impl Screen { | Self::Inventory | Self::Dead | Self::CommandBlock => false, + // WinScreen.extractBackground: the poem fills the screen with the End portal, the + // credits alone blur. Game::menu_blur knows which one rolls. + Self::Win => false, } } } @@ -375,6 +378,7 @@ mod tests { Screen::Inventory, Screen::Dead, Screen::CommandBlock, + Screen::Win, ] { assert!(!screen.blurs_background(true)); assert!(!screen.blurs_background(false)); From 18bf8cd2ef0fda0582bf59540ade05d0ce5a9d27 Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Fri, 23 Oct 2026 02:52:48 +0500 Subject: [PATCH 22/62] Minecarts push each other in their own ticks, as vanilla does OldMinecartBehavior.tick ends with pushAndPickupEntities: after a cart moves, every other cart in its box (0.2 wider) gets push(cart). Horizon pushed all pairs once before any cart moved, so carts placed inside each other stayed exactly overlapping (push skips distances under 1e-4) and never split apart. Pushes now run per cart, after its move, with pushOtherMinecart's Mth sin table facing and float thresholds. --- crates/horizon-client/src/game/minecarts.rs | 119 +++++++++++--------- 1 file changed, 68 insertions(+), 51 deletions(-) diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index 756202530..b9d7f3893 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -16,7 +16,7 @@ use horizon_client::{ sound_engine::{CartSound, SoundEngine, SoundInstance, Sounds}, }; use horizon_core::{ - geometry::{Aabb, Vec3}, + geometry::{Aabb, Vec3, trig}, random::RandomSource, }; use horizon_world::registry::BlockStateId; @@ -683,8 +683,7 @@ impl Game<'_> { } } } - /// `AbstractMinecart.push(player)` when the player walks into a cart, - /// and carts pushing each other (`pushOtherMinecart`). + /// `AbstractMinecart.push(player)` when the player walks into a cart. fn push_carts(&mut self) { let player = self.player.as_ref().map(|p| p.position); let riding = self.riding; @@ -719,55 +718,71 @@ impl Game<'_> { } } } - for j in i + 1..self.carts.len() { - let (a, b) = (&self.carts[i], &self.carts[j]); - if !a - .bounds() - .inflate(Vec3::new(0.2, 0.0, 0.2)) - .intersects(b.bounds()) - { - continue; - } - let (mut xa, mut za) = (b.position.x - a.position.x, b.position.z - a.position.z); - let dd = xa * xa + za * za; - if dd < 1.0e-4 { - continue; - } - let d = dd.sqrt(); - let pow = (1.0 / d).min(1.0); - xa = xa / d * pow * f64::from(0.1f32) * 0.5; - za = za / d * pow * f64::from(0.1f32) * 0.5; - let dir = - glam::DVec2::new(b.position.x - a.position.x, b.position.z - a.position.z) - .normalize_or_zero(); - let r = a.yaw.to_radians(); - let facing = - glam::DVec2::new(f64::from(r.cos()), f64::from(r.sin())).normalize_or_zero(); - if dir.dot(facing).abs() < f64::from(0.8f32) { - continue; - } - let (ma, mb) = (a.velocity, b.velocity); - let (fa, fb) = (a.kind == CartKind::Furnace, b.kind == CartKind::Furnace); - let (na, nb) = if fb && !fa { - ( - Vec3::new(ma.x * 0.2 + mb.x - xa, ma.y, ma.z * 0.2 + mb.z - za), - Vec3::new(mb.x * 0.95, mb.y, mb.z * 0.95), - ) - } else if fa && !fb { - ( - Vec3::new(ma.x * 0.95, ma.y, ma.z * 0.95), - Vec3::new(mb.x * 0.2 + ma.x + xa, mb.y, mb.z * 0.2 + ma.z + za), - ) - } else { - let (xdd, zdd) = ((mb.x + ma.x) / 2.0, (mb.z + ma.z) / 2.0); - ( - Vec3::new(ma.x * 0.2 + xdd - xa, ma.y, ma.z * 0.2 + zdd - za), - Vec3::new(mb.x * 0.2 + xdd + xa, mb.y, mb.z * 0.2 + zdd + za), - ) - }; - self.carts[i].velocity = na; - self.carts[j].velocity = nb; + } + } + /// `OldMinecartBehavior.pushAndPickupEntities` for carts, at the end of + /// cart `i`'s own tick: each other cart in its box (0.2 wider on each + /// side) gets `push(cart i)`. Running it per cart, after that cart moved + /// and before the next one does, is what splits stacked carts apart. + fn push_from_cart(&mut self, i: usize) { + let reach = f64::from(0.2f32); + let hitbox = self.carts[i].bounds().inflate(Vec3::new(reach, 0.0, reach)); + for j in 0..self.carts.len() { + if j == i || !hitbox.intersects(self.carts[j].bounds()) { + continue; } + // AbstractMinecart.push(entity): `this` is cart j, `entity` cart i. + let (this, other) = (&self.carts[j], &self.carts[i]); + let (mut xa, mut za) = ( + other.position.x - this.position.x, + other.position.z - this.position.z, + ); + let dd = xa * xa + za * za; + if dd < f64::from(1.0e-4f32) { + continue; + } + let d = dd.sqrt(); + xa /= d; + za /= d; + let pow = (1.0 / d).min(1.0); + xa = xa * pow * f64::from(0.1f32) * 0.5; + za = za * pow * f64::from(0.1f32) * 0.5; + // pushOtherMinecart (old movement): only along this cart's facing. + let dir = glam::DVec2::new( + other.position.x - this.position.x, + other.position.z - this.position.z, + ) + .normalize_or_zero(); + let r = f64::from(this.yaw * 0.017453292f32); + let facing = glam::DVec2::new(f64::from(trig::cos(r)), f64::from(trig::sin(r))) + .normalize_or_zero(); + if dir.dot(facing).abs() < f64::from(0.8f32) { + continue; + } + let (mt, mo) = (this.velocity, other.velocity); + let (ft, fo) = ( + this.kind == CartKind::Furnace, + other.kind == CartKind::Furnace, + ); + let (nt, no) = if fo && !ft { + ( + Vec3::new(mt.x * 0.2 + (mo.x - xa), mt.y, mt.z * 0.2 + (mo.z - za)), + Vec3::new(mo.x * 0.95, mo.y, mo.z * 0.95), + ) + } else if !fo && ft { + ( + Vec3::new(mt.x * 0.95, mt.y, mt.z * 0.95), + Vec3::new(mo.x * 0.2 + (mt.x + xa), mo.y, mo.z * 0.2 + (mt.z + za)), + ) + } else { + let (xdd, zdd) = ((mo.x + mt.x) / 2.0, (mo.z + mt.z) / 2.0); + ( + Vec3::new(mt.x * 0.2 + (xdd - xa), mt.y, mt.z * 0.2 + (zdd - za)), + Vec3::new(mo.x * 0.2 + (xdd + xa), mo.y, mo.z * 0.2 + (zdd + za)), + ) + }; + self.carts[j].velocity = nt; + self.carts[i].velocity = no; } } /// Every cart but the ridden one (which ticks with its rider). @@ -794,6 +809,7 @@ impl Game<'_> { } if alive { self.carts[i] = c; + self.push_from_cart(i); i += 1; } else { self.carts.remove(i); @@ -867,6 +883,7 @@ impl Game<'_> { } if alive { self.carts[i] = c; + self.push_from_cart(i); } else { self.carts.remove(i); self.riding = None; From 18078e058d52e7aef20cea156326d3816ca61918 Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Fri, 23 Oct 2026 03:47:04 +0500 Subject: [PATCH 23/62] Explosions hurt and push minecarts, so TNT minecarts chain ServerExplosion.hurtEntities skipped minecarts: a TNT minecart's blast never reached the carts beside it. Carts now take the explosion's damage through VehicleEntity.hurtServer (destroyed past 40, where MinecartTNT.destroy primes a TNT cart with a 0-39 tick fuse, as damageSourceIgnitesTnt counts explosions) and the knockback from their eyes. The exploding cart is the explosion's source, so it is removed before the blast and can't hit itself. Cart ticks now look carts up by id, since a blast can remove or prime other carts mid-loop. --- crates/horizon-client/src/game/explosion.rs | 30 ++++++++++++++++++++- crates/horizon-client/src/game/minecarts.rs | 30 ++++++++++++++------- 2 files changed, 50 insertions(+), 10 deletions(-) diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs index 5cf67f586..0923b4110 100644 --- a/crates/horizon-client/src/game/explosion.rs +++ b/crates/horizon-client/src/game/explosion.rs @@ -224,7 +224,7 @@ impl Game<'_> { } set.entries().map(|(k, _)| k.0).collect() } - /// `ServerExplosion.hurtEntities` (player, mobs, items, primed TNT); + /// `ServerExplosion.hurtEntities` (player, mobs, items, primed TNT, minecarts); /// the player takes `damage_type`. /// `ServerExplosion.hurtEntities` for the player: damage scaled by /// distance and exposure, through a raised shield (`hurtServer` blocks @@ -460,6 +460,34 @@ impl Game<'_> { ); } self.tnts = tnts; + // Minecarts: VehicleEntity.hurtServer (explosions ignite TNT carts), + // then the push from their eyes (0.85 of their height). + let ids: Vec<u32> = self.carts.iter().map(|c| c.id).collect(); + for id in ids { + let Some(i) = self.carts.iter().position(|c| c.id == id) else { + continue; + }; + let bounds = self.carts[i].bounds(); + let feet = self.carts[i].position; + let dist = distance([feet.x, feet.y, feet.z]) / diameter; + if dist > 1.0 { + continue; + } + let (lo, hi) = (bounds.min_position(), bounds.max_position()); + let exposure = self.seen_percent(center, [lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z]); + self.hurt_cart(i, damage(dist, exposure), false, true); + let Some(c) = self.carts.iter_mut().find(|c| c.id == id) else { + continue; + }; + let eye_height = f64::from((hi.y - lo.y) as f32 * 0.85f32); + let dir = direction([feet.x, feet.y + eye_height, feet.z]); + let power = (1.0 - dist) * f64::from(exposure); + c.velocity = Vec3::new( + c.velocity.x + dir[0] * power, + c.velocity.y + dir[1] * power, + c.velocity.z + dir[2] * power, + ); + } } /// `Level.explode` on the server: positions, entities, blocks, fire; then /// the client's explosion sound. diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index b9d7f3893..9173139aa 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -637,6 +637,9 @@ impl Game<'_> { let r = self.world.random.next_double(); let power = (4.0 + r * 1.5 * speed) as f32; let at = [c.position.x, c.position.y, c.position.z]; + // The cart is the explosion's source: it is gone before the blast + // looks for entities, so it can't hit itself. + self.carts.retain(|x| x.id != c.id); let _ = self.server_explode(at, power, BlockInteraction::Destroy, false); } /// `MinecartHopper.suckInItems`: items above, into the five slots. @@ -792,14 +795,17 @@ impl Game<'_> { let ticking = self.entity_ticking_area(); // A server player's minecart moves with its rider (lan_vehicles.rs). let ridden = self.guest_vehicles(); - let mut i = 0; - while i < self.carts.len() { + // By id: an exploding cart can destroy or prime others mid-loop. + let ids: Vec<u32> = self.carts.iter().map(|c| c.id).collect(); + for id in ids { + let Some(i) = self.carts.iter().position(|c| c.id == id) else { + continue; + }; let p = self.carts[i].position; - if Some(self.carts[i].id) == self.riding - || ridden.contains(&self.carts[i].id) + if Some(id) == self.riding + || ridden.contains(&id) || !ticking(p.x.floor() as i32, p.z.floor() as i32) { - i += 1; continue; } let mut c = self.carts[i].clone(); @@ -807,10 +813,12 @@ impl Game<'_> { if c.kind == CartKind::Hopper { self.hopper_cart_pickup(&mut c); } + let Some(i) = self.carts.iter().position(|c| c.id == id) else { + continue; + }; if alive { self.carts[i] = c; self.push_from_cart(i); - i += 1; } else { self.carts.remove(i); } @@ -881,6 +889,10 @@ impl Game<'_> { p.velocity = Vec3::ZERO; p.fall_distance = 0.0; } + let Some(i) = self.carts.iter().position(|x| x.id == c.id) else { + self.riding = None; + return true; + }; if alive { self.carts[i] = c; self.push_from_cart(i); @@ -1138,8 +1150,8 @@ impl Game<'_> { } /// `VehicleEntity.hurtServer`: shake, add the damage, break past 40 (at /// once for creative players); TNT minecarts prime instead when moving - /// or hurt by fire. - fn hurt_cart(&mut self, i: usize, damage: f32, creative: bool, fire: bool) { + /// or hurt by fire or an explosion (`damageSourceIgnitesTnt`). + pub(super) fn hurt_cart(&mut self, i: usize, damage: f32, creative: bool, fire: bool) { let c = &mut self.carts[i]; c.hurt_dir = -c.hurt_dir; c.hurt_time = 10; @@ -1148,7 +1160,7 @@ impl Game<'_> { if destroyed { let mut c = self.carts.remove(i); let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z; - if c.kind == CartKind::Tnt && (fire || speed >= 0.01) { + if c.kind == CartKind::Tnt && (fire || speed >= f64::from(0.01f32)) { // MinecartTNT.destroy: prime instead of breaking. if c.fuse < 0 { self.prime_cart(&mut c); From bdbe59155d344623d9dec6871cfac2a11891fac1 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 01:56:28 +0200 Subject: [PATCH 24/62] Locator bar: drop the live-backdrop check main removed #1271 removed the title's live world backdrop (backdrop_live), so the locator bar hides on the title alone. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 4d56f21e6..e186e9e3f 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9801,7 +9801,7 @@ impl Game<'_> { self.fov_degrees(camera_alpha as f32, camera.to_array()) }; self.locator_camera = - (!live && !title).then_some((camera.to_array(), view_yaw, view_pitch, fov_degrees)); + (!title).then_some((camera.to_array(), view_yaw, view_pitch, fov_degrees)); let bob = if title { glam::Mat4::IDENTITY } else { From 3f58e512e091751e95046504842054768ac3f2d8 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 02:16:54 +0200 Subject: [PATCH 25/62] Options test: Credits & Attribution follows Horizon's two buttons main (#1271) pins Horizon Settings and Mods as the grid's last buttons; this branch adds Credits & Attribution after them. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/options_ui.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 617c2ee9d..383946991 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -4184,9 +4184,13 @@ mod tests { }) .collect() }; - // Vanilla's ten Options buttons, the last two Horizon's. + // Vanilla's Options buttons, Horizon's two in the Telemetry and Credits slots, then + // Credits & Attribution (WinScreen's credits). let main = pushes(&mut ui); - assert_eq!(&main[main.len() - 2..], [Page::Horizon, Page::Mods]); + assert_eq!( + &main[main.len() - 3..], + [Page::Horizon, Page::Mods, Page::Credits] + ); ui.push(Page::Horizon); assert_eq!( pushes(&mut ui), From 768f14919038fa03e6e5a7d6d51772c75b09c212 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 03:04:19 +0200 Subject: [PATCH 26/62] Horizon Settings > AI Agent: turn agent control on, see who is connected, copy the details Horizon Settings gains a row: "AI Agent..." and "No AI: Off". No AI hides the AI Agent page and closes the control socket at once. The AI Agent page has an Agent Control switch (horizon-extras.txt agentControl, off by default): on, the game the player starts opens the default control endpoint, so horizon-ctl and MCP clients reach it without --control. Turning it off closes the endpoint at once; dropping a control server now also stops its listener thread. The page shows whether an agent is connected, when it last sent a command and the socket, and Copy Connection Details copies the socket path, a horizon-ctl line to try and the MCP config for this game. agent_control_e2e.py --scenario setting covers it: Agent Control on opens the endpoint without --control, the pages list their widgets, Copy works, and turning the switch off removes the endpoint while the game keeps running. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/control.rs | 54 ++++++- crates/horizon-client/src/extras.rs | 25 +++- crates/horizon-client/src/game.rs | 20 +-- .../horizon-client/src/game/agent_settings.rs | 140 ++++++++++++++++++ crates/horizon-client/src/game/control.rs | 7 + crates/horizon-client/src/game/options.rs | 7 + .../horizon-client/src/game/startup_menu.rs | 3 +- crates/horizon-client/src/options_ui.rs | 64 ++++++++ tools/agent_control_e2e.py | 70 ++++++++- 9 files changed, 370 insertions(+), 20 deletions(-) create mode 100644 crates/horizon-client/src/game/agent_settings.rs diff --git a/crates/horizon-client/src/control.rs b/crates/horizon-client/src/control.rs index 9749cc9bd..931bcbdf5 100644 --- a/crates/horizon-client/src/control.rs +++ b/crates/horizon-client/src/control.rs @@ -13,7 +13,11 @@ use std::{ io::{self, BufRead, BufReader, Read, Write}, net::{Ipv4Addr, TcpListener, TcpStream}, path::{Path, PathBuf}, - sync::mpsc, + sync::{ + Arc, + atomic::{AtomicBool, AtomicUsize, Ordering}, + mpsc, + }, thread, }; @@ -151,6 +155,12 @@ pub struct Server { path: PathBuf, requests: mpsc::Receiver<Request>, sender: mpsc::Sender<Request>, + /// Clients connected now (an MCP server keeps one open; horizon-ctl one per command). + clients: Arc<AtomicUsize>, + /// Set when the server is dropped: the listener stops accepting and exits. + closed: Arc<AtomicBool>, + /// The TCP port, to wake the listener when closing. + port: Option<u16>, } /// `$HORIZON_CONTROL`, else `horizon-control.sock` in the user's runtime @@ -174,10 +184,15 @@ impl Server { } let (sender, requests) = mpsc::channel(); let local = sender.clone(); + let clients = Arc::new(AtomicUsize::new(0)); + let counted = clients.clone(); + let closed = Arc::new(AtomicBool::new(false)); + let mut tcp_port = None; if uses_tcp(path) { let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0))?; let token = random_token(); let port = listener.local_addr()?.port(); + tcp_port = Some(port); write_private( path, &serde_json::json!({ "transport": "tcp", "port": port, "token": token }) @@ -186,6 +201,8 @@ impl Server { spawn_listener( move || listener.accept().map(|(s, _)| s), sender, + counted, + closed.clone(), move |stream: TcpStream| { let _ = stream.set_nodelay(true); let mut stream = Stream::Tcp(stream); @@ -199,6 +216,8 @@ impl Server { spawn_listener( move || listener.accept().map(|(s, _)| s), sender, + counted, + closed.clone(), |s| Some(Stream::Unix(s)), )?; } @@ -207,6 +226,9 @@ impl Server { path: path.to_owned(), requests, sender: local, + clients, + closed, + port: tcp_port, }) } /// Commands from inside the process only (`--benchmark` without `--control`). @@ -216,8 +238,15 @@ impl Server { path: PathBuf::new(), requests, sender, + clients: Arc::default(), + closed: Arc::default(), + port: None, } } + /// How many clients are connected. + pub fn clients(&self) -> usize { + self.clients.load(Ordering::Relaxed) + } /// Sends commands as a socket client would, from another thread. pub fn sender(&self) -> mpsc::Sender<Request> { self.sender.clone() @@ -234,6 +263,8 @@ impl Server { fn spawn_listener<S: Send + 'static>( mut accept_next: impl FnMut() -> io::Result<S> + Send + 'static, sender: mpsc::Sender<Request>, + clients: Arc<AtomicUsize>, + closed: Arc<AtomicBool>, accept: impl Fn(S) -> Option<Stream> + Send + Sync + 'static, ) -> io::Result<()> { let accept = std::sync::Arc::new(accept); @@ -241,17 +272,24 @@ fn spawn_listener<S: Send + 'static>( .name("horizon-control".into()) .spawn(move || { loop { - let Ok(stream) = accept_next() else { + let next = accept_next(); + if closed.load(Ordering::Relaxed) { + return; + } + let Ok(stream) = next else { thread::sleep(std::time::Duration::from_millis(10)); continue; }; let sender = sender.clone(); let accept = accept.clone(); + let clients = clients.clone(); let _ = thread::Builder::new() .name("horizon-control-client".into()) .spawn(move || { if let Some(stream) = accept(stream) { + clients.fetch_add(1, Ordering::Relaxed); serve(stream, &sender); + clients.fetch_sub(1, Ordering::Relaxed); } }); } @@ -287,6 +325,18 @@ fn authenticate(stream: &mut Stream, token: &str) -> bool { impl Drop for Server { fn drop(&mut self) { + if self.path.as_os_str().is_empty() { + return; + } + // Wake the listener so it sees `closed` and exits (agent control turned off in-game). + self.closed.store(true, Ordering::Relaxed); + match self.port { + Some(port) => drop(TcpStream::connect((Ipv4Addr::LOCALHOST, port))), + #[cfg(unix)] + None => drop(UnixStream::connect(&self.path)), + #[cfg(not(unix))] + None => {} + } let _ = std::fs::remove_file(&self.path); } } diff --git a/crates/horizon-client/src/extras.rs b/crates/horizon-client/src/extras.rs index 2dbcd1a8f..698741846 100644 --- a/crates/horizon-client/src/extras.rs +++ b/crates/horizon-client/src/extras.rs @@ -109,6 +109,9 @@ pub struct Extras { pub sort_key: String, /// No AI: every AI feature hidden and off (`horizon_core::no_ai`; the launcher writes it too). pub no_ai: bool, + /// Agents may control the game the player starts: it opens its control socket for + /// horizon-ctl and MCP clients (off by default; an agent's own launch always opens it). + pub agent_control: bool, } impl Default for Extras { fn default() -> Self { @@ -138,6 +141,7 @@ impl Default for Extras { sort: false, sort_key: "key.keyboard.unknown".into(), no_ai: false, + agent_control: false, } } } @@ -202,6 +206,7 @@ impl Extras { "sort" => e.sort = flag(e.sort), "sortKey" if value.starts_with("key.") => e.sort_key = value.to_owned(), horizon_core::no_ai::KEY => e.no_ai = flag(e.no_ai), + "agentControl" => e.agent_control = flag(e.agent_control), _ => {} } } @@ -209,7 +214,7 @@ impl Extras { } pub fn serialize(&self) -> String { format!( - "fullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\n{}:{}\n", + "fullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\n{}:{}\nagentControl:{}\n", bool_text(self.fullbright), bool_text(self.dynamic_lights), bool_text(self.zoom), @@ -240,6 +245,7 @@ impl Extras { self.sort_key, horizon_core::no_ai::KEY, bool_text(self.no_ai), + bool_text(self.agent_control), ) } /// Binds the extra key `name` (`ZOOM_KEY`, `SORT_KEY`); false for @@ -457,6 +463,9 @@ pub enum Item { MouseTweaksWheel, Sort, SortKey, + /// Not on the Extras page: Horizon Settings shows No AI, its AI Agent page Agent Control. + NoAi, + AgentControl, } /// The Extras page: headers and items. pub fn rows() -> Vec<Result<Item, &'static str>> { @@ -535,6 +544,8 @@ impl Item { Item::FpsLows => "Minimum and 1% low", Item::Keystrokes => "Keystrokes", Item::KeystrokesCps => "Clicks per second", + Item::NoAi => "No AI", + Item::AgentControl => "Agent Control", } } /// The switch this setting belongs to: it does nothing while that is off. @@ -548,7 +559,7 @@ impl Item { MouseTweaksWheel => MouseTweaks, SortKey => Sort, Fullbright | DynamicLights | Zoom | Minimap | Fps | Keystrokes | MouseTweaks | Sort - | AutoReconnect => { + | AutoReconnect | NoAi | AgentControl => { return None; } }) @@ -592,6 +603,12 @@ impl Item { } Item::Keystrokes => "Movement keys, jump and mouse buttons as you press them.", Item::KeystrokesCps => "Clicks in the last second under each mouse button.", + Item::NoAi => { + "Hides and turns off every AI feature: agent control, horizon-ctl and the MCP servers. The launcher's switch too." + } + Item::AgentControl => { + "Your own AI agent can play this game through horizon-ctl or an MCP client, on this computer only." + } } } /// The frame-time cost the main switch of an extra shows. @@ -622,6 +639,8 @@ impl Item { Item::MouseTweaks => e.mouse_tweaks, Item::MouseTweaksWheel => e.mouse_tweaks_wheel, Item::Sort => e.sort, + Item::NoAi => e.no_ai, + Item::AgentControl => e.agent_control, _ => return None, }) } @@ -677,6 +696,8 @@ impl Item { } Item::MinimapShape => e.minimap_round = !e.minimap_round, Item::MinimapZoom => e.minimap_zoom = next(&MINIMAP_ZOOMS, e.minimap_zoom, back), + Item::NoAi => e.no_ai = !e.no_ai, + Item::AgentControl => e.agent_control = !e.agent_control, Item::ZoomKey | Item::SortKey => {} } } diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index aeab446d1..7d12ec63c 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -3,6 +3,7 @@ mod advancements; mod advancements_screen; mod agent; +mod agent_settings; mod allays; mod armor_stands; mod banners; @@ -1427,6 +1428,10 @@ struct Game<'a> { item_columns: Option<machines::ItemColumns>, creative_screen: Creative, control: Option<horizon_client::control::Server>, + /// The Agent Control setting the socket was last opened or closed for (`agent_settings`). + agent_control_on: bool, + /// When an agent's last command came. + agent_last: Option<Instant>, frame_stats: horizon_client::control::FrameStats, /// This play session's frame and tick times, for opt-in performance statistics. perf: horizon_client::telemetry::Session, @@ -11645,6 +11650,8 @@ impl<'a> Game<'a> { item_columns: None, creative_screen: prepared.creative_screen, control: None, + agent_control_on: false, + agent_last: None, frame_stats: Default::default(), perf: Default::default(), pending_screenshot: None, @@ -12439,18 +12446,7 @@ fn start_game<'a>( game.mods.dev = game.options.dev_mods.clone(); game.start_mods(); } - if game.options.control.is_some() && game.settings.extras.no_ai { - // No AI turns agent control off: the socket is never opened. - log::warn!( - "Horizon: control socket not opened: {}", - horizon_core::no_ai::REFUSAL - ); - } else if let Some(path) = &game.options.control { - let server = horizon_client::control::Server::start(path) - .map_err(|e| format!("control socket {}: {e}", path.display()))?; - log::info!("Horizon: control socket {}", server.path().display()); - game.control = Some(server); - } + game.start_agent_control()?; if let Some(scenario) = game.options.benchmark.clone() { let control = game .control diff --git a/crates/horizon-client/src/game/agent_settings.rs b/crates/horizon-client/src/game/agent_settings.rs new file mode 100644 index 000000000..5045f1c49 --- /dev/null +++ b/crates/horizon-client/src/game/agent_settings.rs @@ -0,0 +1,140 @@ +//! Agent control as a setting (Horizon Settings > AI Agent): when the control socket is open, who +//! is connected, and the details an agent needs. The socket opens when the game was started for +//! an agent (`--control`, `--control-socket`: horizon-ctl launch, the launcher's MCP `play`) or +//! when the player turned Agent Control on, and never under No AI (`horizon_core::no_ai`). +//! Turning either switch in the game opens or closes it at once. +use super::Game; +use horizon_client::{Result, control}; +use std::path::PathBuf; + +impl Game<'_> { + /// The endpoint: the one the command line gave, else the default horizon-ctl looks for. + fn agent_socket_path(&self) -> PathBuf { + self.options + .control + .clone() + .unwrap_or_else(control::default_path) + } + + /// At startup: open the socket if the game was started for an agent or Agent Control is on. + pub(super) fn start_agent_control(&mut self) -> Result<()> { + self.agent_control_on = self.settings.extras.agent_control; + if self.options.benchmark.is_some() && self.options.control.is_none() { + return Ok(()); + } + if self.settings.extras.no_ai { + if self.options.control.is_some() { + log::warn!( + "Horizon: control socket not opened: {}", + horizon_core::no_ai::REFUSAL + ); + } + return Ok(()); + } + if let Some(path) = &self.options.control { + // Asked for on the command line: failing to listen is an error. + let server = control::Server::start(path) + .map_err(|e| format!("control socket {}: {e}", path.display()))?; + log::info!("Horizon: control socket {}", server.path().display()); + self.control = Some(server); + } else if self.agent_control_on { + self.open_agent_socket(); + } + Ok(()) + } + + /// The setting's socket: a failure (another game holds the default endpoint) is logged and + /// shown on the AI Agent page, not fatal. + fn open_agent_socket(&mut self) { + let path = self.agent_socket_path(); + match control::Server::start(&path) { + Ok(server) => { + log::info!("Horizon: control socket {}", server.path().display()); + self.control = Some(server); + } + Err(e) => log::warn!("Horizon: control socket {}: {e}", path.display()), + } + } + + /// After a settings change: No AI closes the socket; Agent Control turned on or off opens or + /// closes it. + pub(super) fn sync_agent_control(&mut self) { + let wanted = self.settings.extras.agent_control; + let changed = wanted != self.agent_control_on; + self.agent_control_on = wanted; + let open = self + .control + .as_ref() + .is_some_and(|c| !c.path().as_os_str().is_empty()); + if self.settings.extras.no_ai || (changed && !wanted) { + if open { + log::info!("Horizon: control socket closed"); + self.control = None; + } + } else if changed && wanted && self.control.is_none() { + self.open_agent_socket(); + } + } + + /// An agent's command arrived. + pub(super) fn agent_command_seen(&mut self) { + self.agent_last = Some(std::time::Instant::now()); + } + + /// The AI Agent page's lines: the state, then where agents connect. + pub(super) fn agent_status_lines(&self) -> Vec<String> { + let server = self + .control + .as_ref() + .filter(|c| !c.path().as_os_str().is_empty()); + let mut lines = vec![match server { + Some(s) if s.clients() > 0 => { + let ago = self + .agent_last + .map(|t| format!(", last command {} s ago", t.elapsed().as_secs())) + .unwrap_or_default(); + format!( + "Connected: {} agent connection{}{ago}", + s.clients(), + if s.clients() == 1 { "" } else { "s" } + ) + } + Some(_) => "Waiting for an agent.".into(), + None => "Off: agents can't reach this game.".into(), + }]; + if let Some(s) = server { + if self.options.control.is_some() && !self.agent_control_on { + lines.push("Opened for this session by the program that started the game.".into()); + } + // The full path is too wide for the page: Copy Connection Details has it. + let name = s.path().file_name().unwrap_or_default().to_string_lossy(); + lines.push(format!( + "Socket: {name} (copy the details for its full path)" + )); + } + lines.push("Local only: agents on this computer, never the network.".into()); + lines + } + + /// What Copy Connection Details puts on the clipboard: the socket, a horizon-ctl line to try, + /// and an MCP client's config for this game. + pub(super) fn agent_details(&self) -> String { + let socket = self.agent_socket_path(); + let ctl = std::env::current_exe() + .unwrap_or_default() + .with_file_name(if cfg!(windows) { + "horizon-ctl.exe" + } else { + "horizon-ctl" + }); + let config = serde_json::json!({ "mcpServers": { "horizon-game": { + "command": ctl, "args": ["--socket", socket, "mcp"] } } }); + format!( + "Horizon agent control (this computer only)\nSocket: {}\nTry it: \"{}\" --socket \"{}\" state\nMCP config:\n{}\n", + socket.display(), + ctl.display(), + socket.display(), + serde_json::to_string_pretty(&config).unwrap_or_default() + ) + } +} diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index 6c5eec301..23843bddf 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -117,6 +117,7 @@ impl Game<'_> { self.answer(request, event_loop); } while let Some(request) = self.control.as_ref().and_then(|c| c.try_recv()) { + self.agent_command_seen(); self.answer(request, event_loop); if self.pending_save.is_some() { break; @@ -125,6 +126,11 @@ impl Game<'_> { if self.control.is_some() { self.watch_events(); } + if self.screen == Screen::Options + && self.ui.options.page() == horizon_client::options_ui::Page::Agent + { + self.ui.options.agent_status = self.agent_status_lines(); + } } fn answer(&mut self, request: horizon_client::control::Request, event_loop: &ActiveEventLoop) { @@ -565,6 +571,7 @@ impl Game<'_> { "graphics-advanced" => Page::GraphicsAdvanced, "extras" => Page::Extras, "horizon" => Page::Horizon, + "agent" => Page::Agent, "shader-packs" => Page::ShaderPacks, other => return Err(format!("unknown options page {other}").into()), }; diff --git a/crates/horizon-client/src/game/options.rs b/crates/horizon-client/src/game/options.rs index 61036d18c..dd298619d 100644 --- a/crates/horizon-client/src/game/options.rs +++ b/crates/horizon-client/src/game/options.rs @@ -200,6 +200,13 @@ impl Game<'_> { self.settings.save(&Self::options_path()); self.apply_settings(); self.sync_mods(); + self.sync_agent_control(); + self.ui.options.agent_status = self.agent_status_lines(); + } + Event::CopyAgentDetails => { + use horizon_client::clipboard::Clipboard; + let text = self.agent_details(); + self.clipboard.set(&text); } Event::Close if self.ui.options.resource_error.is_some() => {} Event::Close => { diff --git a/crates/horizon-client/src/game/startup_menu.rs b/crates/horizon-client/src/game/startup_menu.rs index 0c8376397..05a08ee61 100644 --- a/crates/horizon-client/src/game/startup_menu.rs +++ b/crates/horizon-client/src/game/startup_menu.rs @@ -370,7 +370,8 @@ impl Loading { let _ = std::fs::create_dir_all(&dir); packs::open_folder(&dir); } - Event::ButtonClick => {} + // The startup menu runs before the game opens a control socket. + Event::ButtonClick | Event::CopyAgentDetails => {} } } } diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 6431ae613..a981bfdee 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -874,6 +874,8 @@ pub enum Page { /// Horizon Settings: every page Horizon adds, as a mod's settings /// screen hangs off vanilla's Options. Horizon, + /// AI Agent: agent control on or off, whether an agent is connected, the connection details. + Agent, } #[derive(Clone, Debug, PartialEq)] enum Act { @@ -894,6 +896,7 @@ enum Act { /// Pick shader pack `i` of `OptionsUi::shader_packs` (again: off). ToggleShaderPack(usize), OpenShaderPackFolder, + CopyAgentDetails, } enum WKind { Button { @@ -943,6 +946,8 @@ pub enum Event { OpenModFolder, /// Create `shaderpacks/` if needed and open it. OpenShaderPackFolder, + /// Copy how an agent connects (the AI Agent page). + CopyAgentDetails, } /// `SliderableValueSet.applyValueImmediately`: these apply 600 ms after /// the last change (`OptionInstanceSliderButton.delayedApplyAt`). @@ -998,6 +1003,8 @@ pub struct OptionsUi { pub shader_packs: crate::shader_pack::Folder, /// The pack that failed to load last and why (set by the game). pub shader_pack_error: Option<(String, String)>, + /// The AI Agent page's status lines (set by the game while it shows). + pub agent_status: Vec<String>, } impl Default for OptionsUi { fn default() -> Self { @@ -1028,6 +1035,7 @@ impl Default for OptionsUi { graphics: Default::default(), shader_packs: Default::default(), shader_pack_error: None, + agent_status: Vec::new(), } } } @@ -1086,6 +1094,7 @@ fn horizon_page_tooltip(page: Page) -> Option<&'static str> { Page::Extras => { "Optional additions, all off by default: the game stays vanilla until you turn one on." } + Page::Agent => "Let your own AI agent play: horizon-ctl and MCP clients on this computer.", Page::Mods => { "Mods made for Horizon, from the horizon-mods folder. Each runs in a sandbox and stays off until you turn it on." } @@ -1107,6 +1116,11 @@ fn pairs(opts: &[Opt]) -> Vec<Row> { .collect() } impl OptionsUi { + /// A switch of `horizon-extras.txt` as the Extras page draws it: "Caption: On". + fn extra_button(&self, s: &Settings, item: crate::extras::Item) -> Widget { + let label = format!("{}: {}", item.caption(), item.value(&s.extras)); + button(0.0, 0.0, 150.0, Text::literal(label), Act::Extra(item)) + } fn settings_search_active(&self) -> bool { self.settings_search.focused && matches!(self.page(), Page::Video | Page::Controls | Page::KeyBinds) @@ -1200,6 +1214,7 @@ impl OptionsUi { Page::PadBinds => "Controller Binds", Page::Extras => "Horizon Extras", Page::Horizon => "Horizon Settings", + Page::Agent => "AI Agent", } } fn scrollbar_x(&self, width: f32) -> f32 { @@ -1316,8 +1331,31 @@ impl OptionsUi { open("Extras...", Page::Extras), Some(open("Mods...", Page::Mods)), ), + // No AI hides the AI Agent page and everything AI. + if s.extras.no_ai { + Row::Buttons(self.extra_button(s, crate::extras::Item::NoAi), None) + } else { + Row::Buttons( + open("AI Agent...", Page::Agent), + Some(self.extra_button(s, crate::extras::Item::NoAi)), + ) + }, ] } + Page::Agent => { + let mut rows = vec![Row::Buttons( + self.extra_button(s, crate::extras::Item::AgentControl), + Some(button( + 0.0, + 0.0, + 150.0, + Text::literal("Copy Connection Details"), + Act::CopyAgentDetails, + )), + )]; + rows.extend(self.agent_status.iter().cloned().map(Row::Note)); + rows + } Page::Video => { // Horizon's graphics screens, Simple and Advanced. let mut rows = vec![Row::Buttons( @@ -2499,6 +2537,7 @@ impl OptionsUi { events.push(Event::Changed); } Act::OpenShaderPackFolder => events.push(Event::OpenShaderPackFolder), + Act::CopyAgentDetails => events.push(Event::CopyAgentDetails), Act::None => {} } } @@ -4146,8 +4185,33 @@ mod tests { Page::Controller, Page::Extras, Page::Mods, + Page::Agent, ] ); + // No AI hides the AI Agent page. + let mut no_ai = Settings::default(); + no_ai.extras.no_ai = true; + let (widgets, _, _, _) = ui.layout(&no_ai, 427.0, 240.0); + assert!(!widgets.iter().any(|w| matches!( + &w.kind, + WKind::Button { + act: Act::Push(Page::Agent), + .. + } + ))); + // The AI Agent page: the switch, Copy and the status the game sets. + ui.push(Page::Agent); + ui.agent_status = vec!["Waiting for an agent.".into()]; + let (widgets, _, _, _) = ui.layout(&s, 427.0, 240.0); + let acts: Vec<&Act> = widgets + .iter() + .filter_map(|w| match &w.kind { + WKind::Button { act, .. } => Some(act), + _ => None, + }) + .collect(); + assert!(acts.contains(&&Act::Extra(crate::extras::Item::AgentControl))); + assert!(acts.contains(&&Act::CopyAgentDetails)); // Vanilla's own pages keep the Horizon pages they had. ui.stack = vec![Page::Main, Page::Video]; let video = pushes(&mut ui); diff --git a/tools/agent_control_e2e.py b/tools/agent_control_e2e.py index 5be9e1865..ce012e714 100644 --- a/tools/agent_control_e2e.py +++ b/tools/agent_control_e2e.py @@ -54,7 +54,7 @@ POSITIONAL = { 'click_button': ['label'], 'type': ['text'], 'wait': ['ticks'], 'wait_ready': ['seconds'], 'command': ['command'], 'look_at_block': ['x', 'y', 'z'], 'click': ['id'], 'set': ['id', 'value'], 'give': ['item', 'count'], 'options_get': ['keys'], 'options_set': ['key', 'value'], - 'wait_for': ['condition', 'value'], + 'wait_for': ['condition', 'value'], 'options': ['page'], } # Booleans the game takes as bare words. BARE = {'click_slot': ['right', 'shift'], 'click': ['right', 'middle', 'shift']} @@ -635,9 +635,73 @@ def no_ai_check(mode, ctl, resources): shutil.rmtree(work, ignore_errors=True) +def setting_check(mode, ctl, out, resources): + """Agent Control turned on in Horizon Settings > AI Agent: the game the player starts (no + --control) opens the default endpoint, the page shows the agent connected, Copy Connection + Details copies the socket, and turning the switch off closes the endpoint at once.""" + work, env = scratch(mode, resources) + socket = work / 'c.sock' + env['HORIZON_CONTROL'] = str(socket) # the default endpoint, this home's + (work / 'horizon-extras.txt').write_text('agentControl:true\n') + args = [str(ctl.with_name('horizon-client'))] + if sys.platform == 'darwin': + args.append('--offscreen') + game = subprocess.Popen(args, cwd=work, env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + d = None + try: + deadline = time.time() + 300 + while not socket.exists(): + assert game.poll() is None, f'the game exited ({game.returncode})' + assert time.time() < deadline, 'Agent Control on, but no control socket' + time.sleep(0.5) + d = (Cli if mode == 'cli' else Mcp)(ctl, socket, work, env) + assert d('state')['screen'] == 'title' # the player's own game, at its title screen + d('options', page='horizon') + tree = widgets(d) + assert {'ai-agent', 'no-ai'} <= set(tree), sorted(tree) + d('screenshot', path=str(out / f'{mode}-horizon-settings.png')) + d('options', page='agent') + tree = widgets(d) + switch = next(w for w in tree.values() if w.get('label', '').startswith('Agent Control')) + assert switch['label'] == 'Agent Control: On', switch + d('screenshot', path=str(out / f'{mode}-ai-agent.png')) + copy = next(w for w in tree.values() if w.get('label') == 'Copy Connection Details') + d('click', id=copy['id']) + # Off: the endpoint goes away and the next command can't reach the game. + try: + d('click', id=switch['id']) + except Failed: + pass # the reply may be lost with the socket + deadline = time.time() + 30 + while socket.exists(): + assert time.time() < deadline, 'Agent Control off, but the socket stayed' + time.sleep(0.5) + assert 'agentControl:false' in (work / 'horizon-extras.txt').read_text() + assert game.poll() is None, 'the game exited when Agent Control went off' + print(f'[{mode}] PASS: setting') + return True + except (Failed, AssertionError, StopIteration, json.JSONDecodeError, subprocess.TimeoutExpired) as e: + print(f'[{mode}] FAIL: setting: {e!r}') + return False + finally: + if d is not None: + try: + d.close() + except Exception: + pass + game.terminate() + try: + game.wait(30) + except subprocess.TimeoutExpired: + game.kill() + shutil.rmtree(work, ignore_errors=True) + + def run(mode, ctl, out, resources, which='survival'): if which == 'no-ai': return no_ai_check(mode, ctl, resources) + if which == 'setting': + return setting_check(mode, ctl, out, resources) work, env = scratch(mode, resources) socket = work / 'c.sock' driver = (Cli if mode == 'cli' else Mcp)(ctl, socket, work, env) @@ -666,7 +730,7 @@ def run(mode, ctl, out, resources, which='survival'): def main(): parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument('--mode', choices=['cli', 'mcp', 'both'], default='both') - parser.add_argument('--scenario', choices=[*SCENARIOS, 'no-ai', 'all'], default='all') + parser.add_argument('--scenario', choices=[*SCENARIOS, 'no-ai', 'setting', 'all'], default='all') parser.add_argument('--bin-dir', help='prebuilt horizon-client and horizon-ctl (default: build with the fast profile)') parser.add_argument('--out', default=str(ROOT / '.local/agent-control-e2e'), help='screenshots go here') args = parser.parse_args() @@ -684,7 +748,7 @@ def main(): out = Path(args.out) out.mkdir(parents=True, exist_ok=True) modes = ['cli', 'mcp'] if args.mode == 'both' else [args.mode] - scenarios = [*SCENARIOS, 'no-ai'] if args.scenario == 'all' else [args.scenario] + scenarios = [*SCENARIOS, 'no-ai', 'setting'] if args.scenario == 'all' else [args.scenario] results = {f'{m}/{s}': run(m, bins / 'horizon-ctl', out, resources, s) for m in modes for s in scenarios} print(json.dumps(results)) sys.exit(0 if all(results.values()) else 1) From 7db6ce51a60d0166438eddf9b9e327c0c4004a84 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 03:10:58 +0200 Subject: [PATCH 27/62] Docs: control Horizon with your AI agent (players), the full inventory (developers) website/docs/agents.md, in the nav under "Going further", is the player's page. It covers what an agent can do, connecting it from the launcher, copy-paste config for Claude Code, Codex, Cursor and any MCP client, the game's AI Agent page, a CLI quick reference, safety and No AI. docs/agent-control.md is rewritten for developers: - the surfaces, and why one MCP server covers the launcher and the game; - the inventory, before and after, for the launcher and the game; - No AI on every surface, and the launcher commands that stay; - connecting from the launcher and the game; - the design rules for a new command. docs/launcher-commands.md lists every launcher command, its arguments and its MCP tool. It is generated from the clap definition (cli_tools::markdown). The launcher test the_launcher_reference_is_up_to_date fails when it is stale or a tool is undocumented, like horizon-ctl's generated reference. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- docs/agent-control.md | 455 ++++++++++++++++++++---------------- docs/launcher-commands.md | 478 ++++++++++++++++++++++++++++++++++++++ launcher/src/cli_tools.rs | 127 ++++++++++ website/docs/agents.md | 126 ++++++++++ website/docs/nav.json | 2 +- 5 files changed, 990 insertions(+), 198 deletions(-) create mode 100644 docs/launcher-commands.md create mode 100644 website/docs/agents.md diff --git a/docs/agent-control.md b/docs/agent-control.md index 8fc59b484..5383cc03c 100644 --- a/docs/agent-control.md +++ b/docs/agent-control.md @@ -1,237 +1,298 @@ # Agent control: driving the launcher and the game -AI agents and scripts control Horizon through four surfaces: +A player's own AI agent (Claude Code, Codex, Cursor, any MCP client) or a script can do +everything a player does with the mouse and keyboard, in the launcher and in the game. This page +covers developers: the surfaces, the full inventory, and the rules every new command follows. +Players read [Control Horizon with your AI agent](../website/docs/agents.md) +(playhorizon.dev/docs/agents). + +The command lists are generated, so they can't drift: + +- [launcher-commands.md](launcher-commands.md): every `horizon-launcher` command, its arguments + and its MCP tool. It comes from the CLI's clap definition (`cli_tools::markdown`), and the + launcher test `the_launcher_reference_is_up_to_date` fails when it is stale or a tool is missing. +- [horizon-ctl-commands.md](horizon-ctl-commands.md): every `horizon-ctl` command, its MCP tool + and its arguments. It comes from the command table (`horizon-ctl help --markdown`), and the + test `the_generated_reference_is_up_to_date` fails when it is stale. + +## Surfaces | Surface | Where | Transport | | --- | --- | --- | -| Game control socket | `horizon-client --control` (`crates/horizon-client/src/control.rs`, commands in `src/game/control.rs`, `agent.rs` and friends) | text line in, one JSON line out; Unix socket, or localhost TCP + token where there is none | -| `horizon-ctl` | `crates/horizon-client/src/bin/horizon-ctl/` | CLI over the socket: one table of commands (`commands.rs`) gives help, argument checks and the MCP tools | -| `horizon-ctl mcp` | same | MCP over stdio, a tool per `horizon-ctl` command | -| Launcher CLI and MCP | `launcher/src/cli.rs`, `launcher/src/mcp.rs` | `horizon-launcher <cmd> [--json]`; `horizon-launcher mcp` (stdio) | +| Game control socket | `horizon-client --control` / `--control-socket PATH`, or Agent Control on in Horizon Settings > AI Agent (`crates/horizon-client/src/control.rs`; commands in `src/game/control.rs`, `agent.rs`, `ui_control.rs`, `saves_control.rs` and friends) | text line in, one JSON line out; Unix socket, or localhost TCP and a token where there is none | +| `horizon-ctl` | `crates/horizon-client/src/bin/horizon-ctl/` | CLI over the socket; one table of commands (`commands.rs`) gives the help, the argument checks, the MCP tools and the reference | +| `horizon-ctl mcp` | same | MCP over stdio, one tool per command of the table | +| Launcher CLI | `launcher/src/cli.rs` | `horizon-launcher <command> [--json]` | +| Launcher MCP | `launcher/src/mcp.rs`, `cli_tools.rs`, `game_tools.rs` | `horizon-launcher mcp` (stdio): every CLI command as a tool, the session tools, and the game's tools as `game_*` | +| Connecting | `launcher/src/agents.rs`, `agents_page.rs`; `src/game/agent_settings.rs` | `horizon-launcher agent-config`; Settings > AI in the launcher; Horizon Settings > AI Agent in the game | +| No AI | `crates/horizon-core/src/no_ai.rs` | `noAi:true` in `<game home>/horizon-extras.txt`, read by every surface | -This page is the inventory of what each surface can do and the design every new command -follows. Quick start for players and scripts: [native-client.md](native-client.md#agent-control-horizon-ctl-and-mcp). +## One MCP server for everything -## What exists today +An agent adds one server, `horizon-launcher mcp`. It holds: -Legend: **yes** complete, **part** partial (see note), **no** missing, **—** not applicable. -"Socket" is the game's own command; `horizon-ctl` and its MCP offer the subset in its table -(`horizon-ctl help --game` lists everything the game takes, test hooks included). +- **The launcher's CLI, generated.** `cli_tools.rs` walks the clap definition. Each command is a + tool named after its words (`mods search` is `mods_search`). Its arguments are the command's, + in snake_case, with clap's help, choices and defaults. A call runs that command with `--json` + as a child process and returns what it printed. A new CLI command is a new tool with no extra + code. +- **Session tools**, which keep something running between calls: + - `play` (the game, under control: `world`, `creative`, `join`, `offscreen`, `arg`); + - `server`, `server_command`, `server_log`, `server_stop`; + - `account_sign_in`, `account_list`. +- **The game's tools.** It runs the selected version's `horizon-ctl mcp` (shipped beside the + game) as a child. It lists that server's tools as `game_<name>`, all but `launch`, and passes + calls and results through, images included. `play` starts the game with a control socket in + the launcher's data folder. While no game answers, `game_*` calls say to call `play`. + +Why one server rather than two: the game's tools stay defined once, in horizon-ctl's table. The +agent's client needs one entry and one approval. The version that plays is always the one the +launcher selected, so the game's tools always match the game. `horizon-ctl mcp` stays available +on its own, for a game started by hand or by a script. + +## Inventory, before and after + +Before is `main` at 2026-10-23, before #1342, #1343, #1344, #1345 and #1353. After is with +them. CLI is `horizon-launcher` for the launcher and `horizon-ctl` for the game. MCP is +`horizon-launcher mcp` (the game's tools as `game_*`) and `horizon-ctl mcp`. **part** means only +through a generic command (`ui` and `click` by widget, or a raw socket line that horizon-ctl +passes on without checking it). ### Launcher -| Capability | Window | CLI | MCP | Notes | -| --- | --- | --- | --- | --- | -| Releases, installed versions, select | yes | yes | yes | `versions`, `list_versions`; selecting happens on install only (no `select` command) | -| Install / remove a version | yes | yes | yes | | -| Prepare resources | yes | yes | yes | | -| Start the client | yes | yes (attached) | yes | MCP starts it detached and cannot reach it afterwards | -| Dedicated server: start, console, log, stop | yes | yes | yes | | -| Accounts (no secrets) | yes | yes | yes | names and UUIDs only; sign-in is a device code the player enters | -| Launcher settings (game folder, auto-install, opening animation, desktop entry) | yes | part | no | CLI has `desktop-entry`; the rest only in the window | -| Logs, crash report | yes | yes | yes | | -| Updates (Horizon and launcher) | yes | yes | yes | MCP only checks | -| Patch notes, links | yes | yes | yes | | -| Benchmark | — | yes | no | | -| Telemetry consent | PR #250 | PR #250 | PR #250 | opt-in, in review | -| Friends: join by invite code | yes | yes (`play --join`) | no | | -| Profiles, packs, mods | no | no | no | the launcher has none yet | -| The running game's controls | — | no | no | an agent needs a second MCP server (`horizon-ctl mcp`) | +| Capability | Window | CLI before | MCP before | CLI after | MCP after | Notes | +| --- | --- | --- | --- | --- | --- | --- | +| Releases and installed versions | Play, version picker | yes | yes | yes | yes | `versions [--installed]` | +| Install, remove a version | Play | yes | yes | yes | yes | `remove` needs `confirm` in MCP | +| Pick the version that plays | Play | no | no | yes | yes | `settings selected-version TAG` | +| Prepare resources | Play | yes | yes | yes | yes | | +| Start the game | Play | yes | yes | yes | yes | `play --world --creative --join --arg`; MCP `play` adds `offscreen` | +| Join a friend by invite code | Play | yes | no | yes | yes | `play --join CODE` | +| Dedicated server here: start, console, log, stop | Servers | yes | yes | yes | yes | `server`; MCP `server`, `server_command`, `server_log`, `server_stop` | +| Hosted servers: list, create, set up, run a command, forget | Servers | yes | no | yes | yes | `servers ...`; `servers_forget` needs `confirm` | +| Accounts: list, sign in, sign out, select, offline | Settings | yes | part | yes | yes | names and UUIDs only; sign-in is a device code; `account_offline` was missing | +| Update channel (Alpha, Stable) | Settings | yes | yes | yes | yes | | +| Game folder, server folder, install new versions, opening animation | Settings | no | no | yes | yes | `settings [KEY VALUE]` | +| Extra game arguments | Settings | yes | no | yes | yes | `game-args` | +| Applications menu entry (Linux) | Settings | yes | no | yes | yes | `desktop-entry` | +| Updates: check and install | Settings | yes | part | yes | yes | MCP could only check | +| Patch notes, links | Patch notes, footer | yes | yes | yes | yes | | +| Game log, crash reports | Settings | yes | yes | yes | yes | `logs [--crash]` | +| Data collection: status, allow, deny, show, delete, send, bug, benchmark upload | Settings > Data | yes | part | yes | yes | sending was missing in MCP; `data_delete` needs `confirm` | +| Mod browser: search, check, install, update, remove, list (mods, resource packs, shader packs, modpacks) | Mods | yes | no | yes | yes | `mods ...`; `mods_remove` needs `confirm` | +| Modpacks: import, port, play, remove, list | Modpacks | yes | no | yes | yes | `modpack ...`; `modpack_remove` needs `confirm` | +| Launcher benchmark | (none) | yes | no | yes | yes | | +| The game it started | (the game) | (horizon-ctl) | yes | (horizon-ctl) | yes | `game_*` | +| Connect an AI agent | Settings > AI | no | (none) | yes | (none) | `agent-config [--client] [--test]`; the agent is already connected, so there is no tool | +| No AI | Settings > AI | no | (none) | yes | (none) | `no-ai [on\|off]`; the player's switch, never an agent's | ### Game -| Capability | Socket | horizon-ctl / MCP | Notes | -| --- | --- | --- | --- | -| Session: launch, wait until ready, open/create a world, save, quit, logs | yes | yes | `launch`, `wait-ready`, `open`, `save`, `quit`, `logs` | -| Player and world state | yes | yes | `state`, `status` (renderer, streaming, memory) | -| Crosshair target | yes | yes | `looking-at` | -| Blocks: one, a box, nearest of a kind | yes | yes | `block`, `blocks`, `find-block` | -| Entities near the player | yes | yes | `entities [RADIUS] [TYPE]`; no single-entity detail | -| Inventory, armor, offhand, carried stack | yes | yes | `inventory` | -| Containers and stations: read, click slots | yes | yes | `screen`/`menu`, `click-slot ID`, `container X Y Z` | -| Crafting (grid, result, recipe book) | part | part | grid by `click-slot`; the recipe book only by `click-at` | -| Movement, look, path-finding | yes | yes | `move`, `goto`, `look`, `look-at`, `turn --over`, `mouse-move` | -| Act on the world | yes | yes | `break`, `place`, `interact`, `use-item`, `attack`, `select`, `drop` | -| Raw input: keys, mouse buttons | yes | yes | `key`, `mouse`, `release`; `key w down` stays held through `wait` until `key w up`, `release` or `stop` | -| Controllers | yes | yes | `pad` button/stick/trigger/status (a virtual pad) | -| Chat and commands | yes | yes | `chat`, `command`, `type`, `messages`, `chat-log` | -| Screens: which is open | yes | yes | `screen` gives a label (`title`, `options`, `inventory`...) but not the options page or sub-screen | -| Screens: widgets | part | part | `screen` lists **labelled buttons** only (label, bounds, enabled); sliders, fields, list rows, tabs and switches are invisible | -| Screens: act on a widget | part | part | `click-button LABEL` (buttons only), `click-at X Y`; no slider set, no field focus, no row select by id | -| Options | part | no | `options PAGE` opens a page and `render-distance N` sets one value; no read, no set of the other ~120 options | -| Packs (resource packs) | no | no | only through the Packs screen by pixel | -| F3 debug data | part | part | `status` has the overlay flags and the renderer; not the F3 lines | -| Screenshots | yes | yes | PNG of the next frame (works `--offscreen`) | -| Recording video | no | no | | -| Benchmarks and frame stats | yes | yes | `bench`, `stats`, `fly`, `--benchmark` | -| Multiplayer: connect, disconnect, respawn | yes | part | `connect`/`disconnect` are socket-only | -| LAN and friends hosting | yes | no | `lan open/close/status`, `friends host/stop/status` socket-only | -| Cheats and test hooks | yes | part | `give`, `time`, `setblock`, `summon`, `effect`; `xp`, `enchant`, `potion`, `trade`, `fill`, `particle`, `sculk` socket-only | -| Waits | part | part | `wait TICKS`, `wait-ready`; no "until screen X", "until chunks loaded", "until chat says Y" | -| Events | no | no | everything is polled | -| Errors with reasons | part | part | `{"error": "text"}`; horizon-ctl adds `kind` (`usage`, `connection`) to its own errors only | +| Capability | Screen | CLI before | MCP before | CLI after | MCP after | Notes | +| --- | --- | --- | --- | --- | --- | --- | +| Start, wait until ready, save, quit, log | (all) | yes | yes | yes | yes | `launch`, `wait-ready`, `save`, `quit`, `logs` | +| Every widget of every screen, by id; click, set, type | (all) | yes | yes | yes | yes | `ui`, `click ID`, `set ID VALUE`, `type`; `click-at`, `drag-at`, `scroll-at` by pixel | +| Title menu, pause menu | Title, Pause | yes | yes | yes | yes | `ui`/`click`, `pause`, `resume` | +| Worlds: list | Select World | part | part | yes | yes | `worlds` | +| Worlds: create, open | Create New World | yes | yes | yes | yes | `open WORLD [SEED] [creative]` | +| Worlds: rename, back up | Edit World | part | part | yes | yes | `world-rename`, `world-backup` | +| Worlds: delete | Select World | part | part | yes | yes | `world-delete FOLDER --confirm`; it was possible through `click` without any confirm | +| Servers list | Multiplayer | part | part | yes | yes | `servers` (names and addresses; reads servers.dat) | +| Join a server or an invite code, leave | Multiplayer | part | no | yes | yes | `connect`, `disconnect` | +| Open to LAN | Pause > Open to LAN | part | no | yes | yes | `lan open\|close\|status` | +| Play with Friends: host, stop, status | Pause | part | no | yes | yes | `friends host\|stop\|status` | +| Vanilla options, every page | Options | yes | part | yes | yes | `options-get`, `options-set` (all of options.txt, typed); `options PAGE` was socket-only | +| Horizon Settings: Graphics, Shader Packs, Controller, Extras, Mods, AI Agent | Horizon Settings | part | part | yes | yes | `options horizon\|graphics\|extras\|agent...`, then `ui`/`click`/`set` | +| Agent control on or off, status, connection details | Horizon Settings > AI Agent | no | no | yes | yes | new page (#1353) | +| Key binds | Controls > Key Binds | yes | yes | yes | yes | `options-set key_key.jump key.keyboard.j` | +| Resource packs, shader packs | Options > Resource Packs, Shader Packs | part | part | yes | yes | `options packs`, `options shader-packs`, then `ui` rows and `click`; `options-set resourcePacks` | +| Chat and commands | Chat | yes | yes | yes | yes | `chat`, `command`, `messages`, `chat-log` | +| Inventory, containers, stations | Inventory, Chest... | yes | part | yes | yes | `inventory`, `screen`, `click-slot`; `container X Y Z` was socket-only | +| Crafting, recipe book | Crafting | part | part | yes | yes | the grid by `click-slot`; the recipe book by `ui`/`click` | +| Trading, riding, shearing (right-click an entity) | Merchant, Horse | part | no | yes | yes | `interact-entity ID`; `mouse` was CLI-only | +| Horse, llama inventory | Horse | no | no | yes | yes | `mount-menu` | +| Books, lecterns, signs | Book, Sign | part | part | yes | yes | `book [next\|back\|take\|done]`, `signedit X Y Z` | +| Move, look, find a path | (playing) | yes | yes | yes | yes | `move`, `goto`, `look`, `look-at`, `turn`, `jump` | +| Mine, place, use, attack, hotbar, drop | (playing) | yes | yes | yes | yes | `break`, `place`, `interact`, `use-item`, `attack`, `select`, `drop` | +| Raw keys and mouse buttons | (all) | yes | part | yes | yes | `key`; `mouse`, `release` were CLI-only | +| Controllers | (all) | yes | no | yes | yes | `pad` | +| Respawn | Death | yes | yes | yes | yes | `respawn` | +| Screenshots | (all) | yes | yes | yes | yes | PNG of the next frame, `--offscreen` too | +| F3 data | F3 | yes | part | yes | yes | `key f3`; `status` (renderer, chunks, memory) was CLI-only | +| Waits and events | (all) | yes | yes | yes | yes | `wait`, `wait-for`, `events` | +| Effects, experience, enchantments, potions, fill | (cheats) | part | no | yes | yes | `effect`, `effects`, `xp`, `enchant`, `potion`, `fill` | +| Benchmarks and frame stats | (all) | yes | part | yes | yes | `bench`, `stats` were CLI-only; `fly` | -### After the PRs in [Status](#status) +## No AI -| Capability | Before | After | -| --- | --- | --- | -| Screens: widgets | labelled buttons only | every widget of every screen (`ui`): id, kind, label, bounds, slider value, tab selected, slots with stacks | -| Screens: act on a widget | `click-button LABEL`, `click-at X Y` | `click ID [right\|middle] [shift]`, `set ID VALUE` (sliders), `click` focuses fields | -| Options | open a page; `render-distance` only | `options-get` all 193 `options.txt` options typed with ranges/choices; `options-set` validates, applies, saves | -| Waits | `wait TICKS`, `wait-ready` | `wait-for screen\|widget\|loaded\|chat\|event` with timeout errors | -| Events | none (poll) | `events [--since SEQ]`: screen, chat, death, respawn, item, dimension, world | -| Launch headless | `--offscreen` by hand | `launch --offscreen` in horizon-ctl and its MCP; `launch_client {offscreen}` | -| The running game from the launcher's MCP | no (a second server) | every game tool as `game_*` through `horizon-launcher mcp` | +One switch hides and turns off every AI feature: `noAi:true` in `<game home>/horizon-extras.txt`. +The game home is `HORIZON_HOME`, else the data dir's `horizon`. The game reads its extras from +its working directory, which is that folder. `horizon_core::no_ai` reads and writes the switch: -## Design +- `is_on(home)` and `check(home)` read it; +- `set(home, on)` keeps the file's other lines, and writes no file to turn off a switch that was + never on; +- `REFUSAL` is the one line every surface prints. -### One vocabulary, four surfaces +The switch is in three places: Settings > AI in the launcher, Horizon Settings in the game +(`Item::NoAi`), and `horizon-launcher no-ai on|off`. When it is on: + +| Surface | What happens | +| --- | --- | +| Game | opens no control socket, even with `--control` (it logs the refusal); Horizon Settings hides AI Agent...; turning it on in a running game closes the socket at once | +| `horizon-ctl` | every command refuses: exit status 4, `{"error": REFUSAL, "kind": "denied"}` | +| `horizon-ctl mcp` | refuses to start (exit 4, REFUSAL on stderr); a session already running refuses each call | +| `horizon-launcher mcp` | refuses to start; a running session answers each `tools/call` with error -32000 and REFUSAL | +| Launcher CLI | `mcp` and `agent-config` are hidden from the help and refuse | +| Launcher window | Settings > AI shows only the No AI switch, without Connect an AI agent | +| Companion (#1068) | uses the same switch (see horizon-parity companion-notes.md) | + +Every other launcher command stays usable: versions, install, remove, prepare, play, server, +notes, links, account, update-channel, settings, game-args, logs, update, desktop-entry, data, +modpack, mods, servers, no-ai and benchmark. None of them drives the game for an agent. The +launcher itself, packagers, the docs and players' scripts need them, and `no-ai` has to stay to +turn the switch off. + +## Connecting + +- **Launcher, Settings > AI > Connect an AI agent:** + - a client picker (Claude Code, Codex, Cursor, any MCP client) with its config and a Copy button; + - for clients with a CLI, the add command, shown and run only on **Add to ...**: + `claude mcp add --scope user horizon -- <exe> mcp`, `codex mcp add horizon -- <exe> mcp`; + - **Test the connection** (`agents::self_test`) starts `<exe> mcp`, lists its tools and says + how many answered. + - `horizon-launcher agent-config [--client ID] [--json] [--test]` prints the same thing. +- **Game, Horizon Settings > AI Agent:** + - **Agent Control** (`agentControl` in horizon-extras.txt, off by default) opens the default + endpoint (`$HORIZON_CONTROL`, else `horizon-control.sock` in the runtime directory) in a game + the player started. Turning it off closes the endpoint and stops its listener. + - The page shows whether a client is connected (`Server::clients`), when the last command came, + and the socket's name. + - **Copy Connection Details** copies the socket path, a `horizon-ctl --socket ... state` line + and an `mcpServers` config for this game's `horizon-ctl mcp`. +- **The default:** a game an agent starts (`play` in MCP, `horizon-ctl launch`, `--control`) is + under control. A game the player starts from the window is not, until they turn Agent Control + on. An open socket lets any program of that user drive the game, so it opens only when an agent + asked for the game, or when the player chose it. + +## Design rules for a new command + +### One vocabulary - **A command has one name**, kebab-case, the same on the socket, in `horizon-ctl` and in the - launcher CLI. Its MCP tool is the name with `_` for `-` (`click-slot` → `click_slot`). - The launcher's MCP offers the game's tools under a `game_` prefix (`game_click_slot`) so they - never collide with its own (`logs` exists on both sides). -- **Arguments** are positional words then `--flags`; the `horizon-ctl` table (`Param`) is the - source of truth and generates the MCP `inputSchema`. A new game command is not done until it - is in that table. + launcher CLI. Its MCP tool is the name with `_` for `-` (`click-slot` is `click_slot`). In the + launcher, a subcommand's words are joined (`mods search` is `mods_search`). The launcher's MCP + offers every game tool as `game_<name>`, so none collides with its own (`logs` is on both + sides). A launcher tool whose name starts with `game_` (`game_args`) is matched first. +- **Arguments:** positional words, then `--flags`. + - The game: the `horizon-ctl` table (`Param`) is the source of truth. It generates the MCP + `inputSchema` and the reference. A game command is not done until it is in that table. + - The launcher: the clap definition is the source of truth. Give every argument a help line; + it becomes the tool's description. - **Replies are one JSON object.** A query returns its data; an action returns `{"ok": true, ...}` plus what changed (`clicked`, `screen`, `drops`...). -- **Errors** are `{"error": "<sentence an agent can act on>", "kind": "<reason>"}`. Kinds: - `usage` (bad or missing argument), `unknown` (no such command, widget, option, entity), - `state` (the game is not in a state that allows it: no world, wrong screen, disabled - widget), `busy` (another action or benchmark runs), `timeout`, `connection` (game not - reachable), `denied` (needs consent, below). The message names what to do next - ("no world open; use: open WORLD"). -- **Shapes are shared**: a position is `[x, y, z]`; a block is - `{"pos", "block", "state", "loaded"}`; an item stack is `{"item", "count", "damage"?, - "components"?}`; a slot is a stack plus `"slot": ID` (the slot ids of - `click-slot`); bounds are `[x, y, w, h]` in GUI pixels, the coordinates of `click-at`. +- **Errors** are `{"error": "<sentence an agent can act on>", "kind": "<reason>"}`. The kinds: + - `usage`: a bad or missing argument; + - `unknown`: no such command, widget, option or entity; + - `state`: the game is not in a state that allows it (no world, wrong screen, disabled widget); + - `busy`: another action or a benchmark is running; + - `timeout`; + - `connection`: the game can't be reached; + - `denied`: No AI is on (exit status 4). -### Structured UI: the widget tree + The message names what to do next ("no world open; use: open WORLD"). +- **Shapes are shared:** + - a position is `[x, y, z]`; + - a block is `{"pos", "block", "state", "loaded"}`; + - an item stack is `{"item", "count", "damage"?, "components"?}`; + - a slot is a stack plus `"slot": ID` (the slot ids of `click-slot`); + - bounds are `[x, y, w, h]` in GUI pixels, the coordinates of `click-at`. -`ui` returns every interactive element the last frame drew, on every screen (title menus, -pause, options pages, inventories and stations, chat, death, Play with Friends): +### Safety + +- **Local only.** The socket is a Unix socket in the user's runtime directory, or a TCP port on + 127.0.0.1 behind a 128-bit token in a file only the user can read. It is never `0.0.0.0` and + never a network listener. Both MCP servers use stdio. +- **Confirm what can't be undone.** A command that deletes the player's things requires + `confirm` and carries the MCP `destructiveHint`. In the game these are `world-delete`, `fill` + and `setblock` (the table's `DESTRUCTIVE`); in the launcher, `remove`, `modpack remove`, + `mods remove`, `servers forget`, `account sign-out` and `data delete` (`cli_tools::DESTRUCTIVE`). + Without `confirm: true` the call is refused and the message says to ask the player. In the game + CLI the flag is `--confirm`. The launcher CLI asks nothing: a person typing `remove` meant it. +- **Ask before reaching out.** A command that sends data or reaches other people carries + `openWorldHint`, and its description says "only when the player asks". In the game these are + `connect`, `lan`, `friends`, `chat` and `command`; in the launcher, `data allow`, `data send`, + `data bug`, `data benchmark` and `servers create`. `play`'s `join` argument says the same. + Telemetry stays opt-in, and only `data allow` turns it on. +- **No secrets.** No surface returns tokens, session files, keychain entries or invite secrets + the player didn't ask to share: + - accounts are names and UUIDs; + - sign-in is a device code the player enters; + - `--session-file` is read once and deleted; + - `servers` reads names and addresses only. +- **Vanilla behaviour untouched.** Control code reads state and synthesizes the input events a + player produces; registering widgets for the tree draws nothing. A change to game files runs + `tools/parity.py --changed origin/main`. + +### The widget tree + +`ui` returns every interactive element the last frame drew, on every screen: ```json {"screen": "options", "gui_size": [427, 240], "frame": 3061, "widgets": [ {"id": "fov", "kind": "slider", "label": "FOV: 70", "bounds": [40, 50, 150, 20], "enabled": true, "value": 0.5}, - {"id": "video-settings", "kind": "button", "label": "Video Settings...", "bounds": [...], "enabled": true}, - {"id": "row-2", "kind": "row", "bounds": [...], "enabled": true}, {"id": "done", "kind": "button", "label": "Done", "bounds": [...], "enabled": true}]} ``` -- **Ids are stable and readable**: the label up to its `:` as a slug (`FOV: 70` → `fov`, - `Video Settings...` → `video-settings`); a repeated slug gets `-2`, `-3` in draw order; - unlabelled elements are `<kind>-<n>` in draw order. The id of a slider does not change - when its value (and so its label) does. World, server and language rows carry their - names; inventory, creative and menu slots are `slot-<ID>` with - their stack (an item tab's display slots are `slot-900` up). -- **Kinds**: `button`, `slider` (`value` 0..1 as drawn), `field` (text box), `row` (list - entry: world, server, pack, language), `tab` (`selected`), `slot`. -- **Actions by id**: `click ID [right|middle]` (move the pointer there and click, exactly as a - player would; `middle` is the pick block button, which clones a stack in creative), `set ID VALUE` (a slider to a 0..1 position, a click on its track, as vanilla - `AbstractSliderButton.onClick` reads the pointer). `type TEXT` keeps typing into the focused - field; `click` on a field focuses it. After a click or a set, the next `ui`, `click` or - `set` waits for a redrawn frame, so it never reads the screen the click left. -- **No new code paths in screens**: the tree is built from what the draw functions already - register for the controller's focus navigation (`widgets.rs`), so every screen that a - controller can drive is in it, and clicks go through the same window events as the mouse. +- **Ids are stable and readable.** An id is the label up to its `:`, as a slug (`FOV: 70` is + `fov`, `AI Agent...` is `ai-agent`). A repeated slug gets `-2`, `-3`; unlabelled elements are + `<kind>-<n>`. A slider's id doesn't change with its value. Slots are `slot-<ID>` with their + stack. +- **Kinds:** `button`, `slider` (`value` 0..1), `field`, `row` (a world, server, pack or + language), `tab` (`selected`), `slot`. +- **Actions:** + - `click ID [right|middle] [shift]` clicks where the mouse would. + - `set ID VALUE` moves a slider. + - `type` types into the focused field. -### Options + After a click, the next `ui`, `click` or `set` waits for a redrawn frame. +- **No new code paths in screens.** The tree is built from what the draw functions already + register for controller navigation (`widgets.rs`). -- `options-get [KEY...]`: every option of `options.txt` by its vanilla key, with its value - and what it accepts: `{"key": "fov", "value": 70, "type": "int", "min": 30, "max": 110}`, - enums with `choices`, key bindings as `key.keyboard.w`. Next: Horizon's own files - (`horizon-graphics.txt`, `horizon-controller.txt`, extras) under their own keys. -- `options-set KEY VALUE`: validated like vanilla's `OptionInstance.set` (out of range is an - error here, not a silent reset), applied at once as the options screen would apply it, and - saved. Reply: the new value. -- `options [PAGE]` keeps opening a page for screenshots and for `ui`. +### Waits and events -### Inventory, containers, world, entities +- `wait-for screen NAME|widget ID|loaded|chat TEXT|event KIND [--timeout S] [--since SEQ]` + replies when the condition holds, or with `kind: timeout`. +- `events [--since SEQ]` returns what happened since SEQ: screens, chat, deaths, respawns, items, + dimensions and worlds (the newest 256). Take `last` before an action, and wait with `--since`, + so the action's event can't slip in before the wait. -The existing commands stay and keep their shapes: `inventory`, `screen`, `click-slot`, -`block`, `blocks`, `find-block`, `entities`, `looking-at`. Planned additions: `entity ID` -(full detail: equipment, effects, passengers, AI state), `entities` filters by position and -radius around any point (`--at X Y Z`), and `blocks --of BLOCK` to keep a box query small. +## Tests -### Waits +- **Unit tests:** + - horizon-ctl: the table, the schemas, the reference, the No AI refusal, the destructive and + network annotations; + - the launcher: generated tools, `confirm`, the reference, the agent configs; + - `horizon_core::no_ai`; + - `options_ui`: the AI Agent page, and that No AI hides it. +- **`tools/agent_control_e2e.py`** drives a real game, offscreen on macOS and on a virtual screen + on Linux, through the CLI and MCP: + - `survival`, `ui`, `options`, `events`, `consume`, `pick`, `suggestions`; + - `manage`: worlds, servers, effects, books, LAN, the options pages and `confirm`; + - `no-ai`: every surface refuses; + - `setting`: Agent Control on opens the endpoint, the AI Agent page, Copy, and off closes it. +- **`tools/launcher_mcp_e2e.py`** drives `horizon-launcher mcp`: the generated tools, `play` and + the `game_*` tools, `confirm`, `agent-config` and `--test`, and No AI. -`wait-for CONDITION [--timeout S] [--since SEQ]` replies when the condition holds, or with -an error of kind `timeout` saying what screen it ended on (`wait TICKS` waits for ticks): +## Later -- `screen NAME` (the label `state` shows), `widget ID` (a widget is on screen), -- `loaded` (a world is open, the player exists and no chunk is pending), -- `chat TEXT` (a new chat line containing TEXT), `event KIND` (an event of that kind); - both count from `--since SEQ`, else from now: take `last` from `events` before an action - so its event can't slip in before the wait starts. +These are tracked in FEATURES.md (LATER): -### Events - -`events [--since SEQ]` returns what happened since SEQ, oldest first, and `last`, the SEQ to -pass next time (the game keeps the newest 256): - -```json -{"event": "world", "seq": 1, "tick": 0, "state": "opened", "name": "Survival"} -{"event": "screen", "seq": 2, "tick": 0, "from": "title", "to": "playing"} -{"event": "item", "seq": 3, "tick": 110, "item": "minecraft:oak_log", "delta": 3} -{"event": "chat", "seq": 4, "tick": 140, "text": "[Player] hello"} -{"event": "death", "seq": 7, "tick": 300} -{"event": "respawn", "seq": 9, "tick": 330} -{"event": "dimension", "seq": 12, "tick": 900, "from": "minecraft:overworld", "to": "minecraft:the_nether"} -``` - -Events are found by comparing state once per event loop turn on the game thread, and only -under `--control` (no hooks inside game logic), so they cannot change what the game does. -Next: `subscribe [KIND...]`, the same events as a stream on one connection, for clients that -keep one open (MCP tools reply once, so `events` is what MCP offers). - -### The launcher's MCP proxies the game - -An agent configures one MCP server, `horizon-launcher mcp`. It runs the selected version's -`horizon-ctl mcp` (shipped beside the game) as a child and lists every one of its tools as -`game_<name>` (all but `launch`), passing calls and results (images included) through, so -the game's tools are defined once, in horizon-ctl's table. `launch_client` starts the game -with a control socket in the launcher's data folder (`world`, `creative`, `offscreen` -optional) and returns once it answers. While no game listens, `game_*` calls fail with -`kind: "state"` and say to call `launch_client`. A game the player starts from the window -is not under control. - -### Safety - -- **Local only.** The socket is a Unix socket in the user's runtime directory, or a TCP port - on 127.0.0.1 behind a 128-bit token in a file only the user can read. Never `0.0.0.0`, - never a network listener; the launcher's MCP is stdio. -- **No secrets.** No surface returns tokens, session files or keychain entries: accounts are - names and UUIDs, `--session-file` is read once and deleted, and `options-get` leaves out - nothing secret because `options.txt` holds none (server addresses are in `servers.dat`, - which no command reads). -- **Consent for anything that sends data.** Commands that reach the network (`connect`, - `chat`/`command` on a server, `lan open`, `friends host`, `install_version`, - `check_updates`, telemetry) carry the MCP `openWorldHint` annotation and their description - says "only when the player asks". Telemetry stays opt-in (PR #250); no agent command turns - it on. Destructive ones (`remove_version`, `sign_out`, `fill`, `setblock`) carry - `destructiveHint`. -- **Vanilla behaviour untouched.** Control code reads state and synthesizes the same input - events a player produces; registering widgets for the tree draws nothing. Every PR that - touches game files runs `tools/parity.py --changed origin/main`. - -## Status - -| Step | PR | -| --- | --- | -| This document | #321 | -| `ui`, `click ID`, `set ID VALUE`: the widget tree of every screen | #349 | -| `options-get` / `options-set` | #350 | -| `wait-for`, `events` | #351 | -| The launcher's MCP proxies the game (`game_*`), `launch_client` under control | #342 | -| Next: `subscribe` (a stream), error `kind` on every game error, MCP annotations (`openWorldHint`, `destructiveHint`) | | -| Next: `entity ID`, `entities --at`, packs (`packs list|enable|disable`), F3 lines, Horizon's own option files, launcher settings over CLI/MCP | | - -Each PR adds its tests: unit tests next to the code, and scenarios in -`tools/agent_control_e2e.py` (`survival`, `ui`, `options`, `events`; CLI and MCP) and -`tools/launcher_mcp_e2e.py`, which drive the real game offscreen on macOS or on a virtual -screen on Linux. `tools/lan_e2e.py` runs two games at once, a host that opens its world to LAN -and a guest that joins it, and checks from both sides what a guest sees and can do (player -list, own model, armour, name tags, chest lids, crafting, fall damage). +- Horizon's own option files by key (`horizon-graphics.txt`, controller, extras) next to + `options-get` and `options-set`. +- Adding and removing saved servers by command. +- `subscribe`: events as a stream on one connection. +- Launcher window screenshots in this page's PRs. +- No AI changed in the launcher while a game is open: the game rewrites its extras when it saves. +- A confirmation question in the launcher CLI for destructive commands. diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md new file mode 100644 index 000000000..579659e68 --- /dev/null +++ b/docs/launcher-commands.md @@ -0,0 +1,478 @@ +# Launcher commands + +<!-- Generated from launcher/src/cli.rs by cli_tools::markdown(); a test fails when this file is out of date. Update it with: HORIZON_WRITE_DOCS=1 cargo test --manifest-path launcher/Cargo.toml the_launcher_reference --> + +Every command of `horizon-launcher`, and the tool `horizon-launcher mcp` offers for it. A tool's arguments are the command's, in snake_case. A tool runs the command with `--json` and returns what it printed. The tools that change the player's things for good need `confirm: true`. The tools that send something or reach other people say "only when the player asks". The game's own tools, `game_*`, are in [horizon-ctl-commands.md](horizon-ctl-commands.md). With No AI on, `mcp` and `agent-config` are hidden and refuse; every other command stays. See [agent-control.md](agent-control.md#no-ai). + +## `horizon-launcher versions` + +List Horizon releases, or the installed versions. + + horizon-launcher versions + +- `--installed`: Only the versions installed here (no network) + +MCP: `versions`. + +## `horizon-launcher install` + +Download and install a release (a tag such as v2026.10.13, or "latest"). + + horizon-launcher install <TAG> + +- `TAG` + +MCP: `install`. + +## `horizon-launcher remove` + +Remove an installed version. + + horizon-launcher remove <TAG> + +- `TAG` + +MCP: `remove`, needs `confirm: true`. + +## `horizon-launcher prepare` + +Prepare a version's resources from your own Minecraft install. + + horizon-launcher prepare + +- `--minecraft`: The game folder of the official launcher, Prism Launcher, MultiMC, the Modrinth App, ATLauncher or GDLauncher (default: the launcher's, then every launcher's default) + +MCP: `prepare`. + +## `horizon-launcher play` + +Start the client. + + horizon-launcher play + +- `--world`: Open or create this world (a folder under saves) at once +- `--creative`: Creative mode for a new world +- `--join`: Join a friend's world with its invite code +- `--arg`: An extra argument for the game, passed through as-is (repeatable), for example --server-thread + +MCP: `play`, then the `game_*` tools. + +## `horizon-launcher server` + +Run a dedicated server here; type commands into its console. + + horizon-launcher server + +- `--dir`: The server's folder (default: the one the launcher uses) +- `--accept-eula`: Agree to the Minecraft EULA (https://aka.ms/MinecraftEULA) + +MCP: `server`, `server_command`, `server_log`, `server_stop`. + +## `horizon-launcher notes` + +Show a release's patch notes (default: the newest). + + horizon-launcher notes [TAG] + +- `TAG` + +MCP: `notes`. + +## `horizon-launcher links` + +Show the Discord, sponsor and website links. + + horizon-launcher links + +MCP: `links`. + +## `horizon-launcher account list` + +The signed-in accounts and which one plays. + + horizon-launcher account list + +MCP: `account_list`. + +## `horizon-launcher account sign-in` + +Sign in with a Microsoft account in your browser (device code). + + horizon-launcher account sign-in + +MCP: `account_sign_in`. + +## `horizon-launcher account sign-out` + +Sign out: the account's tokens leave the keychain. + + horizon-launcher account sign-out <WHO> + +- `WHO`: Its name or UUID + +MCP: `account_sign_out`, needs `confirm: true`. + +## `horizon-launcher account select` + +Play as this account. + + horizon-launcher account select <WHO> + +- `WHO` + +MCP: `account_select`. + +## `horizon-launcher account offline` + +Play offline, without an account. + + horizon-launcher account offline + +MCP: `account_offline`. + +## `horizon-launcher update-channel` + +Show or set which Horizon releases install by themselves: stable (a tested build about once a day) or alpha (every release as soon as it is built; can break). + + horizon-launcher update-channel [CHANNEL] + +- `CHANNEL` (stable, alpha): Omit to show the current channel + +MCP: `update_channel`. + +## `horizon-launcher settings` + +Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off. + + horizon-launcher settings [KEY] [VALUE] + +- `KEY` (selected-version, minecraft-dir, server-dir, install-new-versions, opening-animation) +- `VALUE`: The new value (with KEY) + +MCP: `settings`. + +## `horizon-launcher game-args` + +Show or set the extra arguments the game starts with (for example --server-thread); quotes group a word with spaces in it. + + horizon-launcher game-args [ARGS] + +- `ARGS`: Omit to show the current arguments + +MCP: `game_args`. + +## `horizon-launcher logs` + +Print the end of the game's log (logs/latest.log in the game folder), or its newest crash report. + + horizon-launcher logs + +- `--lines`: How many lines of latest.log +- `--crash`: The newest crash report instead + +MCP: `logs`. + +## `horizon-launcher update` + +Look for a newer Horizon release and launcher, and install them. + + horizon-launcher update + +- `--check`: Only report what is available + +MCP: `update`. + +## `horizon-launcher desktop-entry` + +Linux: put Horizon in the applications menu (an entry and the icon, under $XDG_DATA_HOME), or take it out with --remove. + + horizon-launcher desktop-entry + +- `--remove`: Remove the entry and the icon, and stop adding them back + +MCP: `desktop_entry`. + +## `horizon-launcher data status` + +What is allowed, the install ID and how many items wait (the default). + + horizon-launcher data status + +MCP: `data_status`. + +## `horizon-launcher data allow` + +Turn kinds on: performance, crashes, bugs, benchmarks, or all. + + horizon-launcher data allow <KINDS>... + +- `KINDS` + +MCP: `data_allow`, only when the player asks. + +## `horizon-launcher data deny` + +Turn kinds off: performance, crashes, bugs, benchmarks, or all. + + horizon-launcher data deny <KINDS>... + +- `KINDS` + +MCP: `data_deny`. + +## `horizon-launcher data show` + +Print exactly what would be sent. + + horizon-launcher data show + +MCP: `data_show`. + +## `horizon-launcher data delete` + +Delete everything sent from here, and what waits, and take a new install ID. + + horizon-launcher data delete + +MCP: `data_delete`, needs `confirm: true`. + +## `horizon-launcher data send` + +Send what is waiting now. + + horizon-launcher data send + +MCP: `data_send`, only when the player asks. + +## `horizon-launcher data bug` + +Send a bug report you write; it is printed first, as it would leave. + + horizon-launcher data bug <TEXT> + +- `TEXT` +- `--log`: Add the end of the game's log (scrubbed, without chat) +- `--yes`: Send without asking + +MCP: `data_bug`, only when the player asks. + +## `horizon-launcher data benchmark` + +Upload a benchmark report (docs/benchmark-report.md); it is printed first. + + horizon-launcher data benchmark <FILE> + +- `FILE` +- `--yes` + +MCP: `data_benchmark`, only when the player asks. + +## `horizon-launcher modpack list` + +The imported packs and their coverage (the default). + + horizon-launcher modpack list + +MCP: `modpack_list`. + +## `horizon-launcher modpack import` + +Import a .mrpack, a CurseForge zip or an instance folder, and write its coverage report. + + horizon-launcher modpack import <PATH> + +- `PATH` + +MCP: `modpack_import`. + +## `horizon-launcher modpack port` + +Get the jars of what this computer can port and carry them over. + + horizon-launcher modpack port <PACK> + +- `PACK`: The pack's folder name, as list shows it +- `--from`: A folder with your own jars (an installed instance, a downloads folder) + +MCP: `modpack_port`. + +## `horizon-launcher modpack play` + +Play a ported pack as its own profile. + + horizon-launcher modpack play <PACK> + +- `PACK` + +MCP: `modpack_play`. + +## `horizon-launcher modpack remove` + +Remove an imported pack: its jars, ports and the profile's saves. + + horizon-launcher modpack remove <PACK> + +- `PACK` + +MCP: `modpack_remove`, needs `confirm: true`. + +## `horizon-launcher mods list` + +What the browser installed (the default). + + horizon-launcher mods list + +MCP: `mods_list`. + +## `horizon-launcher mods search` + +Search for packs Horizon loads. + + horizon-launcher mods search [TEXT]... + +- `TEXT` +- `--kind` (mod, resource, shader, modpack) +- `--everything`: Also what was made for other versions or runs only partly, each marked +- `--source` (modrinth, curseforge) + +MCP: `mods_search`. + +## `horizon-launcher mods check` + +Say how well a Java mod runs in Horizon: its jar is downloaded (checksum checked), carried over and read; the answer is kept. + + horizon-launcher mods check <PROJECT> + +- `PROJECT` +- `--everything`: Allow a version made for another Minecraft version (1.21 and later) +- `--source` (modrinth, curseforge) + +MCP: `mods_check`. + +## `horizon-launcher mods install` + +Install a pack and what it needs, by its id or slug (checksums checked); a Java mod is ported into horizon-mods and turned on; a modpack is imported. + + horizon-launcher mods install <PROJECT> + +- `PROJECT` +- `--everything`: Allow a version made for another Minecraft version +- `--source` (modrinth, curseforge) + +MCP: `mods_install`. + +## `horizon-launcher mods update` + +Update what the browser installed (or one pack). + + horizon-launcher mods update [PROJECT] + +- `PROJECT` +- `--check`: Only say what is newer + +MCP: `mods_update`. + +## `horizon-launcher mods remove` + +Remove a pack the browser installed. + + horizon-launcher mods remove <PROJECT> + +- `PROJECT` + +MCP: `mods_remove`, needs `confirm: true`. + +## `horizon-launcher servers list` + +The servers, their folder and whether they run. + + horizon-launcher servers list + +MCP: `servers_list`. + +## `horizon-launcher servers create` + +Create a server; with no options it is a new world, survival, normal, 10 players, friends only. + + horizon-launcher servers create + +- `--name` +- `--seed`: The new world's seed (default: random) +- `--copy-world`: Start from a copy of this world folder (one of your saves) +- `--mode` (survival, creative, adventure, spectator) +- `--difficulty` (peaceful, easy, normal, hard) +- `--max-players` +- `--open`: Let anyone in (no whitelist) +- `--check-accounts`: Check players' Minecraft accounts (they must sign in with Microsoft) +- `--player`: Who may join (repeatable); the first becomes an operator +- `--accept-eula`: Agree to the Minecraft EULA (https://aka.ms/MinecraftEULA) + +MCP: `servers_create`, only when the player asks. + +## `horizon-launcher servers set-up` + +Copy an installed, prepared version's programs and game files for the servers (again). + + horizon-launcher servers set-up + +MCP: `servers_set_up`. + +## `horizon-launcher servers run` + +Run a horizon-server command on a server, for example: servers run "My server" -- status. + + horizon-launcher servers run <SERVER> -- <ARGS>... + +- `SERVER`: The server's name or folder +- `ARGS` + +MCP: `servers_run`. + +## `horizon-launcher servers forget` + +Take a server off the list (its folder stays). + + horizon-launcher servers forget <SERVER> + +- `SERVER` + +MCP: `servers_forget`, needs `confirm: true`. + +## `horizon-launcher mcp` + +Serve the Model Context Protocol on stdin and stdout, for AI agents (refused while No AI is on). + + horizon-launcher mcp + +MCP: none: this command is the MCP server. + +## `horizon-launcher agent-config` + +How to connect an AI agent (Claude Code, Codex, Cursor, any MCP client) to `mcp`: the config to paste and the command that adds it (refused while No AI is on). + + horizon-launcher agent-config + +- `--client` (claude-code, codex, cursor, generic): Only this client +- `--test`: Start the MCP server as a client would and say whether it answered + +MCP: none: it prints how to connect a client to `mcp`. + +## `horizon-launcher no-ai` + +Show or set No AI: on hides and turns off every AI feature (the companion, agent control, horizon-ctl and both MCP servers); off, the default, makes them available. + + horizon-launcher no-ai [STATE] + +- `STATE` (on, off): Omit to show the current state + +MCP: none: the player's switch. + +## `horizon-launcher benchmark` + +Measure the launcher: starts (the first is the cold one), page switching, idle CPU and memory, the release list fetch; writes a benchmark report to benchmarks/ in its data folder. + + horizon-launcher benchmark + +- `--repeats`: How many times to start it + +MCP: `benchmark`. diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs index e5d9d5a20..307f17dba 100644 --- a/launcher/src/cli_tools.rs +++ b/launcher/src/cli_tools.rs @@ -232,6 +232,111 @@ impl Tool { } } +/// The tools mcp.rs runs itself for a CLI command, and what an agent uses instead of the +/// player-only ones. +#[cfg(test)] +fn session_tool(words: &str) -> &'static str { + match words { + "play" => "`play`, then the `game_*` tools", + "server" => "`server`, `server_command`, `server_log`, `server_stop`", + "account sign-in" => "`account_sign_in`", + "account list" => "`account_list`", + "mcp" => "none: this command is the MCP server", + "agent-config" => "none: it prints how to connect a client to `mcp`", + _ => "none: the player's switch", + } +} + +/// docs/launcher-commands.md: every CLI command, its arguments and its MCP tool, from the CLI's +/// definition. A test keeps the file equal to this. +#[cfg(test)] +fn markdown() -> String { + let mut out = String::from( + "# Launcher commands\n\n<!-- Generated from launcher/src/cli.rs by cli_tools::markdown(); a test fails when this file is out of date. Update it with: HORIZON_WRITE_DOCS=1 cargo test --manifest-path launcher/Cargo.toml the_launcher_reference -->\n\n\ +Every command of `horizon-launcher`, and the tool `horizon-launcher mcp` offers for it. A tool's \ +arguments are the command's, in snake_case. A tool runs the command with `--json` and returns what it printed. \ +The tools that change the player's things for good need `confirm: true`. \ +The tools that send something or reach other people say \"only when the player asks\". \ +The game's own tools, `game_*`, are in [horizon-ctl-commands.md](horizon-ctl-commands.md). \ +With No AI on, `mcp` and `agent-config` are hidden and refuse; every other command stays. See [agent-control.md](agent-control.md#no-ai).\n\n", + ); + let mut rows = Vec::new(); + collect(&crate::cli::command(), &mut Vec::new(), &mut rows); + let generated: Vec<String> = all().iter().map(|t| t.words()).collect(); + for (words, cmd) in rows { + let usage = cmd + .clone() + .bin_name(format!("horizon-launcher {words}")) + .render_usage() + .to_string(); + let usage = usage + .trim_start_matches("Usage: ") + .replace(" [OPTIONS]", ""); + out += &format!("## `horizon-launcher {words}`\n\n"); + if let Some(about) = cmd.get_about() { + out += &format!("{about}.\n\n"); + } + out += &format!(" {usage}\n\n"); + let args: Vec<&clap::Arg> = cmd.get_arguments().filter(|a| shown(a)).collect(); + for arg in &args { + let name = match arg.get_long() { + Some(long) => format!("--{long}"), + None => arg.get_id().as_str().to_uppercase(), + }; + let help = arg.get_help().map(ToString::to_string).unwrap_or_default(); + let choices: Vec<String> = arg + .get_possible_values() + .iter() + .map(|v| v.get_name().to_owned()) + .collect(); + let choices = if choices.is_empty() || matches!(arg.get_action(), ArgAction::SetTrue) { + String::new() + } else { + format!(" ({})", choices.join(", ")) + }; + let help = if help.is_empty() { + String::new() + } else { + format!(": {help}") + }; + out += &format!("- `{name}`{choices}{help}\n"); + } + if !args.is_empty() { + out += "\n"; + } + let mcp = if generated.contains(&words) { + let path: Vec<String> = words.split(' ').map(str::to_owned).collect(); + let mut text = format!("`{}`", tool_name(&path)); + if DESTRUCTIVE.contains(&words.as_str()) { + text += ", needs `confirm: true`"; + } else if OPEN_WORLD.contains(&words.as_str()) { + text += ", only when the player asks"; + } + text + } else { + session_tool(&words).to_owned() + }; + out += &format!("MCP: {mcp}.\n\n"); + } + out.truncate(out.trim_end().len()); + out.push('\n'); + out +} + +/// Every command a player can type, groups included when they run on their own. +#[cfg(test)] +fn collect(cmd: &Command, path: &mut Vec<String>, out: &mut Vec<(String, Command)>) { + for sub in cmd.get_subcommands().filter(|c| c.get_name() != "help") { + path.push(sub.get_name().to_owned()); + if sub.has_subcommands() { + collect(sub, path, out); + } else { + out.push((path.join(" "), sub.clone())); + } + path.pop(); + } +} + /// Whether an argument is part of a tool (not --help, --version or the global --json). fn shown(arg: &clap::Arg) -> bool { !arg.is_hide_set() && !matches!(arg.get_id().as_str(), "help" | "version" | "json") @@ -315,6 +420,28 @@ mod tests { ); } + #[test] + fn the_launcher_reference_is_up_to_date() { + let path = + std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../docs/launcher-commands.md"); + let want = markdown(); + if std::env::var_os("HORIZON_WRITE_DOCS").is_some() { + std::fs::write(&path, &want).unwrap(); + } + let have = std::fs::read_to_string(&path).unwrap_or_default(); + assert!( + have == want, + "docs/launcher-commands.md is out of date: HORIZON_WRITE_DOCS=1 cargo test --manifest-path launcher/Cargo.toml the_launcher_reference" + ); + for tool in all() { + assert!( + have.contains(&format!("`{}`", tool.name)), + "{} undocumented", + tool.name + ); + } + } + #[test] fn destructive_tools_need_confirm() { let remove = tool("remove"); diff --git a/website/docs/agents.md b/website/docs/agents.md new file mode 100644 index 000000000..32ba58362 --- /dev/null +++ b/website/docs/agents.md @@ -0,0 +1,126 @@ +# Control Horizon with your AI agent + +Your own AI agent can drive the launcher and the game: Claude Code, Codex, Cursor or any client that speaks MCP (the Model Context Protocol). It runs on your computer and uses the same commands you can type in a terminal. It can install a version, start the game, play it, change settings and manage your worlds. Before it deletes anything, it asks you. If you don't want any of this, one **No AI** switch hides and turns off every AI feature. + +## What an agent can do + +Everything you can do with the mouse and keyboard, through commands instead of clicks: + +- **In the launcher:** + - install, remove and prepare versions; + - start the game, alone or with a world, or a server; + - your settings, the update channel and the extra game arguments; + - the mod browser (mods, resource packs, shader packs, modpacks), imported modpacks and hosted servers; + - your accounts (names only), logs and crash reports, patch notes, the data collection settings and the benchmark. +- **In the game:** + - read what is on screen (every button, slider, field and slot, by name), click and type; + - move, look, mine, place, attack, use items and pick from the hotbar; + - the inventory, chests and every other container, crafting, trading, books and signs; + - every options page, including Horizon Settings, and any option by its key; + - worlds (create, open, rename, back up, delete), servers, LAN and Play with Friends; + - chat and commands, screenshots, F3 data, waiting for an event and the game's log. + +The full lists are in the repository: [launcher commands](https://github.com/ludovic111/horizon/blob/main/docs/launcher-commands.md) and [game commands](https://github.com/ludovic111/horizon/blob/main/docs/horizon-ctl-commands.md). + +## Connect it from the launcher + +The easiest way. Open the launcher's **Settings** and scroll to **AI**: + +1. Under **Connect an AI agent**, pick your client: **Claude Code**, **Codex**, **Cursor** or **Any MCP client**. +2. For Claude Code and Codex, **Add to Claude Code** (or **Add to Codex**) runs that client's own command to add Horizon. The command is shown above the button, and runs only when you click it. For the others, **Copy** the config and paste it into the file named above it. +3. **Test the connection** starts Horizon's MCP server the way your client will and says how many tools it offers. +4. Restart your agent if it was open, then ask it: "Say hello from Horizon". + +One server, called `horizon`, covers both the launcher and the game. Ask your agent to start the game and it starts it under its control. The game's tools are the ones whose names begin with `game_`. + +## Copy-paste config + +The launcher prints these with the exact path of your copy: `horizon-launcher agent-config`. The paths below are the usual ones: + +- **macOS:** `/Applications/Horizon.app/Contents/MacOS/horizon-launcher` +- **Windows:** where you extracted the zip, for example `C:\Horizon\horizon-launcher.exe` +- **Linux:** where you put the AppImage or binary + +**Claude Code**, in a terminal: + +```sh +claude mcp add --scope user horizon -- /Applications/Horizon.app/Contents/MacOS/horizon-launcher mcp +``` + +**Codex**, in a terminal: + +```sh +codex mcp add horizon -- /Applications/Horizon.app/Contents/MacOS/horizon-launcher mcp +``` + +Or in `~/.codex/config.toml`: + +```toml +[mcp_servers.horizon] +command = "/Applications/Horizon.app/Contents/MacOS/horizon-launcher" +args = ["mcp"] +``` + +**Cursor** (`~/.cursor/mcp.json`), **Claude Desktop**, and **any other MCP client** that takes the usual JSON: + +```json +{ + "mcpServers": { + "horizon": { + "command": "/Applications/Horizon.app/Contents/MacOS/horizon-launcher", + "args": ["mcp"] + } + } +} +``` + +The server talks over its standard input and output, so it needs no port and is never on the network. + +## A game you started yourself + +A game your agent starts is under its control. A game you start with **Play** is not, unless you allow it. In the game, open **Options**, then **Horizon Settings**, then **AI Agent...**: + +- **Agent Control: On** lets agents on this computer reach the game you started. It is off by default. +- The page shows whether an agent is connected and when it last sent a command. +- **Copy Connection Details** copies where the game listens, a command to try, and an MCP config for `horizon-ctl`, the game's own command line, which comes with the game. + +Turning **Agent Control** off disconnects agents at once. + +## The command line + +The same commands, for scripts and terminals. `--json` prints JSON. + +- See the versions: `horizon-launcher versions` +- Install the newest: `horizon-launcher install latest` +- Play a world: `horizon-launcher play --world "My world"` +- Change a setting: `horizon-launcher settings install-new-versions on` +- Find a shader pack: `horizon-launcher mods search --kind shader sildurs` +- Read the game's log: `horizon-launcher logs` +- Turn No AI on: `horizon-launcher no-ai on` +- Start a game agents control: `horizon-ctl launch --world Test` +- See the game's state: `horizon-ctl state` +- See what is on screen: `horizon-ctl ui` +- Click a button by name: `horizon-ctl click singleplayer` +- Walk somewhere: `horizon-ctl goto 10 64 -3` +- Take a screenshot: `horizon-ctl screenshot shot.png` + +`horizon-ctl help` lists every game command. `horizon-launcher help` lists the launcher's. + +## Safety + +- **Your computer only.** The launcher's server talks only to the agent that started it. The game listens on a local socket that only your user account can open; where there is none (Windows), it uses a localhost port and a secret token in a file only you can read. Nothing listens on your network. +- **It asks before deleting.** Removing a version, a modpack, a mod or a server, deleting a world or your collected data, and signing out need `confirm: true` from the agent. A call without it is refused and tells the agent to ask you first. +- **It asks before reaching out.** The tools that send something or reach other people say "only when the player asks". That covers joining a server, chatting on one, opening to LAN, hosting for friends, creating a server and sending data or a bug report. Data collection stays off until you allow it yourself. +- **No secrets.** No command returns your account tokens, session files or invite secrets. Accounts appear as names. Signing in stays a code that you enter in your own browser. +- **Your agent, your rules.** Clients such as Claude Code ask you before each tool they haven't been allowed to use. Allow only what you are happy for them to do. + +## No AI: turn it all off + +In the launcher's **Settings**, under **AI**, turn on **No AI**. You can also use **No AI** in the game's **Horizon Settings**, or type `horizon-launcher no-ai on`. Then: + +- the **Connect an AI agent** section and the game's **AI Agent** page are hidden; +- the game opens no control socket, even when it is started with one; +- `horizon-ctl`, `horizon-ctl mcp` and `horizon-launcher mcp` refuse with "AI features are off: turn off No AI in the launcher's settings"; +- the launcher's own commands (install, play, server, update and the rest) keep working, so scripts and packagers don't break. + +Turn it off the same way to bring everything back. diff --git a/website/docs/nav.json b/website/docs/nav.json index bef3aac57..e44fddb26 100644 --- a/website/docs/nav.json +++ b/website/docs/nav.json @@ -2,6 +2,6 @@ { "group": "Start here", "pages": ["index", "install"] }, { "group": "Playing", "pages": ["settings", "multiplayer", "troubleshooting"] }, { "group": "Hosting", "pages": ["hosting"] }, - { "group": "Going further", "pages": ["modpacks", "mods", "performance"] }, + { "group": "Going further", "pages": ["modpacks", "mods", "performance", "agents"] }, { "group": "Project", "pages": ["contributing", "faq"] } ] From d6f8dda823921845fed39d5b1722d33afc4e4dc9 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 05:13:25 +0200 Subject: [PATCH 28/62] Metal: the GPU frame timer measures the frame again (read about 0.01 ms) On Apple GPUs timestamps go only at pass boundaries, and the frame was bracketed by two one-thread compute passes. Two things made it read about 0.01 ms: - Metal resolves counter samples without waiting for the passes that write them. Resolved in the frame's own command buffer, the end timestamp was mostly the one an earlier frame left in the shared query. Each readback slot now has its own queries, and with markers a slot is resolved in a later frame, once on_submitted_work_done says the GPU finished the frame it timed. - A compute pass depends on nothing, so the end marker ran alongside the frame's render passes. The end is now a render pass that loads the frame's target, shading one pixel with every write masked: it runs after every pass that drew into the target. The start stays a compute pass (cheaper than a load and store of the target). M4 Pro, render distance 32, offscreen: GPU p50 0.002 ms before, now 1.95 ms against a 1.95 ms frame (village) and 4.46 ms against 4.51 ms (mountain), where the frame is GPU-bound. Vulkan and DirectX 12, which write timestamps between commands, are unchanged but for the per-slot queries. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/gfx.rs | 8 +- crates/horizon-client/src/gfx/timing.rs | 230 ++++++++++++++++++------ 2 files changed, 185 insertions(+), 53 deletions(-) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index dfa2c7239..c0b873a5e 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -4003,7 +4003,11 @@ impl Renderer { cull.end(&self.device, &mut encoder); } if let Some(timer) = &mut self.gpu_timer { - timer.end(&mut encoder); + timer.end( + &self.device, + &mut encoder, + (&view_target, self.config.format.remove_srgb_suffix()), + ); } let readback = self.screenshot.take().and_then(|path| { // The copy and PNG writer both assume 8-bit pixels; a float surface would make @@ -4034,7 +4038,7 @@ impl Renderer { cull.submitted(); } if let Some(timer) = &mut self.gpu_timer { - timer.submitted(); + timer.submitted(&self.queue); timer.collect(&self.device, &mut self.gpu_times); } if let Some((path, buffer)) = readback { diff --git a/crates/horizon-client/src/gfx/timing.rs b/crates/horizon-client/src/gfx/timing.rs index 8f8eee6ee..5fc566fe7 100644 --- a/crates/horizon-client/src/gfx/timing.rs +++ b/crates/horizon-client/src/gfx/timing.rs @@ -1,18 +1,35 @@ //! GPU frame time from timestamp queries, read back a few frames late so the //! CPU never waits for it. Frames whose readback slot is still busy go untimed. //! -//! Where the GPU can only time pass boundaries (Apple GPUs on Metal), the -//! frame is bracketed by two one-thread compute passes that write the -//! timestamps (Metal leaves an empty pass's timestamps at zero). +//! Where the GPU can only time pass boundaries (Apple GPUs on Metal), a +//! one-thread compute pass stamps the frame's start, and a render pass over +//! the frame's target that shades one pixel with every write masked stamps +//! its end (Metal leaves the timestamps of a pass that does nothing at zero). +//! A pass that loads the target runs after every pass that draws into it; a +//! compute pass, which depends on nothing, ran alongside them. Metal also +//! resolves timestamps without waiting for the passes that write them, so +//! they are resolved in a later frame, once the GPU has finished this one. +//! Resolved in the frame itself, the end was mostly the one an earlier frame +//! left in the query, and frames read about 0.01 ms. use std::sync::{ Arc, atomic::{AtomicU8, Ordering}, }; -const SLOTS: usize = 4; +/// Frames in flight at once; on Metal a slot is busy for about five frames. +const SLOTS: usize = 8; +/// Each slot's timestamps have their own queries and resolve range. +const RESOLVE_STRIDE: u64 = wgpu::QUERY_RESOLVE_BUFFER_ALIGNMENT; +/// The frame's target and its format. +pub type Target<'a> = (&'a wgpu::TextureView, wgpu::TextureFormat); const FREE: u8 = 0; -const PENDING: u8 = 1; -const MAPPED: u8 = 2; +/// Its frame is submitted; with markers, until the GPU has finished it. +const RUNNING: u8 = 1; +/// Its frame is finished: its timestamps can be resolved. +const DONE: u8 = 2; +/// Resolved and on its way back. +const PENDING: u8 = 3; +const MAPPED: u8 = 4; struct Slot { buffer: wgpu::Buffer, @@ -27,10 +44,29 @@ pub struct GpuTimer { current: Option<usize>, next: usize, period_ns: f32, - /// Timestamps between commands, or else this pass's boundaries. - marker: Option<wgpu::ComputePipeline>, + /// Timestamps between commands, or else these passes' boundaries. + markers: Option<Markers>, + /// Slots resolved in this frame's commands, read back once it is submitted. + resolved: Vec<usize>, } +/// The marker passes: the start's compute pipeline, and the end's shader and +/// pipeline, for the target format it was made for. +struct Markers { + module: wgpu::ShaderModule, + start: wgpu::ComputePipeline, + end: Option<(wgpu::TextureFormat, wgpu::RenderPipeline)>, +} + +/// The start's one thread; the end's triangle over the whole target (the +/// pass's scissor keeps one pixel), shading nothing it writes. +const MARKER: &str = + "@vertex fn cover(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> { + return vec4<f32>(f32(i & 1u) * 4.0 - 1.0, f32(i >> 1u) * 4.0 - 1.0, 0.0, 1.0); +} +@fragment fn nothing() -> @location(0) vec4<f32> { return vec4<f32>(0.0); } +@compute @workgroup_size(1) fn mark() {}"; + impl GpuTimer { /// The features timing uses that the adapter has (none: no timing). pub fn features(adapter: &wgpu::Adapter) -> wgpu::Features { @@ -44,11 +80,11 @@ impl GpuTimer { let queries = device.create_query_set(&wgpu::QuerySetDescriptor { label: Some("Frame timestamps"), ty: wgpu::QueryType::Timestamp, - count: 2, + count: 2 * SLOTS as u32, }); let resolve = device.create_buffer(&wgpu::BufferDescriptor { label: Some("Frame timestamp resolve"), - size: 16, + size: RESOLVE_STRIDE * SLOTS as u64, usage: wgpu::BufferUsages::QUERY_RESOLVE | wgpu::BufferUsages::COPY_SRC, mapped_at_creation: false, }); @@ -70,42 +106,43 @@ impl GpuTimer { current: None, next: 0, period_ns: queue.get_timestamp_period(), - marker: (!device + markers: (!device .features() .contains(wgpu::Features::TIMESTAMP_QUERY_INSIDE_ENCODERS)) .then(|| { let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("Frame timestamp"), - source: wgpu::ShaderSource::Wgsl( - "@compute @workgroup_size(1) fn mark() {}".into(), - ), + source: wgpu::ShaderSource::Wgsl(MARKER.into()), }); - device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { - label: Some("Frame timestamp"), - layout: None, - module: &module, - entry_point: Some("mark"), - compilation_options: Default::default(), - cache: None, - }) + Markers { + start: device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { + label: Some("Frame timestamp"), + layout: None, + module: &module, + entry_point: Some("mark"), + compilation_options: Default::default(), + cache: None, + }), + module, + end: None, + } }), + resolved: Vec::new(), }) } pub fn begin(&mut self, encoder: &mut wgpu::CommandEncoder) { + if self.markers.is_some() { + for slot in 0..SLOTS { + if self.slots[slot].state.load(Ordering::Acquire) == DONE { + self.resolve(encoder, slot); + } + } + } let slot = self.next; self.current = (self.slots[slot].state.load(Ordering::Acquire) == FREE).then_some(slot); - if self.current.is_some() { - self.stamp(encoder, 0); - } - } - pub fn end(&mut self, encoder: &mut wgpu::CommandEncoder) { let Some(slot) = self.current else { return }; - self.stamp(encoder, 1); - encoder.resolve_query_set(&self.queries, 0..2, &self.resolve, 0); - encoder.copy_buffer_to_buffer(&self.resolve, 0, &self.slots[slot].buffer, 0, 16); - } - fn stamp(&self, encoder: &mut wgpu::CommandEncoder, index: u32) { - let Some(marker) = &self.marker else { + let index = 2 * slot as u32; + let Some(markers) = &self.markers else { encoder.write_timestamp(&self.queries, index); return; }; @@ -113,29 +150,85 @@ impl GpuTimer { label: Some("Frame timestamp"), timestamp_writes: Some(wgpu::ComputePassTimestampWrites { query_set: &self.queries, - beginning_of_pass_write_index: (index == 0).then_some(0), - end_of_pass_write_index: (index == 1).then_some(1), + beginning_of_pass_write_index: Some(index), + end_of_pass_write_index: None, }), }); - pass.set_pipeline(marker); + pass.set_pipeline(&markers.start); pass.dispatch_workgroups(1, 1, 1); } - /// After the frame's submission: start reading its timestamps back. - pub fn submitted(&mut self) { + /// After the frame's last pass into `target` (the frame's own, of `format`). + pub fn end( + &mut self, + device: &wgpu::Device, + encoder: &mut wgpu::CommandEncoder, + (target, format): Target, + ) { + let Some(slot) = self.current else { return }; + let index = 2 * slot as u32 + 1; + let Some(markers) = &mut self.markers else { + encoder.write_timestamp(&self.queries, index); + self.resolve(encoder, slot); + return; + }; + if markers.end.as_ref().is_none_or(|(f, _)| *f != format) { + markers.end = Some((format, end_pipeline(device, &markers.module, format))); + } + let (_, pipeline) = markers.end.as_ref().expect("made above"); + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some("Frame timestamp"), + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: target, + depth_slice: None, + resolve_target: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Load, + store: wgpu::StoreOp::Store, + }, + })], + timestamp_writes: Some(wgpu::RenderPassTimestampWrites { + query_set: &self.queries, + beginning_of_pass_write_index: None, + end_of_pass_write_index: Some(index), + }), + ..Default::default() + }); + pass.set_pipeline(pipeline); + pass.set_scissor_rect(0, 0, 1, 1); + pass.draw(0..3, 0..1); + } + /// Copy `slot`'s timestamps to its readback buffer. + fn resolve(&mut self, encoder: &mut wgpu::CommandEncoder, slot: usize) { + let (first, at) = (2 * slot as u32, RESOLVE_STRIDE * slot as u64); + encoder.resolve_query_set(&self.queries, first..first + 2, &self.resolve, at); + encoder.copy_buffer_to_buffer(&self.resolve, at, &self.slots[slot].buffer, 0, 16); + self.slots[slot].state.store(RUNNING, Ordering::Release); + self.resolved.push(slot); + } + /// After the frame's submission: start reading back what it resolved, + /// and with markers, wait for the GPU to finish the frame it timed. + pub fn submitted(&mut self, queue: &wgpu::Queue) { + for slot in self.resolved.drain(..) { + let state = self.slots[slot].state.clone(); + state.store(PENDING, Ordering::Release); + self.slots[slot] + .buffer + .slice(..) + .map_async(wgpu::MapMode::Read, move |result| { + state.store( + if result.is_ok() { MAPPED } else { FREE }, + Ordering::Release, + ); + }); + } let Some(slot) = self.current.take() else { return; }; - let state = self.slots[slot].state.clone(); - state.store(PENDING, Ordering::Release); - self.slots[slot] - .buffer - .slice(..) - .map_async(wgpu::MapMode::Read, move |result| { - state.store( - if result.is_ok() { MAPPED } else { FREE }, - Ordering::Release, - ); - }); + if self.markers.is_some() { + let state = self.slots[slot].state.clone(); + state.store(RUNNING, Ordering::Release); + queue.on_submitted_work_done(move || state.store(DONE, Ordering::Release)); + } self.next = (slot + 1) % SLOTS; } /// GPU milliseconds of frames whose timestamps have arrived, oldest first. @@ -149,11 +242,46 @@ impl GpuTimer { if let Ok(data) = slot.buffer.slice(..).get_mapped_range() { // Read unaligned: the mapping isn't guaranteed to be 8-byte aligned. let stamps: [u64; 2] = bytemuck::pod_read_unaligned(&data[..16]); - let ticks = stamps[1].saturating_sub(stamps[0]); - out.push((ticks as f64 * f64::from(self.period_ns) / 1e6) as f32); + // A start marker that ran late (rare on Metal) leaves the frame untimed. + if let Some(ticks) = stamps[1].checked_sub(stamps[0]) { + out.push((ticks as f64 * f64::from(self.period_ns) / 1e6) as f32); + } } slot.buffer.unmap(); slot.state.store(FREE, Ordering::Release); } } } + +/// The end marker's pipeline for a `format` target, every write masked. +fn end_pipeline( + device: &wgpu::Device, + module: &wgpu::ShaderModule, + format: wgpu::TextureFormat, +) -> wgpu::RenderPipeline { + device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Frame timestamp"), + layout: None, + vertex: wgpu::VertexState { + module, + entry_point: Some("cover"), + compilation_options: Default::default(), + buffers: &[], + }, + primitive: wgpu::PrimitiveState::default(), + depth_stencil: None, + multisample: wgpu::MultisampleState::default(), + fragment: Some(wgpu::FragmentState { + module, + entry_point: Some("nothing"), + compilation_options: Default::default(), + targets: &[Some(wgpu::ColorTargetState { + format, + blend: None, + write_mask: wgpu::ColorWrites::empty(), + })], + }), + multiview_mask: None, + cache: None, + }) +} From 0c133101b695d8bccfa6d546411da6a171a80888 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 00:55:22 +0200 Subject: [PATCH 29/62] Screen overlays: wrap texels with a select, not integer modulo The camera overlays (the vignette every frame) read up to four texels a pixel, each wrapped with two integer modulos. Intel GPUs emulate integer division. Reducing the coordinate to one period first (fract, as the shader did before) leaves every read at most one texel outside the sprite, so a select wraps it. Same texels and weights; clamp-to-edge is unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/screen.wgsl | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/screen.wgsl b/crates/horizon-client/src/screen.wgsl index a82b0f890..f32274bc8 100644 --- a/crates/horizon-client/src/screen.wgsl +++ b/crates/horizon-client/src/screen.wgsl @@ -23,9 +23,11 @@ struct Out { } const SAMPLE_BLUR: u32 = 1u; const SAMPLE_CLAMP: u32 = 2u; -// A texel of the sprite, addressed by repeat or clamp-to-edge. +// A texel of the sprite, addressed by repeat or clamp-to-edge. With repeat, `p` is at most one +// texel outside the sprite (`sample` reduces the coordinate first), so wrapping is a select: no +// integer division, which Intel GPUs emulate (it cost 0.85 ms a frame on the vignette on an HD 620). fn texel(origin: vec2<i32>, size: vec2<i32>, p: vec2<i32>, clamp_edge: bool) -> vec4<f32> { - var q = ((p % size) + size) % size; + var q = select(select(p, p - size, p >= size), p + size, p < vec2(0)); if clamp_edge { q = clamp(p, vec2(0), size - 1); } return textureLoad(atlas, origin + q, 0); } @@ -34,7 +36,8 @@ fn sample(in: Out) -> vec4<f32> { let origin = vec2<i32>(round(in.rect.xy * dims)); let size = max(vec2<i32>(round((in.rect.zw - in.rect.xy) * dims)), vec2(1)); let clamp_edge = (in.sampling & SAMPLE_CLAMP) != 0u; - let p = in.uv * vec2<f32>(size); + // Repeat: one period of the sprite, so every texel read is at most one outside it. + let p = select(fract(in.uv), in.uv, clamp_edge) * vec2<f32>(size); if (in.sampling & SAMPLE_BLUR) == 0u { return texel(origin, size, vec2<i32>(floor(p)), clamp_edge) * in.color; } From 7acebbae45fb84ec7c905e05f4ac4e4220914d0b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 04:23:58 +0200 Subject: [PATCH 30/62] Server players: the HUD's bubbles and golden hearts follow the server, absorption is saved, Nether lava pushes harder The server sends a player's own air supply and absorption amount (Entity.DATA_AIR_SUPPLY_ID, Player.DATA_PLAYER_ABSORPTION_ID) when they change, and the client applies them: on the server thread and as a LAN guest the breath meter follows the server's Respiration-extended air (#1304) and the golden hearts show (#1306). The connected client's tick sets the helmet's Respiration and the Nether's FAST_LAVA as the window's own tick does (#1309). AbsorptionAmount is written from the live body and read back on load, in the window's world and for a server's players (#1307). lan_e2e: absorption, breath and lava checks. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- .../horizon-client/src/attribute_updates.rs | 5 + crates/horizon-client/src/game.rs | 1 + crates/horizon-client/src/game/agent.rs | 2 + crates/horizon-client/src/game/lan.rs | 3 + crates/horizon-client/src/game/lan_actions.rs | 6 + crates/horizon-client/src/game/remote.rs | 31 ++++- crates/horizon-client/src/lan/guest.rs | 9 ++ crates/horizon-client/src/lan/hub.rs | 25 +++- crates/horizon-client/src/lan/playerdata.rs | 7 + crates/horizon-client/src/motion.rs | 2 + crates/horizon-client/src/save.rs | 10 +- tools/lan_e2e.py | 122 +++++++++++++++++- 12 files changed, 215 insertions(+), 8 deletions(-) diff --git a/crates/horizon-client/src/attribute_updates.rs b/crates/horizon-client/src/attribute_updates.rs index b81db5835..1dcc21028 100644 --- a/crates/horizon-client/src/attribute_updates.rs +++ b/crates/horizon-client/src/attribute_updates.rs @@ -22,6 +22,11 @@ impl PlayerMotion { pub fn refresh_attributes(&mut self) -> Result<()> { live_updates::refresh(self) } + /// `Player.internalSetAbsorptionAmount`: the amount as given, unclamped + /// (the saved `AbsorptionAmount`, or what a client's server sent). + pub fn internal_set_absorption(&mut self, value: f32) -> Result<()> { + self.store_absorption(value) + } } impl HealthWorld for PlayerMotion { type Error = Box<dyn std::error::Error>; diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 5da86dfaf..d689ad8fc 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9516,6 +9516,7 @@ impl Game<'_> { if let Some(p) = &self.player { level.position = Some([p.position.x, p.position.y, p.position.z]); level.health = p.health.health(); + level.absorption = p.health.absorption(); let extra = level .player_extra .get_or_insert_with(|| horizon_world::nbt::Tag::Compound(Default::default())); diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index ea686e711..b30adca5c 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -459,6 +459,8 @@ impl Game<'_> { "sneaking": self.keys.contains(&KeyCode::ShiftLeft), "sprinting": self.keys.contains(&KeyCode::ControlLeft), "health": p.health.health(), + "absorption": p.health.absorption(), + "air": p.air, "food": p.health.food.food, "saturation": p.health.food.saturation, "xp": { "level": self.experience.level, "progress": self.experience.progress, "total": self.experience.total }, diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 4e05ea600..0ea2a6faa 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -393,6 +393,9 @@ impl Game<'_> { "sneaking": g.sneaking, "sleeping": g.bed, "health": g.health, + // The server's body: its air supply and golden hearts. + "air": g.motion.as_ref().map(|m| m.air), + "absorption": g.motion.as_ref().map(|m| m.health.absorption()), // FoodData: food level, saturation and exhaustion. "food": [ f64::from(g.food), diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 0d70b16f6..65cbf2e5f 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -217,6 +217,12 @@ impl Game<'_> { host.hub.guests[i].position[2], ); host.hub.guests[i].motion = PlayerMotion::new(self.motion, p).ok().map(Box::new); + // The saved golden hearts go on the first body of a player who + // has been here before. + let saved = host.hub.guests[i].saved_absorption.take(); + if let (Some(m), Some(amount)) = (host.hub.guests[i].motion.as_mut(), saved) { + let _ = m.internal_set_absorption(amount); + } let kept = host.hub.guests[i].logs_kept.take(); if let (Some(m), Some((hurts, attacks))) = (host.hub.guests[i].motion.as_mut(), kept) { m.hurt_log = hurts; diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 5461a4cd0..70096277f 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -1867,11 +1867,27 @@ impl Game<'_> { // player lies down in the bed, or gets up. if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) { for (index, _, value) in &p.values { - if let (14, Value::OptPos(bed)) = (index, value) { - if bed.is_some() && self.sleeping.is_none() { - self.sleep_timer = 0; + match (index, value) { + (14, Value::OptPos(bed)) => { + if bed.is_some() && self.sleeping.is_none() { + self.sleep_timer = 0; + } + self.sleeping = *bed; } - self.sleeping = *bed; + // Entity.DATA_AIR_SUPPLY_ID and + // Player.DATA_PLAYER_ABSORPTION_ID: the bubbles + // and golden hearts the server's player has. + (1, Value::Int(air)) => { + if let Some(pl) = self.player.as_mut() { + pl.air = *air; + } + } + (17, Value::Float(amount)) => { + if let Some(pl) = self.player.as_mut() { + let _ = pl.internal_set_absorption(*amount); + } + } + _ => {} } } } @@ -2997,6 +3013,13 @@ impl Game<'_> { ); let was_flying = player.flying; player.yaw = self.yaw; + // As the window's own tick has them: the helmet's Respiration + // (decreaseAirSupply) and the dimension's FAST_LAVA, the Nether's + // stronger lava current. + player.respiration = self.armor[0] + .as_ref() + .map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32); + player.fluids.fast_lava = self.dim == Dim::Nether; let dead = self.screen == Screen::Dead; // LivingEntity.isImmobile: a sleeper lies still in the bed. if let Some(head) = self.sleeping { diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs index 1916344bb..3c5d4b50c 100644 --- a/crates/horizon-client/src/lan/guest.rs +++ b/crates/horizon-client/src/lan/guest.rs @@ -149,6 +149,9 @@ pub struct Guest { /// The ender chest inventory (`PlayerEnderChestContainer`, 27 slots). pub ender_items: Vec<Option<ItemStack>>, pub health: f32, + /// The saved `AbsorptionAmount`, until the player's first body on the + /// server takes it (the body holds the live amount). + pub saved_absorption: Option<f32>, pub food: i32, pub saturation: f32, pub xp_level: i32, @@ -168,6 +171,10 @@ pub struct Guest { /// `lastSentHealth`, `lastSentFood` and `lastFoodSaturationZero`. pub sent_health: Option<(f32, i32, bool)>, pub sent_xp: Option<(f32, i32, i32)>, + /// The air supply and absorption the player's client was last sent + /// (Entity.DATA_AIR_SUPPLY_ID, Player.DATA_PLAYER_ABSORPTION_ID); their + /// defaults until either changes. + pub sent_air: (i32, f32), /// Where the player last died (Player.lastDeathLocation), sent with the respawn. pub last_death: Option<[i32; 3]>, /// The last action sequence to acknowledge at the next tick (-1: none). @@ -280,6 +287,7 @@ impl Guest { craft_result: None, ender_items: vec![None; 27], health: 20.0, + saved_absorption: None, food: 20, saturation: 5.0, xp_level: 0, @@ -292,6 +300,7 @@ impl Guest { menu_state: 0, sent_health: None, sent_xp: None, + sent_air: (300, 0.0), last_death: None, ack_up_to: std::cell::Cell::new(-1), sent_selected: 0, diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index bf66f979b..1455e60b8 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -1755,6 +1755,27 @@ impl Hub { })); } } + // ServerEntity.sendDirtyEntityData: the air supply and the absorption + // amount the server's body changed go to the player, whose HUD draws + // them (bubbles, golden hearts). + let g = &mut self.guests[i]; + if let Some(m) = g.motion.as_ref() { + let now = (m.air, m.health.absorption()); + let mut values = Vec::new(); + if now.0 != g.sent_air.0 { + values.push((1, serializer::INT, Value::Int(now.0))); + } + if now.1.to_bits() != g.sent_air.1.to_bits() { + values.push((17, serializer::FLOAT, Value::Float(now.1))); + } + if !values.is_empty() { + g.sent_air = now; + g.send(&C::SetEntityData(play::SetEntityData { + id: g.entity_id, + values, + })); + } + } // Sent when the health or the food level changes, or the saturation // reaches or leaves zero; a dead player's health of 0 too. let g = &mut self.guests[i]; @@ -2465,9 +2486,11 @@ impl Hub { global: false, })); } - // lastSentExp, lastSentHealth and lastSentFood. + // lastSentExp, lastSentHealth and lastSentFood; the client's new + // player starts with the default air and no absorption. g.sent_health = None; g.sent_xp = None; + g.sent_air = (300, 0.0); let (cx, cz) = g.chunk(); g.send(&C::SetChunkCacheCenter(play::SetChunkCacheCenter { x: cx, diff --git a/crates/horizon-client/src/lan/playerdata.rs b/crates/horizon-client/src/lan/playerdata.rs index 8797f25a2..6a26306fb 100644 --- a/crates/horizon-client/src/lan/playerdata.rs +++ b/crates/horizon-client/src/lan/playerdata.rs @@ -61,6 +61,7 @@ pub fn apply(guest: &mut Guest, level: &Level) { guest.head_yaw = guest.yaw; guest.on_ground = level.on_ground; guest.health = level.health; + guest.saved_absorption = Some(level.absorption); guest.food = level.food; guest.saturation = level.saturation; guest.xp_level = level.xp_level; @@ -123,6 +124,12 @@ pub fn store(guest: &Guest, level: &mut Level) { level.dimension = guest.dimension.clone(); level.rotation = [guest.yaw, guest.pitch]; level.health = guest.health; + level.absorption = guest + .motion + .as_ref() + .map_or(guest.saved_absorption.unwrap_or(0.0), |m| { + m.health.absorption() + }); level.food = guest.food; level.saturation = guest.saturation; level.xp_level = guest.xp_level; diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs index 1920026b9..c0c882e0f 100644 --- a/crates/horizon-client/src/motion.rs +++ b/crates/horizon-client/src/motion.rs @@ -338,6 +338,8 @@ impl PlayerMotion { .and_then(|t| crate::save::number(t.get("Air"))) .unwrap_or(300) as i32; self.set_health(level.health, false)?; + // LivingEntity.readAdditionalSaveData: internalSetAbsorptionAmount. + self.internal_set_absorption(level.absorption)?; self.health.food.food = level.food; self.health.food.saturation = level.saturation; self.flying = level.flying; diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 0cfe3c585..2fbb04dc4 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -2266,6 +2266,8 @@ pub struct Level { pub position: Option<[f64; 3]>, pub rotation: [f32; 2], pub health: f32, + /// LivingEntity `AbsorptionAmount`: the golden hearts left. + pub absorption: f32, pub food: i32, pub saturation: f32, /// (slot, item, count, damage): 0..36 inventory, 100..103 armor (feet..head), 150 offhand. @@ -2455,6 +2457,7 @@ impl Level { } self.motion = read_doubles::<3>(p.get("Motion")).unwrap_or_default(); self.health = f("Health").map_or(20.0, |v| v as f32); + self.absorption = f("AbsorptionAmount").map_or(0.0, |v| v as f32); self.food = n("foodLevel").map_or(20, |v| v as i32); self.saturation = f("foodSaturationLevel").map_or(5.0, |v| v as f32); self.food_exhaustion = f("foodExhaustionLevel").unwrap_or(0.0) as f32; @@ -2626,6 +2629,7 @@ impl Level { ("OnGround", Tag::Byte(i8::from(self.on_ground))), ("fall_distance", Tag::Double(self.fall_distance.to_bits())), ("Health", Tag::Float(self.health.to_bits())), + ("AbsorptionAmount", Tag::Float(self.absorption.to_bits())), ("foodLevel", Tag::Int(self.food)), ("foodSaturationLevel", Tag::Float(self.saturation.to_bits())), ( @@ -2731,7 +2735,6 @@ impl Level { ("seenCredits", Tag::Byte(0)), ("HurtTime", Tag::Short(0)), ("DeathTime", Tag::Short(0)), - ("AbsorptionAmount", Tag::Float(0)), ("FallFlying", Tag::Byte(0)), ] { map.entry(key.into()).or_insert(value); @@ -4114,6 +4117,7 @@ mod tests { position: Some([1.5, 70.0, -3.25]), rotation: [90.0, 10.0], health: 17.0, + absorption: 5.0, food: 15, saturation: 2.5, inventory: vec![ @@ -4144,6 +4148,7 @@ mod tests { assert_eq!(back.position, Some([1.5, 70.0, -3.25])); assert_eq!(back.rotation, [90.0, 10.0]); assert_eq!((back.health, back.food, back.saturation), (17.0, 15, 2.5)); + assert_eq!(back.absorption, 5.0); let mut inv = back.inventory.clone(); inv.sort(); assert_eq!( @@ -4178,10 +4183,13 @@ mod tests { let mut again = Level { player_extra: Some(extra), ender_items: ender, + // The live amount, not the one the loaded compound held (#1307). + absorption: 2.0, ..back }; again.write(&dir).unwrap(); let third = Level::read(&dir).unwrap(); + assert_eq!(third.absorption, 2.0); assert!(matches!( third .player_extra diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index c5a90150f..a4fdafe71 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -131,6 +131,12 @@ address. The script then checks, from both sides, what a guest's game used to ge get off by sneaking; the other side sees the animal move. - lightning: a bolt summoned beside the host, then the guest: both sides get the bolt and flash the sky (on its server thread the host's window is a client of it too). +- absorption: the host and the guest each take Absorption II and a hit of 3: their own HUD has the + server's golden hearts, 8 then 5 (#1306). +- breath: the host and the guest each stay underwater for 15 s in a Respiration III helmet: their + own bubbles follow the server's air, which the enchantment makes last (#1304). +- lava: (--server-thread) the host and the guest each stand in a Nether lava current with Fire + Resistance, which pushes them at the Nether's strength (#1309). - flight: a player in creative double-taps jump and flies, stays up, and stops flying in survival: the guest, and on the server thread the host's window too, take what may fly from the server's abilities (ClientPacketListener.handlePlayerAbilities). @@ -172,7 +178,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts', 'absorption', 'breath', 'lava'] class Game: @@ -2297,6 +2303,117 @@ def check_flight(host, guest, out): +def own(game): + """The player's own state, as its client has it.""" + return game('state')['player'] + + +def server_player(host, game): + """The player's entry on the server: the guest's in the host's `lan status`, on the server + thread the host's too; the host's own world otherwise.""" + if game is host and not SERVER_THREAD: + return own(host) + name = GUEST_NAME if game is not host else host.player + return next(g for g in host.raw('lan', 'status')['guests'] if g['name'] == name) + + +def check_absorption(host, guest, out): + """Absorption II's golden hearts on each player's own HUD: 8 of them, and 5 once a hit of 3 took + its share: the client shows what the server's player has (#1306).""" + seen = {} + for game in (host, guest): + game('command', command='gamemode survival') + game('command', command='effect give @s minecraft:absorption 120 1') + game.wait(10) + given = own(game)['absorption'] + game('command', command='damage @s 3 minecraft:generic') + game.wait(20) + me = own(game) + server = server_player(host, game) + game.shot(out, 'absorption') + game('command', command='effect clear @s minecraft:absorption') + seen[game.name] = {'given': given, 'left': me['absorption'], 'health': me['health'], + 'server': server.get('absorption')} + for name, s in seen.items(): + assert s['given'] == 8.0 and s['left'] == 5.0 == s['server'] and s['health'] == 20.0, \ + f'{name}: {seen}' + return seen + + +def check_breath(host, guest, out): + """Underwater in a Respiration III helmet for 15 s: the enchantment makes the air last on the + server, and each player's own bubbles follow the server's air (#1304).""" + hx, hy, hz = (int(v // 1) for v in pos_of(host)) + seen = {} + for game, dz in ((host, -4), (guest, 4)): + x, y, z = hx + 3, hy, hz + dz + game('command', command='gamemode survival') + game('command', command='item replace entity @s armor.head with ' + 'minecraft:diamond_helmet[minecraft:enchantments={"minecraft:respiration":3}]') + game('command', command=f'fill {x - 1} {y - 1} {z - 1} {x + 1} {y + 2} {z + 1} minecraft:stone') + game('command', command=f'fill {x} {y} {z} {x} {y + 1} {z} minecraft:water') + game('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + host.wait(300) + for game in (host, guest): + game.shot(out, 'breath') + seen[game.name] = {'own': own(game)['air'], 'server': server_player(host, game).get('air')} + for game, dz in ((host, -4), (guest, 4)): + x, y, z = hx + 3, hy, hz + dz + game('command', command='item replace entity @s armor.head with minecraft:air') + host('command', command=f'fill {x - 1} {y - 1} {z - 1} {x + 1} {y + 2} {z + 1} minecraft:air') + host('command', command=f'fill {x - 1} {y - 1} {z - 1} {x + 1} {y - 1} {z + 1} minecraft:stone') + guest.wait(40) + # 300 ticks lose about 75 of the 300 with Respiration III, all of it without. + for name, s in seen.items(): + assert s['server'] > 150 and abs(s['own'] - s['server']) <= 10, f'{name}: {seen}' + return seen + + +def check_lava(host, guest, out): + """(--server-thread) Standing in a settled Nether lava current with Fire Resistance: the + Nether's FAST_LAVA pushes each player about three times as hard as the Overworld's (#1309).""" + if not SERVER_THREAD: + return 'skipped (needs --server-thread)' + seen = {} + back = {g.name: pos_of(g) for g in (host, guest)} + try: + for game, z in ((host, 0), (guest, 6)): + game('command', command=f'execute in minecraft:the_nether run tp @s 0.5 100 {z + 0.5}') + state = wait_dimension(game, 'minecraft:the_nether', 600) + assert state.get('dimension') == 'minecraft:the_nether', f'{game.name} is in {state.get("dimension")}' + game.wait(40) + # A one-wide obsidian channel along x: a source at x = -3, the current flowing east. + game('command', command=f'fill -5 98 {z - 2} 6 104 {z + 2} minecraft:air') + game('command', command=f'fill -5 98 {z - 1} 6 98 {z + 1} minecraft:obsidian') + game('command', command=f'fill -5 99 {z - 1} 6 99 {z - 1} minecraft:obsidian') + game('command', command=f'fill -5 99 {z + 1} 6 99 {z + 1} minecraft:obsidian') + game('command', command=f'fill -4 99 {z} -4 99 {z} minecraft:obsidian') + game('command', command='effect give @s minecraft:fire_resistance 120 0 true') + game('command', command='gamemode survival') + game('command', command=f'setblock -3 99 {z} minecraft:lava') + host.wait(100) + for game, z in ((host, 0), (guest, 6)): + game('command', command=f'tp @s 0.5 99 {z + 0.5}') + host.wait(60) + for game, z in ((host, 0), (guest, 6)): + v = own(game)['velocity'] + seen[game.name] = {'vx': v[0], 'level': game.raw('block', 0, 99, z).get('state')} + game.shot(out, 'lava') + finally: + for game, z in ((host, 0), (guest, 6)): + host('command', command=f'execute in minecraft:the_nether run fill -5 98 {z - 2} 6 104 {z + 2} minecraft:air') + x, y, zz = back[game.name] + game('command', command='effect clear @s minecraft:fire_resistance') + game('command', command=f'execute in minecraft:overworld run tp @s {x:.2f} {y:.2f} {zz:.2f}') + for game in (host, guest): + wait_dimension(game, 'minecraft:overworld', 600) + guest.wait(40) + # The Overworld's current settles at about 0.0047 a tick, the Nether's at about 0.014. + for name, s in seen.items(): + assert s['vx'] > 0.009, f'{name}: {seen}' + return seen + + def check_ladder(host, guest, out): """#1255: climbing down a ladder doesn't hurt where the guest lands.""" x, y, z = (int(v // 1) for v in pos_of(guest)) @@ -3075,7 +3192,8 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name 'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast, 'light': check_light, 'plates': check_plates, 'swings': check_swings, 'cracks': check_cracks, - 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts} + 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts, + 'absorption': check_absorption, 'breath': check_breath, 'lava': check_lava} def run(ctl, out, resources, checks): From ed28e1dd0d6f6959179ba5f1914cfb69de14d1ae Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 04:56:08 +0200 Subject: [PATCH 31/62] Contact damage: magma, cactus, lit campfires and sweet berry bushes hurt in both modes Entity.applyEffectsFromBlocks: MagmaBlock.stepOn burns a player standing on it who is not sneaking (hot_floor, 1), CactusBlock and CampfireBlock.entityInside hurt what touches them (cactus 1, campfire 1, soul campfire 2, lit only). A server's players (LAN guests, and the host on the server thread) now get these and the grown sweet berry bush prick along the moves their client sent that tick: the server rebuilds the tick's movement history and runs the damage half of the block effects. lan_e2e `contacts`: magma, sneaking on magma, a lit campfire, a cactus, grown and young berry bushes, for the host and the guest. Fixes #1305, #1311, #1312, #1313. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game/lan_actions.rs | 25 +++++++ crates/horizon-client/src/motion.rs | 73 ++++++++++++++++++- .../horizon-client/src/motion/environment.rs | 2 +- tools/lan_e2e.py | 64 +++++++++++++++- 4 files changed, 158 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 0d70b16f6..9d1181b80 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -1765,6 +1765,7 @@ impl Game<'_> { } let in_wall = !g.sleeping && self.in_wall(g.position, g.eye_height()); let at = g.position; + let sneaking = g.sneaking; let sounds = self.as_guest(host, conn, |game| { let (rules, motion) = (game.world.health_rules, game.motion); let health = &motion.health; @@ -1783,6 +1784,26 @@ impl Game<'_> { let _ = w.fluid_base_tick(); w.player.ground.on_ground = from_ground; let travelled: Vec<[f64; 3]> = moves.iter().map(|m| m.0).collect(); + // Entity.move's movementThisTick: each move, from where the + // tick's first one started. + let end = w.player.position; + let start = travelled + .iter() + .fold(end, |p, d| p.subtract(Vec3::new(d[0], d[1], d[2]))); + w.player.history.clear(); + let mut from = start; + for d in &travelled { + let delta = Vec3::new(d[0], d[1], d[2]); + let to = from.add_vector(delta); + w.player + .history + .add(horizon_world::entity_move::MovementRecord { + from, + to, + original: Some(delta), + }); + from = to; + } for (moved, on_ground) in moves { let movement = Vec3::new(moved[0], moved[1], moved[2]); if w.player.ground.on_ground && !on_ground && moved[1] > 0.0 { @@ -1808,6 +1829,10 @@ impl Game<'_> { if w.climbable().unwrap_or(false) { w.player.fall_distance = 0.0; } + // Entity.applyEffectsFromBlocks along those moves: magma, cactus, + // lit campfires and grown sweet berry bushes hurt (#1305). + w.player.shift_key_down = sneaking; + let _ = w.server_block_damage(start); let _ = w.tick_environment_damage(); let _ = w.apply_fire_contact(); let _ = w.server_hazards_tick(in_wall); diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs index 1920026b9..8831a5912 100644 --- a/crates/horizon-client/src/motion.rs +++ b/crates/horizon-client/src/motion.rs @@ -1029,9 +1029,22 @@ impl MotionWorld<'_, '_, '_> { } /// `Entity.applyEffectsFromBlocks` for the blocks Horizon's player reacts /// to inside its movement path: powder snow (`PowderSnowBlock.entityInside` - /// and the FREEZE / EXTINGUISH effects), cobwebs and sweet berry bushes. Pressure plates, tripwires and - /// rails are the world tick's scan. + /// and the FREEZE / EXTINGUISH effects), cobwebs, sweet berry bushes, + /// cactus and lit campfires, and the magma block it stands on + /// (`stepOn`). Pressure plates, tripwires and rails are the world tick's + /// scan. pub fn apply_effects_from_blocks(&mut self) -> Result<()> { + self.effects_from_blocks(false) + } + /// What `applyEffectsFromBlocks` does to a server's player along the + /// moves its client sent since `from` (in its history): the damage of + /// magma, cactus, lit campfires and grown sweet berry bushes. Its client + /// moves it, so the slowing and the rest are the client's. + pub fn server_block_damage(&mut self, from: Vec3) -> Result<()> { + self.player.old_position = from; + self.effects_from_blocks(true) + } + fn effects_from_blocks(&mut self, damage_only: bool) -> Result<()> { use horizon_world::entity_move::MovementRecord; let mut movements: Vec<MovementRecord> = self.player.history.records().iter().copied().collect(); @@ -1056,6 +1069,19 @@ impl MotionWorld<'_, '_, '_> { if self.player.spectator { return Ok(()); } + // Block.stepOn for the block under an entity on the ground: + // MagmaBlock's hot floor hurts unless it steps carefully (sneaks). + if self.player.ground.on_ground { + let on = self.legacy_on_position()?; + let magma = self + .assets + .registry + .state(self.block(on)) + .is_some_and(|s| s.name == "minecraft:magma_block"); + if magma && !self.player.shift_key_down { + self.environment_hurt("minecraft:hot_floor", 1.0)?; + } + } let mut visited = std::collections::HashSet::new(); let mut entered = Vec::new(); for movement in &movements { @@ -1081,6 +1107,7 @@ impl MotionWorld<'_, '_, '_> { &mut visited, &mut entered, budget, + damage_only, )?; from = to; } @@ -1093,11 +1120,19 @@ impl MotionWorld<'_, '_, '_> { &mut visited, &mut entered, 16, + damage_only, )?; } } if budget <= 0 { - self.check_inside_blocks(movement.to, movement.to, &mut visited, &mut entered, 1)?; + self.check_inside_blocks( + movement.to, + movement.to, + &mut visited, + &mut entered, + 1, + damage_only, + )?; } } // InsideBlockEffectApplier.StepBasedCollector: the blocks entered @@ -1137,6 +1172,7 @@ impl MotionWorld<'_, '_, '_> { visited: &mut std::collections::HashSet<i64>, entered: &mut Vec<(i32, BlockPos)>, max_iterations: i32, + damage_only: bool, ) -> Result<i32> { let deflated = self.player.dimensions.bounds(to).deflate(Vec3::new( f64::from(1.0e-5_f32), @@ -1213,6 +1249,33 @@ impl MotionWorld<'_, '_, '_> { } }; if inside && visited.insert(p.pack()) { + // CactusBlock and CampfireBlock.entityInside (`entity.hurt`). + match name { + "minecraft:cactus" => self.environment_hurt("minecraft:cactus", 1.0)?, + "minecraft:campfire" | "minecraft:soul_campfire" => { + let lit = self + .assets + .registry + .state(state) + .and_then(|s| s.properties.get("lit")) + .is_some_and(|v| v == "true"); + let damage = if name == "minecraft:campfire" { + 1.0 + } else { + 2.0 + }; + if lit { + self.environment_hurt("minecraft:campfire", damage)?; + } + } + "minecraft:sweet_berry_bush" if damage_only => { + self.sweet_berry_bush_damage(state)?; + } + _ => {} + } + if damage_only { + continue; + } match name { "minecraft:powder_snow" => { self.powder_snow_inside(p)?; @@ -1261,6 +1324,10 @@ impl MotionWorld<'_, '_, '_> { /// is at least 0.003 on X or Z. fn sweet_berry_bush_inside(&mut self, state: BlockStateId) -> Result<()> { self.make_stuck_in_block(Vec3::new(f64::from(0.8_f32), 0.75, f64::from(0.8_f32))); + self.sweet_berry_bush_damage(state) + } + /// The server's half of `SweetBerryBushBlock.entityInside`: the prick. + fn sweet_berry_bush_damage(&mut self, state: BlockStateId) -> Result<()> { let age = self .assets .registry diff --git a/crates/horizon-client/src/motion/environment.rs b/crates/horizon-client/src/motion/environment.rs index a9bb33678..fc3c63c77 100644 --- a/crates/horizon-client/src/motion/environment.rs +++ b/crates/horizon-client/src/motion/environment.rs @@ -6,7 +6,7 @@ use horizon_world::{ living_fluid::{LivingFluidWorld, TravelFluidTag}, }; impl MotionWorld<'_, '_, '_> { - fn environment_hurt(&mut self, source: &str, damage: f32) -> Result<()> { + pub(super) fn environment_hurt(&mut self, source: &str, damage: f32) -> Result<()> { if self.player.invulnerable || self.player.spectator { return Ok(()); } diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index c5a90150f..4226f8521 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -131,6 +131,9 @@ address. The script then checks, from both sides, what a guest's game used to ge get off by sneaking; the other side sees the animal move. - lightning: a bolt summoned beside the host, then the guest: both sides get the bolt and flash the sky (on its server thread the host's window is a client of it too). +- contacts: the host and the guest each stand on magma (and sneak on it), stand on a lit campfire, + walk against a cactus and through grown sweet berry bushes: the server hurts them, but + not the sneaking player or young bushes (#1305, #1311, #1312, #1313). - flight: a player in creative double-taps jump and flies, stays up, and stops flying in survival: the guest, and on the server thread the host's window too, take what may fly from the server's abilities (ClientPacketListener.handlePlayerAbilities). @@ -172,7 +175,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts', 'contacts'] class Game: @@ -2297,6 +2300,62 @@ def check_flight(host, guest, out): +def own(game): + """The player's own state, as its client has it.""" + return game('state')['player'] + + +def check_contacts(host, guest, out): + """Blocks that hurt what touches them, on the server: standing on magma (but not sneaking on it) + and on a lit campfire, walking against a cactus and through grown sweet berry bushes, for the + host and the guest (#1305, #1311, #1312, #1313); a young bush pricks no one.""" + hx, hy, hz = (int(v // 1) for v in pos_of(host)) + host('command', command='gamerule natural_health_regeneration false') + seen = {} + try: + for game, dz in ((host, -4), (guest, 4)): + x, y, z = hx + 2, hy, hz + dz + game('command', command='gamemode survival') + game('command', command='effect clear @s') + for case, blocks, walk in ( + ('magma', [(0, -1, 'minecraft:magma_block')], False), + ('sneaking', [(0, -1, 'minecraft:magma_block')], False), + ('campfire', [(0, 0, 'minecraft:campfire[lit=true]')], False), + ('cactus', [(2, -1, 'minecraft:sand'), (2, 0, 'minecraft:cactus')], True), + ('berries', [(k, -1, 'minecraft:grass_block') for k in range(1, 4)] + + [(k, 0, 'minecraft:sweet_berry_bush[age=3]') for k in range(1, 4)], True), + ('young', [(k, -1, 'minecraft:grass_block') for k in range(1, 4)] + + [(k, 0, 'minecraft:sweet_berry_bush[age=0]') for k in range(1, 4)], True)): + game('command', command='effect give @s minecraft:instant_health 1 5 true') + game('command', command=f'fill {x - 1} {y - 2} {z - 1} {x + 4} {y - 1} {z + 1} minecraft:stone') + game('command', command=f'fill {x - 1} {y} {z - 1} {x + 4} {y + 2} {z + 1} minecraft:air') + # A wall ends the walk before the player leaves the floor. + game('command', command=f'fill {x + 5} {y - 1} {z - 1} {x + 5} {y + 2} {z + 1} minecraft:stone') + for dx, dy, block in blocks: + game('command', command=f'setblock {x + dx} {y + dy} {z} {block}') + stand = 0.5 if case == 'campfire' else 0.0 + game('command', command=f'tp @s {x + 0.5} {y + stand} {z + 0.5}') + game.raw('look-at', f'{x + 10:.2f}', f'{y + 1.6:.2f}', f'{z + 0.5:.2f}') + game.wait(30) + before = own(game)['health'] + keys = (['shift'] if case == 'sneaking' else []) + (['w'] if walk else []) + for k in keys: + game.raw('key', k, 'down') + game.wait(60) + for k in keys: + game.raw('key', k, 'up') + game.wait(10) + seen[f'{game.name}-{case}'] = (before, own(game)['health']) + game.shot(out, f'contacts-{case}') + host('command', command=f'fill {x - 1} {y} {z - 1} {x + 5} {y + 2} {z + 1} minecraft:air') + finally: + host('command', command='gamerule natural_health_regeneration true') + for case, (before, after) in seen.items(): + safe = case.endswith(('sneaking', 'young')) + assert (after == before) if safe else (after < before), f'{case}: {before} -> {after} (all: {seen})' + return seen + + def check_ladder(host, guest, out): """#1255: climbing down a ladder doesn't hurt where the guest lands.""" x, y, z = (int(v // 1) for v in pos_of(guest)) @@ -3075,7 +3134,8 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name 'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast, 'light': check_light, 'plates': check_plates, 'swings': check_swings, 'cracks': check_cracks, - 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts} + 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts, + 'contacts': check_contacts} def run(ctl, out, resources, checks): From 2898b40670eb253a924560d5edfe8c3a4256a725 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 04:58:56 +0200 Subject: [PATCH 32/62] Server players: an axe-disabled shield stays down 5 s, death forgets the digging ItemCooldowns ticks once a tick for each player: a server's players count their shield cooldown down in tick_guests, and the host's world in tick_world (it was in tick_using, which ran for the host and again for every guest's swap, so a guest's shield came back early on the server thread). A guest that dies stops digging (its mining, the delay and the crack go), so the block it was breaking doesn't break once it respawns. lan_e2e: `shield` (a vindicator's axe disables each player's shield; the server's cooldown then falls 40 in 40 ticks) and `deathmining` (die while breaking obsidian, respawn, the obsidian stays). `lan status` and the agent state report the shield cooldown. Fixes #1315, #1316. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game.rs | 5 +- crates/horizon-client/src/game/agent.rs | 1 + crates/horizon-client/src/game/lan.rs | 2 + crates/horizon-client/src/game/lan_actions.rs | 30 ++++ tools/lan_e2e.py | 133 +++++++++++++++++- 5 files changed, 167 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 5da86dfaf..f15b6e9f6 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -3581,8 +3581,6 @@ impl Game<'_> { } } fn tick_using(&mut self) { - // ItemCooldowns.tick for the shield. - self.shield_cooldown = self.shield_cooldown.saturating_sub(1); let Some(hand) = self.used_hand() else { return; }; @@ -4285,6 +4283,9 @@ impl Game<'_> { fn tick_world(&mut self, running: bool) -> Result<()> { self.update_chunk_tickets(); horizon_client::spans::time("tick_effects", || self.tick_effects()); + // Player.tick's ItemCooldowns.tick for the window's player (a + // server's players count theirs down in `tick_guests`). + self.shield_cooldown = self.shield_cooldown.saturating_sub(1); horizon_client::spans::time("tick_using", || self.tick_using()); horizon_client::spans::time("tick_hud", || self.tick_hud()); // The player's digging comes in with its packets, before the level diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index ea686e711..f9a8e8c04 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -461,6 +461,7 @@ impl Game<'_> { "health": p.health.health(), "food": p.health.food.food, "saturation": p.health.food.saturation, + "shield_cooldown": self.shield_cooldown, "xp": { "level": self.experience.level, "progress": self.experience.progress, "total": self.experience.total }, "effects": self.potions.effects.list.iter().map(|e| json!({ "id": e.id, "duration_ticks": e.duration, "amplifier": e.amplifier })).collect::<Vec<_>>(), }) diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 4e05ea600..f09d2cc22 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -390,6 +390,8 @@ impl Game<'_> { "placed": g.placed, "loaded": g.loaded, "game_mode": g.game_mode, + // ItemCooldowns: the ticks the shield an axe disabled stays down. + "shield_cooldown": h.play.get(&g.conn).map_or(0, |p| p.shield_cooldown), "sneaking": g.sneaking, "sleeping": g.bed, "health": g.health, diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 0d70b16f6..4cf5d0a0e 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -34,6 +34,8 @@ pub(super) struct GuestPlay { destroy_delay: u32, using: Option<(usize, u32)>, use_delay: u32, + /// The shield's ItemCooldowns entry: an axe disabled it for this many ticks. + pub(super) shield_cooldown: u32, attack_ticks: u32, /// The main hand's item at the guest's last tick (`Game::attack_item`). attack_item: Option<std::sync::Arc<str>>, @@ -117,6 +119,7 @@ pub(super) struct GuestSwap { destroy_delay: u32, using: Option<(usize, u32)>, use_delay: u32, + pub(super) shield_cooldown: u32, attack_ticks: u32, attack_item: Option<std::sync::Arc<str>>, swing: horizon_client::first_person::SwingState, @@ -290,6 +293,7 @@ impl Game<'_> { let destroy_delay = std::mem::replace(&mut self.destroy_delay, play.destroy_delay); let using = std::mem::replace(&mut self.using, play.using.take()); let use_delay = std::mem::replace(&mut self.use_delay, play.use_delay); + let shield_cooldown = std::mem::replace(&mut self.shield_cooldown, play.shield_cooldown); let attack_ticks = std::mem::replace(&mut self.attack_ticks, play.attack_ticks); let attack_item = std::mem::replace(&mut self.attack_item, play.attack_item.take()); let swing = std::mem::replace(&mut self.swing, play.swing); @@ -369,6 +373,7 @@ impl Game<'_> { destroy_delay, using, use_delay, + shield_cooldown, attack_ticks, attack_item, swing, @@ -421,6 +426,7 @@ impl Game<'_> { destroy_delay, using, use_delay, + shield_cooldown, attack_ticks, attack_item, swing, @@ -480,6 +486,7 @@ impl Game<'_> { play.destroy_delay = std::mem::replace(&mut self.destroy_delay, destroy_delay); play.using = std::mem::replace(&mut self.using, using); play.use_delay = std::mem::replace(&mut self.use_delay, use_delay); + play.shield_cooldown = std::mem::replace(&mut self.shield_cooldown, shield_cooldown); play.attack_ticks = std::mem::replace(&mut self.attack_ticks, attack_ticks); play.attack_item = std::mem::replace(&mut self.attack_item, attack_item); play.swing = std::mem::replace(&mut self.swing, swing); @@ -1562,6 +1569,9 @@ impl Game<'_> { continue; } let play = host.play.entry(conn).or_default(); + // Player.tick's ItemCooldowns.tick, once a tick for each player + // (the shield an axe disabled). + play.shield_cooldown = play.shield_cooldown.saturating_sub(1); let digging = play.digging; let using = play.using.is_some(); let delayed = play.destroy_delay > 0 || play.use_delay > 0 || play.attack_ticks < 100; @@ -1616,6 +1626,9 @@ impl Game<'_> { self.guest_dig_feedback(host, conn); self.guest_pickups(host, gi); self.guest_orbs(host, gi); + if host.hub.guests[gi].health <= 0.0 && !host.hub.guests[gi].dead { + self.guest_forget_digging(host, conn); + } let g = &mut host.hub.guests[gi]; if g.health <= 0.0 && !g.dead { g.dead = true; @@ -1968,6 +1981,23 @@ impl Game<'_> { /// `level.destroyBlockProgress(id, pos, -1)` for a guest: its crack on `pos` is gone, for the /// host and the other guests. + /// A player who dies digs and uses nothing any more: the block it was + /// breaking, or had left to break (`hasDelayedDestroy`), stays, and its + /// crack goes. Respawning gives it a new ServerPlayerGameMode (#1315). + fn guest_forget_digging(&mut self, host: &mut LanHost, conn: u32) { + let Some(play) = host.play.get_mut(&conn) else { + return; + }; + let cracked = play.digging.take().filter(|_| play.last_progress >= 0); + play.mining = None; + play.delayed = None; + play.destroy_delay = 0; + play.using = None; + play.last_progress = -1; + if let Some((pos, _)) = cracked { + self.guest_crack_gone(host, conn, pos); + } + } fn guest_crack_gone(&mut self, host: &mut LanHost, conn: u32, pos: [i32; 3]) { let Some(id) = host.hub.guest(conn).map(|g| g.entity_id) else { return; diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index c5a90150f..c68fbff7d 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -131,6 +131,10 @@ address. The script then checks, from both sides, what a guest's game used to ge get off by sneaking; the other side sees the animal move. - lightning: a bolt summoned beside the host, then the guest: both sides get the bolt and flash the sky (on its server thread the host's window is a client of it too). +- shield: the host axes the guest's raised shield, then the guest the host's: it stays disabled + for 5 s on that player's own cooldown, then blocks again (#1316). +- deathmining: the host and the guest each die while breaking obsidian and let go on the death + screen: once respawned, the obsidian stays (#1315). - flight: a player in creative double-taps jump and flies, stays up, and stops flying in survival: the guest, and on the server thread the host's window too, take what may fly from the server's abilities (ClientPacketListener.handlePlayerAbilities). @@ -172,7 +176,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts', 'shield', 'deathmining'] class Game: @@ -2297,6 +2301,130 @@ def check_flight(host, guest, out): +def own(game): + """The player's own state, as its client has it.""" + return game('state')['player'] + + +def server_player(host, game): + """The player's entry on the server: the guest's in the host's `lan status`, on the server + thread the host's too; the host's own world otherwise.""" + if game is host and not SERVER_THREAD: + return own(host) + name = GUEST_NAME if game is not host else host.player + return next(g for g in host.raw('lan', 'status')['guests'] if g['name'] == name) + + +def check_shield(host, guest, out): + """An axe disables a raised shield for 5 s (100 ticks), counted down once a tick on the + server: a vindicator's axe hits each player's shield, then the cooldown left falls by about 40 + over 40 ticks (#1316).""" + host('command', command='gamerule natural_health_regeneration false') + rates = {} + try: + for game, dz in ((host, -4), (guest, 4)): + x, y, z = (int(v // 1) for v in pos_of(host)) + z += dz + game('command', command='gamemode survival') + game('command', command='effect give @s minecraft:resistance 60 4 true') + game('command', command='effect give @s minecraft:instant_health 1 5 true') + game('command', command='item replace entity @s weapon.mainhand with minecraft:air') + game('command', command='item replace entity @s weapon.offhand with minecraft:shield') + game('command', command=f'fill {x - 1} {y} {z - 1} {x + 4} {y + 2} {z + 1} minecraft:air') + game('command', command=f'fill {x - 1} {y - 1} {z - 1} {x + 4} {y - 1} {z + 1} minecraft:stone') + game('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + game.wait(10) + game.raw('look-at', f'{x + 2.5:.2f}', f'{y + 1.5:.2f}', f'{z + 0.5:.2f}') + game.raw('mouse', 'right', 'down') + game.wait(10) + host('command', command=f'summon minecraft:vindicator {x + 2.5} {y} {z + 0.5} ' + '{PersistenceRequired:1b,Rotation:[90f,0f]}') + host('command', command='item replace entity @e[type=minecraft:vindicator] weapon.mainhand ' + 'with minecraft:iron_axe') + first = None + for _ in range(60): + game.wait(5) + first = server_player(host, game).get('shield_cooldown', 0) + if first: + break + host('command', command='kill @e[type=minecraft:vindicator]') + game.raw('mouse', 'right', 'up') + assert first, f'{game.name}: the vindicator never disabled the shield' + start = server_player(host, game)['shield_cooldown'] + game.wait(40) + end = server_player(host, game)['shield_cooldown'] + rates[game.name] = {'first': first, 'start': start, 'end': end} + game.shot(out, 'shield') + game('command', command='item replace entity @s weapon.offhand with minecraft:air') + game('command', command='effect clear @s') + finally: + host('command', command='kill @e[type=minecraft:vindicator]') + host('command', command='gamerule natural_health_regeneration true') + for name, r in rates.items(): + assert r['first'] <= 100, f'{name}: {rates}' + # Once a tick: 40 down over 40 ticks, give or take the ticks the two queries straddle. + assert 30 <= r['start'] - r['end'] <= 50, f'{name}: {rates}' + return rates + + +def respawn_when_ready(game): + """Press Respawn once the death screen lets it (DeathScreen's 20-tick delay, counted from when + the screen opens).""" + for _ in range(20): + try: + return game.raw('respawn') + except Failed as e: + if 'not active yet' not in str(e): + raise + game.wait(10) + return game.raw('respawn') + + +def check_death_mining(host, guest, out): + """A player who dies while breaking obsidian, and lets go of attack on the death screen, doesn't + break it once respawned: death forgets the digging (#1315).""" + host('command', command='gamerule keep_inventory true') + hx, hy, hz = (int(v // 1) for v in pos_of(host)) + seen = {} + try: + for game, dz in ((host, -3), (guest, 3)): + x, y, z = hx + 2, hy, hz + dz + game('command', command='gamemode survival') + game('command', command='item replace entity @s weapon.mainhand with minecraft:diamond_pickaxe') + game('command', command=f'setblock {x + 2} {y} {z} minecraft:obsidian') + game('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + game.wait(10) + game.raw('look-at', f'{x + 2.5:.2f}', f'{y + 0.5:.2f}', f'{z + 0.5:.2f}') + game.wait(5) + game.raw('mouse', 'left', 'down') + game.wait(10) + game('command', command='kill @s') + game.wait(10) + # The death screen lets go of the button (Minecraft.setScreen); let go again once back. + try: + game.raw('mouse', 'left', 'up') + except Failed: + pass + game.wait(10) + respawn_when_ready(game) + game.wait(2) + try: + game.raw('mouse', 'left', 'up') + except Failed: + pass + # Obsidian takes a diamond pickaxe about 190 ticks. + game.wait(240) + seen[game.name] = host.raw('block', x + 2, y, z).get('block') + game.shot(out, 'death-mining') + host('command', command=f'setblock {x + 2} {y} {z} minecraft:air') + game('command', command='item replace entity @s weapon.mainhand with minecraft:air') + finally: + host('command', command='gamerule keep_inventory false') + for name, block in seen.items(): + assert block == 'minecraft:obsidian', f'{name}: {seen}' + return seen + + def check_ladder(host, guest, out): """#1255: climbing down a ladder doesn't hurt where the guest lands.""" x, y, z = (int(v // 1) for v in pos_of(guest)) @@ -3075,7 +3203,8 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name 'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast, 'light': check_light, 'plates': check_plates, 'swings': check_swings, 'cracks': check_cracks, - 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts} + 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts, + 'shield': check_shield, 'deathmining': check_death_mining} def run(ctl, out, resources, checks): From 5c4600e4034ed5a5a0fc50c3d498dccbc8ab04cf Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 04:59:14 +0200 Subject: [PATCH 33/62] /setworldspawn moves the world spawn, not the player's respawn point SetWorldSpawnCommand sets the level's spawn and its angle; a player without a bed or anchor respawns there (it used to set the player's own spawn point, so other players and later deaths kept the old one). The angle is saved in level.dat's spawn (yaw, pitch), and a guest whose saved respawn point is the world spawn follows it when it moves. lan_e2e `worldspawn`: /setworldspawn 24 blocks east, then the host and the guest die and respawn there. Fixes #1310. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game/commands.rs | 14 +++++- crates/horizon-client/src/lan/playerdata.rs | 7 ++- crates/horizon-client/src/save.rs | 13 +++++- tools/lan_e2e.py | 50 ++++++++++++++++++++- 4 files changed, 78 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index f174f98c1..f35354f74 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -2322,7 +2322,19 @@ impl Game<'_> { Some(Arg::Coords(c)) => c.rotation(self.source_rotation()), _ => [0.0, 0.0], }; - self.level.spawn = Some([f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])]); + // LevelData.setRespawnData: the world's spawn (level.dat `spawn`). + let old = self.level.world_spawn.replace(pos); + self.level.world_spawn_angle = rot; + // A player whose respawn point is the world spawn (no bed, anchor or + // spawnpoint of its own) respawns at the new one. + let floor = |s: Vec3| [s.x.floor() as i32, s.y.floor() as i32, s.z.floor() as i32]; + if self.respawn_config.is_none() && self.spawn.map(floor) == old { + self.spawn = Some(Vec3::new( + f64::from(pos[0]) + 0.5, + f64::from(pos[1]), + f64::from(pos[2]) + 0.5, + )); + } let args = [ Text::literal(pos[0].to_string()), Text::literal(pos[1].to_string()), diff --git a/crates/horizon-client/src/lan/playerdata.rs b/crates/horizon-client/src/lan/playerdata.rs index 8797f25a2..841f4da38 100644 --- a/crates/horizon-client/src/lan/playerdata.rs +++ b/crates/horizon-client/src/lan/playerdata.rs @@ -71,7 +71,12 @@ pub fn apply(guest: &mut Guest, level: &Level) { guest.game_mode = level.mode(); guest.flying = level.flying; guest.selected = (level.selected_slot.max(0) as usize).min(8); - guest.spawn = level.spawn.map(|s| [s[0] + 0.5, s[1], s[2] + 0.5]); + // A point that is the world spawn is none of the player's own: it + // respawns wherever the world spawn is then (`setworldspawn`). + guest.spawn = level + .spawn + .filter(|s| Some(s.map(|v| v.floor() as i32)) != level.world_spawn) + .map(|s| [s[0] + 0.5, s[1], s[2] + 0.5]); guest.saved = level.player_extra.clone(); guest.recipe_book = level.recipe_book.clone(); guest.dimension = match level.dimension.as_str() { diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 0cfe3c585..8787415d9 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -2288,6 +2288,8 @@ pub struct Level { pub dimension: String, /// World spawn (`level.dat` `spawn`), distinct from a bed respawn point. pub world_spawn: Option<[i32; 3]>, + /// The world spawn's yaw and pitch (`setworldspawn`'s rotation). + pub world_spawn_angle: [f32; 2], pub difficulty: String, pub hardcore: bool, /// `difficulty_settings.locked` (LevelData.isDifficultyLocked). @@ -2365,6 +2367,11 @@ impl Level { ] }), }; + let angle = |k: &str| match data.get("spawn").and_then(|s| s.get(k)) { + Some(Tag::Float(b)) => f32::from_bits(*b), + _ => 0.0, + }; + level.world_spawn_angle = [angle("yaw"), angle("pitch")]; if let Some(d) = data.get("difficulty_settings") { level.difficulty = text(d.get("difficulty")).unwrap_or_else(|| "normal".into()); level.hardcore = n(d.get("hardcore")) != 0; @@ -2857,8 +2864,8 @@ impl Level { Tag::compound([ ("pos", Tag::IntArray(spawn.to_vec())), ("dimension", string("minecraft:overworld")), - ("yaw", Tag::Float(0f32.to_bits())), - ("pitch", Tag::Float(0f32.to_bits())), + ("yaw", Tag::Float(self.world_spawn_angle[0].to_bits())), + ("pitch", Tag::Float(self.world_spawn_angle[1].to_bits())), ]), ), ("difficulty_settings", difficulty), @@ -4126,6 +4133,7 @@ mod tests { xp_total: 30, dimension: "minecraft:the_nether".into(), world_spawn: Some([8, 64, 8]), + world_spawn_angle: [45.0, -10.0], spawn: Some([20.0, 70.0, 20.0]), difficulty_locked: true, flying: true, @@ -4160,6 +4168,7 @@ mod tests { ); assert_eq!(back.dimension, "minecraft:the_nether"); assert_eq!(back.world_spawn, Some([8, 64, 8])); + assert_eq!(back.world_spawn_angle, [45.0, -10.0]); assert_eq!(back.spawn, Some([20.0, 70.0, 20.0])); assert!(back.difficulty_locked); assert!(back.weather.raining); diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index c5a90150f..6f416306b 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -131,6 +131,8 @@ address. The script then checks, from both sides, what a guest's game used to ge get off by sneaking; the other side sees the animal move. - lightning: a bolt summoned beside the host, then the guest: both sides get the bolt and flash the sky (on its server thread the host's window is a client of it too). +- worldspawn: the host moves the world spawn (`setworldspawn`): the host and the guest, with no bed, + respawn there (#1310). - flight: a player in creative double-taps jump and flies, stays up, and stops flying in survival: the guest, and on the server thread the host's window too, take what may fly from the server's abilities (ClientPacketListener.handlePlayerAbilities). @@ -172,7 +174,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts', 'worldspawn'] class Game: @@ -2297,6 +2299,49 @@ def check_flight(host, guest, out): +def respawn_when_ready(game): + """Press Respawn once the death screen lets it (DeathScreen's 20-tick delay, counted from when + the screen opens).""" + for _ in range(20): + try: + return game.raw('respawn') + except Failed as e: + if 'not active yet' not in str(e): + raise + game.wait(10) + return game.raw('respawn') + + +def check_world_spawn(host, guest, out): + """`setworldspawn` moves the world spawn: the host and the guest, with no bed of their own, + respawn there once killed (#1310).""" + hx, hy, hz = (int(v // 1) for v in pos_of(host)) + sx, sz = hx + 24, hz + host('command', command='gamerule respawn_radius 0') + host('command', command=f'fill {sx - 2} {hy - 1} {sz - 2} {sx + 2} {hy - 1} {sz + 2} minecraft:stone') + host('command', command=f'fill {sx - 2} {hy} {sz - 2} {sx + 2} {hy + 3} {sz + 2} minecraft:air') + seen = {} + try: + host('command', command=f'setworldspawn {sx} {hy} {sz}') + for game in (host, guest): + game('command', command='gamemode survival') + game('command', command='kill @s') + game.wait(20) + respawn_when_ready(game) + game.wait(60) + seen[game.name] = [round(v, 2) for v in pos_of(game)] + game.shot(out, 'world-spawn') + finally: + host('command', command=f'setworldspawn {hx} {hy} {hz}') + host('command', command='gamerule respawn_radius 10') + for game in (host, guest): + game('command', command=f'tp @s {hx + 0.5} {hy} {hz + 0.5}') + guest.wait(20) + for name, at in seen.items(): + assert abs(at[0] - (sx + 0.5)) < 1 and abs(at[2] - (sz + 0.5)) < 1, f'{name}: {seen}, spawn {sx} {sz}' + return seen + + def check_ladder(host, guest, out): """#1255: climbing down a ladder doesn't hurt where the guest lands.""" x, y, z = (int(v // 1) for v in pos_of(guest)) @@ -3075,7 +3120,8 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name 'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast, 'light': check_light, 'plates': check_plates, 'swings': check_swings, 'cracks': check_cracks, - 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts} + 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts, + 'worldspawn': check_world_spawn} def run(ctl, out, resources, checks): From 65bd2d0d45e15710af70cad00f642ae80f48b86e Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 04:59:19 +0200 Subject: [PATCH 34/62] Items push out of blocks; a server's client digs at the server's speed ItemEntity.tick: an item stuck inside a full block (one set on it) has no physics on the server and moves toward the closest free side (Entity.moveTowardsClosestSpace: north, south, west, east, up; 0.1 to 0.3 a tick), instead of staying in the block (#1252). A server's client (LAN guests, and the window on the server thread) digs at the same speed as the server: getDestroyProgress with the submerged mining speed, haste, fatigue and efficiency, not the plain tool speed, so it no longer finishes early under water and gets the block put back (#1254). lan_e2e: `drops` (a diamond under a block set on it comes out, in both views) and `underwater` (dirt by hand at eye height under water: about halfway at 35 ticks on client and server, broken by 105). Fixes #1252, #1254. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/entities.rs | 78 ++++++++++++++++++++++-- crates/horizon-client/src/game.rs | 9 ++- crates/horizon-client/src/game/agent.rs | 2 + crates/horizon-client/src/game/remote.rs | 19 ++---- tests/test_remote_mining.py | 4 ++ tools/lan_e2e.py | 77 ++++++++++++++++++++++- 6 files changed, 167 insertions(+), 22 deletions(-) diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs index cfbdb0636..65536d710 100644 --- a/crates/horizon-client/src/entities.rs +++ b/crates/horizon-client/src/entities.rs @@ -98,12 +98,73 @@ impl ItemEntity { lava_hurt, } } - /// Returns false when the item should be removed. + /// `ItemEntity.tick` on a server: an item whose box is inside a block + /// (one placed where it lay) has no physics this tick + /// (`level.noCollision(box.deflate(1.0E-7))`). + pub fn inside_block(&self, world: &World, collision: &BlockCollisionRegistry<'_>) -> bool { + let mut scene = SceneCollisions { + world, + binding: collision, + subject: None, + }; + let inner = self.bounds().deflate(Vec3::new(1.0e-7, 1.0e-7, 1.0e-7)); + !crate::collisions::no_collision_empty(&mut scene, inner) + } + /// `Entity.moveTowardsClosestSpace` from the middle of the item's box: + /// towards the nearest side of its block (north, south, west, east or + /// up) without a full collision cube, at `speed` (`nextFloat() * 0.2 + + /// 0.1`). + pub fn move_towards_closest_space(&mut self, world: &World, facts: &BlockFacts, speed: f32) { + let bounds = self.bounds(); + let at = Vec3::new( + self.position.x, + (bounds.min_position().y + bounds.max_position().y) / 2.0, + self.position.z, + ); + let pos = [ + at.x.floor() as i32, + at.y.floor() as i32, + at.z.floor() as i32, + ]; + let delta = [ + at.x - f64::from(pos[0]), + at.y - f64::from(pos[1]), + at.z - f64::from(pos[2]), + ]; + // (axis, step): NORTH, SOUTH, WEST, EAST, UP. + let mut closest = (1, 1); + let mut nearest = f64::MAX; + for (axis, step) in [(2, -1), (2, 1), (0, -1), (0, 1), (1, 1)] { + let mut n = pos; + n[axis] += step; + if !facts.get(world.block(n[0], n[1], n[2])).full_collision { + let d = if step > 0 { + 1.0 - delta[axis] + } else { + delta[axis] + }; + if d < nearest { + nearest = d; + closest = (axis, step); + } + } + } + let push = f64::from(closest.1 as f32 * speed); + let v = self.velocity.scale(0.75); + self.velocity = match closest.0 { + 0 => Vec3::new(push, v.y, v.z), + 1 => Vec3::new(v.x, push, v.z), + _ => Vec3::new(v.x, v.y, push), + }; + } + /// Returns false when the item should be removed. `no_physics`: the item + /// moves through blocks this tick ([`ItemEntity::inside_block`]). pub fn tick( &mut self, world: &World, facts: &BlockFacts, collision: &BlockCollisionRegistry<'_>, + no_physics: bool, ) -> bool { self.ticks += 1; self.previous = self.position; @@ -140,15 +201,22 @@ impl ItemEntity { subject: None, }; let wanted = self.velocity; - let moved = scene - .resolve(self.bounds(), wanted, 0.0, self.on_ground) - .unwrap_or(Vec3::ZERO); + // Entity.move with noPhysics: straight through, the ground as it was. + let moved = if no_physics { + wanted + } else { + scene + .resolve(self.bounds(), wanted, 0.0, self.on_ground) + .unwrap_or(Vec3::ZERO) + }; self.position = Vec3::new( self.position.x + moved.x, self.position.y + moved.y, self.position.z + moved.z, ); - self.on_ground = wanted.y < 0.0 && moved.y != wanted.y; + if !no_physics { + self.on_ground = wanted.y < 0.0 && moved.y != wanted.y; + } if moved.x != wanted.x { self.velocity.x = 0.0; } diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 5da86dfaf..0b1ca23fd 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -2101,7 +2101,14 @@ impl Game<'_> { ) { continue; } - let alive = item.tick(&self.world, self.res.facts(), self.collision); + // ItemEntity.tick's noPhysics (servers only): out of a block + // placed on it, towards the closest open side (#1252). + let no_physics = merging && item.inside_block(&self.world, self.collision); + if no_physics { + let speed = self.world.random.next_float() * 0.2 + 0.1; + item.move_towards_closest_space(&self.world, self.res.facts(), speed); + } + let alive = item.tick(&self.world, self.res.facts(), self.collision, no_physics); cells.moved(i, item.previous, item.position); // ItemEntity.tick: merge every 2 ticks while moving between // blocks, every 40 otherwise, before the lifetime check. diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index ea686e711..15564dc3e 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -478,6 +478,8 @@ impl Game<'_> { "sleeping": self.sleeping, // The item in use: its slot and for how many ticks. "using": self.using.map(|(slot, ticks)| json!({ "slot": slot, "ticks": ticks })), + // The block being dug: how far along, after how many ticks. + "mining": self.mining.as_ref().map(|m| json!({ "pos": m.pos, "progress": m.progress, "ticks": m.ticks })), // The arm swings started (LivingEntity.swing). "swings": self.swings_started, "time": { "day_time": self.world.day_time, "day": self.world.day_time.div_euclid(24000), "time_of_day": self.world.day_time.rem_euclid(24000) }, diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 5461a4cd0..563ab4170 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3469,22 +3469,13 @@ impl Game<'_> { return; } let facts = self.res.facts().get(state).clone(); - let held = self.held().cloned(); - let mut speed = self.res.items().mining_speed(held.as_ref(), &facts.name); - if self.player.as_ref().is_some_and(|p| !p.ground.on_ground) { - speed /= 5.0; - } - let harvest = !facts.requires_tool - || self - .res - .items() - .correct_for_drops(held.as_ref(), &facts.name); - let progress = if facts.hardness < 0.0 { - 0.0 - } else if facts.hardness == 0.0 { + // The server's own getDestroyProgress: under water, off the ground, + // with haste, fatigue and efficiency, so the client stops digging + // when the server is done too (#1254). + let progress = if facts.hardness == 0.0 { 1.0 } else { - speed / facts.hardness / if harvest { 30.0 } else { 100.0 } + self.destroy_progress(hit.pos) }; let same = self .remote diff --git a/tests/test_remote_mining.py b/tests/test_remote_mining.py index 236b85c28..1a35b3865 100644 --- a/tests/test_remote_mining.py +++ b/tests/test_remote_mining.py @@ -79,6 +79,10 @@ impl Game { } fn pick(&self) -> Option<Hit> { Some(self.hit) } fn held(&self) -> Option<&()> { None } + // Game::destroy_progress (hand.rs) for a harvestable block on the ground. + fn destroy_progress(&self, _: [i32; 3]) -> f32 { + self.res.speed / self.res.facts.hardness / 30.0 + } fn next_sequence(&mut self) -> i32 { self.sequence += 1; self.sequence } fn predict_break(&mut self, pos: [i32; 3], _: u32, _: i32) { self.world.broken.push(pos); } fn send(&mut self, S::PlayerAction(packet): S) { self.packets.push(packet); } diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index c5a90150f..6bdc52905 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -131,6 +131,10 @@ address. The script then checks, from both sides, what a guest's game used to ge get off by sneaking; the other side sees the animal move. - lightning: a bolt summoned beside the host, then the guest: both sides get the bolt and flash the sky (on its server thread the host's window is a client of it too). +- drops: an item lies where the host, then the guest, places a block: it comes out of the block + on the server, and both sides see it outside (#1252). +- underwater: the host and the guest each dig dirt by hand standing under water: five times slower + than in the air on their own client as on the server, and it breaks (#1254). - flight: a player in creative double-taps jump and flies, stays up, and stops flying in survival: the guest, and on the server thread the host's window too, take what may fly from the server's abilities (ClientPacketListener.handlePlayerAbilities). @@ -172,7 +176,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts', 'drops', 'underwater'] class Game: @@ -2297,6 +2301,74 @@ def check_flight(host, guest, out): +def check_drops(host, guest, out): + """A dropped item lying where a block is then placed comes out of it (#1252): the server moves + it towards the closest open side (ItemEntity.tick's noPhysics, Entity.moveTowardsClosestSpace), + and both sides see it outside the block. The host places one, then the guest.""" + hx, hy, hz = (int(v // 1) for v in pos_of(host)) + seen = {} + for game, dz in ((host, -3), (guest, 3)): + x, y, z = hx + 3, hy, hz + dz + game('command', command=f'fill {x - 1} {y} {z - 1} {x + 1} {y + 2} {z + 1} minecraft:air') + game('command', command=f'summon minecraft:item {x + 0.5} {y} {z + 0.5} ' + '{Item:{id:"minecraft:diamond",count:1},PickupDelay:32767}') + game.wait(20) + game('command', command=f'setblock {x} {y} {z} minecraft:stone') + game.wait(60) + for viewer in (host, guest): + near = [e['pos'] for e in viewer.raw('entities', 24, 'minecraft:item')['entities'] + if abs(e['pos'][0] - x - 0.5) < 2 and abs(e['pos'][2] - z - 0.5) < 2] + seen[f'{game.name} places, {viewer.name} sees'] = ([x, y, z], near) + game.shot(out, 'drops') + host('command', command='kill @e[type=minecraft:item]') + host('command', command=f'setblock {x} {y} {z} minecraft:air') + for name, (block, near) in seen.items(): + inside = [p for p in near if all(block[i] <= p[i] < block[i] + 1 for i in range(3))] + assert near and not inside, f'{name}: items {near} in block {block} (all: {seen})' + return seen + + +def check_underwater(host, guest, out): + """Digging dirt by hand underwater, standing on the bottom of a pool: five times slower than in + the air (SUBMERGED_MINING_SPEED), on the player's own client as on the server. Halfway through + the client is about halfway (it doesn't break the block early, which the server would put + back), and the block breaks (#1254). The dirt is at eye height, the player's head under water. + The host, then the guest.""" + hx, hy, hz = (int(v // 1) for v in pos_of(host)) + seen = {} + for game, dz in ((host, -4), (guest, 4)): + x, y, z = hx + 3, hy, hz + dz + game('command', command='gamemode survival') + game('command', command='item replace entity @s weapon.mainhand with minecraft:air') + game('command', command=f'fill {x - 1} {y - 1} {z - 1} {x + 2} {y + 3} {z + 1} minecraft:stone') + game('command', command=f'fill {x} {y} {z} {x} {y + 2} {z} minecraft:water') + game('command', command=f'setblock {x + 1} {y + 1} {z} minecraft:dirt') + game('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + game.wait(40) + game.raw('look-at', f'{x + 1.5:.2f}', f'{y + 1.5:.2f}', f'{z + 0.5:.2f}') + game.wait(5) + game.raw('mouse', 'left', 'down') + # Dirt by hand: 15 ticks in the air, 75 under water. + game.wait(35) + halfway = {'mining': game('state').get('mining'), 'client': game.raw('block', x + 1, y + 1, z).get('block'), + 'server': host.raw('block', x + 1, y + 1, z).get('block'), 'y': y + 1} + game.wait(70) + game.raw('mouse', 'left', 'up') + game.wait(10) + done = host.raw('block', x + 1, y + 1, z).get('block') + game.shot(out, 'underwater') + seen[game.name] = {'halfway': halfway, 'done': done} + host('command', command=f'fill {x - 1} {y - 1} {z - 1} {x + 2} {y + 3} {z + 1} minecraft:air') + host('command', command=f'fill {x - 1} {y - 1} {z - 1} {x + 2} {y - 1} {z + 1} minecraft:stone') + for name, s in seen.items(): + h = s['halfway'] + assert h['client'] == 'minecraft:dirt' == h['server'], f'{name} broke it early: {seen}' + assert h['mining'] and h['mining']['pos'][1] == h['y'] and 0.3 < h['mining']['progress'] < 0.7, f'{name} digs at the wrong speed: {seen}' + # Broken: air, or the pool's water flowing in. + assert s['done'] in ('minecraft:air', 'minecraft:water'), f'{name} never broke it: {seen}' + return seen + + def check_ladder(host, guest, out): """#1255: climbing down a ladder doesn't hurt where the guest lands.""" x, y, z = (int(v // 1) for v in pos_of(guest)) @@ -3075,7 +3147,8 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name 'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast, 'light': check_light, 'plates': check_plates, 'swings': check_swings, 'cracks': check_cracks, - 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts} + 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts, + 'drops': check_drops, 'underwater': check_underwater} def run(ctl, out, resources, checks): From feeefb3a33db6cc33c0798f535d9bdc0e7aeb306 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 05:38:46 +0200 Subject: [PATCH 35/62] Mobs: a punch shows smooth and slow, as on vanilla's client The server sends a knocked-back, pushed or jumping mob's move at once (Entity.needsSync), and the remote client walks every living entity along the server's positions with vanilla's SteppedInterpolationHandler: each position takes the type's update interval to reach, sped up while steps pile up. Before, the client waited for the next due update and then lerped there in fewer ticks, so a hit pig jumped away fast. tools/test_stepped_interpolation_parity.py drives vanilla's unmodified InterpolationData and the Rust port with the same packets and ticks (random cases and a punched pig's knockback); 135236 positions and rotations match bit for bit. Fixes #1374 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game/dragon.rs | 1 + crates/horizon-client/src/game/lan.rs | 5 + .../horizon-client/src/game/lan_entities.rs | 1 + crates/horizon-client/src/game/remote.rs | 144 ++++++-- crates/horizon-client/src/lan/entity.rs | 39 +- crates/horizon-client/src/lan/hub.rs | 1 + crates/horizon-client/src/mobs.rs | 7 + crates/horizon-client/src/mobs/living.rs | 3 + crates/horizon-client/tests/lan_bot.rs | 1 + .../examples/stepped_interpolation_fixture.rs | 93 +++++ crates/horizon-world/src/lib.rs | 1 + .../src/stepped_interpolation.rs | 341 ++++++++++++++++++ .../VanillaSteppedInterpolationOracle.java | 148 ++++++++ tools/test_stepped_interpolation_parity.py | 103 ++++++ 14 files changed, 858 insertions(+), 30 deletions(-) create mode 100644 crates/horizon-world/examples/stepped_interpolation_fixture.rs create mode 100644 crates/horizon-world/src/stepped_interpolation.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSteppedInterpolationOracle.java create mode 100644 tools/test_stepped_interpolation_parity.py diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index 222e59229..6dd02893d 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -2700,6 +2700,7 @@ impl Game<'_> { equipment: Vec::new(), attributes: Vec::new(), precise: false, + needs_sync: false, }) } } diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 4e05ea600..e2c218a34 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -760,6 +760,7 @@ impl Game<'_> { (e.yaw, e.pitch, e.head_yaw) = (m.yaw, m.head_pitch, m.head_yaw); e.on_ground = m.on_ground; e.velocity = [m.velocity.x, m.velocity.y, m.velocity.z]; + e.needs_sync = m.needs_sync; mob_meta(m, hub, &mut e.meta); mob_equipment(m, hub, &mut e.equipment); self.mob_attributes(m, &mut e.attributes); @@ -828,6 +829,10 @@ impl Game<'_> { } else { states.clear(); } + // ServerEntity.sendChanges clears needsSync once it has looked. + for m in &mut self.mobs { + m.needs_sync = false; + } let entities = states.as_slice(); let spawn = self.spawn.map_or([0.5, 80.0, 0.5], |s| [s.x, s.y, s.z]); let events = { diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs index 5f46f7c21..631498edd 100644 --- a/crates/horizon-client/src/game/lan_entities.rs +++ b/crates/horizon-client/src/game/lan_entities.rs @@ -39,6 +39,7 @@ fn state(id: u32, kind: &str, position: [f64; 3], yaw: f32, on_ground: bool) -> equipment: Vec::new(), attributes: Vec::new(), precise: false, + needs_sync: false, } } diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 5461a4cd0..454773e38 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -40,7 +40,11 @@ use horizon_protocol::{ registry::{Builtin, DimensionType, Dynamic, ceil_log2}, text::{Language, format_java, plain}, }; -use horizon_world::{nbt::Tag, registry::BlockStateId}; +use horizon_world::{ + nbt::Tag, + registry::BlockStateId, + stepped_interpolation::{Path, PosRot, Start, SteppedInterpolation}, +}; use std::{ collections::{HashMap, VecDeque}, sync::Arc, @@ -85,6 +89,15 @@ struct Lerp { steps: u32, } +/// `SteppedInterpolationHandler.doInterpolate`'s `setPos` and `setRot` on a +/// mob: its yaw kept continuous (the same turn as vanilla's, without the +/// wrap that would spin it in the frame between ticks), its pitch clamped. +fn place_interpolated(m: &mut Mob, at: PosRot) { + m.position = Vec3::new(at.position[0], at.position[1], at.position[2]); + m.yaw += wrap_degrees(at.yaw - m.yaw); + m.head_pitch = (at.pitch % 360.0).clamp(-90.0, 90.0); +} + pub(super) struct Remote { pub session: Session, pub brand: String, @@ -123,6 +136,8 @@ pub(super) struct Remote { use_target: Option<[i32; 3]>, entities: HashMap<i32, Tracked>, lerps: HashMap<i32, Lerp>, + /// Living entities' `SteppedInterpolationHandler`s. + stepped: HashMap<i32, SteppedInterpolation>, /// `LivingEntity.lerpHeadTo`: the head yaw and the ticks left to reach it. head_lerps: HashMap<i32, (f32, u32)>, /// Item entities waiting for their item data. @@ -380,6 +395,7 @@ impl Game<'_> { use_target: None, entities: HashMap::new(), lerps: HashMap::new(), + stepped: HashMap::new(), head_lerps: HashMap::new(), pending_items: HashMap::new(), health: (20.0, 20, 5.0), @@ -931,6 +947,7 @@ impl Game<'_> { if let Some(r) = self.remote.as_mut() { r.entities.clear(); r.lerps.clear(); + r.stepped.clear(); r.head_lerps.clear(); r.pending_items.clear(); // A new ClientLevel: a new chunk storage, centred on 0, 0. @@ -1322,6 +1339,9 @@ impl Game<'_> { mob.persistent = true; self.mobs.retain(|m| m.id != id as u32); self.mobs.push(mob); + if let Some(r) = self.remote.as_mut() { + r.stepped.remove(&id); + } } if let Some(r) = self.remote.as_mut() { if kind == "minecraft:item" { @@ -1336,23 +1356,77 @@ impl Game<'_> { ); } } + /// A move packet for entity `id`: to the end of `path` (None: a + /// rotation alone), turned to `rotation` if it has one. `far_snaps`: + /// an `EntityPositionSync`, which puts an entity more than 64 blocks + /// away there at once. fn move_entity( &mut self, id: i32, - position: [f64; 3], + path: Option<Path>, rotation: Option<(f32, f32)>, on_ground: bool, + far_snaps: bool, ) { let mob = self.mobs.iter_mut().find(|m| m.id == id as u32); + let tracked = self + .remote + .as_ref() + .and_then(|r| r.entities.get(&id)) + .map(|t| t.position); + let position = path + .as_ref() + .map(Path::end) + .or(tracked) + .or_else(|| { + mob.as_ref() + .map(|m| [m.position.x, m.position.y, m.position.z]) + }) + .unwrap_or([0.0; 3]); if let Some(r) = self.remote.as_mut() { if let Some(t) = r.entities.get_mut(&id) { t.position = position; } + if let Some(m) = mob { + // A living entity: LivingEntity.createInterpolationHandler's + // SteppedInterpolationHandler, over its type's update interval. + let entity = PosRot { + position: [m.position.x, m.position.y, m.position.z], + yaw: m.yaw, + pitch: m.head_pitch, + }; + let far = far_snaps && { + let d = [0, 1, 2].map(|i| position[i] - entity.position[i]); + d[0] * d[0] + d[1] * d[1] + d[2] * d[2] > 4096.0 + }; + let handler = r.stepped.entry(id).or_insert_with(|| { + let interval = horizon_client::lan::tracking::settings(&m.kind.id).1; + SteppedInterpolation::new(interval as i32) + }); + let snap = if far { + handler.cancel(); + let (yaw, pitch) = rotation.unwrap_or((m.yaw, m.head_pitch)); + Some(PosRot { + position, + yaw, + pitch, + }) + } else { + match handler.interpolate_to(entity, path, rotation) { + Start::Snap(at) => Some(at), + Start::Interpolating | Start::Unchanged => None, + } + }; + if let Some(at) = snap { + place_interpolated(m, at); + m.previous = m.position; + } + m.on_ground = on_ground; + return; + } // AbstractInterpolationHandler.interpolateTo: without a rotation, - // the one it was heading for (or has). - let rotation = rotation - .or_else(|| r.lerps.get(&id).and_then(|l| l.rotation)) - .or_else(|| mob.as_ref().map(|m| (m.yaw, m.head_pitch))); + // the one it was heading for. + let rotation = rotation.or_else(|| r.lerps.get(&id).and_then(|l| l.rotation)); r.lerps.insert( id, Lerp { @@ -1365,9 +1439,6 @@ impl Game<'_> { *p = position; } } - if let Some(m) = mob { - m.on_ground = on_ground; - } self.turn_remote_object(id, rotation.map(|(yaw, _)| yaw), on_ground); self.turn_remote_projectile(id, rotation); } @@ -1384,6 +1455,7 @@ impl Game<'_> { if let Some(r) = self.remote.as_mut() { r.entities.remove(&id); r.lerps.remove(&id); + r.stepped.remove(&id); r.head_lerps.remove(&id); r.pending_items.remove(&id); } @@ -1743,17 +1815,36 @@ impl Game<'_> { .and_then(|r| r.entities.get(&m.id)) .map(|t| t.position); let Some(base) = base else { return Ok(()) }; - let position = m.delta.as_ref().map_or(base, |d| d.end(base)); + // VecDeltaCodec.decode: each step's position from the last. + let path = m.delta.as_ref().map(|d| match d { + play::VecDelta::Linear(_) => Path::Linear(d.end(base)), + play::VecDelta::Stepped(steps) => { + let mut at = base; + Path::Stepped( + steps + .iter() + .map(|(delta, ticks)| { + at = play::VecDelta::apply(at, *delta); + (at, *ticks) + }) + .collect(), + ) + } + }); let rotation = m.rotation.map(|(y, x)| { ( horizon_protocol::buf::unpack_degrees(y), horizon_protocol::buf::unpack_degrees(x), ) }); - self.move_entity(m.id, position, rotation, m.on_ground); + self.move_entity(m.id, path, rotation, m.on_ground, false); } C::EntityPositionSync(p) => { - self.move_entity(p.id, p.path.end(), Some((p.yaw, p.pitch)), p.on_ground) + let path = match p.path { + play::PositionPath::Linear(at) => Path::Linear(at), + play::PositionPath::Stepped(steps) => Path::Stepped(steps), + }; + self.move_entity(p.id, Some(path), Some((p.yaw, p.pitch)), p.on_ground, true) } C::TeleportEntity(p) => { let base = self @@ -1773,7 +1864,13 @@ impl Game<'_> { rel(play::relative::Y, 1), rel(play::relative::Z, 2), ]; - self.move_entity(p.id, position, Some((p.yaw, p.pitch)), p.on_ground); + self.move_entity( + p.id, + Some(Path::Linear(position)), + Some((p.yaw, p.pitch)), + p.on_ground, + false, + ); } C::SetPassengers(p) => self.remote_set_passengers(p.vehicle, &p.passengers), C::MoveVehicle(p) => self.remote_move_vehicle(p.position, p.yaw), @@ -3149,6 +3246,7 @@ impl Game<'_> { return; }; let mut lerps = std::mem::take(&mut r.lerps); + let stepped = &mut r.stepped; let head_lerps = &mut r.head_lerps; let players = &r.level_players; let mut using = Vec::new(); @@ -3179,22 +3277,12 @@ impl Game<'_> { // LivingEntity.updateSwingTime. m.anim.attack_anim_o = m.anim.attack_anim; horizon_client::mobs::ai::tick_swing(m); - // Entity.commonTick: LinearInterpolationHandler.interpolate. - if let Some(l) = lerps.get_mut(&(m.id as i32)) - && l.steps > 0 + // Entity.tick: the SteppedInterpolationHandler's step. + if let Some(at) = stepped + .get_mut(&(m.id as i32)) + .and_then(|h| h.interpolate()) { - let n = f64::from(l.steps); - m.position = Vec3::new( - m.position.x + (l.target[0] - m.position.x) / n, - m.position.y + (l.target[1] - m.position.y) / n, - m.position.z + (l.target[2] - m.position.z) / n, - ); - if let Some((yaw, pitch)) = l.rotation { - let alpha = 1.0 / l.steps as f32; - m.yaw += wrap_degrees(yaw - m.yaw) * alpha; - m.head_pitch += (pitch - m.head_pitch) * alpha; - } - l.steps -= 1; + place_interpolated(m, at); } // LivingEntity.aiStep: the head's own interpolation. if let Some((yaw, steps)) = head_lerps.get_mut(&(m.id as i32)) diff --git a/crates/horizon-client/src/lan/entity.rs b/crates/horizon-client/src/lan/entity.rs index c4e8052c0..86fea8b65 100644 --- a/crates/horizon-client/src/lan/entity.rs +++ b/crates/horizon-client/src/lan/entity.rs @@ -59,6 +59,8 @@ pub struct EntityState { /// `Entity.getRequiresPrecisePosition` (primed TNT and falling blocks /// touching a block): moves are sent as full position syncs. pub precise: bool, + /// `Entity.needsSync`: send its changes this tick, due or not. + pub needs_sync: bool, } impl EntityState { @@ -79,6 +81,7 @@ impl EntityState { self.equipment.clear(); self.attributes.clear(); self.precise = false; + self.needs_sync = false; } } @@ -322,7 +325,7 @@ impl ServerEntity { // SynchedEntityData.isDirty: once for every client. let dirty = e.meta != self.meta; let due = self.interval != 0 && self.tick.is_multiple_of(self.interval); - if due || dirty { + if due || dirty || e.needs_sync { let rotation = (pack_degrees(e.pitch), pack_degrees(e.yaw)); let turned = |a: i8, b: i8| (i32::from(a) - i32::from(b)).abs() >= 1; let rotate = self.arrow @@ -398,7 +401,7 @@ impl ServerEntity { } else { None }; - if self.track_deltas { + if self.track_deltas || e.needs_sync { let diff: f64 = (0..3) .map(|k| (e.velocity[k] - self.velocity[k]).powi(2)) .sum(); @@ -855,6 +858,7 @@ mod tests { equipment: Vec::new(), attributes: Vec::new(), precise: false, + needs_sync: false, } } @@ -918,6 +922,37 @@ mod tests { assert!(matches!(jump[0], play::Clientbound::EntityPositionSync(_))); } + #[test] + fn a_knocked_back_mob_is_sent_at_once() { + let mut s = added(&state(0.0)); + changes(&mut s, &state(0.0)); + // Not due (tick 1 of 3), but LivingEntity.knockback set needsSync: + // its move and its new motion go out now. + let mut knocked = state(0.3); + knocked.velocity = [0.2, 0.3, 0.0]; + knocked.needs_sync = true; + let out = changes(&mut s, &knocked); + assert!( + matches!( + out[..], + [ + play::Clientbound::SetEntityMotion(_), + play::Clientbound::MoveEntityPos(_) + ] + ), + "{out:?}" + ); + // Then every third tick again. + assert!(changes(&mut s, &state(0.5)).is_empty()); + assert!(matches!( + changes(&mut s, &state(0.6))[..], + [ + play::Clientbound::SetEntityMotion(_), + play::Clientbound::MoveEntityPos(_) + ] + )); + } + #[test] fn fireballs_bundle_their_motion_with_their_power() { let mut e = state(0.0); diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index bf66f979b..060ec7193 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -1547,6 +1547,7 @@ impl Hub { equipment, attributes, precise: false, + needs_sync: false, } } diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index db2ebeb60..76f622d9c 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -792,6 +792,9 @@ pub struct Mob { pub on_ground: bool, pub horizontal_collision: bool, pub vertical_collision_below: bool, + /// `Entity.needsSync`: knocked back, pushed or jumped since its server + /// last sent it, so the next update goes out at once. + pub needs_sync: bool, pub health: f32, pub hurt_time: i32, pub invulnerable: i32, @@ -1361,8 +1364,10 @@ impl PendingPushes { } /// Adds the pending pushes aimed at `m` to its velocity, in push order. pub fn apply_mob_pushes(m: &mut Mob, pending: &mut PendingPushes) { + // Entity.push(x, y, z) sets needsSync. let mut add = |v: Vec3| { m.velocity = Vec3::new(m.velocity.x + v.x, m.velocity.y + v.y, m.velocity.z + v.z); + m.needs_sync = true; }; if !pending.list.is_empty() { pending.list.retain(|(id, v)| { @@ -1529,6 +1534,7 @@ impl Mob { on_ground: false, horizontal_collision: false, vertical_collision_below: false, + needs_sync: false, hurt_time: 0, invulnerable: 0, death_time: 0, @@ -1769,6 +1775,7 @@ impl Mob { if power <= 0.0 { return; } + self.needs_sync = true; while xd * xd + zd * zd < f64::from(1.0e-5_f32) { xd = (self.random.next_double() - self.random.next_double()) * 0.01; zd = (self.random.next_double() - self.random.next_double()) * 0.01; diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs index ebbfabf6b..d5b3c7091 100644 --- a/crates/horizon-client/src/mobs/living.rs +++ b/crates/horizon-client/src/mobs/living.rs @@ -832,6 +832,9 @@ impl Mob { }; } pub fn jump_from_ground(&mut self, w: &MobWorld) { + // LivingEntity.jumpFromGround (and the rabbit's and cubes' own, + // which call it or do the same): needsSync. + self.needs_sync = true; if self.species() == super::Species::Rabbit { super::rabbit::jump(self, w); return; diff --git a/crates/horizon-client/tests/lan_bot.rs b/crates/horizon-client/tests/lan_bot.rs index bd22d6e0a..4f5f17a3b 100644 --- a/crates/horizon-client/tests/lan_bot.rs +++ b/crates/horizon-client/tests/lan_bot.rs @@ -433,6 +433,7 @@ fn guests_see_each_other_and_the_world_entities() { equipment: Vec::new(), attributes: Vec::new(), precise: false, + needs_sync: false, }; let first = thread::spawn(move || { let mut bot = connect(port, "Alex", false)?; diff --git a/crates/horizon-world/examples/stepped_interpolation_fixture.rs b/crates/horizon-world/examples/stepped_interpolation_fixture.rs new file mode 100644 index 000000000..d2228d8b5 --- /dev/null +++ b/crates/horizon-world/examples/stepped_interpolation_fixture.rs @@ -0,0 +1,93 @@ +//! The Rust side of tools/test_stepped_interpolation_parity.py: replays the +//! harness's events (VanillaSteppedInterpolationOracle's input format) on +//! `SteppedInterpolation` and writes the entity after each one. +use horizon_world::stepped_interpolation::{Path, PosRot, Start, SteppedInterpolation}; +use std::fmt::Write as _; + +/// `Entity.setRot`: yaw and pitch wrapped, pitch clamped (`setXRot`). +fn set_rot(entity: &mut PosRot, yaw: f32, pitch: f32) { + entity.yaw = yaw % 360.0; + entity.pitch = (pitch % 360.0 % 360.0).clamp(-90.0, 90.0); +} + +fn main() { + let args: Vec<String> = std::env::args().collect(); + let input = std::fs::read_to_string(&args[1]).expect("input"); + let mut out = String::new(); + let mut handler = SteppedInterpolation::new(0); + let mut entity = PosRot::default(); + for line in input.lines() { + let f: Vec<&str> = line.split_whitespace().collect(); + let num = |i: usize| f[i].parse::<f64>().expect("number"); + let what = match f[0] { + "case" => { + handler = SteppedInterpolation::new(f[1].parse().expect("steps")); + entity = PosRot { + position: [num(2), num(3), num(4)], + yaw: f[5].parse().expect("yaw"), + pitch: f[6].parse().expect("pitch"), + }; + "c" + } + "move" => { + let mut i = 2; + let path = match f[1] { + "L" => { + i += 3; + Some(Path::Linear([num(2), num(3), num(4)])) + } + "S" => { + let n: usize = f[2].parse().expect("count"); + i = 3; + let mut steps = Vec::new(); + for _ in 0..n { + steps.push(( + [num(i), num(i + 1), num(i + 2)], + f[i + 3].parse().expect("ticks"), + )); + i += 4; + } + Some(Path::Stepped(steps)) + } + _ => None, + }; + let rotation = (f[i] == "R").then(|| { + ( + f[i + 1].parse().expect("yaw"), + f[i + 2].parse().expect("pitch"), + ) + }); + match handler.interpolate_to(entity, path, rotation) { + Start::Snap(at) => { + entity.position = at.position; + set_rot(&mut entity, at.yaw, at.pitch); + "s" + } + Start::Unchanged => "k", + Start::Interpolating => "i", + } + } + "tick" => match handler.interpolate() { + Some(at) => { + entity.position = at.position; + set_rot(&mut entity, at.yaw, at.pitch); + "t" + } + None => "n", + }, + other => panic!("unknown event {other}"), + }; + let p = entity.position; + writeln!( + out, + "{what} {:x} {:x} {:x} {:x} {:x}", + p[0].to_bits(), + p[1].to_bits(), + p[2].to_bits(), + entity.yaw.to_bits(), + entity.pitch.to_bits() + ) + .expect("write"); + } + std::fs::write(&args[2], out).expect("output"); +} diff --git a/crates/horizon-world/src/lib.rs b/crates/horizon-world/src/lib.rs index 819262d46..b6d05ecf6 100644 --- a/crates/horizon-world/src/lib.rs +++ b/crates/horizon-world/src/lib.rs @@ -137,6 +137,7 @@ pub mod player_equipment; pub mod living_use_flags; pub mod status_effect; +pub mod stepped_interpolation; pub mod synced_values; pub mod inventory_use; diff --git a/crates/horizon-world/src/stepped_interpolation.rs b/crates/horizon-world/src/stepped_interpolation.rs new file mode 100644 index 000000000..a7157d90a --- /dev/null +++ b/crates/horizon-world/src/stepped_interpolation.rs @@ -0,0 +1,341 @@ +//! How a client moves a living entity it doesn't simulate along the +//! positions its server sends (vanilla `SteppedInterpolationHandler`, which +//! `LivingEntity.createInterpolationHandler` gives every living entity on a +//! client): each position is a step the entity walks to in the type's update +//! interval (3 ticks for most mobs), one after the other, sped up while +//! steps pile up. A punched mob's first move, sent at once (`needsSync`), +//! thus takes three ticks to show, and the rest follow it. + +use std::collections::VecDeque; + +/// A position and rotation (`PositionAndRotation`). +#[derive(Clone, Copy, Debug, Default, PartialEq)] +pub struct PosRot { + pub position: [f64; 3], + pub yaw: f32, + pub pitch: f32, +} + +impl PosRot { + /// `PositionAndRotation.is`: the same rotation and `Vec3.equals` + /// position (`Double.compare`, so -0.0 is not 0.0). + fn is(&self, position: [f64; 3], yaw: f32, pitch: f32) -> bool { + self.yaw == yaw && self.pitch == pitch && same_position(self.position, position) + } +} + +/// `Vec3.equals`. +fn same_position(a: [f64; 3], b: [f64; 3]) -> bool { + (0..3).all(|i| a[i].to_bits() == b[i].to_bits()) +} + +/// `PositionPath`: where a move packet puts an entity, either straight +/// there or through the positions the server stepped it through, each +/// with the ticks it took. +#[derive(Clone, Debug, PartialEq)] +pub enum Path { + Linear([f64; 3]), + Stepped(Vec<([f64; 3], i32)>), +} + +impl Path { + pub fn end(&self) -> [f64; 3] { + match self { + Path::Linear(p) => *p, + Path::Stepped(steps) => steps.last().map_or([0.0; 3], |s| s.0), + } + } +} + +/// What the client does with the entity when a packet arrives. +#[derive(Clone, Copy, Debug, PartialEq)] +pub enum Start { + /// Moves on to it over the coming ticks. + Interpolating, + /// Already headed there: nothing changes. + Unchanged, + /// Is put there at once (`snapTo`): types with no update interval. + Snap(PosRot), +} + +/// `SteppedInterpolationHandler` and its `InterpolationData`. +#[derive(Clone, Debug)] +pub struct SteppedInterpolation { + /// `AbstractInterpolationHandler.interpolationSteps`: the type's + /// `updateInterval`. + steps: i32, + /// The data's own position and rotation: where the last packet said. + target: PosRot, + /// `lastStepPosRot`: where the step being walked started. + last: PosRot, + remaining: VecDeque<(PosRot, i32)>, + current_step_ticks: f32, + remaining_ticks: f32, + speed: f32, +} + +/// `Mth.wrapDegrees(float)`. +fn wrap_degrees(degrees: f32) -> f32 { + let mut wrapped = degrees % 360.0; + if wrapped >= 180.0 { + wrapped -= 360.0; + } + if wrapped < -180.0 { + wrapped += 360.0; + } + wrapped +} + +/// `Mth.lerp(float, float, float)`. +fn lerp(a: f32, from: f32, to: f32) -> f32 { + from + a * (to - from) +} + +/// `Mth.rotLerp`. +fn rot_lerp(a: f32, from: f32, to: f32) -> f32 { + from + a * wrap_degrees(to - from) +} + +impl SteppedInterpolation { + /// The handler of an entity type whose update interval is `steps` ticks. + pub fn new(steps: i32) -> Self { + Self { + steps, + target: PosRot::default(), + last: PosRot::default(), + remaining: VecDeque::new(), + current_step_ticks: 0.0, + remaining_ticks: 0.0, + speed: 1.0, + } + } + /// `hasActiveInterpolation`. + pub fn active(&self) -> bool { + !self.remaining.is_empty() + } + /// Where the entity is headed: the last packet's position and rotation + /// while interpolating (`AbstractInterpolationHandler.interpolateTo`'s + /// `current`), else where it is. + pub fn heading(&self, entity: PosRot) -> PosRot { + if self.active() { self.target } else { entity } + } + /// `AbstractInterpolationHandler.interpolateTo(path, yRot, xRot, + /// hasRotation)` for an entity at `entity`: a packet without a position + /// (`path` None) keeps the one it is headed for, one without a rotation + /// the rotation. + pub fn interpolate_to( + &mut self, + entity: PosRot, + path: Option<Path>, + rotation: Option<(f32, f32)>, + ) -> Start { + let current = self.heading(entity); + let path = path.unwrap_or(Path::Linear(current.position)); + let (yaw, pitch) = rotation.unwrap_or((current.yaw, current.pitch)); + let end = path.end(); + if self.steps == 0 { + self.cancel(); + return Start::Snap(PosRot { + position: end, + yaw, + pitch, + }); + } + if self.active() && self.target.is(end, yaw, pitch) { + return Start::Unchanged; + } + // SteppedInterpolationHandler.startInterpolating. + if !self.active() { + self.last = entity; + self.current_step_ticks = 1.0; + } + if same_position(end, self.target.position) { + self.add_step( + PosRot { + position: end, + yaw, + pitch, + }, + self.steps, + ); + } else { + self.add_steps(&path, yaw, pitch); + } + self.target = PosRot { + position: end, + yaw, + pitch, + }; + Start::Interpolating + } + /// `cancel` (`InterpolationData.reset`). + pub fn cancel(&mut self) { + self.remaining.clear(); + self.remaining_ticks = 0.0; + self.speed = 1.0; + } + /// `AbstractInterpolationHandler.interpolate`, once a client tick: where + /// the entity is put, or None when there is nothing to walk (and the + /// handler resets). The client moves the entity only this way, so the + /// target never needs the deltas `adjustInterpolationTargetFromDeltas` + /// would add. + pub fn interpolate(&mut self) -> Option<PosRot> { + if !self.active() { + self.cancel(); + return None; + } + // doInterpolate: getNewPositionAndRotation, then advance by the + // level's relative tick speed (1 at the normal tick rate). + let at = self.new_position(); + self.advance(1.0); + Some(at) + } + /// `InterpolationData.addStep`. + fn add_step(&mut self, step: PosRot, ticks: i32) { + self.remaining.push_back((step, ticks)); + self.remaining_ticks += ticks as f32; + } + /// `InterpolationData.addSteps`: a stepped path's steps take their own + /// ticks, turning by the share of the path each one ends. + fn add_steps(&mut self, path: &Path, yaw: f32, pitch: f32) { + match path { + Path::Linear(p) => self.add_step( + PosRot { + position: *p, + yaw, + pitch, + }, + self.steps, + ), + Path::Stepped(steps) => { + if yaw == self.target.yaw && pitch == self.target.pitch { + for (p, ticks) in steps { + self.add_step( + PosRot { + position: *p, + yaw, + pitch, + }, + *ticks, + ); + } + return; + } + let total: i32 = steps.iter().map(|s| s.1).sum(); + let mut offset = 0; + let (from_yaw, from_pitch) = (self.target.yaw, self.target.pitch); + for (p, ticks) in steps { + offset += ticks; + let a = offset as f32 / total as f32; + let step = PosRot { + position: *p, + yaw: rot_lerp(a, from_yaw, yaw), + pitch: lerp(a, from_pitch, pitch), + }; + self.add_step(step, *ticks); + } + } + } + } + /// `InterpolationData.getNewPositionAndRotation`. + fn new_position(&mut self) -> PosRot { + while let Some(&(step, ticks)) = self.remaining.front() { + if self.current_step_ticks < ticks as f32 { + let a = self.current_step_ticks / ticks as f32; + let t = f64::from(a); + let (from, to) = (self.last.position, step.position); + return PosRot { + position: [0, 1, 2].map(|i| from[i] + (to[i] - from[i]) * t), + yaw: rot_lerp(a, self.last.yaw, step.yaw), + pitch: lerp(a, self.last.pitch, step.pitch), + }; + } + self.current_step_ticks -= ticks as f32; + self.last = step; + self.remaining.pop_front(); + } + self.target + } + /// `InterpolationData.advance`: faster while more than one update's + /// worth of steps waits. + fn advance(&mut self, ticks: f32) { + let steps = self.steps as f32; + let target_speed = (self.remaining_ticks / steps).max(1.0); + self.speed = lerp(1.0 / steps, self.speed, target_speed); + let moved = if ticks * self.speed < self.remaining_ticks { + ticks * self.speed + } else { + self.speed = 1.0; + self.remaining_ticks + }; + self.current_step_ticks += moved; + self.remaining_ticks -= moved; + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn at(x: f64) -> PosRot { + PosRot { + position: [x, 0.0, 0.0], + yaw: 0.0, + pitch: 0.0, + } + } + + #[test] + fn a_position_takes_the_update_interval_to_reach() { + let mut h = SteppedInterpolation::new(3); + let mut entity = at(0.0); + h.interpolate_to(entity, Some(Path::Linear([0.3, 0.0, 0.0])), None); + let mut seen = Vec::new(); + while let Some(p) = h.interpolate() { + entity = p; + seen.push((p.position[0] * 1000.0).round() / 1000.0); + } + assert_eq!(seen, [0.1, 0.2, 0.3]); + assert!(!h.active()); + assert_eq!(entity.position[0], 0.3); + } + + #[test] + fn steps_that_pile_up_are_walked_faster() { + let mut h = SteppedInterpolation::new(3); + let mut entity = at(0.0); + let mut ticks = 0; + for k in 1..=4 { + h.interpolate_to(entity, Some(Path::Linear([f64::from(k), 0.0, 0.0])), None); + if let Some(p) = h.interpolate() { + entity = p; + } + ticks += 1; + } + while let Some(p) = h.interpolate() { + entity = p; + ticks += 1; + } + // Four packets a tick apart: 12 ticks of steps, walked in fewer. + assert!(ticks < 12, "{ticks}"); + assert_eq!(entity.position[0], 4.0); + } + + #[test] + fn no_update_interval_snaps() { + let mut h = SteppedInterpolation::new(0); + let start = h.interpolate_to( + at(0.0), + Some(Path::Linear([2.0, 0.0, 0.0])), + Some((90.0, 0.0)), + ); + assert_eq!( + start, + Start::Snap(PosRot { + position: [2.0, 0.0, 0.0], + yaw: 90.0, + pitch: 0.0 + }) + ); + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSteppedInterpolationOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSteppedInterpolationOracle.java new file mode 100644 index 000000000..b3edd6e48 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSteppedInterpolationOracle.java @@ -0,0 +1,148 @@ +package dev.horizonlab.parity; + +import java.io.PrintWriter; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import net.minecraft.core.PositionAndRotation; +import net.minecraft.world.entity.PositionPath; +import net.minecraft.world.entity.PositionStep; +import net.minecraft.world.phys.Vec3; + +/** + * How a client walks a living entity along the positions its server sends: the unmodified + * {@code SteppedInterpolationHandler.InterpolationData} (setStartingPoint, addStep, addSteps, + * getNewPositionAndRotation, advance, reset), driven the way + * {@code AbstractInterpolationHandler.interpolateTo} / {@code interpolate} and + * {@code SteppedInterpolationHandler.startInterpolating} / {@code doInterpolate} drive it, with the + * entity's own {@code setPos} / {@code setRot}. The handler's entity hooks are out of scope: the + * entity moves only by its interpolation (no deltas to adjust) at the normal tick rate. + * + * <p>Input (args[0]), one event a line: {@code case STEPS X Y Z YAW PITCH} (a fresh entity there + * with a handler of that many interpolation steps), {@code move L X Y Z} or {@code move S N + * (X Y Z TICKS)xN} or {@code move N} (no position), then {@code R YAW PITCH} or {@code -} (no + * rotation), and {@code tick}. Output (args[1]): the entity after every event. + */ +public final class VanillaSteppedInterpolationOracle { + private static Method method(Class<?> owner, String name, Class<?>... types) throws Exception { + Method m = owner.getDeclaredMethod(name, types); + m.setAccessible(true); + return m; + } + + private static String hex(double v) { + return Long.toHexString(Double.doubleToRawLongBits(v)); + } + + private static String hex(float v) { + return Integer.toHexString(Float.floatToRawIntBits(v)); + } + + public static void main(String[] args) throws Exception { + Class<?> dataClass = Class.forName("net.minecraft.world.entity.SteppedInterpolationHandler$InterpolationData"); + Constructor<?> create = dataClass.getDeclaredConstructor(); + create.setAccessible(true); + Method advance = method(dataClass, "advance", float.class, int.class); + Method addStep = method(dataClass, "addStep", Vec3.class, float.class, float.class, int.class); + Method addSteps = method(dataClass, "addSteps", PositionPath.class, float.class, float.class, int.class); + Method setStartingPoint = method(dataClass, "setStartingPoint", Vec3.class, float.class, float.class); + Method next = method(dataClass, "getNewPositionAndRotation"); + Method reset = method(dataClass, "reset"); + Field remaining = dataClass.getDeclaredField("remainingSteps"); + remaining.setAccessible(true); + + Object data = null; + int steps = 0; + Vec3 pos = Vec3.ZERO; + float yRot = 0; + float xRot = 0; + try (PrintWriter out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1])))) { + for (String line : Files.readAllLines(Path.of(args[0]))) { + String[] f = line.trim().split(" "); + int i = 1; + String what; + switch (f[0]) { + case "case" -> { + data = create.newInstance(); + steps = Integer.parseInt(f[1]); + pos = new Vec3(Double.parseDouble(f[2]), Double.parseDouble(f[3]), Double.parseDouble(f[4])); + yRot = Float.parseFloat(f[5]); + xRot = Float.parseFloat(f[6]); + what = "c"; + } + case "move" -> { + PositionPath path = null; + switch (f[i++]) { + case "L" -> { + path = PositionPath.of(new Vec3(Double.parseDouble(f[i]), Double.parseDouble(f[i + 1]), Double.parseDouble(f[i + 2]))); + i += 3; + } + case "S" -> { + int n = Integer.parseInt(f[i++]); + List<PositionStep> list = new ArrayList<>(); + for (int k = 0; k < n; k++) { + list.add(new PositionStep(new Vec3(Double.parseDouble(f[i]), Double.parseDouble(f[i + 1]), Double.parseDouble(f[i + 2])), Integer.parseInt(f[i + 3]))); + i += 4; + } + path = PositionPath.stepped(List.copyOf(list)); + } + default -> { + } + } + boolean hasRotation = f[i].equals("R"); + float y = hasRotation ? Float.parseFloat(f[i + 1]) : 0; + float x = hasRotation ? Float.parseFloat(f[i + 2]) : 0; + boolean active = !((List<?>) remaining.get(data)).isEmpty(); + PositionAndRotation.Mutable target = (PositionAndRotation.Mutable) data; + // AbstractInterpolationHandler.interpolateTo(path, yRot, xRot, hasRotation). + PositionAndRotation current = active ? target : PositionAndRotation.of(pos, yRot, xRot); + if (path == null) path = PositionPath.of(current.position()); + if (!hasRotation) { + y = current.yRot(); + x = current.xRot(); + } + Vec3 end = path.endPosition(); + if (steps == 0) { + // snapTo, then cancel. + pos = end; + yRot = y % 360.0F; + xRot = Math.clamp(x % 360.0F % 360.0F, -90.0F, 90.0F); + reset.invoke(data); + what = "s"; + } else if (active && target.is(end, y, x)) { + what = "k"; + } else { + // SteppedInterpolationHandler.startInterpolating. + if (!active) setStartingPoint.invoke(data, pos, yRot, xRot); + if (Objects.equals(end, target.position())) addStep.invoke(data, end, y, x, steps); + else addSteps.invoke(data, path, y, x, steps); + target.set(end, y, x); + what = "i"; + } + } + case "tick" -> { + // AbstractInterpolationHandler.interpolate. + if (((List<?>) remaining.get(data)).isEmpty()) { + reset.invoke(data); + what = "n"; + } else { + PositionAndRotation t = (PositionAndRotation) next.invoke(data); + pos = t.position(); + yRot = t.yRot() % 360.0F; + xRot = Math.clamp(t.xRot() % 360.0F % 360.0F, -90.0F, 90.0F); + advance.invoke(data, 1.0F, steps); + what = "t"; + } + } + default -> throw new IllegalArgumentException(line); + } + out.println(what + " " + hex(pos.x) + " " + hex(pos.y) + " " + hex(pos.z) + " " + hex(yRot) + " " + hex(xRot)); + } + } + } +} diff --git a/tools/test_stepped_interpolation_parity.py b/tools/test_stepped_interpolation_parity.py new file mode 100644 index 000000000..998d5a4ba --- /dev/null +++ b/tools/test_stepped_interpolation_parity.py @@ -0,0 +1,103 @@ +#!/usr/bin/env python3 +"""Compare how a client walks a living entity along its server's positions with vanilla. + +Vanilla's unmodified SteppedInterpolationHandler.InterpolationData (VanillaSteppedInterpolationOracle +drives it as the handler does) and horizon-world's SteppedInterpolation replay the same packets and +client ticks: move packets with and without a position or rotation, straight or stepped paths, +repeats of the one the entity is headed for, packets a tick apart that pile up and others after it +stopped, for update intervals of 1 to 3 ticks, plus a punched pig's knockback as the server sends it +(its first move at once, `needsSync`, then every update interval). The entity's position and rotation +after every event must match bit for bit. The handler's entity hooks (deltas, passengers) are out of +scope. +""" +import os +import random +import subprocess +try: + from . import lab, test_rust_parity as base +except ImportError: + import lab + import test_rust_parity as base + +# A pig punched on flat ground, its positions on the server tick by tick (knockback 0.4 along x). +KNOCKBACK = [(0.0, 0.0), (0.3032, 0.3608), (0.4638, 0.636), (0.6049, 0.8273), (0.7279, 0.9363), (0.8345, 0.9648), + (0.926, 0.9143), (1.0037, 0.7864), (1.0688, 0.5827), (1.1223, 0.3046), (1.1654, 0.0), (1.1147, 0.0), + (0.9968, 0.0), (0.8418, 0.0), (0.6664, 0.0)] + + +def position(rng, p): + return [round(v + rng.uniform(-0.6, 0.6), rng.choice([2, 4, 17])) for v in p] + + +def rotation(rng): + return [round(rng.uniform(-400, 400), rng.choice([0, 1, 3])), round(rng.uniform(-120, 120), rng.choice([0, 2]))] + + +def cases(count, seed): + rng = random.Random(seed) + lines = [] + for interval in (1, 2, 3): + # The knockback: a packet for the hit tick's move, then every interval (each phase). + for phase in range(interval): + lines.append(f'case {interval} 10.5 64.0 0.5 90.0 0.0') + for k in range(1, len(KNOCKBACK)): + if k == 1 or (k + phase) % interval == 0: + x, y = KNOCKBACK[k] + lines.append(f'move L {10.5 + x!r} {64 + y!r} 0.5 -') + lines.append('tick') + lines += ['tick'] * 6 + for _ in range(count): + p = [rng.uniform(-100, 100), rng.uniform(-64, 300), rng.uniform(-100, 100)] + yaw, pitch = rotation(rng) + lines.append(f'case {rng.choice([1, 2, 3, 3, 3])} {p[0]!r} {p[1]!r} {p[2]!r} {yaw!r} {pitch!r}') + last = None + for _ in range(rng.randrange(1, 40)): + if rng.random() < 0.45: + lines.append('tick') + continue + if last is not None and rng.random() < 0.15: + line = last # the same packet again + else: + if rng.random() < 0.1: + line = 'move N' + elif rng.random() < 0.2: + n = rng.randrange(1, 5) + steps = [] + for _ in range(n): + p = position(rng, p) + steps.append(f'{p[0]!r} {p[1]!r} {p[2]!r} {rng.randrange(1, 4)}') + line = f'move S {n} ' + ' '.join(steps) + else: + p = position(rng, p) if rng.random() < 0.9 else p + line = f'move L {p[0]!r} {p[1]!r} {p[2]!r}' + rot = rotation(rng) if rng.random() < 0.6 else None + line += f' R {rot[0]!r} {rot[1]!r}' if rot else ' -' + last = line + lines.append(line) + lines += ['tick'] * rng.choice([0, 1, 1, 2, 3, 6]) + return lines + + +def main(): + lock, jars, libraries = base.verify_artifacts() + build = lab.LOCAL / 'stepped-interpolation-parity' + build.mkdir(parents=True, exist_ok=True) + classes = build / 'classes' + classes.mkdir(exist_ok=True) + events = build / 'events.txt' + events.write_text('\n'.join(cases(3000, 1374)) + '\n', encoding='utf-8') + classpath = os.pathsep.join(map(str, [jars['client'], *libraries])) + oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSteppedInterpolationOracle.java' + subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', + '-cp', classpath, '-d', str(classes), str(oracle)], check=True) + subprocess.run(['java', '-Xmx512M', '-cp', str(classes) + os.pathsep + classpath, + 'dev.horizonlab.parity.VanillaSteppedInterpolationOracle', str(events), str(build / 'vanilla.txt')], + check=True) + subprocess.run(['cargo', 'run', '--quiet', '--release', '-p', 'horizon-world', '--example', + 'stepped_interpolation_fixture', '--', str(events), str(build / 'rust.txt')], cwd=lab.ROOT, check=True) + matched = base.compare(build / 'vanilla.txt', build / 'rust.txt') + print(f'Stepped interpolation parity passed: {matched} entity positions and rotations match vanilla') + + +if __name__ == '__main__': + main() From 144741b7c7f165353dc4c34ae0e9ebad0707cbb6 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 06:39:22 +0200 Subject: [PATCH 36/62] Screen overlays: one texture sample, as on main The vignette, drawn over every frame, went from one texture sample to up to four texel loads and per-pixel address arithmetic: +0.85 ms of GPU a frame on an HD 620 (integer modulo, removed in the commit before), still +0.4 ms after it. - A blurred sprite gets a one-texel border in the atlas, copied from its opposite edges: the hardware's bilinear sample of the atlas with the entity group's linear sampler is then GL_LINEAR with repeat, edges included. Clamp-to-edge keeps the sample point half a texel inside the sprite, which is what the hardware's clamp does for both filters. - Each sampling has its own pipeline, the shader specialised by override constants: a repeat sprite runs main's arithmetic and one sample, nearest or linear; only clamp adds a clamp. The sampling moves from the vertices to the quad, so the vertex layout is main's again. - A black vignette changes no pixel (it darkens by texture x colour), and is no longer drawn: in daylight its brightness fades to 0 within half a minute, so most frames outdoors skip it, which main never could. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/gfx.rs | 92 ++++++++++++--------- crates/horizon-client/src/hud.rs | 54 +++++++++++- crates/horizon-client/src/screen.wgsl | 56 ++++++------- crates/horizon-client/src/screen_effects.rs | 29 +++++-- 4 files changed, 156 insertions(+), 75 deletions(-) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 3aa4ace2a..f1cc3393d 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -357,8 +357,9 @@ pub struct Renderer { border_group: wgpu::BindGroup, border_uniform: wgpu::Buffer, border_vertices: wgpu::Buffer, - /// Screen effects: alpha-blended and vignette (`dst * (1 - src)`) pipelines. - screen_pipelines: [wgpu::RenderPipeline; 2], + /// Screen effects: alpha-blended, then vignette (`dst * (1 - src)`) + /// pipelines, each for every sampling (index `blend * 4 + sampling`). + screen_pipelines: [wgpu::RenderPipeline; 8], screen_buffer: wgpu::Buffer, screen_capacity: u64, entity_group: wgpu::BindGroup, @@ -1983,7 +1984,7 @@ impl Renderer { source: wgpu::ShaderSource::Wgsl(include_str!("screen.wgsl").into()), }); let screen_attributes = - wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Float32x4,3=>Float32x4,4=>Uint32]; + wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Float32x4,3=>Float32x4]; let screen_vertex = [Some(wgpu::VertexBufferLayout { array_stride: std::mem::size_of::<crate::screen_effects::ScreenVertex>() as u64, step_mode: wgpu::VertexStepMode::Vertex, @@ -2001,37 +2002,52 @@ impl Renderer { operation: wgpu::BlendOperation::Add, }, }; - let screen_pipelines = - [("fs_screen", alpha_blend), ("fs_vignette", vignette_blend)].map(|(entry, blend)| { - device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { - label: Some("Screen effects"), - layout: Some(&entity_layout), - vertex: wgpu::VertexState { - module: &screen_shader, - entry_point: Some("vs_screen"), - compilation_options: Default::default(), - buffers: &screen_vertex, - }, - primitive: wgpu::PrimitiveState { - cull_mode: None, - ..Default::default() - }, - depth_stencil: None, - multisample: Default::default(), - fragment: Some(wgpu::FragmentState { - module: &screen_shader, - entry_point: Some(entry), - compilation_options: Default::default(), - targets: &[Some(wgpu::ColorTargetState { - format: config.format.remove_srgb_suffix(), - blend: Some(blend), - write_mask: wgpu::ColorWrites::ALL, - })], - }), - multiview_mask: None, - cache: None, - }) - }); + // One per blend and `.png.mcmeta` sampling (screen_effects::SAMPLE_*): + // the shader is specialised, so a pixel pays for none of the others. + let screen_pipelines: [wgpu::RenderPipeline; 8] = std::array::from_fn(|i| { + let (entry, blend) = if i & 4 == 0 { + ("fs_screen", alpha_blend) + } else { + ("fs_vignette", vignette_blend) + }; + let on = |bit: u32| f64::from(u8::from(i as u32 & bit != 0)); + let constants = [ + ("BLUR", on(crate::screen_effects::SAMPLE_BLUR)), + ("CLAMP", on(crate::screen_effects::SAMPLE_CLAMP)), + ]; + let compilation_options = wgpu::PipelineCompilationOptions { + constants: &constants, + ..Default::default() + }; + device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Screen effects"), + layout: Some(&entity_layout), + vertex: wgpu::VertexState { + module: &screen_shader, + entry_point: Some("vs_screen"), + compilation_options: compilation_options.clone(), + buffers: &screen_vertex, + }, + primitive: wgpu::PrimitiveState { + cull_mode: None, + ..Default::default() + }, + depth_stencil: None, + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module: &screen_shader, + entry_point: Some(entry), + compilation_options, + targets: &[Some(wgpu::ColorTargetState { + format: config.format.remove_srgb_suffix(), + blend: Some(blend), + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }) + }); let screen_capacity = 64; let screen_buffer = device.create_buffer(&wgpu::BufferDescriptor { label: Some("Screen effect vertices"), @@ -3911,11 +3927,11 @@ impl Renderer { pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); pass.set_vertex_buffer(0, self.screen_buffer.slice(..)); for (i, quad) in frame.screen.iter().enumerate() { - let pipeline = match quad.blend { - crate::screen_effects::Blend::Alpha => &self.screen_pipelines[0], - crate::screen_effects::Blend::Vignette => &self.screen_pipelines[1], + let blend = match quad.blend { + crate::screen_effects::Blend::Alpha => 0, + crate::screen_effects::Blend::Vignette => 4, }; - pass.set_pipeline(pipeline); + pass.set_pipeline(&self.screen_pipelines[blend + (quad.sampling & 3) as usize]); pass.draw_indexed(0..6, (i * 4) as i32, 0..1); } } diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 43ae29c74..dbd44266a 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -104,6 +104,20 @@ fn walk(dir: &Path, out: &mut Vec<PathBuf>) { } /// A packed atlas image: sprite name, size and RGBA pixels. type PackedImage = (String, u32, u32, Vec<u8>); +/// `image` inside a one-texel border copied from its opposite edges, the +/// texels repeat addressing reads past each edge. +fn wrap_border((name, w, h, data): &PackedImage) -> PackedImage { + let (bw, bh) = (w + 2, h + 2); + let mut out = Vec::with_capacity((bw * bh * 4) as usize); + for y in 0..bh { + let row = (y + h - 1) % h; + for x in 0..bw { + let at = ((row * w + (x + w - 1) % w) * 4) as usize; + out.extend_from_slice(&data[at..at + 4]); + } + } + (name.clone(), bw, bh, out) +} /// Sprites the atlas definitions (`atlases/*.json`) add beyond the texture /// files already packed: generated ones (`paletted_permutations` such as the /// armour trim sprites, `unstitch` regions) and files listed under another id. @@ -326,6 +340,16 @@ impl HudAtlas { if full { Self::slots(&mut images, crate::trims::slot_size(root)); } + // Blurred sprites are sampled linearly in the atlas (screen.wgsl): a + // border wrapped from their own edges keeps the filter off their + // neighbours, as repeat addressing of their own texture would. + let mut bordered = std::collections::HashSet::new(); + for image in &mut images { + if flags.get(&image.0).is_some_and(|f: &TextureFlags| f.blur) { + *image = wrap_border(image); + bordered.insert(image.0.clone()); + } + } images.sort_by(|a, b| b.2.cmp(&a.2).then(b.1.cmp(&a.1))); let width = 4096u32; let mut placements = Vec::with_capacity(images.len()); @@ -350,6 +374,8 @@ impl HudAtlas { let dst = (((py + row) * width + px) * 4) as usize; pixels[dst..dst + (w * 4) as usize].copy_from_slice(src); } + let b = u32::from(bordered.contains(name)); + let (px, py, w, h) = (px + b, py + b, w - 2 * b, h - 2 * b); sprites.insert( name.clone(), Rect { @@ -357,8 +383,8 @@ impl HudAtlas { v0: py as f32 / height as f32, u1: (px + w) as f32 / width as f32, v1: (py + h) as f32 / height as f32, - w: *w, - h: *h, + w, + h, }, ); } @@ -1246,6 +1272,30 @@ impl HudRenderer { mod tests { use super::*; + #[test] + fn a_wrapped_border_repeats_the_opposite_edges() { + // 2x2 texels a b / c d, one byte each in red. + let image = ( + "x".to_owned(), + 2, + 2, + [1u8, 2, 3, 4] + .iter() + .flat_map(|&v| [v, 0, 0, 255]) + .collect(), + ); + let (_, w, h, data) = wrap_border(&image); + assert_eq!((w, h), (4, 4)); + let red: Vec<u8> = data.chunks(4).map(|t| t[0]).collect(); + #[rustfmt::skip] + assert_eq!(red, [ + 4, 3, 4, 3, + 2, 1, 2, 1, + 4, 3, 4, 3, + 2, 1, 2, 1, + ]); + } + #[test] fn the_fonts_only_atlas_measures_text_like_the_full_one() { // A synthetic default font: two 8x8 glyphs, 3 and 5 pixels wide. diff --git a/crates/horizon-client/src/screen.wgsl b/crates/horizon-client/src/screen.wgsl index f32274bc8..e70aeb896 100644 --- a/crates/horizon-client/src/screen.wgsl +++ b/crates/horizon-client/src/screen.wgsl @@ -3,51 +3,49 @@ // with the sampler vanilla gives it (ReloadableTexture.setSampler: linear // when `blur`, clamp-to-edge when `clamp`, else nearest and repeat). @group(0) @binding(1) var atlas: texture_2d<f32>; +// The block sprites' sampler (nearest), and the entity group's lightmap +// sampler (linear) for `blur`. A blurred sprite has a one-texel border in the +// atlas, wrapped as repeat reads it (hud.rs), so the hardware's bilinear +// sample is GL_LINEAR with repeat; clamp-to-edge keeps the sample point half +// a texel inside. Each sampling has its own pipeline (gfx.rs), so a pixel +// costs what it did with nearest and repeat only: one sample. +@group(0) @binding(2) var nearest_sampler: sampler; +@group(0) @binding(4) var linear_sampler: sampler; +override BLUR: bool = false; +override CLAMP: bool = false; struct Out { @builtin(position) clip: vec4<f32>, @location(0) uv: vec2<f32>, @location(1) @interpolate(flat) rect: vec4<f32>, @location(2) color: vec4<f32>, - @location(3) @interpolate(flat) sampling: u32, + // With clamp-to-edge, the sprite's first and last texel centres. + @location(3) @interpolate(flat) edges: vec4<f32>, } @vertex fn vs_screen(@location(0) pos: vec2<f32>, @location(1) uv: vec2<f32>, - @location(2) rect: vec4<f32>, @location(3) color: vec4<f32>, - @location(4) sampling: u32) -> Out { + @location(2) rect: vec4<f32>, @location(3) color: vec4<f32>) -> Out { var out: Out; out.clip = vec4(pos, 0.0, 1.0); out.uv = uv; out.rect = rect; out.color = color; - out.sampling = sampling; + let half = 0.5 / vec2<f32>(textureDimensions(atlas)); + out.edges = vec4(rect.xy + half, rect.zw - half); return out; } -const SAMPLE_BLUR: u32 = 1u; -const SAMPLE_CLAMP: u32 = 2u; -// A texel of the sprite, addressed by repeat or clamp-to-edge. With repeat, `p` is at most one -// texel outside the sprite (`sample` reduces the coordinate first), so wrapping is a select: no -// integer division, which Intel GPUs emulate (it cost 0.85 ms a frame on the vignette on an HD 620). -fn texel(origin: vec2<i32>, size: vec2<i32>, p: vec2<i32>, clamp_edge: bool) -> vec4<f32> { - var q = select(select(p, p - size, p >= size), p + size, p < vec2(0)); - if clamp_edge { q = clamp(p, vec2(0), size - 1); } - return textureLoad(atlas, origin + q, 0); -} fn sample(in: Out) -> vec4<f32> { - let dims = vec2<f32>(textureDimensions(atlas)); - let origin = vec2<i32>(round(in.rect.xy * dims)); - let size = max(vec2<i32>(round((in.rect.zw - in.rect.xy) * dims)), vec2(1)); - let clamp_edge = (in.sampling & SAMPLE_CLAMP) != 0u; - // Repeat: one period of the sprite, so every texel read is at most one outside it. - let p = select(fract(in.uv), in.uv, clamp_edge) * vec2<f32>(size); - if (in.sampling & SAMPLE_BLUR) == 0u { - return texel(origin, size, vec2<i32>(floor(p)), clamp_edge) * in.color; + var f = in.uv; + if !CLAMP { + // Repeat: one period of the sprite. + f = fract(f); } - // GL_LINEAR: the four texels around the sample point, weighted. - let c = p - 0.5; - let i = vec2<i32>(floor(c)); - let t = c - floor(c); - let a = mix(texel(origin, size, i, clamp_edge), texel(origin, size, i + vec2(1, 0), clamp_edge), t.x); - let b = mix(texel(origin, size, i + vec2(0, 1), clamp_edge), texel(origin, size, i + vec2(1, 1), clamp_edge), t.x); - return mix(a, b, t.y) * in.color; + var uv = in.rect.xy + f * (in.rect.zw - in.rect.xy); + if CLAMP { + uv = clamp(uv, in.edges.xy, in.edges.zw); + } + if BLUR { + return textureSampleLevel(atlas, linear_sampler, uv, 0.0) * in.color; + } + return textureSampleLevel(atlas, nearest_sampler, uv, 0.0) * in.color; } @fragment fn fs_screen(in: Out) -> @location(0) vec4<f32> { let c = sample(in); diff --git a/crates/horizon-client/src/screen_effects.rs b/crates/horizon-client/src/screen_effects.rs index 48f468d4d..269a534e7 100644 --- a/crates/horizon-client/src/screen_effects.rs +++ b/crates/horizon-client/src/screen_effects.rs @@ -27,8 +27,6 @@ pub struct ScreenVertex { /// Atlas rectangle (u0, v0, u1, v1) of the sprite. pub rect: [f32; 4], pub color: [f32; 4], - /// How the sprite is sampled: [`SAMPLE_BLUR`] and [`SAMPLE_CLAMP`]. - pub sampling: u32, } /// Linear filtering (`TextureMetadataSection.blur`), else nearest. pub const SAMPLE_BLUR: u32 = 1; @@ -43,6 +41,8 @@ pub fn sampling(flags: TextureFlags) -> u32 { pub struct ScreenQuad { pub vertices: [ScreenVertex; 4], pub blend: Blend, + /// How the sprite is sampled: [`SAMPLE_BLUR`] and [`SAMPLE_CLAMP`]. + pub sampling: u32, } /// What the camera sees this frame. @@ -124,9 +124,9 @@ impl ScreenEffects { uv: uv[i], rect, color, - sampling, }), blend: Blend::Alpha, + sampling, }; let full = [[-1.0, -1.0], [1.0, -1.0], [1.0, 1.0], [-1.0, 1.0]]; // ScreenEffectRenderer.submitBlockSprite: u1/v1 at (-1, -1), colour 0xFF191919. @@ -187,10 +187,10 @@ impl ScreenEffects { uv: [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]][i], rect, color, - sampling, } }), blend, + sampling, }; let rgba = |c: u32| { let [a, r, g, b] = c.to_be_bytes(); @@ -213,6 +213,12 @@ impl ScreenEffects { } else { Blend::Alpha }; + // The vignette darkens by texture × colour: black (in + // daylight its brightness fades to 0 within half a + // minute) leaves every pixel as it was. + if blend == Blend::Vignette && color & 0x00ff_ffff == 0 { + continue; + } if let Some(rect) = sprite(texture) { out.push(gui(rect, rgba(*color), blend, texture_sampling(texture))); } @@ -283,7 +289,18 @@ mod tests { let quads = e.build(&input); assert_eq!(quads.len(), 1); assert_eq!(quads[0].blend, Blend::Vignette); - assert_eq!(quads[0].vertices[0].sampling, 0); + assert_eq!(quads[0].sampling, 0); + // A black vignette (faded out in daylight) changes no pixel: no quad. + // Below 1/255 the colour's channels are 0; a border warning tints it. + for (brightness, warning, drawn) in [(0.003, 0.0, 0), (0.004, 0.0, 1), (0.0, 0.5, 1)] { + let overlays = [crate::hud_overlays::vignette(320, 240, brightness, warning)]; + let input = ScreenInputs { + block_overlay: None, + gui_overlays: &overlays, + ..input + }; + assert_eq!(e.build(&input).len(), drawn, "{brightness} {warning}"); + } } #[test] fn standalone_textures_sample_by_their_metadata() { @@ -323,7 +340,7 @@ mod tests { on_fire: false, gui_overlays: &[crate::hud_overlays::vignette(320, 240, 1.0, 0.0)], }); - let sampling: Vec<_> = quads.iter().map(|q| q.vertices[0].sampling).collect(); + let sampling: Vec<_> = quads.iter().map(|q| q.sampling).collect(); assert_eq!(sampling, [0, SAMPLE_CLAMP, SAMPLE_BLUR]); } #[test] From 5c9f11b9546e4067ba9fc406290024a3428e64fc Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 07:58:53 +0200 Subject: [PATCH 37/62] Benchmark: a 1080p set next to 720p perf_bench ran every game in a 1280x720 window only. It now runs the standard set at 1280x720 and 1920x1080 (--sizes picks others), each size its own reports: <label>-rd<N>.json at 720p as before, <label>-1080p-rd<N>.json at 1080p. Horizon takes vanilla's --width and --height for its window's starting size (1280x720 by default); perf_bench passes them to every game, and to Horizon only off 720p, so builds before this one still run the 720p set. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game.rs | 18 ++++++++++-- docs/benchmark.md | 6 ++-- tests/test_perf_bench.py | 8 +++++ tools/perf_bench.py | 49 +++++++++++++++++++++++-------- 4 files changed, 62 insertions(+), 19 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 0faca0ab4..00088e799 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -267,6 +267,9 @@ struct Options { /// Render into a texture instead of the window (`--offscreen`), so a /// GPU the display cannot present from can still be benchmarked. offscreen: bool, + /// `--width` and `--height` (vanilla's own arguments): the window's + /// starting size, 1280x720 by default. + window_size: [u32; 2], /// Multiplayer: `--server HOST[:PORT]` joins at start; `--name` is the offline player name. server: Option<String>, /// `--name`, `HORIZON_PLAYER_NAME` or the signed-in account's name; else @@ -326,6 +329,7 @@ impl Options { no_pause: false, control: None, offscreen: false, + window_size: [1280, 720], spikes: std::env::var("HORIZON_SPIKES") .ok() .and_then(|v| v.parse().ok()), @@ -348,7 +352,7 @@ impl Options { match arg.as_str() { "--help" | "-h" => { println!( - "Horizon — Minecraft Java Edition {} in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --world-frames N Exit after N frames drawn in the world (testing)\n --smoke-report PATH Write a JSON report on exit\n --benchmark SCENARIO Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n --session-file PATH Signed-in account from the launcher (read once, then deleted)\n --dev-mod PATH A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n --no-server-thread Run single player's world in the frame, not on its server thread\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.", + "Horizon — Minecraft Java Edition {} in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --width N, --height N Window size (default 1280 x 720)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --world-frames N Exit after N frames drawn in the world (testing)\n --smoke-report PATH Write a JSON report on exit\n --benchmark SCENARIO Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n --session-file PATH Signed-in account from the launcher (read once, then deleted)\n --dev-mod PATH A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n --no-server-thread Run single player's world in the frame, not on its server thread\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.", horizon_core::VANILLA_VERSION ); return Ok(None); @@ -397,6 +401,8 @@ impl Options { "--timeout-seconds" => o.timeout = Duration::from_secs(value.parse()?), "--smoke-report" => o.report = Some(value.into()), "--screenshot-after" => o.screenshot_after = Some(value.parse()?), + "--width" => o.window_size[0] = value.parse::<u32>()?.max(1), + "--height" => o.window_size[1] = value.parse::<u32>()?.max(1), "--world" => o.world = Some(value), "--dev-mod" => o.dev_mods.push(std::path::absolute(&value)?), "--benchmark" => { @@ -10574,6 +10580,7 @@ impl ApplicationHandler for Game<'_> { } // The Window constructor: created fullscreen when options.txt says so. let fullscreen = self.settings.fullscreen; + let size = self.options.window_size.map(f64::from); self.fullscreen = horizon_client::window::FullscreenState::new(fullscreen); let attributes = Window::default_attributes() .with_title("Horizon") @@ -10585,7 +10592,7 @@ impl ApplicationHandler for Game<'_> { ); let window = match event_loop.create_window( attributes - .with_inner_size(winit::dpi::LogicalSize::new(1280.0, 720.0)) + .with_inner_size(winit::dpi::LogicalSize::new(size[0], size[1])) .with_fullscreen(fullscreen.then_some(winit::window::Fullscreen::Borderless(None))), ) { Ok(w) => Arc::new(w), @@ -12678,6 +12685,11 @@ impl Loading { } // The Window constructor: created fullscreen when options.txt says so. let fullscreen = self.settings.fullscreen; + let size = self + .options + .as_ref() + .map_or([1280, 720], |o| o.window_size) + .map(f64::from); self.fullscreen = horizon_client::window::FullscreenState::new(fullscreen); let attributes = Window::default_attributes() .with_title("Horizon") @@ -12689,7 +12701,7 @@ impl Loading { ); let window = match event_loop.create_window( attributes - .with_inner_size(winit::dpi::LogicalSize::new(1280.0, 720.0)) + .with_inner_size(winit::dpi::LogicalSize::new(size[0], size[1])) .with_fullscreen(fullscreen.then_some(winit::window::Fullscreen::Borderless(None))), ) { Ok(w) => Arc::new(w), diff --git a/docs/benchmark.md b/docs/benchmark.md index 99ce40130..8bcc432e0 100644 --- a/docs/benchmark.md +++ b/docs/benchmark.md @@ -4,7 +4,7 @@ ## What is measured -One game is started per render distance (8, 16 and 32 chunks by default), each from a fresh world, so nothing generated by an earlier run is reused. In each game: +One game is started per window size (1280x720 and 1920x1080 by default) and render distance (8, 16 and 32 chunks by default), each from a fresh world, so nothing generated by an earlier run is reused. In each game: 1. **Start to the title screen.** Wall-clock time from starting the process to the first frame of the title screen with no loading overlay. 2. **Create the world.** A creative world named `PerfBench`, seed 1234, default world type and difficulty, created the way the game's own Create World does. **Start to in-world** is the time from starting the process until the player has spawned and every chunk around the spawn is loaded and drawn. @@ -16,7 +16,7 @@ One game is started per render distance (8, 16 and 32 chunks by default), each f - **Same machine, same run conditions.** Games run one at a time; the load average before and after each run and the machine (CPU, RAM, OS) are stored with the results. Runs on a machine doing other work are marked as such and not published. - **Same settings, one file.** Every game gets the same `options.txt`, written by the driver: render distance, simulation distance 12, unlimited frame rate (`maxFps:260`), VSync off, FOV 70, automatic GUI scale, windowed, no pause on lost focus, and `inactivityFpsLimit:minimized` (both games otherwise drop to 30 FPS after a minute without input). Everything else stays at vanilla's defaults: Horizon reads vanilla's `options.txt` keys and its defaults match vanilla's (the options harness checks it), and Horizon's own settings (`horizon-graphics.txt`) are left at their defaults, which render as vanilla does. -- **Same resolution.** Both windows are 1280x720 (Horizon's default window; vanilla gets `--width 1280 --height 720`). The size each game actually renders at is stored with the results. +- **Same resolution.** Both games get the same window size, `--width` and `--height` (vanilla's own launch arguments, which Horizon takes too): 1280x720, the size results were first published at, then 1920x1080, the commonest screen; `--sizes` picks others. The size each game actually renders at is stored with the results: a compositor or screen smaller than the window can shrink it. - **Same world and path.** Same seed and world type; same paths, yaw and pitch, same flight speed; the same steps in the same order. Vanilla is driven by a small dev-only Fabric mod (`mods/horizon/src/bench`), which only calls the game's own code: it creates the world with `WorldOpenFlows.createFreshLevel` as the Create World screen does, teleports with `/tp`, sets the time with `/time set`, and places the player on the path each frame as Horizon's `horizon-ctl fly` does. - **Warm-up excluded.** Each scene's flight starts only after its chunks are loaded and drawn and 2 seconds have passed; the load itself is reported separately. JIT warm-up of the JVM during the first scene is part of vanilla's real behaviour and is not removed. - **The same statistics code.** Horizon returns its raw frame times (`horizon-ctl fly ... raw`) and the vanilla mod writes its own; `stats()` in the driver computes every figure for both. @@ -55,7 +55,7 @@ python3 tools/perf_bench.py --game vanilla-mods --label mods-mine python3 tools/perf_bench.py --table horizon-mine vanilla-mine mods-mine ``` -Options: `--distances 8,16`, `--scenes village,ocean`, `--seconds 20`, `--repeats 5`, `--heap 4G` (vanilla), `--offscreen` (Horizon, for locked or headless sessions). Results go to `benchmarks/perf/<label>-rd<N>.json`, one [benchmark report](benchmark-report.md) per render distance (the same format the game's `--benchmark` and the launcher write), with the load average before each game; each game's log, and the vanilla driver's event log, stay in `.local/perf-bench/`. Keep the machine otherwise idle, plugged in, and the window on a screen. +Options: `--distances 8,16`, `--sizes 1920x1080`, `--scenes village,ocean`, `--seconds 20`, `--repeats 5`, `--heap 4G` (vanilla), `--offscreen` (Horizon, for locked or headless sessions). Results go to `benchmarks/perf/<label>-rd<N>.json` at 1280x720 and `<label>-1080p-rd<N>.json` at 1920x1080 (other sizes `<label>-<W>x<H>-rd<N>.json`; `--table` takes those labels), one [benchmark report](benchmark-report.md) per window size and render distance (the same format the game's `--benchmark` and the launcher write), with the load average before each game; each game's log, and the vanilla driver's event log, stay in `.local/perf-bench/`. Keep the machine otherwise idle, plugged in, and the window on a screen. ## Results diff --git a/tests/test_perf_bench.py b/tests/test_perf_bench.py index ea074442e..8e67348f0 100644 --- a/tests/test_perf_bench.py +++ b/tests/test_perf_bench.py @@ -38,6 +38,14 @@ class PerfBenchStatsTests(unittest.TestCase): self.assertIsNone(frames("x", 0, [])) json.dumps(s) + def test_window_sizes_name_their_reports(self): + from tools.perf_bench import SIZES, parse_sizes, size_label + self.assertEqual(parse_sizes("1280x720,1920X1080"), [(1280, 720), (1920, 1080)]) + self.assertEqual(SIZES, [(1280, 720), (1920, 1080)]) + self.assertEqual(size_label("horizon-m4", 1280, 720), "horizon-m4") + self.assertEqual(size_label("horizon-m4", 1920, 1080), "horizon-m4-1080p") + self.assertEqual(size_label("horizon-m4", 2560, 1080), "horizon-m4-2560x1080") + def test_one_options_file_sets_the_render_distance(self): self.assertEqual(OPTIONS["renderDistance"].format(distance=16), "16") self.assertEqual(OPTIONS["graphicsPreset"], '"custom"') diff --git a/tools/perf_bench.py b/tools/perf_bench.py index 9dedc4d01..31024737c 100644 --- a/tools/perf_bench.py +++ b/tools/perf_bench.py @@ -256,6 +256,23 @@ def write_options(game_dir, distance, version=None): return text +# Window sizes of the standard set (every game gets --width/--height): 720p, +# the size results were first published at, and 1080p, the commonest screen. +SIZES = [(1280, 720), (1920, 1080)] + + +def parse_sizes(text): + """"1280x720,1920x1080" as [(1280, 720), (1920, 1080)].""" + return [tuple(int(v) for v in size.lower().split("x")) for size in text.split(",") if size] + + +def size_label(label, width, height): + """Reports at 1280x720 keep the plain label; other sizes add theirs: horizon-m4-1080p, or -2560x1080.""" + if (width, height) == SIZES[0]: + return label + return f"{label}-{height}p" if width * 9 == height * 16 else f"{label}-{width}x{height}" + + def scene_list(args): picked = args.scenes.split(",") if args.scenes else [s[0] for s in SCENES] return [s for s in SCENES if s[0] in picked] @@ -375,6 +392,9 @@ def run_horizon(args, distance): client = Path(args.build).resolve() / "horizon-client" command = [str(client), "--resources", str(Path(args.resources).resolve()), "--control-socket", str(sock), "--no-pause", "--weather", "clear", "--time", "6000"] + if (args.width, args.height) != SIZES[0]: + # 1280x720 is Horizon's own window; builds before --width open only that one. + command += ["--width", str(args.width), "--height", str(args.height)] if args.offscreen: command.append("--offscreen") for carry in dev_mods(args): @@ -796,8 +816,8 @@ def main(): p.add_argument("--seconds", type=float, default=12.0, help="flight duration per scene") p.add_argument("--settle", type=float, default=2.0, help="seconds held at the start before each flight") p.add_argument("--timeout", type=float, default=300.0, help="seconds allowed for each load") - p.add_argument("--width", type=int, default=1280, help="vanilla window width (Horizon's is 1280x720)") - p.add_argument("--height", type=int, default=720) + p.add_argument("--sizes", default=",".join(f"{w}x{h}" for w, h in SIZES), + help="window sizes, each a set of reports (default 1280x720 and 1920x1080)") p.add_argument("--heap", default="2G", help="vanilla -Xmx (the official launcher's default is 2G)") p.add_argument("--offscreen", action="store_true", help="Horizon renders into a texture and does not wait for the window (locked macOS sessions)") @@ -817,17 +837,20 @@ def main(): args.label = args.label or f"{args.game}-{platform.node().split('.')[0]}" WORK.mkdir(parents=True, exist_ok=True) run = {"horizon": run_horizon, "neoforge": run_neoforge}.get(args.game, run_vanilla) - for d in [int(x) for x in args.distances.split(",")]: - runs = [] - for _ in range(args.repeats): - load_before = os.getloadavg() - result = run(args, d) - result["load_before"], result["load_after"] = load_before, os.getloadavg() - runs.append(result) - out = ROOT / "benchmarks/perf" / f"{args.label}-rd{d}.json" - out.parent.mkdir(parents=True, exist_ok=True) - out.write_text(json.dumps(report(args, d, runs, app(args)), indent=1) + "\n") - print(out) + label = args.label + for args.width, args.height in parse_sizes(args.sizes): + args.label = size_label(label, args.width, args.height) + for d in [int(x) for x in args.distances.split(",")]: + runs = [] + for _ in range(args.repeats): + load_before = os.getloadavg() + result = run(args, d) + result["load_before"], result["load_after"] = load_before, os.getloadavg() + runs.append(result) + out = ROOT / "benchmarks/perf" / f"{args.label}-rd{d}.json" + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(report(args, d, runs, app(args)), indent=1) + "\n") + print(out) def app(args): From 4dff61b697f8f032f374a6b71bea80b1af23d866 Mon Sep 17 00:00:00 2001 From: kerneldroid <212222389+kerneldroid@users.noreply.github.com> Date: Fri, 23 Oct 2026 10:37:14 +0500 Subject: [PATCH 38/62] feat(shaders): complete wgpu Iris/Horizon API-2 shader pipeline, shadow & G-buffer passes, GLSL translator fixes, and settings/import UI --- crates/horizon-client/src/game.rs | 3 + crates/horizon-client/src/game/options.rs | 6 + crates/horizon-client/src/game/packs.rs | 54 ++ .../horizon-client/src/game/shader_packs.rs | 26 + .../horizon-client/src/game/startup_menu.rs | 27 + crates/horizon-client/src/gfx.rs | 214 ++++- crates/horizon-client/src/gfx/java_stages.rs | 308 +++++-- crates/horizon-client/src/gfx/pack_stages.rs | 254 +++++- crates/horizon-client/src/gfx/world_post.rs | 557 +++++++++++- crates/horizon-client/src/graphics_ui.rs | 13 +- crates/horizon-client/src/java_pack.rs | 27 +- crates/horizon-client/src/options_ui.rs | 311 ++++++- crates/horizon-client/src/shader_pack.rs | 825 +++++++++++++++++- .../src/shader_pack_prelude.wgsl | 108 ++- crates/horizon-shaderpack/src/lib.rs | 28 +- crates/horizon-shaderpack/src/pipeline.rs | 144 ++- crates/horizon-shaderpack/src/properties.rs | 87 +- crates/horizon-shaderpack/src/source.rs | 22 +- crates/horizon-shaderpack/src/translate.rs | 439 +++++++--- crates/horizon-shaderpack/tests/translate.rs | 41 +- docs/shader-packs.md | 20 +- examples/shaderpacks/horizon-ultra/LICENSE | 13 + examples/shaderpacks/horizon-ultra/pack.toml | 134 +++ .../horizon-ultra/shaders/bloom_godrays.wgsl | 61 ++ .../shaders/deferred_lighting.wgsl | 92 ++ .../horizon-ultra/shaders/final_tonemap.wgsl | 29 + .../shaders/water_reflections.wgsl | 58 ++ 27 files changed, 3614 insertions(+), 287 deletions(-) create mode 100644 examples/shaderpacks/horizon-ultra/LICENSE create mode 100644 examples/shaderpacks/horizon-ultra/pack.toml create mode 100644 examples/shaderpacks/horizon-ultra/shaders/bloom_godrays.wgsl create mode 100644 examples/shaderpacks/horizon-ultra/shaders/deferred_lighting.wgsl create mode 100644 examples/shaderpacks/horizon-ultra/shaders/final_tonemap.wgsl create mode 100644 examples/shaderpacks/horizon-ultra/shaders/water_reflections.wgsl diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 0faca0ab4..95c8749f3 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -10700,6 +10700,9 @@ impl ApplicationHandler for Game<'_> { WindowEvent::CloseRequested => { self.pending_save.as_mut().unwrap().quit = true; } + WindowEvent::DroppedFile(path) => { + self.import_shader_pack_path(&path); + } WindowEvent::Focused(focused) => { self.focused = focused; if !focused { diff --git a/crates/horizon-client/src/game/options.rs b/crates/horizon-client/src/game/options.rs index ea7a5f5c5..c715b4d1a 100644 --- a/crates/horizon-client/src/game/options.rs +++ b/crates/horizon-client/src/game/options.rs @@ -243,6 +243,12 @@ impl Game<'_> { super::packs::open_folder(&dir); } Event::Credits => self.open_win_screen(false, super::win::Finish::Options), + Event::ImportShaderPack => { + self.import_shader_pack_dialog(); + } + Event::ReloadShaderPack => { + self.load_shader_pack(); + } } } Ok(()) diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs index 94e61d948..13de550e1 100644 --- a/crates/horizon-client/src/game/packs.rs +++ b/crates/horizon-client/src/game/packs.rs @@ -34,6 +34,60 @@ pub fn open_folder(dir: &Path) { log::warn!("Horizon: could not open {}: {e}", dir.display()); } } +/// Open a native file dialog to pick a shader pack `.zip` or folder, falling +/// back to opening `dir` in the system file manager when no dialog helper is present. +pub fn pick_shader_pack(dir: &Path) -> Option<PathBuf> { + let _ = std::fs::create_dir_all(dir); + let output = if cfg!(target_os = "windows") { + std::process::Command::new("powershell") + .args([ + "-NoProfile", + "-Command", + "Add-Type -AssemblyName System.Windows.Forms; $f = New-Object System.Windows.Forms.OpenFileDialog; $f.Filter = 'Shader Packs (*.zip;pack.toml)|*.zip;pack.toml|All Files (*.*)|*.*'; if ($f.ShowDialog() -eq 'OK') { Write-Output $f.FileName }", + ]) + .output() + .ok() + } else if cfg!(target_os = "macos") { + std::process::Command::new("osascript") + .args([ + "-e", + "POSIX path of (choose file with prompt \"Select Shader Pack (.zip)\")", + ]) + .output() + .ok() + } else { + std::process::Command::new("zenity") + .args([ + "--file-selection", + "--title=Import Shader Pack (.zip)", + "--file-filter=Shader Packs (*.zip) | *.zip", + ]) + .output() + .ok() + .filter(|o| o.status.success()) + .or_else(|| { + std::process::Command::new("kdialog") + .args(["--getopenfilename", ".", "*.zip|Shader Packs (*.zip)"]) + .output() + .ok() + }) + }; + if let Some(out) = output + && out.status.success() + { + let raw = String::from_utf8_lossy(&out.stdout).trim().to_owned(); + if !raw.is_empty() { + let p = PathBuf::from(raw); + if p.file_name().is_some_and(|n| n == "pack.toml") { + return p.parent().map(Path::to_path_buf); + } + return Some(p); + } + return None; + } + open_folder(dir); + None +} /// The resource root to load from, given the vanilla root and the selection. pub fn startup_root(vanilla: &Path, selected: &[String]) -> std::io::Result<PathBuf> { let all = packs::discover(vanilla, &packs_dir()); diff --git a/crates/horizon-client/src/game/shader_packs.rs b/crates/horizon-client/src/game/shader_packs.rs index 7d628ef44..d7ec206ec 100644 --- a/crates/horizon-client/src/game/shader_packs.rs +++ b/crates/horizon-client/src/game/shader_packs.rs @@ -101,6 +101,32 @@ impl Game<'_> { self.load_shader_pack(); } } + /// Import a shader pack from `source` into `shaderpacks/`, activate it, and reload. + pub(super) fn import_shader_pack_path(&mut self, source: &std::path::Path) { + let dest = dir(); + match shader_pack::import_pack(source, &dest) { + Ok(id) => { + self.ui.options.shader_packs = Default::default(); + self.ui.options.shader_packs.poll(dest); + self.settings.horizon.shader_pack = id; + self.ui.options.shader_pack_config = None; + self.ui.options.sync_shader_pack_config(&self.settings); + self.settings.save(&Self::options_path()); + self.load_shader_pack(); + } + Err(e) => { + log::warn!("Horizon: shader pack import failed: {e}"); + self.system_message(Text::literal(format!("Shader pack import: {e}"))); + } + } + } + /// Open the system file picker (or `shaderpacks/` folder) to import a shader pack. + pub(super) fn import_shader_pack_dialog(&mut self) { + let dest = dir(); + if let Some(chosen) = super::packs::pick_shader_pack(&dest) { + self.import_shader_pack_path(&chosen); + } + } fn shader_pack_error(&mut self, id: &str, error: &str) { log::warn!("Horizon: shader pack {id}: {error}"); // The Shader Packs page says why on the pack's row: the first line, diff --git a/crates/horizon-client/src/game/startup_menu.rs b/crates/horizon-client/src/game/startup_menu.rs index a5d076878..e01dd6dc6 100644 --- a/crates/horizon-client/src/game/startup_menu.rs +++ b/crates/horizon-client/src/game/startup_menu.rs @@ -387,6 +387,22 @@ impl Loading { self.menu.win = Some((screen, Instant::now())); } } + Event::ImportShaderPack => { + let dir = horizon_client::shader_pack::folder(); + if let Some(chosen) = packs::pick_shader_pack(&dir) + && let Ok(id) = horizon_client::shader_pack::import_pack(&chosen, &dir) + { + self.menu.options.shader_packs = Default::default(); + self.menu.options.shader_packs.poll(dir); + self.settings.horizon.shader_pack = id; + self.menu.options.shader_pack_config = None; + self.menu.options.sync_shader_pack_config(&self.settings); + self.save_menu_settings(); + } + } + Event::ReloadShaderPack => { + self.save_menu_settings(); + } // The startup menu runs before the game opens a control socket. Event::ButtonClick | Event::CopyAgentDetails => {} } @@ -452,6 +468,17 @@ impl Loading { } self.apply_menu_settings(); } + WindowEvent::DroppedFile(path) => { + let dir = horizon_client::shader_pack::folder(); + if let Ok(id) = horizon_client::shader_pack::import_pack(&path, &dir) { + self.menu.options.shader_packs = Default::default(); + self.menu.options.shader_packs.poll(dir); + self.settings.horizon.shader_pack = id; + self.menu.options.shader_pack_config = None; + self.menu.options.sync_shader_pack_config(&self.settings); + self.save_menu_settings(); + } + } WindowEvent::RedrawRequested => self.draw(), WindowEvent::ModifiersChanged(modifiers) => self.menu.modifiers = modifiers.state(), WindowEvent::Focused(false) => { diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index c14a32e2c..0fd03e01b 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -332,6 +332,11 @@ pub struct Renderer { /// (`crosshair_globals`). crosshair_group: wgpu::BindGroup, crosshair_globals: wgpu::Buffer, + shadow_pipeline: wgpu::RenderPipeline, + shadow_entity_pipeline: wgpu::RenderPipeline, + shadow_globals: wgpu::Buffer, + shadow_group: wgpu::BindGroup, + shadow_entity_group: wgpu::BindGroup, entity_pipeline: wgpu::RenderPipeline, weather: weather::Weather, crumbling_pipeline: wgpu::RenderPipeline, @@ -1271,6 +1276,38 @@ impl Renderer { usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }); + let shadow_globals = device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Shader pack shadow globals"), + size: std::mem::size_of::<Globals>() as u64, + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let shadow_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Terrain shadow"), + layout: Some(&layout), + vertex: wgpu::VertexState { + module: &shader, + entry_point: Some("vs_terrain"), + compilation_options: Default::default(), + buffers: &terrain_buffers, + }, + primitive: wgpu::PrimitiveState { + topology: tri, + cull_mode: Some(wgpu::Face::Back), + ..Default::default() + }, + depth_stencil: Some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(true), + depth_compare: Some(wgpu::CompareFunction::GreaterEqual), + stencil: Default::default(), + bias: Default::default(), + }), + multisample: Default::default(), + fragment: None, + multiview_mask: None, + cache: None, + }); let prepared = prepared.unwrap_or_else(|| { PreparedTextures::new(sprite_pixels, sprite_size, layers, sprite_mips, forcefield) }); @@ -1384,6 +1421,16 @@ impl Renderer { &lightmap_view, &lightmap_sampler, ); + let shadow_group = terrain_group( + &device, + "Shader pack shadow terrain resources", + &bindings, + &shadow_globals, + &sprite_views, + &sprite_sampler, + &lightmap_view, + &lightmap_sampler, + ); let index_quads = 1 << 16; let indices = Self::quad_indices(&device, index_quads); let instance_capacity = 4096; @@ -1539,6 +1586,32 @@ impl Renderer { }, ], }); + let shadow_entity_group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("Shader pack shadow entity resources"), + layout: &entity_bindings, + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: shadow_globals.as_entire_binding(), + }, + wgpu::BindGroupEntry { + binding: 1, + resource: wgpu::BindingResource::TextureView(&atlas_view), + }, + wgpu::BindGroupEntry { + binding: 2, + resource: wgpu::BindingResource::Sampler(&atlas_sampler), + }, + wgpu::BindGroupEntry { + binding: 3, + resource: wgpu::BindingResource::TextureView(&lightmap_view), + }, + wgpu::BindGroupEntry { + binding: 4, + resource: wgpu::BindingResource::Sampler(&lightmap_sampler), + }, + ], + }); let entity_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("Entity layout"), bind_group_layouts: &[Some(&entity_bindings)], @@ -1649,6 +1722,32 @@ impl Renderer { wgpu::ColorWrites::ALL, ) }; + let shadow_entity_pipeline = + device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Entity shadow"), + layout: Some(&entity_layout), + vertex: wgpu::VertexState { + module: &entity_shader, + entry_point: Some("vs_entity"), + compilation_options: Default::default(), + buffers: &entity_vertex, + }, + primitive: wgpu::PrimitiveState { + cull_mode: None, + ..Default::default() + }, + depth_stencil: Some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(true), + depth_compare: Some(wgpu::CompareFunction::GreaterEqual), + stencil: Default::default(), + bias: Default::default(), + }), + multisample: Default::default(), + fragment: None, + multiview_mask: None, + cache: None, + }); // RenderPipelines.WATER_MASK: the boat's water patch writes depth only. let water_mask_pipeline = entity_pipeline_with( "Water mask", @@ -2157,6 +2256,11 @@ impl Renderer { debug_line_capacity: 4096, crosshair_group, crosshair_globals, + shadow_pipeline, + shadow_entity_pipeline, + shadow_globals, + shadow_group, + shadow_entity_group, entity_pipeline, weather, crumbling_pipeline, @@ -2661,7 +2765,12 @@ impl Renderer { &pack.id, java, )?), - None => Pack::Horizon(pack_stages::PackStages::new(&self.device, format, pack)?), + None => Pack::Horizon(pack_stages::PackStages::new( + &self.device, + &self.queue, + format, + pack, + )?), }), None => None, }; @@ -2703,6 +2812,16 @@ impl Renderer { &self.lightmap_view, &self.lightmap_sampler, ); + self.shadow_group = terrain_group( + &self.device, + "Shader pack shadow terrain resources", + &self.terrain_layout, + &self.shadow_globals, + &views, + &self.sprite_sampler, + &self.lightmap_view, + &self.lightmap_sampler, + ); } pub fn view_projection(&self, frame: &Frame) -> Mat4 { self.projection( @@ -3544,6 +3663,32 @@ impl Renderer { } // The world's targets: the screen, or the scaled target of `post`. let pack = self.pack.is_some() && !frame.title; + let shadow_cfg = if pack { + self.pack.as_ref().and_then(|p| match p { + Pack::Horizon(s) if s.needs_shadow => Some((s.shadow_res, s.shadow_dist)), + Pack::Java(s) if s.needs_shadow() => Some(s.shadow_config(frame.shader.dimension)), + _ => None, + }) + } else { + None + }; + if let Some((shadow_res, shadow_dist)) = shadow_cfg { + self.world_post + .prepare_shadow(&self.device, shadow_res, shadow_dist, sun, -sun); + let shadow_globals = Globals { + view_proj: (self.world_post.shadow_proj * self.world_post.shadow_view) + .to_cols_array_2d(), + ..globals + }; + self.uploads.buffer( + &mut encoder, + &self.shadow_globals, + 0, + bytemuck::bytes_of(&shadow_globals), + ); + } else { + self.world_post.shadow_active = false; + } let scaled = self.world_post .prepare(&self.device, [self.config.width, self.config.height], pack); @@ -3552,6 +3697,36 @@ impl Renderer { None => (&view_target, &self.depth), }; let cull = self.cull.as_ref().filter(|_| culling && solid_draws > 0); + if shadow_cfg.is_some() { + let shadow_view = self.world_post.shadow_depth().clone(); + let mut shadow_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some("Horizon shadow"), + color_attachments: &[], + depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { + view: &shadow_view, + depth_ops: Some(wgpu::Operations { + load: wgpu::LoadOp::Clear(0.0), + store: wgpu::StoreOp::Store, + }), + stencil_ops: None, + }), + ..Default::default() + }); + if solid_draws > 0 && !flat_frame { + shadow_pass.set_bind_group(0, &self.shadow_group, &[]); + shadow_pass.set_pipeline(&self.shadow_pipeline); + shadow_pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); + shadow_pass.set_vertex_buffer(1, self.instances.slice(..)); + self.draw_sections(&mut shadow_pass, &self.indirect, 0, 0, solid_draws); + } + if entity_quads > 0 { + shadow_pass.set_pipeline(&self.shadow_entity_pipeline); + shadow_pass.set_bind_group(0, &self.shadow_entity_group, &[]); + shadow_pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); + shadow_pass.set_vertex_buffer(0, self.entity_buffer.slice(..)); + shadow_pass.draw_indexed(0..entity_quads * 6, 0, 0..1); + } + } { let attachments = [Some(wgpu::RenderPassColorAttachment { view: world_view, @@ -3753,6 +3928,33 @@ impl Renderer { pass.set_vertex_buffer(0, self.debug_line_buffer.slice(..)); pass.draw(0..4, debug_depth..debug_depth + debug_top); } + if pack { + drop(pass); + self.world_post.capture_opaque_depth(&mut encoder); + let attachments = [Some(wgpu::RenderPassColorAttachment { + view: world_view, + resolve_target: None, + depth_slice: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Load, + store: wgpu::StoreOp::Store, + }, + })]; + pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some("Horizon world, translucent"), + color_attachments: &attachments, + depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { + view: world_depth, + depth_ops: Some(wgpu::Operations { + load: wgpu::LoadOp::Load, + store: wgpu::StoreOp::Store, + }), + stencil_ops: None, + }), + ..Default::default() + }); + pass.set_bind_group(0, &self.group, &[]); + } match self.flat.as_ref().filter(|_| flat_frame) { Some(flat) => { pass.set_pipeline(&flat.translucent); @@ -3824,6 +4026,15 @@ impl Renderer { ); } } + if pack && scaled.is_some() { + self.world_post.build_gbuffer( + &self.queue, + &mut encoder, + &pack_uniform, + frame.shader.eye_light, + frame.shader.rain, + ); + } if let (true, Some((color, depth)), Some(size), Some(stages)) = (pack, &scaled, self.world_post.size(), self.pack.as_mut()) { @@ -3837,6 +4048,7 @@ impl Renderer { size, &self.world_post, pack_uniform, + frame.shader.eye_light, ), Pack::Java(stages) => stages.run( &self.device, diff --git a/crates/horizon-client/src/gfx/java_stages.rs b/crates/horizon-client/src/gfx/java_stages.rs index e9f8ddbb1..8091b0703 100644 --- a/crates/horizon-client/src/gfx/java_stages.rs +++ b/crates/horizon-client/src/gfx/java_stages.rs @@ -1,17 +1,20 @@ //! A Java (OptiFine/Iris) shader pack on the GPU (docs/shader-packs.md): //! Iris's colour targets (`colortex0..`, each with a main and an alternate -//! side) and the pack's `begin`, `prepare`, `deferred`, `composite` and -//! `final` programs as full-screen passes over them, as Iris's -//! `CompositeRenderer` runs them. Horizon's world enters `colortex0` and -//! `depthtex0..2` after `prepare`, where Iris's gbuffers programs would have -//! drawn, and the last picture goes to `world_post`. The targets keep GL's -//! layout (row 0 at the bottom, which the translated vertex programs -//! produce), so the world is flipped going in and the picture coming out. +//! side), pre-translucent depth (`depthtex1`/`depthtex2`), directional +//! shadow map (`shadowtex0`/`shadowtex1`) and the pack's `begin`, `prepare`, +//! `deferred`, `composite` and `final` programs as full-screen passes over +//! them, as Iris's `CompositeRenderer` runs them. Horizon's world enters +//! `colortex0` and `depthtex0..2` after `prepare`, where Iris's gbuffers +//! programs would have drawn, and the last picture goes to `world_post`. The +//! targets keep GL's layout (row 0 at the bottom, which the translated vertex +//! programs produce), so the world is flipped going in and the picture coming +//! out. use super::pack_stages::FrameUniform; use crate::java_pack::{JavaFolder, JavaPasses}; use glam::{Mat3, Mat4, Vec3, Vec4}; use horizon_shaderpack::pipeline::TargetSettings; use horizon_shaderpack::pipeline::{Directives, Program, target_index}; +use horizon_shaderpack::properties::Blend; use horizon_shaderpack::uniforms::{CustomUniforms, SmoothFloat, UniformState}; use std::collections::{BTreeMap, BTreeSet, HashMap}; @@ -35,6 +38,7 @@ const MAX_ATTRIBUTES: usize = 8; const BLIT: &str = r#" @group(0) @binding(0) var color: texture_2d<f32>; @group(0) @binding(1) var depth: texture_depth_2d; +@group(0) @binding(2) var opaque_depth: texture_depth_2d; @vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f { @@ -45,15 +49,20 @@ fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f { struct World { @location(0) color: vec4f, @location(1) depth: vec4f, + @location(2) opaque_depth: vec4f, } -// The world's colour and depth, upside down into GL's layout; Horizon's -// reversed depth (near 1) as GL's (near 0). +// The world's colour, depth and pre-translucent depth, upside down into GL's +// layout; Horizon's reversed depth (near 1) as GL's (near 0). @fragment fn world_in(@builtin(position) p: vec4f) -> World { let size = textureDimensions(depth); let xy = vec2u(u32(p.x), size.y - 1u - u32(p.y)); - return World(textureLoad(color, xy, 0), vec4f(1.0 - textureLoad(depth, xy, 0))); + return World( + textureLoad(color, xy, 0), + vec4f(1.0 - textureLoad(depth, xy, 0)), + vec4f(1.0 - textureLoad(opaque_depth, xy, 0)), + ); } // A target, upside down back into wgpu's layout. @@ -64,6 +73,42 @@ fn present(@builtin(position) p: vec4f) -> @location(0) vec4f { } "#; +/// Convert a GL `Blend` override from `shaders.properties` into a wgpu `BlendState`. +fn blend_state(blend: &Blend) -> Option<wgpu::BlendState> { + let Blend::Factors(factors) = blend else { + return None; + }; + let map_factor = |name: &str| -> wgpu::BlendFactor { + use wgpu::BlendFactor as B; + match name { + "ZERO" => B::Zero, + "ONE" => B::One, + "SRC_COLOR" => B::Src, + "ONE_MINUS_SRC_COLOR" => B::OneMinusSrc, + "DST_COLOR" => B::Dst, + "ONE_MINUS_DST_COLOR" => B::OneMinusDst, + "SRC_ALPHA" => B::SrcAlpha, + "ONE_MINUS_SRC_ALPHA" => B::OneMinusSrcAlpha, + "DST_ALPHA" => B::DstAlpha, + "ONE_MINUS_DST_ALPHA" => B::OneMinusDstAlpha, + "SRC_ALPHA_SATURATE" => B::SrcAlphaSaturated, + _ => B::One, + } + }; + Some(wgpu::BlendState { + color: wgpu::BlendComponent { + src_factor: map_factor(&factors[0]), + dst_factor: map_factor(&factors[1]), + operation: wgpu::BlendOperation::Add, + }, + alpha: wgpu::BlendComponent { + src_factor: map_factor(&factors[2]), + dst_factor: map_factor(&factors[3]), + operation: wgpu::BlendOperation::Add, + }, + }) +} + /// A wgpu format for each of Iris's (`InternalTextureFormat`), renderable /// everywhere: 8-bit unsigned normalized formats stay, signed normalized, /// 16-bit and packed float ones become half floats, integer ones 32-bit. @@ -123,11 +168,12 @@ struct Target { #[derive(Clone, Copy, Debug, PartialEq)] enum Source { Target(u32), - /// `depthtex0..2`: the world's depth. + /// `depthtex0` / `gdepthtex`: the world's depth (including translucent water). Depth, + /// `depthtex1` / `depthtex2`: the opaque world's depth (before translucent water). + OpaqueDepth, Noise, - /// `shadowtex*`: no shadow map yet, so a far depth (nothing in shadow); - /// also Distant Horizons' and Voxy's depth, as without those mods. + /// `shadowtex*`: directional sun/moon shadow map depth (or far depth for DH/Voxy). Shadow, /// Anything else (`shadowcolor*`, custom textures): white or black. Blank(bool), @@ -135,7 +181,8 @@ enum Source { fn source(name: &str) -> Source { match name { - "depthtex0" | "depthtex1" | "depthtex2" | "gdepthtex" => Source::Depth, + "depthtex0" | "gdepthtex" => Source::Depth, + "depthtex1" | "depthtex2" => Source::OpaqueDepth, "noisetex" => Source::Noise, "shadowtex0" | "shadowtex1" | "shadow" | "watershadow" => Source::Shadow, n if n.starts_with("dhDepthTex") || n.starts_with("vxDepthTex") => Source::Shadow, @@ -146,6 +193,7 @@ fn source(name: &str) -> Source { /// A sampler of a pass: its texture and sampler bindings. struct SamplerBinding { + name: String, source: Source, dimension: wgpu::TextureViewDimension, /// `isampler` (true) or `usampler` (false). @@ -183,6 +231,7 @@ struct Common { repeat: wgpu::Sampler, compare: wgpu::Sampler, noise: wgpu::TextureView, + custom_textures: BTreeMap<String, wgpu::TextureView>, /// Full-screen triangle data per attribute kind (see `PassGpu::attributes`). vertices: [wgpu::Buffer; 4], world_layout: wgpu::BindGroupLayout, @@ -196,6 +245,7 @@ struct Bound { size: [u32; 2], targets: BTreeMap<u32, Target>, depth: wgpu::TextureView, + opaque_depth: wgpu::TextureView, /// Per pass, then `final`. groups: Vec<wgpu::BindGroup>, world_in: (wgpu::RenderPipeline, wgpu::BindGroup), @@ -217,6 +267,7 @@ struct Folder { passes: Vec<PassGpu>, final_pass: Option<PassGpu>, directives: Directives, + shadow_enabled: bool, } pub struct JavaStages { @@ -234,9 +285,25 @@ pub struct JavaStages { uniform_state: UniformState, /// `eyeBrightnessSmooth`, block then sky. eye_smooth: [SmoothFloat; 2], + /// `wetness`, smoothed with `wetnessHalflife` / `drynessHalflife`. + wetness_smooth: SmoothFloat, + /// `centerDepthSmooth`, smoothed with `centerDepthHalflife`. + center_depth_smooth: SmoothFloat, } impl JavaStages { + /// Whether any dimension folder in this pack reads directional shadow maps. + pub fn needs_shadow(&self) -> bool { + self.folders.iter().any(|f| f.shadow_enabled) + } + + /// Shadow map resolution and distance for `dimension`. + pub fn shadow_config(&self, dimension: i8) -> (u32, f32) { + let idx = self.folder_for[(dimension.clamp(-1, 1) + 1) as usize].unwrap_or(0); + let d = &self.folders[idx].directives; + (d.shadow_map_resolution, d.shadow_distance) + } + /// The pipelines of a loaded Java pack, or wgpu's error. pub fn new( device: &wgpu::Device, @@ -245,7 +312,7 @@ impl JavaStages { id: &str, pack: &JavaPasses, ) -> Result<Self, String> { - let common = Common::new(device, queue); + let common = Common::new(device, queue, &pack.custom_textures); let folder_for = [-1, 0, 1].map(|d| pack.folder_for(d)); let scope = device.push_error_scope(wgpu::ErrorFilter::Validation); let folders = pack @@ -275,6 +342,7 @@ impl JavaStages { passes, final_pass, directives: plan.directives, + shadow_enabled: plan.shadow_enabled, }) }) .collect::<Result<Vec<_>, _>>()?; @@ -295,6 +363,8 @@ impl JavaStages { uniforms: pack.uniforms.clone(), uniform_state: UniformState::default(), eye_smooth: [SmoothFloat::default(); 2], + wetness_smooth: SmoothFloat::default(), + center_depth_smooth: SmoothFloat::default(), }) } @@ -335,10 +405,26 @@ impl JavaStages { self.previous, ); inputs.set_world(&world, directives.sun_path_rotation); + inputs.shadow_view = post.shadow_view; + inputs.shadow_projection = post.gl_shadow_projection(); + inputs.ambient_occlusion_level = directives.ambient_occlusion_level; + inputs.shadow_map_resolution = directives.shadow_map_resolution as f32; let half_life = directives.eye_brightness_half_life; for (i, smooth) in self.eye_smooth.iter_mut().enumerate() { inputs.eye_smooth[i] = smooth.update(inputs.eye[i], half_life, half_life, frame_time); } + inputs.wetness = self.wetness_smooth.update( + frame.weather[0], + directives.wetness_half_life, + directives.dryness_half_life, + frame_time, + ); + inputs.center_depth_smooth = self.center_depth_smooth.update( + 0.5, + directives.center_depth_half_life, + directives.center_depth_half_life, + frame_time, + ); self.uniforms .update(&mut self.uniform_state, frame_time, &|name| { inputs.builtin(name) @@ -496,10 +582,28 @@ impl JavaStages { size, ) .create_view(&Default::default()); + let opaque_depth = texture( + "Java shader pack opaque depth", + wgpu::TextureFormat::R32Float, + wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, + size, + ) + .create_view(&Default::default()); let mut blank = Vec::new(); let groups = all .clone() - .map(|pass| pass.bind(device, queue, &targets, &depth, &self.common, &mut blank)) + .map(|pass| { + pass.bind( + device, + queue, + &targets, + &depth, + &opaque_depth, + post, + &self.common, + &mut blank, + ) + }) .collect(); // The world goes into colortex0's side the gbuffers would write. @@ -509,7 +613,11 @@ impl JavaStages { &self.common, &self.common.world_layout, "world_in", - &[colortex0.format, wgpu::TextureFormat::R32Float], + &[ + colortex0.format, + wgpu::TextureFormat::R32Float, + wgpu::TextureFormat::R32Float, + ], ); let world_group = device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("Java shader pack world"), @@ -523,6 +631,10 @@ impl JavaStages { binding: 1, resource: wgpu::BindingResource::TextureView(world_depth), }, + wgpu::BindGroupEntry { + binding: 2, + resource: wgpu::BindingResource::TextureView(post.opaque_depth()), + }, ], }); @@ -571,6 +683,7 @@ impl JavaStages { size, targets, depth, + opaque_depth, groups, world_in: (world_pipeline, world_group), world_alt: plan.flipped_after_prepare.contains(&0), @@ -593,6 +706,7 @@ fn world_in(encoder: &mut wgpu::CommandEncoder, bound: &Bound) { let attachments = [ Some(color_attachment(side, None)), Some(color_attachment(&bound.depth, None)), + Some(color_attachment(&bound.opaque_depth, None)), ]; let mut render = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { label: Some("Java shader pack world"), @@ -666,7 +780,11 @@ fn blit_pipeline( } impl Common { - fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Self { + fn new( + device: &wgpu::Device, + queue: &wgpu::Queue, + custom_map: &BTreeMap<String, (u32, u32, Vec<u8>)>, + ) -> Self { let sampler = |filter, address, compare| { device.create_sampler(&wgpu::SamplerDescriptor { label: Some("Java shader pack"), @@ -714,6 +832,34 @@ impl Common { }, noise.size(), ); + let mut custom_textures = BTreeMap::new(); + for (name, (w, h, bytes)) in custom_map { + let tex = device.create_texture(&wgpu::TextureDescriptor { + label: Some(name), + size: wgpu::Extent3d { + width: *w, + height: *h, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, + view_formats: &[], + }); + queue.write_texture( + tex.as_image_copy(), + bytes, + wgpu::TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(*w * 4), + rows_per_image: None, + }, + tex.size(), + ); + custom_textures.insert(name.clone(), tex.create_view(&Default::default())); + } // The full-screen triangle (0, 0), (2, 0), (0, 2): the pack's // projection maps 0..1 to the screen. Texture coordinates are the // position; colours white; normals up. @@ -754,12 +900,14 @@ impl Common { repeat: sampler(Linear, Repeat, None), compare: sampler(Linear, ClampToEdge, Some(wgpu::CompareFunction::LessEqual)), noise: noise.create_view(&Default::default()), + custom_textures, vertices, world_layout: device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some("Java shader pack world"), entries: &[ texture_entry(0, unfilterable), texture_entry(1, wgpu::TextureSampleType::Depth), + texture_entry(2, wgpu::TextureSampleType::Depth), ], }), present_layout: device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { @@ -841,6 +989,7 @@ impl PassGpu { .cloned() .unwrap_or_else(|| format!("{sampler}_s")); samplers.push(SamplerBinding { + name: sampler.clone(), source: source(sampler), dimension, signed, @@ -885,7 +1034,7 @@ impl PassGpu { )), ) } - (false, Source::Depth | Source::Shadow) => ( + (false, Source::Depth | Source::OpaqueDepth | Source::Shadow) => ( wgpu::TextureSampleType::Float { filterable: false }, Some(false), ), @@ -979,10 +1128,11 @@ impl PassGpu { // Output location `l` writes target `draw_buffers[l]` (or the screen). let outputs = &program.fragment.interface.outputs; + let pass_blend = program.pass.blend.as_ref().and_then(blend_state); let target_states: Vec<Option<wgpu::ColorTargetState>> = match screen { Some(format) => vec![Some(wgpu::ColorTargetState { format, - blend: None, + blend: pass_blend, write_mask: if outputs.contains_key(&0) { wgpu::ColorWrites::ALL } else { @@ -994,12 +1144,25 @@ impl PassGpu { .iter() .enumerate() .map(|(l, &i)| { + let format = formats + .get(i as usize) + .copied() + .unwrap_or(wgpu::TextureFormat::Rgba8Unorm); + // Only filterable float/unorm formats support blending. + let can_blend = matches!( + sample_type(format), + wgpu::TextureSampleType::Float { filterable: true } + ); + let buf_blend = program + .pass + .buffer_blends + .iter() + .find(|(idx, _)| *idx == i) + .map(|(_, b)| blend_state(b)) + .unwrap_or(pass_blend); Some(wgpu::ColorTargetState { - format: formats - .get(i as usize) - .copied() - .unwrap_or(wgpu::TextureFormat::Rgba8Unorm), - blend: None, + format, + blend: if can_blend { buf_blend } else { None }, write_mask: if outputs.contains_key(&(l as u32)) { wgpu::ColorWrites::ALL } else { @@ -1068,37 +1231,54 @@ impl PassGpu { } /// The pass's bind group over `targets`. + #[allow(clippy::too_many_arguments)] fn bind( &self, device: &wgpu::Device, queue: &wgpu::Queue, targets: &BTreeMap<u32, Target>, depth: &wgpu::TextureView, + opaque_depth: &wgpu::TextureView, + post: &super::world_post::Post, common: &Common, blank: &mut Vec<wgpu::Texture>, ) -> wgpu::BindGroup { let mut views = Vec::new(); for s in &self.samplers { - let view = match (s.compare, s.source) { - (true, _) => blank_view(device, queue, blank, s, BlankKind::FarDepth), - (false, Source::Target(i)) if s.dimension == wgpu::TextureViewDimension::D2 => { - match targets.get(&i) { - Some(t) if self.reads_alt.contains(&i) => t.alt_view.clone(), - Some(t) => t.main_view.clone(), - None => blank_view(device, queue, blank, s, BlankKind::Color(false)), + let view = if let Some(custom) = common + .custom_textures + .get(&s.name) + .filter(|_| !s.compare && s.dimension == wgpu::TextureViewDimension::D2) + { + custom.clone() + } else { + match (s.compare, s.source) { + (true, Source::Shadow) if post.shadow_active => post.shadow_depth().clone(), + (true, _) => blank_view(device, queue, blank, s, BlankKind::FarDepth), + (false, Source::Target(i)) if s.dimension == wgpu::TextureViewDimension::D2 => { + match targets.get(&i) { + Some(t) if self.reads_alt.contains(&i) => t.alt_view.clone(), + Some(t) => t.main_view.clone(), + None => blank_view(device, queue, blank, s, BlankKind::Color(false)), + } } + (false, Source::Depth) if s.dimension == wgpu::TextureViewDimension::D2 => { + depth.clone() + } + (false, Source::OpaqueDepth) + if s.dimension == wgpu::TextureViewDimension::D2 => + { + opaque_depth.clone() + } + (false, Source::Shadow) => blank_view(device, queue, blank, s, BlankKind::Far), + (false, Source::Noise) if s.dimension == wgpu::TextureViewDimension::D2 => { + common.noise.clone() + } + (false, Source::Blank(white)) => { + blank_view(device, queue, blank, s, BlankKind::Color(white)) + } + _ => blank_view(device, queue, blank, s, BlankKind::Color(false)), } - (false, Source::Depth) if s.dimension == wgpu::TextureViewDimension::D2 => { - depth.clone() - } - (false, Source::Shadow) => blank_view(device, queue, blank, s, BlankKind::Far), - (false, Source::Noise) if s.dimension == wgpu::TextureViewDimension::D2 => { - common.noise.clone() - } - (false, Source::Blank(white)) => { - blank_view(device, queue, blank, s, BlankKind::Color(white)) - } - _ => blank_view(device, queue, blank, s, BlankKind::Color(false)), }; let sampler = match (s.compare, s.source) { _ if s.shared.is_some() => match s.shared.as_deref() { @@ -1110,7 +1290,7 @@ impl PassGpu { (true, _) => &common.compare, _ if s.signed.is_some() => &common.nearest, (false, Source::Noise) => &common.repeat, - (false, Source::Depth | Source::Shadow) => &common.nearest, + (false, Source::Depth | Source::OpaqueDepth | Source::Shadow) => &common.nearest, (false, Source::Target(i)) => { match targets.get(&i).map(|t| sample_type(t.format)) { Some(wgpu::TextureSampleType::Float { filterable: true }) | None => { @@ -1432,6 +1612,8 @@ struct Inputs { view: Mat4, /// GL's: near at -1, far at 1. projection: Mat4, + shadow_view: Mat4, + shadow_projection: Mat4, camera: Vec3, previous: (Mat4, Mat4, Vec3), size: [f32; 2], @@ -1442,6 +1624,10 @@ struct Inputs { /// `eyeBrightness` and `eyeBrightnessSmooth`: block, sky light × 16. eye: [f32; 2], eye_smooth: [f32; 2], + wetness: f32, + center_depth_smooth: f32, + ambient_occlusion_level: f32, + shadow_map_resolution: f32, /// `CelestialUniforms`, in view space. sun_position: Vec3, moon_position: Vec3, @@ -1490,6 +1676,8 @@ impl Inputs { let mut out = Self { view, projection, + shadow_view: Mat4::IDENTITY, + shadow_projection: Mat4::IDENTITY, camera, previous: previous.unwrap_or((view, projection, camera)), size: size.map(|v| v as f32), @@ -1499,6 +1687,10 @@ impl Inputs { frame: *frame, eye: [0.0; 2], eye_smooth: [0.0; 2], + wetness: frame.weather[0], + center_depth_smooth: 0.5, + ambient_occlusion_level: 1.0, + shadow_map_resolution: 2048.0, sun_position: Vec3::ZERO, moon_position: Vec3::ZERO, up_position: Vec3::ZERO, @@ -1591,27 +1783,42 @@ impl Inputs { }), "upPosition" => vec3(self.up_position), "moonPhase" => vec![f.moon[3]], - "rainStrength" | "wetness" => vec![f.weather[0]], + "rainStrength" => vec![f.weather[0]], + "wetness" => vec![self.wetness], "thunderStrength" => vec![f.weather[1]], "fogColor" => f.fog_color[..3].to_vec(), "skyColor" => f.sky_color[..3].to_vec(), "isEyeInWater" => vec![f.camera_state[0]], "nightVision" => vec![f.camera_state[1]], - "darknessFactor" => vec![f.camera_state[2]], + "darknessFactor" | "darknessLightFactor" => vec![f.camera_state[2]], + "blindness" => vec![f.camera_state[3]], "screenBrightness" => vec![1.0], + "centerDepthSmooth" => vec![self.center_depth_smooth], + "ambientOcclusionLevel" => vec![self.ambient_occlusion_level], + "shadowMapResolution" => vec![self.shadow_map_resolution], "eyeBrightness" => self.eye.to_vec(), // An ivec2: the smoothed value truncated. "eyeBrightnessSmooth" => self.eye_smooth.map(f32::trunc).to_vec(), "hasSkylight" => vec![f.dimension[1]], + "heldItemId" | "heldItemId2" | "heldBlockLightValue" | "heldBlockLightValue2" => { + vec![0.0] + } + "biome" | "biome_category" => vec![0.0], + "biome_precipitation" => vec![if f.weather[0] > 0.01 { 1.0 } else { 0.0 }], + "temp" => vec![0.8], + "rainfall" => vec![0.4], + "alphaTestRef" => vec![0.1], + "renderStage" => vec![0.0], + "playerMood" | "currentColorSpace" => vec![0.0], "iris_ModelViewMatrix" | "iris_ModelViewMatrixInverse" => mat(Mat4::IDENTITY), "iris_ProjectionMatrix" | "iris_ModelViewProjectionMatrix" => mat(screen), "iris_ProjectionMatrixInverse" => mat(screen.inverse()), "iris_TextureMatrix" => (0..8).flat_map(|_| mat(Mat4::IDENTITY)).collect(), "iris_NormalMatrix" => Mat3::IDENTITY.to_cols_array().to_vec(), - "shadowModelView" - | "shadowModelViewInverse" - | "shadowProjection" - | "shadowProjectionInverse" => mat(Mat4::IDENTITY), + "shadowModelView" => mat(self.shadow_view), + "shadowModelViewInverse" => mat(self.shadow_view.inverse()), + "shadowProjection" => mat(self.shadow_projection), + "shadowProjectionInverse" => mat(self.shadow_projection.inverse()), _ => return None, }) } @@ -1651,6 +1858,7 @@ mod tests { assert_eq!(source("colortex4"), Source::Target(4)); assert_eq!(source("gaux1"), Source::Target(4)); assert_eq!(source("gdepthtex"), Source::Depth); + assert_eq!(source("depthtex1"), Source::OpaqueDepth); assert_eq!(source("shadowtex1"), Source::Shadow); assert_eq!(source("dhDepthTex0"), Source::Shadow); assert_eq!(source("shadowcolor0"), Source::Blank(true)); diff --git a/crates/horizon-client/src/gfx/pack_stages.rs b/crates/horizon-client/src/gfx/pack_stages.rs index 87d22d07d..08a6b9aea 100644 --- a/crates/horizon-client/src/gfx/pack_stages.rs +++ b/crates/horizon-client/src/gfx/pack_stages.rs @@ -1,9 +1,12 @@ -//! A Horizon shader pack on the GPU (docs/shader-packs.md): each `composite` -//! stage is one full-screen pass that reads the world's colour and depth and -//! the previous stage's output and writes its own target; the last target -//! goes to the screen through `world_post` (copy or FXAA) under the hand and -//! HUD. Only exists while a pack is selected. -use crate::shader_pack::{ShaderPack, VERTEX_ENTRY}; +//! A Horizon shader pack on the GPU (docs/shader-packs.md): each stage +//! (`shadow`, `gbuffer`, `deferred`, `composite`, `final`) is a full-screen +//! pass that reads the world's colour, depth, opaque depth, G-buffer normals +//! and materials, shadow map, noise texture and the previous stage's output, +//! and writes its own target; the last target goes to the screen through +//! `world_post` (copy or FXAA) under the hand and HUD. Only exists while a +//! pack is selected. +use crate::shader_pack::{ShaderPack, StageKind, VERTEX_ENTRY}; +use horizon_shaderpack::uniforms::SmoothFloat; /// The `Frame` uniform of the prelude (`shader_pack_prelude.wgsl`). #[repr(C)] @@ -27,10 +30,29 @@ pub struct FrameUniform { pub dimension: [f32; 4], } +/// The API 2 `FrameExt` uniform of the prelude (`shader_pack_prelude.wgsl`). +#[repr(C)] +#[derive(Clone, Copy, Default, bytemuck::Pod, bytemuck::Zeroable)] +pub struct FrameExtUniform { + pub previous_view: [[f32; 4]; 4], + pub previous_projection: [[f32; 4]; 4], + pub shadow_view: [[f32; 4]; 4], + pub shadow_projection: [[f32; 4]; 4], + pub shadow_inverse_view: [[f32; 4]; 4], + pub shadow_inverse_projection: [[f32; 4]; 4], + pub previous_camera: [f32; 4], + pub shadow_params: [f32; 4], + pub environment: [f32; 4], +} + +const NOISE_SIZE: u32 = 256; + struct Pass { pipeline: wgpu::RenderPipeline, scale: f32, + target_format: wgpu::TextureFormat, uniform: wgpu::Buffer, + uniform_ext: wgpu::Buffer, } /// A stage's output and the bindings that read the world into it. struct Target { @@ -41,24 +63,43 @@ struct Target { pub struct PackStages { pub id: String, + pub needs_shadow: bool, + pub shadow_res: u32, + pub shadow_dist: f32, layout: wgpu::BindGroupLayout, linear: wgpu::Sampler, nearest: wgpu::Sampler, + repeat: wgpu::Sampler, + shadow_sampler: wgpu::Sampler, + noise_view: wgpu::TextureView, passes: Vec<Pass>, - format: wgpu::TextureFormat, /// Built for this world target size. targets: Vec<Target>, /// `world_post`'s bindings of the last stage's output. output: Option<wgpu::BindGroup>, world_size: [u32; 2], + shadow_size: u32, started: std::time::Instant, + last: Option<std::time::Instant>, frames: u32, + previous: Option<([[f32; 4]; 4], [[f32; 4]; 4], [f32; 3])>, + wetness: SmoothFloat, +} + +fn stage_format(name: Option<&str>, default: wgpu::TextureFormat) -> wgpu::TextureFormat { + match name.map(str::to_lowercase).as_deref() { + Some("rgba16float" | "rgba16f") => wgpu::TextureFormat::Rgba16Float, + Some("rgba8unorm" | "rgba8" | "rgba") => wgpu::TextureFormat::Rgba8Unorm, + Some("rgb10a2unorm" | "rgb10_a2") => wgpu::TextureFormat::Rgb10a2Unorm, + _ => default, + } } impl PackStages { /// The pipelines of a loaded (already validated) pack, or wgpu's error. pub fn new( device: &wgpu::Device, + queue: &wgpu::Queue, format: wgpu::TextureFormat, pack: &ShaderPack, ) -> Result<Self, String> { @@ -79,6 +120,16 @@ impl PackStages { ty: wgpu::BindingType::Sampler(ty), count: None, }; + let uniform_entry = |binding| wgpu::BindGroupLayoutEntry { + binding, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Uniform, + has_dynamic_offset: false, + min_binding_size: None, + }, + count: None, + }; let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some("Shader pack stage"), entries: &[ @@ -87,16 +138,15 @@ impl PackStages { texture(2, float), sampler(3, wgpu::SamplerBindingType::Filtering), sampler(4, wgpu::SamplerBindingType::NonFiltering), - wgpu::BindGroupLayoutEntry { - binding: 5, - visibility: wgpu::ShaderStages::FRAGMENT, - ty: wgpu::BindingType::Buffer { - ty: wgpu::BufferBindingType::Uniform, - has_dynamic_offset: false, - min_binding_size: None, - }, - count: None, - }, + uniform_entry(5), + uniform_entry(6), + texture(7, float), + texture(8, float), + texture(9, wgpu::TextureSampleType::Depth), + texture(10, wgpu::TextureSampleType::Depth), + sampler(11, wgpu::SamplerBindingType::Comparison), + texture(12, float), + sampler(13, wgpu::SamplerBindingType::Filtering), ], }); let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { @@ -106,10 +156,18 @@ impl PackStages { }); let constants = pack.constants(); let scope = device.push_error_scope(wgpu::ErrorFilter::Validation); + let stage_count = pack.stages.len(); let passes = pack .stages .iter() - .map(|stage| { + .enumerate() + .map(|(idx, stage)| { + let is_last = idx + 1 == stage_count || stage.kind == StageKind::Final; + let target_format = if is_last { + format + } else { + stage_format(stage.format.as_deref(), format) + }; let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some(&stage.file), source: wgpu::ShaderSource::Wgsl(stage.source.as_str().into()), @@ -140,7 +198,7 @@ impl PackStages { ..Default::default() }, targets: &[Some(wgpu::ColorTargetState { - format, + format: target_format, blend: None, write_mask: wgpu::ColorWrites::ALL, })], @@ -151,38 +209,110 @@ impl PackStages { Pass { pipeline, scale: stage.scale, + target_format, uniform: device.create_buffer(&wgpu::BufferDescriptor { label: Some("Shader pack frame"), size: std::mem::size_of::<FrameUniform>() as u64, usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }), + uniform_ext: device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Shader pack frame ext"), + size: std::mem::size_of::<FrameExtUniform>() as u64, + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }), } }) .collect(); if let Some(error) = pollster::block_on(scope.pop()) { return Err(error.to_string()); } - let sampler = |filter| { + let make_sampler = |filter, address, compare| { device.create_sampler(&wgpu::SamplerDescriptor { label: Some("Shader pack"), + address_mode_u: address, + address_mode_v: address, + address_mode_w: address, mag_filter: filter, min_filter: filter, + compare, ..Default::default() }) }; + let (nw, nh, noise_bytes) = match &pack.custom_noise { + Some((w, h, bytes)) => (*w, *h, bytes.clone()), + None => { + let mut seed = 0x2545_f491_u32; + let bytes: Vec<u8> = (0..NOISE_SIZE * NOISE_SIZE * 4) + .map(|i| { + seed ^= seed << 13; + seed ^= seed >> 17; + seed ^= seed << 5; + if i % 4 == 3 { 255 } else { (seed >> 24) as u8 } + }) + .collect(); + (NOISE_SIZE, NOISE_SIZE, bytes) + } + }; + let noise_tex = device.create_texture(&wgpu::TextureDescriptor { + label: Some("Shader pack noise"), + size: wgpu::Extent3d { + width: nw, + height: nh, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, + view_formats: &[], + }); + queue.write_texture( + noise_tex.as_image_copy(), + &noise_bytes, + wgpu::TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(nw * 4), + rows_per_image: None, + }, + noise_tex.size(), + ); + let (shadow_res, shadow_dist, _) = pack.shadow_config(0); Ok(Self { id: pack.id.clone(), + needs_shadow: pack.needs_shadow(), + shadow_res, + shadow_dist, layout, - linear: sampler(wgpu::FilterMode::Linear), - nearest: sampler(wgpu::FilterMode::Nearest), + linear: make_sampler( + wgpu::FilterMode::Linear, + wgpu::AddressMode::ClampToEdge, + None, + ), + nearest: make_sampler( + wgpu::FilterMode::Nearest, + wgpu::AddressMode::ClampToEdge, + None, + ), + repeat: make_sampler(wgpu::FilterMode::Linear, wgpu::AddressMode::Repeat, None), + shadow_sampler: make_sampler( + wgpu::FilterMode::Linear, + wgpu::AddressMode::ClampToEdge, + Some(wgpu::CompareFunction::GreaterEqual), + ), + noise_view: noise_tex.create_view(&Default::default()), passes, - format, targets: Vec::new(), output: None, world_size: [0, 0], + shadow_size: 0, started: std::time::Instant::now(), + last: None, frames: 0, + previous: None, + wetness: SmoothFloat::default(), }) } @@ -199,9 +329,14 @@ impl PackStages { size: [u32; 2], post: &super::world_post::Post, mut uniform: FrameUniform, + eye_light: [u8; 2], ) -> &wgpu::BindGroup { - if self.world_size != size || self.targets.len() != self.passes.len() { + if self.world_size != size + || self.shadow_size != post.shadow_resolution + || self.targets.len() != self.passes.len() + { self.world_size = size; + self.shadow_size = post.shadow_resolution; self.targets.clear(); for pass in &self.passes { let target_size = size.map(|v| ((v as f32 * pass.scale).round() as u32).max(1)); @@ -216,7 +351,7 @@ impl PackStages { mip_level_count: 1, sample_count: 1, dimension: wgpu::TextureDimension::D2, - format: self.format, + format: pass.target_format, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, view_formats: &[], @@ -251,6 +386,38 @@ impl PackStages { binding: 5, resource: pass.uniform.as_entire_binding(), }, + wgpu::BindGroupEntry { + binding: 6, + resource: pass.uniform_ext.as_entire_binding(), + }, + wgpu::BindGroupEntry { + binding: 7, + resource: wgpu::BindingResource::TextureView(post.normal()), + }, + wgpu::BindGroupEntry { + binding: 8, + resource: wgpu::BindingResource::TextureView(post.material()), + }, + wgpu::BindGroupEntry { + binding: 9, + resource: wgpu::BindingResource::TextureView(post.opaque_depth()), + }, + wgpu::BindGroupEntry { + binding: 10, + resource: wgpu::BindingResource::TextureView(post.shadow_depth()), + }, + wgpu::BindGroupEntry { + binding: 11, + resource: wgpu::BindingResource::Sampler(&self.shadow_sampler), + }, + wgpu::BindGroupEntry { + binding: 12, + resource: wgpu::BindingResource::TextureView(&self.noise_view), + }, + wgpu::BindGroupEntry { + binding: 13, + resource: wgpu::BindingResource::Sampler(&self.repeat), + }, ], }); self.targets.push(Target { @@ -262,6 +429,42 @@ impl PackStages { let last = &self.targets.last().expect("a pack has a stage").view; self.output = Some(post.bind(device, last)); } + let now = std::time::Instant::now(); + let dt = self.last.map_or(0.0, |t| (now - t).as_secs_f32()); + self.last = Some(now); + let wet = self.wetness.update(uniform.weather[0], 60.0, 120.0, dt); + let cam = [ + uniform.camera_position[0], + uniform.camera_position[1], + uniform.camera_position[2], + ]; + let (prev_view, prev_proj, prev_cam) = + self.previous + .unwrap_or((uniform.view, uniform.projection, cam)); + self.previous = Some((uniform.view, uniform.projection, cam)); + let shadow_view = post.shadow_view; + let shadow_proj = post.shadow_proj; + let ext = FrameExtUniform { + previous_view: prev_view, + previous_projection: prev_proj, + shadow_view: shadow_view.to_cols_array_2d(), + shadow_projection: shadow_proj.to_cols_array_2d(), + shadow_inverse_view: shadow_view.inverse().to_cols_array_2d(), + shadow_inverse_projection: shadow_proj.inverse().to_cols_array_2d(), + previous_camera: [prev_cam[0], prev_cam[1], prev_cam[2], dt], + shadow_params: [ + post.shadow_resolution as f32, + post.shadow_distance, + 0.0, + if post.shadow_active { 1.0 } else { 0.0 }, + ], + environment: [ + f32::from(eye_light[0]) * 16.0, + f32::from(eye_light[1]) * 16.0, + wet, + uniform.view_params[2] * 0.5, + ], + }; uniform.time[0] = self.started.elapsed().as_secs_f32(); uniform.time[1] = self.frames as f32; self.frames = self.frames.wrapping_add(1); @@ -269,6 +472,7 @@ impl PackStages { let [w, h] = target.size.map(|v| v as f32); uniform.resolution = [w, h, 1.0 / w, 1.0 / h]; queue.write_buffer(&pass.uniform, 0, bytemuck::bytes_of(&uniform)); + queue.write_buffer(&pass.uniform_ext, 0, bytemuck::bytes_of(&ext)); let attachments = [Some(wgpu::RenderPassColorAttachment { view: &target.view, resolve_target: None, diff --git a/crates/horizon-client/src/gfx/world_post.rs b/crates/horizon-client/src/gfx/world_post.rs index 797ee03b7..69d95aae6 100644 --- a/crates/horizon-client/src/gfx/world_post.rs +++ b/crates/horizon-client/src/gfx/world_post.rs @@ -1,26 +1,148 @@ -//! Resolution scale and FXAA (Horizon settings): the world renders into its -//! own target at the scaled size, then one full-screen pass copies or -//! anti-aliases it onto the screen, under the hand and HUD. A shader pack -//! also needs the target (its stages read the world's colour and depth). +//! Resolution scale, FXAA, and shader-pack G-buffer/shadow targets (Horizon +//! settings): the world renders into its own target at the scaled size, then +//! one full-screen pass copies or anti-aliases it onto the screen, under the +//! hand and HUD. When a shader pack is active, `Post` also maintains: +//! - `opaque_depth` (`depthtex1`/`depthtex2`): depth captured before +//! translucent terrain (water, stained glass, ice) renders; +//! - `normal` (`colortex1`/`scene_normal`) and `material` +//! (`colortex2`/`scene_material`): G-buffer surface normals and material +//! properties reconstructed from depth and scene colour; +//! - `shadow_depth` (`shadowtex0`/`shadowtex1`): the directional sun/moon +//! shadow map and its light-space `shadow_view` and `shadow_proj` matrices. +//! //! With none of them on, the world renders straight to the screen as before. +use super::pack_stages::FrameUniform; +use glam::{Mat4, Vec3, Vec4}; + +const GBUFFER_WGSL: &str = r#" +struct GbufferParams { + inverse_view: mat4x4<f32>, + inverse_projection: mat4x4<f32>, + resolution: vec4<f32>, + // x: eye block light (0..1), y: eye sky light (0..1), z: wetness (0..1), w: sun elevation + env: vec4<f32>, +} + +@group(0) @binding(0) var world_color: texture_2d<f32>; +@group(0) @binding(1) var world_depth: texture_depth_2d; +@group(0) @binding(2) var opaque_depth: texture_depth_2d; +@group(0) @binding(3) var nearest_sampler: sampler; +@group(0) @binding(4) var<uniform> params: GbufferParams; + +struct VsOut { + @builtin(position) clip: vec4<f32>, + @location(0) uv: vec2<f32>, +} + +@vertex +fn vs_gbuffer(@builtin(vertex_index) i: u32) -> VsOut { + let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u)); + var out: VsOut; + out.clip = vec4<f32>(p * 2.0 - 1.0, 0.0, 1.0); + out.uv = vec2<f32>(p.x, 1.0 - p.y); + return out; +} + +struct GbufferOut { + @location(0) normal: vec4<f32>, + @location(1) material: vec4<f32>, +} + +fn world_pos(uv: vec2<f32>, d: f32) -> vec3<f32> { + let v = params.inverse_projection * vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, d, 1.0); + let view = v.xyz / max(v.w, 1e-6); + return (params.inverse_view * vec4<f32>(view, 1.0)).xyz; +} + +@fragment +fn fs_gbuffer(in: VsOut) -> GbufferOut { + let d_all = textureSampleLevel(world_depth, nearest_sampler, in.uv, 0); + let d_opq = textureSampleLevel(opaque_depth, nearest_sampler, in.uv, 0); + let color = textureSampleLevel(world_color, nearest_sampler, in.uv, 0.0); + var out: GbufferOut; + if d_all <= 0.0 && d_opq <= 0.0 { + out.normal = vec4<f32>(0.5, 1.0, 0.5, 0.0); + out.material = vec4<f32>(0.0, params.env.y, 0.0, 1.0); + return out; + } + let d = select(d_all, d_opq, d_opq > 0.0); + let step_uv = params.resolution.zw; + let p0 = world_pos(in.uv, d); + let uv_r = clamp(in.uv + vec2<f32>(step_uv.x, 0.0), vec2<f32>(0.0), vec2<f32>(1.0)); + let uv_l = clamp(in.uv - vec2<f32>(step_uv.x, 0.0), vec2<f32>(0.0), vec2<f32>(1.0)); + let uv_d = clamp(in.uv + vec2<f32>(0.0, step_uv.y), vec2<f32>(0.0), vec2<f32>(1.0)); + let uv_u = clamp(in.uv - vec2<f32>(0.0, step_uv.y), vec2<f32>(0.0), vec2<f32>(1.0)); + let dr = textureSampleLevel(opaque_depth, nearest_sampler, uv_r, 0); + let dl = textureSampleLevel(opaque_depth, nearest_sampler, uv_l, 0); + let dd = textureSampleLevel(opaque_depth, nearest_sampler, uv_d, 0); + let du = textureSampleLevel(opaque_depth, nearest_sampler, uv_u, 0); + let dx = select(world_pos(uv_r, dr) - p0, p0 - world_pos(uv_l, dl), abs(dl - d) < abs(dr - d)); + let dy = select(world_pos(uv_d, dd) - p0, p0 - world_pos(uv_u, du), abs(du - d) < abs(dd - d)); + let raw_n = cross(dy, dx); + let n_len = length(raw_n); + let n = select(vec3<f32>(0.0, 1.0, 0.0), raw_n / max(n_len, 1e-6), n_len > 1e-6); + // Reversed depth: closer translucent geometry has larger depth than opaque geometry. + let is_translucent = select(0.0, 1.0, d_all > d_opq + 1e-5); + let luma = dot(color.rgb, vec3<f32>(0.2126, 0.7152, 0.0722)); + let block_light = clamp(max(params.env.x, smoothstep(0.65, 0.98, luma)), 0.0, 1.0); + let roughness = select(clamp(0.85 - params.env.z * 0.45, 0.1, 1.0), 0.05, is_translucent > 0.5); + out.normal = vec4<f32>(n * 0.5 + 0.5, 1.0); + out.material = vec4<f32>(block_light, params.env.y, is_translucent, roughness); + return out; +} +"#; + +#[repr(C)] +#[derive(Clone, Copy, Default, bytemuck::Pod, bytemuck::Zeroable)] +struct GbufferUniform { + inverse_view: [[f32; 4]; 4], + inverse_projection: [[f32; 4]; 4], + resolution: [f32; 4], + env: [f32; 4], +} + struct WorldTarget { size: [u32; 2], color: wgpu::TextureView, + depth_tex: wgpu::Texture, depth: wgpu::TextureView, + opaque_depth_tex: wgpu::Texture, + opaque_depth: wgpu::TextureView, + normal: wgpu::TextureView, + material: wgpu::TextureView, + gbuffer_group: wgpu::BindGroup, group: wgpu::BindGroup, + opaque_captured: bool, +} + +struct ShadowTarget { + resolution: u32, + depth: wgpu::TextureView, } pub struct Post { layout: wgpu::BindGroupLayout, sampler: wgpu::Sampler, + nearest: wgpu::Sampler, copy: wgpu::RenderPipeline, fxaa: wgpu::RenderPipeline, + gbuffer_layout: wgpu::BindGroupLayout, + gbuffer_pipeline: wgpu::RenderPipeline, + gbuffer_uniform: wgpu::Buffer, format: wgpu::TextureFormat, /// World resolution relative to the window (0.5..=2.0). pub scale: f32, pub antialias: bool, target: Option<WorldTarget>, + shadow: Option<ShadowTarget>, + fallback_shadow: wgpu::TextureView, + fallback_color: wgpu::TextureView, + pub shadow_view: Mat4, + pub shadow_proj: Mat4, + pub shadow_distance: f32, + pub shadow_resolution: u32, + pub shadow_active: bool, } impl Post { @@ -88,17 +210,169 @@ impl Post { min_filter: wgpu::FilterMode::Linear, ..Default::default() }); + let nearest = device.create_sampler(&wgpu::SamplerDescriptor { + label: Some("Horizon post nearest"), + mag_filter: wgpu::FilterMode::Nearest, + min_filter: wgpu::FilterMode::Nearest, + ..Default::default() + }); + + let gbuffer_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some("Horizon gbuffer"), + source: wgpu::ShaderSource::Wgsl(GBUFFER_WGSL.into()), + }); + let gbuffer_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + label: Some("Horizon gbuffer layout"), + entries: &[ + wgpu::BindGroupLayoutEntry { + binding: 0, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Float { filterable: true }, + view_dimension: wgpu::TextureViewDimension::D2, + multisampled: false, + }, + count: None, + }, + wgpu::BindGroupLayoutEntry { + binding: 1, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Depth, + view_dimension: wgpu::TextureViewDimension::D2, + multisampled: false, + }, + count: None, + }, + wgpu::BindGroupLayoutEntry { + binding: 2, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Depth, + view_dimension: wgpu::TextureViewDimension::D2, + multisampled: false, + }, + count: None, + }, + wgpu::BindGroupLayoutEntry { + binding: 3, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::NonFiltering), + count: None, + }, + wgpu::BindGroupLayoutEntry { + binding: 4, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Uniform, + has_dynamic_offset: false, + min_binding_size: None, + }, + count: None, + }, + ], + }); + let gbuffer_pipe_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { + label: Some("Horizon gbuffer"), + bind_group_layouts: &[Some(&gbuffer_layout)], + ..Default::default() + }); + let gbuffer_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Horizon gbuffer"), + layout: Some(&gbuffer_pipe_layout), + vertex: wgpu::VertexState { + module: &gbuffer_shader, + entry_point: Some("vs_gbuffer"), + compilation_options: Default::default(), + buffers: &[], + }, + primitive: Default::default(), + depth_stencil: None, + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module: &gbuffer_shader, + entry_point: Some("fs_gbuffer"), + compilation_options: Default::default(), + targets: &[ + Some(wgpu::ColorTargetState { + format: wgpu::TextureFormat::Rgba8Unorm, + blend: None, + write_mask: wgpu::ColorWrites::ALL, + }), + Some(wgpu::ColorTargetState { + format: wgpu::TextureFormat::Rgba8Unorm, + blend: None, + write_mask: wgpu::ColorWrites::ALL, + }), + ], + }), + multiview_mask: None, + cache: None, + }); + let gbuffer_uniform = device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Horizon gbuffer uniform"), + size: std::mem::size_of::<GbufferUniform>() as u64, + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let fallback_shadow = device + .create_texture(&wgpu::TextureDescriptor { + label: Some("Horizon fallback shadow"), + size: wgpu::Extent3d { + width: 1, + height: 1, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Depth32Float, + usage: wgpu::TextureUsages::RENDER_ATTACHMENT + | wgpu::TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }) + .create_view(&Default::default()); + let fallback_color = device + .create_texture(&wgpu::TextureDescriptor { + label: Some("Horizon fallback gbuffer"), + size: wgpu::Extent3d { + width: 1, + height: 1, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::RENDER_ATTACHMENT + | wgpu::TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }) + .create_view(&Default::default()); Self { copy: pipeline("fs_copy"), fxaa: pipeline("fs_fxaa"), layout, sampler, + nearest, + gbuffer_layout, + gbuffer_pipeline, + gbuffer_uniform, format, scale: 1.0, antialias: false, target: None, + shadow: None, + fallback_shadow, + fallback_color, + shadow_view: Mat4::IDENTITY, + shadow_proj: Mat4::IDENTITY, + shadow_distance: 128.0, + shadow_resolution: 2048, + shadow_active: false, } } + /// The world's colour and depth targets this frame, or `None` to draw /// it straight to the screen. `pack`: a shader pack runs this frame. pub fn prepare( @@ -109,6 +383,7 @@ impl Post { ) -> Option<(wgpu::TextureView, wgpu::TextureView)> { if self.scale == 1.0 && !self.antialias && !pack { self.target = None; + self.shadow_active = false; return None; } let size = window.map(|v| ((v as f32 * self.scale).round() as u32).clamp(1, 8192)); @@ -118,46 +393,284 @@ impl Post { height: size[1], depth_or_array_layers: 1, }; - let texture = |label, format, usage| { - device - .create_texture(&wgpu::TextureDescriptor { - label: Some(label), - size: extent, - mip_level_count: 1, - sample_count: 1, - dimension: wgpu::TextureDimension::D2, - format, - usage, - view_formats: &[], - }) - .create_view(&Default::default()) + let make_tex = |label, format, usage| { + device.create_texture(&wgpu::TextureDescriptor { + label: Some(label), + size: extent, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format, + usage, + view_formats: &[], + }) }; - let color = texture( + let color = make_tex( "Scaled world", self.format, wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, - ); - let depth = texture( + ) + .create_view(&Default::default()); + let depth_tex = make_tex( "Scaled world depth", wgpu::TextureFormat::Depth32Float, - wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, + wgpu::TextureUsages::RENDER_ATTACHMENT + | wgpu::TextureUsages::TEXTURE_BINDING + | wgpu::TextureUsages::COPY_SRC, ); + let depth = depth_tex.create_view(&Default::default()); + let opaque_depth_tex = make_tex( + "Opaque world depth", + wgpu::TextureFormat::Depth32Float, + wgpu::TextureUsages::RENDER_ATTACHMENT + | wgpu::TextureUsages::TEXTURE_BINDING + | wgpu::TextureUsages::COPY_DST, + ); + let opaque_depth = opaque_depth_tex.create_view(&Default::default()); + let normal = make_tex( + "World G-buffer normal", + wgpu::TextureFormat::Rgba8Unorm, + wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, + ) + .create_view(&Default::default()); + let material = make_tex( + "World G-buffer material", + wgpu::TextureFormat::Rgba8Unorm, + wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, + ) + .create_view(&Default::default()); + let gbuffer_group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("Horizon gbuffer"), + layout: &self.gbuffer_layout, + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: wgpu::BindingResource::TextureView(&color), + }, + wgpu::BindGroupEntry { + binding: 1, + resource: wgpu::BindingResource::TextureView(&depth), + }, + wgpu::BindGroupEntry { + binding: 2, + resource: wgpu::BindingResource::TextureView(&opaque_depth), + }, + wgpu::BindGroupEntry { + binding: 3, + resource: wgpu::BindingResource::Sampler(&self.nearest), + }, + wgpu::BindGroupEntry { + binding: 4, + resource: self.gbuffer_uniform.as_entire_binding(), + }, + ], + }); let group = self.bind(device, &color); self.target = Some(WorldTarget { size, color, + depth_tex, depth, + opaque_depth_tex, + opaque_depth, + normal, + material, + gbuffer_group, group, + opaque_captured: false, }); } + if let Some(t) = &mut self.target { + t.opaque_captured = false; + } self.target .as_ref() .map(|t| (t.color.clone(), t.depth.clone())) } + + /// Prepare the directional sun/moon shadow map target and compute its + /// camera-relative orthographic `shadow_view` and `shadow_proj` matrices. + pub fn prepare_shadow( + &mut self, + device: &wgpu::Device, + resolution: u32, + distance: f32, + sun_dir: Vec3, + moon_dir: Vec3, + ) -> &wgpu::TextureView { + let resolution = resolution.clamp(256, 4096); + let distance = distance.clamp(16.0, 512.0); + if self + .shadow + .as_ref() + .is_none_or(|s| s.resolution != resolution) + { + let depth = device + .create_texture(&wgpu::TextureDescriptor { + label: Some("Horizon shadow map"), + size: wgpu::Extent3d { + width: resolution, + height: resolution, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Depth32Float, + usage: wgpu::TextureUsages::RENDER_ATTACHMENT + | wgpu::TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }) + .create_view(&Default::default()); + self.shadow = Some(ShadowTarget { resolution, depth }); + } + let light_dir = if sun_dir.y >= -0.05 { + sun_dir.normalize_or_zero() + } else { + moon_dir.normalize_or_zero() + }; + let dir = if light_dir.length_squared() > 1e-4 { + light_dir + } else { + Vec3::Y + }; + let up = if dir.y.abs() > 0.99 { Vec3::Z } else { Vec3::Y }; + self.shadow_view = Mat4::look_at_rh(dir * distance, Vec3::ZERO, up); + // Reversed-depth orthographic projection for the world's GreaterEqual + // pipelines (near maps to 1.0, far maps to 0.0), and standard 0..1 + // projection for shader sampling. + self.shadow_proj = Mat4::orthographic_rh( + -distance, + distance, + -distance, + distance, + distance * 2.5, + 0.05, + ); + self.shadow_distance = distance; + self.shadow_resolution = resolution; + self.shadow_active = true; + &self.shadow.as_ref().expect("created above").depth + } + + /// Snapshot `world_depth` into `opaque_depth` (`depthtex1`/`depthtex2`) + /// right before translucent water and weather draw. + pub fn capture_opaque_depth(&mut self, encoder: &mut wgpu::CommandEncoder) { + let Some(t) = &mut self.target else { return }; + encoder.copy_texture_to_texture( + t.depth_tex.as_image_copy(), + t.opaque_depth_tex.as_image_copy(), + t.depth_tex.size(), + ); + t.opaque_captured = true; + } + + /// Reconstruct the G-buffer `normal` and `material` textures after the + /// world pass finishes. + pub fn build_gbuffer( + &mut self, + queue: &wgpu::Queue, + encoder: &mut wgpu::CommandEncoder, + frame: &FrameUniform, + eye_light: [u8; 2], + wetness: f32, + ) { + let Some(t) = &mut self.target else { return }; + if !t.opaque_captured { + encoder.copy_texture_to_texture( + t.depth_tex.as_image_copy(), + t.opaque_depth_tex.as_image_copy(), + t.depth_tex.size(), + ); + t.opaque_captured = true; + } + let [w, h] = t.size.map(|v| v.max(1) as f32); + let uniform = GbufferUniform { + inverse_view: frame.inverse_view, + inverse_projection: frame.inverse_projection, + resolution: [w, h, 1.0 / w, 1.0 / h], + env: [ + f32::from(eye_light[0]) / 15.0, + f32::from(eye_light[1]) / 15.0, + wetness, + frame.sun[1], + ], + }; + queue.write_buffer(&self.gbuffer_uniform, 0, bytemuck::bytes_of(&uniform)); + let attachments = [ + Some(wgpu::RenderPassColorAttachment { + view: &t.normal, + resolve_target: None, + depth_slice: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Clear(wgpu::Color::BLACK), + store: wgpu::StoreOp::Store, + }, + }), + Some(wgpu::RenderPassColorAttachment { + view: &t.material, + resolve_target: None, + depth_slice: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Clear(wgpu::Color::BLACK), + store: wgpu::StoreOp::Store, + }, + }), + ]; + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some("Horizon gbuffer"), + color_attachments: &attachments, + ..Default::default() + }); + pass.set_pipeline(&self.gbuffer_pipeline); + pass.set_bind_group(0, &t.gbuffer_group, &[]); + pass.draw(0..3, 0..1); + } + /// The world target's size, once `prepare` made one. pub fn size(&self) -> Option<[u32; 2]> { self.target.as_ref().map(|t| t.size) } + + /// Pre-translucent depth view (`depthtex1`/`depthtex2` / `opaque_depth`). + pub fn opaque_depth(&self) -> &wgpu::TextureView { + self.target + .as_ref() + .map_or(&self.fallback_shadow, |t| &t.opaque_depth) + } + + /// Reconstructed world-space normal G-buffer view (`colortex1` / `scene_normal`). + pub fn normal(&self) -> &wgpu::TextureView { + self.target + .as_ref() + .map_or(&self.fallback_color, |t| &t.normal) + } + + /// Reconstructed material/lightmap G-buffer view (`colortex2` / `scene_material`). + pub fn material(&self) -> &wgpu::TextureView { + self.target + .as_ref() + .map_or(&self.fallback_color, |t| &t.material) + } + + /// Directional sun/moon shadow map view (`shadowtex0`/`shadowtex1` / `shadow_depth`). + pub fn shadow_depth(&self) -> &wgpu::TextureView { + self.shadow + .as_ref() + .map_or(&self.fallback_shadow, |s| &s.depth) + } + + /// OpenGL-convention (-1..1 Z) shadow projection for Java/Iris shader packs. + pub fn gl_shadow_projection(&self) -> Mat4 { + let to_gl = Mat4::from_cols( + Vec4::X, + Vec4::Y, + Vec4::new(0.0, 0.0, -2.0, 0.0), + Vec4::new(0.0, 0.0, 1.0, 1.0), + ); + to_gl * self.shadow_proj + } + /// Bindings that copy (or anti-alias) `view` onto the screen in `finish_with`. pub fn bind(&self, device: &wgpu::Device, view: &wgpu::TextureView) -> wgpu::BindGroup { device.create_bind_group(&wgpu::BindGroupDescriptor { @@ -175,11 +688,13 @@ impl Post { ], }) } + /// Draw the scaled world onto `screen`. pub fn finish(&self, encoder: &mut wgpu::CommandEncoder, screen: &wgpu::TextureView) { let Some(target) = &self.target else { return }; self.finish_with(encoder, screen, &target.group); } + /// Draw what `group` binds (`bind`) onto `screen`. pub fn finish_with( &self, diff --git a/crates/horizon-client/src/graphics_ui.rs b/crates/horizon-client/src/graphics_ui.rs index 514e64a88..fe797af3e 100644 --- a/crates/horizon-client/src/graphics_ui.rs +++ b/crates/horizon-client/src/graphics_ui.rs @@ -112,13 +112,18 @@ pub fn rows(level: Level) -> Vec<Row> { "Waits for the display's refresh: no tearing, a little latency.", ); let gui = v(Opt::GuiScale, None, "Size of menus and the HUD."); + let shader_pack = h( + H::ShaderPack, + High, + "Redraws the world with a pack from the shaderpacks folder. Off is vanilla.", + ); let preset = h( H::Preset, None, "Sets the options below together. Changing one makes it Custom.", ); let mut rows = match level { - Level::Simple => vec![preset, render, lod, far, fov, fps, vsync, gui], + Level::Simple => vec![preset, render, lod, far, fov, fps, vsync, gui, shader_pack], Level::Advanced => vec![ Row::Header("Rendering"), render, @@ -246,11 +251,7 @@ pub fn rows(level: Level) -> Vec<Row> { None, "Lowers the frame rate when minimised, or idle too.", ), - h( - H::ShaderPack, - High, - "Redraws the world with a pack from the shaderpacks folder. Off is vanilla.", - ), + shader_pack, Row::Header("Preferences"), v(Opt::ViewBobbing, None, "Sways the view while walking."), v(Opt::ChunkFade, None, "Fades newly loaded chunks in."), diff --git a/crates/horizon-client/src/java_pack.rs b/crates/horizon-client/src/java_pack.rs index a5bc2904e..5a37aa223 100644 --- a/crates/horizon-client/src/java_pack.rs +++ b/crates/horizon-client/src/java_pack.rs @@ -1,9 +1,9 @@ //! Java (OptiFine/Iris) shader packs in `shaderpacks/` (docs/shader-packs.md): //! a folder holding `shaders/`, or a `.zip`. `horizon-shaderpack` translates //! their full-screen programs (`begin`, `prepare`, `deferred`, `composite`, -//! `final`) to WGSL, and `gfx/java_stages.rs` runs them over Horizon's world -//! as Iris runs them over its own. Geometry programs (`gbuffers_*`, -//! `shadow`) don't run yet: the world is drawn by Horizon. +//! `final`) to WGSL, and `gfx/java_stages.rs` runs them over Horizon's world, +//! G-buffers, pre-translucent depth (`depthtex1`) and directional shadow map +//! (`shadowtex0`/`shadowtex1`) as Iris runs them over its own. use horizon_shaderpack::{ JavaPack, pipeline::{Directives, Program, TargetSettings}, @@ -30,8 +30,10 @@ pub struct JavaFolder { pub final_pass: Option<Program>, /// The targets whose alternate side holds the frame's last write. pub flipped_at_end: BTreeSet<u32>, - /// `sunPathRotation` and `eyeBrightnessHalflife`. + /// `sunPathRotation`, `eyeBrightnessHalflife`, shadow and wetness directives. pub directives: Directives, + /// Whether this dimension's passes read directional shadow maps. + pub shadow_enabled: bool, } /// A loaded Java pack. @@ -41,6 +43,8 @@ pub struct JavaPasses { pub uniforms: CustomUniforms, /// What the pack keeps of the vanilla sky (`clouds`, `sun`, `moon`). pub sky: SkyDirectives, + /// Decoded RGBA8 custom textures (`sampler_name` → `(width, height, rgba)`). + pub custom_textures: BTreeMap<String, (u32, u32, Vec<u8>)>, } impl JavaPasses { @@ -131,11 +135,25 @@ pub fn load( final_pass, flipped_at_end: plan.flipped_at_end, directives: plan.directives, + shadow_enabled: plan.shadow_enabled, }); } if folders.is_empty() { return Err("no deferred, composite or final programs".into()); } + let mut custom_textures = BTreeMap::new(); + for tex in properties.custom_textures() { + if let Some(bytes) = pack.files.read_bytes(&tex.path) { + match crate::shader_pack::decode_png_rgba(&bytes) { + Ok(decoded) => { + custom_textures.insert(tex.sampler, decoded); + } + Err(e) => { + log::warn!("Horizon: shader pack texture {}: {e}", tex.path); + } + } + } + } let uniforms = properties.custom_uniforms(); for problem in &uniforms.problems { log::warn!("Horizon: shader pack custom uniform {problem}"); @@ -144,6 +162,7 @@ pub fn load( folders, uniforms, sky: properties.sky(), + custom_textures, }) } diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 7937958ea..4ae78da40 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -864,6 +864,8 @@ pub enum Page { Mods, /// The shader packs in `shaderpacks/`: pick one, open the folder. ShaderPacks, + /// Interactive options and profiles for the active shader pack. + ShaderPackOptions, /// Horizon's graphics settings (`graphics_ui`). Graphics, GraphicsAdvanced, @@ -901,6 +903,13 @@ enum Act { /// Credits & Attribution's Credits button (WinScreen without the poem). Credits, CopyAgentDetails, + /// Pick and import a shader pack `.zip` or folder into `shaderpacks/`. + ImportShaderPack, + ShaderPackProfile, + ShaderPackSubscreen(String), + ShaderPackBackScreen, + ShaderPackOption(usize), + ResetShaderPackOptions, } enum WKind { Button { @@ -913,6 +922,11 @@ enum WKind { value: f32, opt: Opt, }, + ShaderOptionSlider { + label: Text, + value: f32, + index: usize, + }, Text { text: Text, color: u32, @@ -954,6 +968,10 @@ pub enum Event { Credits, /// Copy how an agent connects (the AI Agent page). CopyAgentDetails, + /// Pick and import a shader pack `.zip` or folder into `shaderpacks/`. + ImportShaderPack, + /// Reload the active shader pack after its options file changed. + ReloadShaderPack, } /// `SliderableValueSet.applyValueImmediately`: these apply 600 ms after /// the last change (`OptionInstanceSliderButton.delayedApplyAt`). @@ -1011,6 +1029,12 @@ pub struct OptionsUi { pub shader_pack_error: Option<(String, String)>, /// The AI Agent page's status lines (set by the game while it shows). pub agent_status: Vec<String>, + /// Loaded interactive configuration for the currently selected shader pack. + pub shader_pack_config: Option<crate::shader_pack::PackConfig>, + /// Classic shader option slider currently being dragged. + pub(crate) dragging_shader_option: Option<usize>, + /// Horizon shader option slider currently being dragged. + pub(crate) hdragging_shader_option: Option<usize>, } impl Default for OptionsUi { fn default() -> Self { @@ -1042,6 +1066,9 @@ impl Default for OptionsUi { shader_packs: Default::default(), shader_pack_error: None, agent_status: Vec::new(), + shader_pack_config: None, + dragging_shader_option: None, + hdragging_shader_option: None, } } } @@ -1172,7 +1199,7 @@ impl OptionsUi { } /// Pick shader pack `i` of the folder, or turn it off when it is the /// one running. - pub(crate) fn toggle_shader_pack(&self, s: &mut Settings, i: usize) { + pub(crate) fn toggle_shader_pack(&mut self, s: &mut Settings, i: usize) { let Some((id, Ok(_))) = self.shader_packs.packs.get(i) else { return; }; @@ -1182,6 +1209,39 @@ impl OptionsUi { } else { id.clone() }; + self.sync_shader_pack_config(s); + } + /// Ensure `shader_pack_config` matches `s.horizon.shader_pack`. + pub fn sync_shader_pack_config(&mut self, s: &Settings) { + let id = s.horizon.shader_pack.as_str(); + if id.is_empty() { + self.shader_pack_config = None; + return; + } + if self + .shader_pack_config + .as_ref() + .is_some_and(|cfg| cfg.id == id) + { + return; + } + let dir = if self.shader_packs.dir.as_os_str().is_empty() { + crate::shader_pack::folder() + } else { + self.shader_packs.dir.clone() + }; + self.shader_pack_config = crate::shader_pack::PackConfig::load(&dir, id).ok(); + } + /// Save the active shader pack options to `shaderpacks/<id>.txt`. + pub(crate) fn save_shader_pack_config(&self) { + if let Some(cfg) = &self.shader_pack_config { + let dir = if self.shader_packs.dir.as_os_str().is_empty() { + crate::shader_pack::folder() + } else { + self.shader_packs.dir.clone() + }; + let _ = cfg.save(&dir); + } } pub(crate) fn shader_pack_failed(&self, id: &str) -> bool { self.shader_pack_error @@ -1215,6 +1275,7 @@ impl OptionsUi { Page::Packs => "resourcePack.title", Page::Mods => "Mods", Page::ShaderPacks => "Shader Packs", + Page::ShaderPackOptions => "Shader Pack Settings", Page::Graphics | Page::GraphicsAdvanced => "options.videoTitle", Page::Controller => "Controller Settings", Page::PadBinds => "Controller Binds", @@ -1587,6 +1648,121 @@ impl OptionsUi { None, )); } + let has_settings = !s.horizon.shader_pack.is_empty() + && self.shader_pack_config.as_ref().is_some_and(|c| { + c.id == s.horizon.shader_pack + && (!c.options.is_empty() || !c.profiles.is_empty()) + }); + if has_settings { + rows.push(Row::Buttons( + button( + 0.0, + 0.0, + 150.0, + Text::literal("Shader Pack Settings..."), + Act::Push(Page::ShaderPackOptions), + ), + Some(button( + 0.0, + 0.0, + 150.0, + Text::literal("Import Shader Pack..."), + Act::ImportShaderPack, + )), + )); + } else { + rows.push(Row::Buttons( + button( + 0.0, + 0.0, + 310.0, + Text::literal("Import Shader Pack..."), + Act::ImportShaderPack, + ), + None, + )); + } + rows + } + Page::ShaderPackOptions => { + let Some(cfg) = &self.shader_pack_config else { + return vec![Row::Header("No configurable options for this shader pack")]; + }; + let screen = cfg.current_screen(); + let mut rows = vec![Row::Note(format!("{} — {}", cfg.id, screen.label))]; + if cfg.active_screen.is_some() { + rows.push(Row::Buttons( + button( + 0.0, + 0.0, + 310.0, + Text::literal("Back to Main Screen"), + Act::ShaderPackBackScreen, + ), + None, + )); + } + let mut widgets = Vec::new(); + for item in &screen.items { + match item { + crate::shader_pack::ScreenItem::Empty => {} + crate::shader_pack::ScreenItem::Profile => { + let label = + Text::literal(format!("Profile: {}", cfg.active_profile_label())); + widgets.push(button(0.0, 0.0, 150.0, label, Act::ShaderPackProfile)); + } + crate::shader_pack::ScreenItem::Subscreen(sub, title) => { + let label = Text::literal(format!("{title}...")); + widgets.push(button( + 0.0, + 0.0, + 150.0, + label, + Act::ShaderPackSubscreen(sub.clone()), + )); + } + crate::shader_pack::ScreenItem::Option(idx) => { + if let Some(opt) = cfg.options.get(*idx) { + let label = Text::literal(format!( + "{}: {}", + opt.label, + opt.display_value() + )); + if let Some(value) = opt.slider_pos() { + widgets.push(Widget { + x: 0.0, + y: 0.0, + w: 150.0, + h: 20.0, + kind: WKind::ShaderOptionSlider { + label, + value, + index: *idx, + }, + list: false, + }); + } else { + widgets.push(button( + 0.0, + 0.0, + 150.0, + label, + Act::ShaderPackOption(*idx), + )); + } + } + } + } + } + let mut iter = widgets.into_iter(); + while let Some(mut first) = iter.next() { + if let Some(second) = iter.next() { + rows.push(Row::Buttons(first, Some(second))); + } else { + first.w = 310.0; + rows.push(Row::Buttons(first, None)); + } + } rows } _ => { @@ -1599,6 +1775,9 @@ impl OptionsUi { fn layout(&mut self, s: &Settings, w: f32, h: f32) -> (Vec<Widget>, f32, f32, f32) { let mut out = Vec::new(); let page = self.page(); + if matches!(page, Page::ShaderPacks | Page::ShaderPackOptions) { + self.sync_shader_pack_config(s); + } let cx = (w / 2.0).floor(); if matches!(page, Page::Video | Page::Controls | Page::KeyBinds) { self.settings_search.x = cx - 100.0; @@ -2079,6 +2258,9 @@ impl OptionsUi { Page::ShaderPacks => { Some(("Open Shader Pack Folder", Act::OpenShaderPackFolder)) } + Page::ShaderPackOptions => { + Some(("Reset to Defaults", Act::ResetShaderPackOptions)) + } _ => None, }; if let Some((label, act)) = folder { @@ -2248,6 +2430,16 @@ impl OptionsUi { 170.0, )); } + if let WKind::Button { + act: Act::ShaderPackOption(i), + .. + } = &wd.kind + && let Some(cfg) = &self.shader_pack_config + && let Some(opt) = cfg.options.get(*i) + && !opt.description.is_empty() + { + tooltip = Some(atlas.font.split(&Text::literal(&opt.description), 170.0)); + } } match &wd.kind { WKind::Button { label, active, act } => { @@ -2288,6 +2480,31 @@ impl OptionsUi { true, ); } + WKind::ShaderOptionSlider { + label, + value, + index, + } => { + let dragging = self.dragging_shader_option == Some(*index); + if hover + && let Some(cfg) = &self.shader_pack_config + && let Some(opt) = cfg.options.get(*index) + && !opt.description.is_empty() + { + tooltip = Some(atlas.font.split(&Text::literal(&opt.description), 170.0)); + } + ui::slider( + batch, + atlas, + wd.x, + wd.y, + wd.w, + label, + *value, + hover || dragging, + true, + ); + } WKind::Text { text, color, @@ -2502,6 +2719,21 @@ impl OptionsUi { set_slider(opt, s, v); events.push(Event::Changed); } + if let Some(idx) = self.dragging_shader_option + && let Some(wd) = widgets.iter().find(|wd| { + matches!(&wd.kind, WKind::ShaderOptionSlider { index, .. } if *index == idx) + }) + { + let v = ui::slider_value(wd.x, wd.w, x); + if let Some(cfg) = &mut self.shader_pack_config + && let Some(opt) = cfg.options.get_mut(idx) + { + opt.set_slider_pos(v); + } + self.save_shader_pack_config(); + events.push(Event::Changed); + events.push(Event::ReloadShaderPack); + } return events; } // Controller Binds: a click cancels the wait. @@ -2589,6 +2821,45 @@ impl OptionsUi { Act::OpenShaderPackFolder => events.push(Event::OpenShaderPackFolder), Act::Credits => events.push(Event::Credits), Act::CopyAgentDetails => events.push(Event::CopyAgentDetails), + Act::ImportShaderPack => events.push(Event::ImportShaderPack), + Act::ShaderPackProfile => { + if let Some(cfg) = &mut self.shader_pack_config { + cfg.cycle_profile(right); + } + self.save_shader_pack_config(); + events.push(Event::Changed); + events.push(Event::ReloadShaderPack); + } + Act::ShaderPackSubscreen(sub) => { + if let Some(cfg) = &mut self.shader_pack_config { + cfg.active_screen = Some(sub); + } + self.scroll = 0.0; + } + Act::ShaderPackBackScreen => { + if let Some(cfg) = &mut self.shader_pack_config { + cfg.active_screen = None; + } + self.scroll = 0.0; + } + Act::ShaderPackOption(i) => { + if let Some(cfg) = &mut self.shader_pack_config + && let Some(opt) = cfg.options.get_mut(i) + { + opt.cycle(right); + } + self.save_shader_pack_config(); + events.push(Event::Changed); + events.push(Event::ReloadShaderPack); + } + Act::ResetShaderPackOptions => { + if let Some(cfg) = &mut self.shader_pack_config { + cfg.reset_all(); + } + self.save_shader_pack_config(); + events.push(Event::Changed); + events.push(Event::ReloadShaderPack); + } Act::None => {} } } @@ -2599,6 +2870,18 @@ impl OptionsUi { set_slider(opt, s, v); events.push(Event::Changed); } + WKind::ShaderOptionSlider { index, .. } => { + self.dragging_shader_option = Some(index); + let v = ui::slider_value(wd.x, wd.w, x); + if let Some(cfg) = &mut self.shader_pack_config + && let Some(opt) = cfg.options.get_mut(index) + { + opt.set_slider_pos(v); + } + self.save_shader_pack_config(); + events.push(Event::Changed); + events.push(Event::ReloadShaderPack); + } WKind::LanguageRow { code, .. } => { if self.language_choice.as_deref() == Some(code.as_str()) { events.extend(self.back(s)); @@ -2627,7 +2910,9 @@ impl OptionsUi { } // AbstractSliderButton suppresses the press sound and plays once on // release, even if the pointer has left the widget or its value stayed. - let slider = self.dragging.take().is_some(); + let slider = self.dragging.take().is_some() + || self.dragging_shader_option.take().is_some() + || self.hdragging_shader_option.take().is_some(); let graphics_slider = self.graphics.release(); if slider || graphics_slider { vec![Event::ButtonClick] @@ -2683,6 +2968,14 @@ impl OptionsUi { /// Escape or Done: leave the current page, applying page results. pub fn back(&mut self, s: &mut Settings) -> Vec<Event> { let mut events = Vec::new(); + if self.page() == Page::ShaderPackOptions + && let Some(cfg) = &mut self.shader_pack_config + && cfg.active_screen.is_some() + { + cfg.active_screen = None; + self.scroll = 0.0; + return events; + } let page = self.stack.pop().unwrap_or(Page::Main); self.scroll = 0.0; self.scrollbar_drag_y = None; @@ -3123,6 +3416,20 @@ mod tests { false, ); assert_eq!(s.horizon.shader_pack, "", "a second click turns it off"); + let import_btn = find(&mut ui, &s, &|a| *a == Act::ImportShaderPack).unwrap(); + assert_eq!( + ui.click( + &mut s, + &atlas, + import_btn.x + 1.0, + import_btn.y + 1.0, + size, + [480, 240], + false, + false, + ), + vec![Event::ButtonClick, Event::ImportShaderPack] + ); let _ = std::fs::remove_dir_all(&dir); } diff --git a/crates/horizon-client/src/shader_pack.rs b/crates/horizon-client/src/shader_pack.rs index f3cf46028..f5a15ca79 100644 --- a/crates/horizon-client/src/shader_pack.rs +++ b/crates/horizon-client/src/shader_pack.rs @@ -1,18 +1,20 @@ //! Horizon shader packs (docs/shader-packs.md): folders in `shaderpacks/` -//! holding a `pack.toml` and WGSL stages. Loading reads the manifest and the +//! holding a `pack.toml` and WGSL stages, plus Java (OptiFine/Iris) shader +//! packs in folders or `.zip` archives. Loading reads the manifest and the //! player's option values, puts the prelude before each stage's source and //! has naga parse and validate it, so a broken pack is reported (file, line, //! column) and never reaches the GPU. +use horizon_shaderpack::{JavaPack, preprocess::Environment, properties::MenuElement}; use serde::Deserialize; use std::{ - collections::BTreeMap, + collections::{BTreeMap, BTreeSet}, fs, path::{Path, PathBuf}, time::SystemTime, }; /// The stage and uniform contract this build provides. -pub const API: u32 = 1; +pub const API: u32 = 2; /// The folder beside `options.txt` that holds the packs. pub const DIR: &str = "shaderpacks"; pub const PRELUDE: &str = include_str!("shader_pack_prelude.wgsl"); @@ -29,6 +31,10 @@ struct Manifest { stage: Vec<StageEntry>, #[serde(default)] options: BTreeMap<String, OptionEntry>, + #[serde(default)] + profiles: BTreeMap<String, BTreeMap<String, toml::Value>>, + #[serde(default)] + textures: BTreeMap<String, String>, } #[derive(Clone, Debug, Deserialize)] #[serde(deny_unknown_fields)] @@ -51,11 +57,16 @@ struct StageEntry { shader: String, entry: Option<String>, scale: Option<f32>, + format: Option<String>, + #[serde(default)] + mipmap: bool, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct OptionEntry { label: Option<String>, + #[serde(default)] + description: String, default: toml::Value, min: Option<f64>, max: Option<f64>, @@ -63,11 +74,20 @@ struct OptionEntry { values: Option<Vec<i64>>, } -/// Where a stage runs. Api 1 has `composite` only. +/// Where a stage runs. Api 1 has `composite` only; Api 2 adds `shadow`, +/// `gbuffer`, `deferred` and `final`. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum StageKind { + /// Directional sun/moon shadow map pass. + Shadow, + /// Material / G-buffer evaluation pass over world colour, depth and normals. + Gbuffer, + /// Opaque world lighting pass (runs before translucent water/weather). + Deferred, /// After the world pass, before the hand: reads the scene's colour and depth. Composite, + /// Final tonemapping / anti-aliasing pass before HUD and menus. + Final, } #[derive(Clone, Debug)] pub struct Stage { @@ -79,6 +99,10 @@ pub struct Stage { pub entry: String, /// Target size relative to the world's. pub scale: f32, + /// Optional target format name (`rgba16float`, `rgba8unorm`). + pub format: Option<String>, + /// Whether the previous stage's output is mipmapped before this stage runs. + pub mipmap: bool, } #[derive(Clone, Copy, Debug, PartialEq)] pub enum OptionKind { @@ -91,16 +115,582 @@ pub enum OptionKind { max: f64, step: f64, }, + /// A Java `#define` / `const` string option cycling through `choices` + /// (or drawn as a slider when `slider` is true and choices are numeric). + Choice { + slider: bool, + }, } #[derive(Clone, Debug, PartialEq)] pub struct PackOption { - /// The WGSL `override` it sets. + /// The WGSL `override` or GLSL `#define`/`const` name it sets. pub key: String, pub label: String, + pub description: String, pub kind: OptionKind, pub values: Vec<i64>, pub default: f64, pub value: f64, + /// Allowed `(raw_value, display_label)` pairs for `OptionKind::Choice`. + pub choices: Vec<(String, String)>, + pub default_choice: String, + pub current_choice: String, +} + +impl PackOption { + /// Formatted current value for UI buttons and labels. + pub fn display_value(&self) -> String { + match self.kind { + OptionKind::Bool => { + if self.value != 0.0 { + "ON".into() + } else { + "OFF".into() + } + } + OptionKind::Int => format!("{}", self.value.round() as i64), + OptionKind::Float { step, .. } => { + if step >= 1.0 { + format!("{:.0}", self.value) + } else if step >= 0.1 { + format!("{:.1}", self.value) + } else { + format!("{:.2}", self.value) + } + } + OptionKind::Choice { .. } => self + .choices + .iter() + .find(|(raw, _)| *raw == self.current_choice) + .map(|(_, label)| label.clone()) + .unwrap_or_else(|| self.current_choice.clone()), + } + } + + /// Normalized `0.0..=1.0` slider position if this option is a slider. + pub fn slider_pos(&self) -> Option<f32> { + match self.kind { + OptionKind::Float { min, max, .. } if max > min => { + Some(((self.value - min) / (max - min)).clamp(0.0, 1.0) as f32) + } + OptionKind::Choice { slider: true } if self.choices.len() > 1 => { + let idx = self + .choices + .iter() + .position(|(raw, _)| *raw == self.current_choice) + .unwrap_or(0); + Some(idx as f32 / (self.choices.len() - 1) as f32) + } + _ => None, + } + } + + /// Update the option from a normalized `0.0..=1.0` slider drag. + pub fn set_slider_pos(&mut self, pos: f32) { + let pos = f64::from(pos.clamp(0.0, 1.0)); + match self.kind { + OptionKind::Float { min, max, step } => { + let mut v = min + pos * (max - min); + if step > 0.0 { + v = (v / step).round() * step; + } + self.value = v.clamp(min, max); + } + OptionKind::Choice { slider: true } if !self.choices.is_empty() => { + let idx = (pos * (self.choices.len() - 1) as f64).round() as usize; + if let Some((raw, _)) = self.choices.get(idx.min(self.choices.len() - 1)) { + self.current_choice = raw.clone(); + } + } + _ => {} + } + } + + /// Cycle or toggle the option (`reverse`: right-click steps backwards). + pub fn cycle(&mut self, reverse: bool) { + match self.kind { + OptionKind::Bool => { + self.value = if self.value == 0.0 { 1.0 } else { 0.0 }; + } + OptionKind::Int if !self.values.is_empty() => { + let cur = self.value.round() as i64; + let idx = self.values.iter().position(|&v| v == cur).unwrap_or(0); + let next = if reverse { + (idx + self.values.len() - 1) % self.values.len() + } else { + (idx + 1) % self.values.len() + }; + self.value = self.values[next] as f64; + } + OptionKind::Float { min, max, step } => { + let delta = if step > 0.0 { step } else { (max - min) * 0.05 }; + let next = if reverse { + self.value - delta + } else { + self.value + delta + }; + self.value = next.clamp(min, max); + } + OptionKind::Choice { .. } if !self.choices.is_empty() => { + let idx = self + .choices + .iter() + .position(|(raw, _)| *raw == self.current_choice) + .unwrap_or(0); + let next = if reverse { + (idx + self.choices.len() - 1) % self.choices.len() + } else { + (idx + 1) % self.choices.len() + }; + self.current_choice = self.choices[next].0.clone(); + } + _ => {} + } + } + + /// Serialized string value for `shaderpacks/<id>.txt`, or `None` if at default. + pub fn saved_string(&self) -> Option<String> { + match self.kind { + OptionKind::Bool => { + let b = self.value != 0.0; + let def = self.default != 0.0; + (b != def).then(|| b.to_string()) + } + OptionKind::Int => { + let i = self.value.round() as i64; + let def = self.default.round() as i64; + (i != def).then(|| i.to_string()) + } + OptionKind::Float { .. } => { + ((self.value - self.default).abs() > 1e-6).then(|| format!("{}", self.value)) + } + OptionKind::Choice { .. } => { + (self.current_choice != self.default_choice).then(|| self.current_choice.clone()) + } + } + } + + /// Reset to the pack's default value. + pub fn reset(&mut self) { + self.value = self.default; + self.current_choice = self.default_choice.clone(); + } +} + +/// A named preset profile in a Horizon or Java shader pack (`Low`, `High`, `Ultra`). +#[derive(Clone, Debug, PartialEq)] +pub struct PackProfile { + pub name: String, + pub label: String, + pub values: BTreeMap<String, String>, +} + +/// An item on a shader pack option screen (`shaders.properties` `screen`). +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum ScreenItem { + Empty, + Profile, + Subscreen(String, String), + Option(usize), +} + +/// A laid-out option screen (main screen or sub-screen). +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct PackScreen { + pub name: String, + pub label: String, + pub columns: u32, + pub items: Vec<ScreenItem>, +} + +/// Interactive configuration metadata and current values for a shader pack, +/// usable directly by the Options UI without a GPU device. +#[derive(Clone, Debug, Default)] +pub struct PackConfig { + pub id: String, + pub options: Vec<PackOption>, + pub profiles: Vec<PackProfile>, + pub main_screen: PackScreen, + pub subscreens: Vec<PackScreen>, + /// Active subscreen name (`None` = main screen). + pub active_screen: Option<String>, +} + +impl PackConfig { + /// Load the configurable options, profiles, and screens for pack `id` in `dir`. + pub fn load(dir: &Path, id: &str) -> Result<Self, String> { + if id.is_empty() { + return Err("no shader pack selected".into()); + } + let path = dir.join(id); + let saved = load_values(dir, id); + if path.join("pack.toml").is_file() { + let manifest = manifest(&path)?; + let mut options = Vec::new(); + for (key, entry) in manifest.options { + options.push(option(key, entry, &saved)?); + } + let mut profiles = Vec::new(); + for (name, map) in manifest.profiles { + let mut values = BTreeMap::new(); + for (k, v) in map { + let s = match v { + toml::Value::Boolean(b) => b.to_string(), + toml::Value::Integer(i) => i.to_string(), + toml::Value::Float(f) => f.to_string(), + toml::Value::String(s) => s, + _ => continue, + }; + values.insert(k, s); + } + profiles.push(PackProfile { + label: humanize_identifier(&name), + name, + values, + }); + } + let mut items = Vec::new(); + if !profiles.is_empty() { + items.push(ScreenItem::Profile); + } + items.extend((0..options.len()).map(ScreenItem::Option)); + return Ok(Self { + id: id.to_owned(), + options, + profiles, + main_screen: PackScreen { + name: String::new(), + label: manifest.pack.name, + columns: 2, + items, + }, + subscreens: Vec::new(), + active_screen: None, + }); + } + if crate::java_pack::is_java_pack(&path) { + return Self::load_java(&path, id, &saved); + } + Err("not a valid shader pack".into()) + } + + fn load_java(path: &Path, id: &str, saved: &BTreeMap<String, String>) -> Result<Self, String> { + let pack = JavaPack::open(path)?; + let values = pack.values(saved); + let env = Environment::iris("Unknown", "", 4); + let props = pack.properties(&values, &env).unwrap_or_default(); + let lang = pack.translations("en_us"); + let sliders: BTreeSet<&str> = props.sliders().into_iter().collect(); + + let option_label = |name: &str, comment: Option<&str>| -> String { + lang.get(&format!("option.{name}")) + .cloned() + .or_else(|| { + comment + .map(str::trim) + .filter(|c| !c.is_empty() && c.len() <= 40 && !c.contains('.')) + .map(str::to_owned) + }) + .unwrap_or_else(|| humanize_identifier(name)) + }; + let option_desc = |name: &str, comment: Option<&str>| -> String { + lang.get(&format!("option.{name}.comment")) + .cloned() + .or_else(|| comment.map(str::to_owned)) + .unwrap_or_default() + }; + + let mut options = Vec::new(); + let mut by_name = BTreeMap::new(); + for (name, b) in &pack.options.bools { + let current = values.bools.get(name).copied().unwrap_or(b.default); + let idx = options.len(); + options.push(PackOption { + key: name.clone(), + label: option_label(name, b.comment.as_deref()), + description: option_desc(name, b.comment.as_deref()), + kind: OptionKind::Bool, + values: Vec::new(), + default: f64::from(u8::from(b.default)), + value: f64::from(u8::from(current)), + choices: Vec::new(), + default_choice: b.default.to_string(), + current_choice: current.to_string(), + }); + by_name.insert(name.clone(), idx); + } + for (name, s) in &pack.options.strings { + let current = values + .strings + .get(name) + .cloned() + .unwrap_or_else(|| s.default.clone()); + let choices: Vec<(String, String)> = s + .allowed + .iter() + .map(|raw| { + let label = lang + .get(&format!("value.{name}.{raw}")) + .or_else(|| lang.get(&format!("option.{name}.value.{raw}"))) + .cloned() + .unwrap_or_else(|| raw.clone()); + (raw.clone(), label) + }) + .collect(); + let idx = options.len(); + options.push(PackOption { + key: name.clone(), + label: option_label(name, s.comment.as_deref()), + description: option_desc(name, s.comment.as_deref()), + kind: OptionKind::Choice { + slider: sliders.contains(name.as_str()), + }, + values: Vec::new(), + default: 0.0, + value: 0.0, + choices, + default_choice: s.default.clone(), + current_choice: current, + }); + by_name.insert(name.clone(), idx); + } + + let profiles: Vec<PackProfile> = props + .profiles(&pack.options) + .unwrap_or_default() + .into_iter() + .map(|p| { + let label = lang + .get(&format!("profile.{}", p.name)) + .cloned() + .unwrap_or_else(|| humanize_identifier(&p.name)); + PackProfile { + name: p.name, + label, + values: p.values, + } + }) + .collect(); + + let referenced: BTreeSet<String> = std::iter::once(None) + .chain(props.screens().into_iter().map(Some)) + .flat_map(|s| props.screen(s).unwrap_or_default()) + .filter_map(|e| match e { + MenuElement::Option(o) => Some(o), + _ => None, + }) + .collect(); + + let build_screen = |screen_name: Option<&str>| -> PackScreen { + let elements = props + .screen(screen_name) + .unwrap_or_else(|| vec![MenuElement::Rest]); + let mut items = Vec::new(); + if screen_name.is_none() + && !profiles.is_empty() + && !elements.contains(&MenuElement::Profile) + { + items.push(ScreenItem::Profile); + } + for el in elements { + match el { + MenuElement::Empty => items.push(ScreenItem::Empty), + MenuElement::Profile => { + if !profiles.is_empty() { + items.push(ScreenItem::Profile); + } + } + MenuElement::Screen(sub) => { + let label = lang + .get(&format!("screen.{sub}")) + .cloned() + .unwrap_or_else(|| humanize_identifier(&sub)); + items.push(ScreenItem::Subscreen(sub, label)); + } + MenuElement::Option(opt) => { + if let Some(&idx) = by_name.get(&opt) { + items.push(ScreenItem::Option(idx)); + } + } + MenuElement::Rest => { + for (idx, opt) in options.iter().enumerate() { + if !referenced.contains(&opt.key) { + items.push(ScreenItem::Option(idx)); + } + } + } + } + } + let name_str = screen_name.unwrap_or("").to_owned(); + let label = match screen_name { + Some(n) => lang + .get(&format!("screen.{n}")) + .cloned() + .unwrap_or_else(|| humanize_identifier(n)), + None => id.to_owned(), + }; + PackScreen { + name: name_str, + label, + columns: props.columns(screen_name).unwrap_or(2), + items, + } + }; + + let main_screen = build_screen(None); + let subscreens = props + .screens() + .into_iter() + .map(|s| build_screen(Some(s))) + .collect(); + + Ok(Self { + id: id.to_owned(), + options, + profiles, + main_screen, + subscreens, + active_screen: None, + }) + } + + /// Currently active screen (main or a sub-screen). + pub fn current_screen(&self) -> &PackScreen { + if let Some(name) = &self.active_screen + && let Some(sub) = self.subscreens.iter().find(|s| s.name == *name) + { + return sub; + } + &self.main_screen + } + + /// Name of the profile matching current option values, or `"Custom"`. + pub fn active_profile_label(&self) -> String { + let map = self.to_map(); + for profile in &self.profiles { + let matches = profile.values.iter().all(|(k, v)| { + if let Some(cur) = map.get(k) { + return cur == v; + } + if let Some(opt) = self.options.iter().find(|o| o.key == *k) { + return match opt.kind { + OptionKind::Bool => (opt.default != 0.0).to_string() == *v, + OptionKind::Int => (opt.default.round() as i64).to_string() == *v, + OptionKind::Float { .. } => format!("{}", opt.default) == *v, + OptionKind::Choice { .. } => opt.default_choice == *v, + }; + } + true + }); + if matches { + return profile.label.clone(); + } + } + "Custom".into() + } + + /// Cycle to the next (or previous) profile and apply its option values. + pub fn cycle_profile(&mut self, reverse: bool) { + if self.profiles.is_empty() { + return; + } + let current = self.active_profile_label(); + let idx = self + .profiles + .iter() + .position(|p| p.label == current) + .map(|i| { + if reverse { + (i + self.profiles.len() - 1) % self.profiles.len() + } else { + (i + 1) % self.profiles.len() + } + }) + .unwrap_or(0); + let values = self.profiles[idx].values.clone(); + for opt in &mut self.options { + if let Some(v) = values.get(&opt.key) { + match opt.kind { + OptionKind::Bool => { + if let Ok(b) = v.parse::<bool>() { + opt.value = f64::from(u8::from(b)); + } + } + OptionKind::Int => { + if let Ok(i) = v.parse::<i64>() { + opt.value = i as f64; + } + } + OptionKind::Float { min, max, .. } => { + if let Ok(f) = v.parse::<f64>() { + opt.value = f.clamp(min, max); + } + } + OptionKind::Choice { .. } => { + opt.current_choice = v.clone(); + } + } + } + } + } + + /// Reset all options to their defaults. + pub fn reset_all(&mut self) { + for opt in &mut self.options { + opt.reset(); + } + } + + /// Export non-default option values as a `key=value` map. + pub fn to_map(&self) -> BTreeMap<String, String> { + let mut out = BTreeMap::new(); + for opt in &self.options { + if let Some(val) = opt.saved_string() { + out.insert(opt.key.clone(), val); + } + } + out + } + + /// Save the current non-default option values to `shaderpacks/<id>.txt`. + pub fn save(&self, dir: &Path) -> Result<(), String> { + save_values(dir, &self.id, &self.to_map()) + } +} + +fn humanize_identifier(raw: &str) -> String { + let mut words = Vec::new(); + let mut current = String::new(); + for ch in raw.chars() { + if ch == '_' || ch == '-' { + if !current.is_empty() { + words.push(std::mem::take(&mut current)); + } + } else if ch.is_uppercase() + && !current.is_empty() + && current.chars().last().is_some_and(char::is_lowercase) + { + words.push(std::mem::take(&mut current)); + current.push(ch); + } else { + current.push(ch); + } + } + if !current.is_empty() { + words.push(current); + } + words + .into_iter() + .map(|w| { + let lower = w.to_lowercase(); + let mut chars = lower.chars(); + match chars.next() { + Some(first) => format!("{}{}", first.to_uppercase(), chars.as_str()), + None => String::new(), + } + }) + .collect::<Vec<_>>() + .join(" ") } pub struct ShaderPack { @@ -109,6 +699,8 @@ pub struct ShaderPack { pub info: Info, pub stages: Vec<Stage>, pub options: Vec<PackOption>, + /// Optional custom noise/LUT texture bytes (RGBA8, width, height) from `[textures]`. + pub custom_noise: Option<(u32, u32, Vec<u8>)>, /// A Java (OptiFine/Iris) pack's translated passes, instead of `stages`. pub java: Option<crate::java_pack::JavaPasses>, dir: PathBuf, @@ -116,7 +708,7 @@ pub struct ShaderPack { } /// Every file's path, length and modification time: a changed stamp means -/// the pack was edited (hot reload). +/// the pack or its `<id>.txt` option file was edited (hot reload). #[derive(Clone, Debug, Default, PartialEq, Eq)] pub struct Stamp(Vec<(PathBuf, u64, Option<SystemTime>)>); impl Stamp { @@ -127,6 +719,17 @@ impl Stamp { { files.push((dir.to_path_buf(), meta.len(), meta.modified().ok())); } + // Also watch the sibling `<id>.txt` options file for live option reloads. + if let Some(name) = dir.file_name() + && let Some(parent) = dir.parent() + { + let txt = parent.join(format!("{}.txt", name.to_string_lossy())); + if let Ok(meta) = fs::metadata(&txt) + && meta.is_file() + { + files.push((txt, meta.len(), meta.modified().ok())); + } + } let mut stack = vec![dir.to_path_buf()]; while let Some(d) = stack.pop() { let Ok(entries) = fs::read_dir(&d) else { @@ -177,6 +780,62 @@ pub fn folder() -> PathBuf { std::env::current_dir().unwrap_or_default().join(DIR) } +/// Import a `.zip` archive or shader pack folder from `source` into +/// `target_dir` (`shaderpacks/`), validating that it holds `pack.toml` or +/// `shaders/`. Returns the imported pack's folder/zip name (`id`). +pub fn import_pack(source: &Path, target_dir: &Path) -> Result<String, String> { + let source = source + .canonicalize() + .unwrap_or_else(|_| source.to_path_buf()); + if !source.exists() { + return Err(format!("{}: file or folder not found", source.display())); + } + let name = source + .file_name() + .map(|n| n.to_string_lossy().into_owned()) + .filter(|n| !n.is_empty()) + .ok_or_else(|| "invalid shader pack path".to_string())?; + let is_horizon = source.is_dir() && source.join("pack.toml").is_file(); + let is_java = crate::java_pack::is_java_pack(&source); + if !is_horizon && !is_java { + return Err(format!( + "{name}: not a shader pack (needs pack.toml or shaders/)" + )); + } + if is_java && source.is_file() { + // Verify the zip actually contains `shaders/` or `pack.toml` at its root. + JavaPack::open(&source)?; + } else if is_horizon { + manifest(&source)?; + } + fs::create_dir_all(target_dir).map_err(|e| format!("{}: {e}", target_dir.display()))?; + let dest = target_dir.join(&name); + if dest.canonicalize().ok() == source.canonicalize().ok() { + return Ok(name); + } + if source.is_file() { + fs::copy(&source, &dest).map_err(|e| format!("failed to copy {name}: {e}"))?; + } else { + copy_dir_recursive(&source, &dest)?; + } + Ok(name) +} + +fn copy_dir_recursive(src: &Path, dst: &Path) -> Result<(), String> { + fs::create_dir_all(dst).map_err(|e| format!("{}: {e}", dst.display()))?; + let entries = fs::read_dir(src).map_err(|e| format!("{}: {e}", src.display()))?; + for entry in entries.flatten() { + let path = entry.path(); + let target = dst.join(entry.file_name()); + if path.is_dir() { + copy_dir_recursive(&path, &target)?; + } else { + fs::copy(&path, &target).map_err(|e| format!("{}: {e}", target.display()))?; + } + } + Ok(()) +} + /// `shaderpacks/` and its packs as the Shader Packs page lists them, read /// again at most once a second while the page is open, so a pack dropped /// into the folder shows up. @@ -199,13 +858,17 @@ impl Folder { self.dir = dir; self.read = Some(std::time::Instant::now()); } + + pub fn invalidate(&mut self) { + self.read = None; + } } /// A Java pack has no manifest: its name is its file name. fn java_info(name: String) -> Info { Info { name, - description: "Iris/OptiFine pack: its full-screen passes run.".into(), + description: "Iris/OptiFine pack: G-buffers, shadow map and post passes.".into(), authors: Vec::new(), version: String::new(), license: String::new(), @@ -216,7 +879,7 @@ fn java_info(name: String) -> Info { fn manifest(dir: &Path) -> Result<Manifest, String> { let text = fs::read_to_string(dir.join("pack.toml")).map_err(|e| format!("pack.toml: {e}"))?; let manifest: Manifest = toml::from_str(&text).map_err(|e| format!("pack.toml: {e}"))?; - if manifest.pack.api > API { + if manifest.pack.api == 0 || manifest.pack.api > API { return Err(format!( "pack.toml: needs shader pack api {}, this Horizon has {API}", manifest.pack.api @@ -225,12 +888,41 @@ fn manifest(dir: &Path) -> Result<Manifest, String> { Ok(manifest) } +pub(crate) fn decode_png_rgba(bytes: &[u8]) -> Result<(u32, u32, Vec<u8>), String> { + let mut decoder = png::Decoder::new(std::io::Cursor::new(bytes)); + decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16); + let mut reader = decoder.read_info().map_err(|e| e.to_string())?; + let mut buf = vec![0u8; reader.output_buffer_size().unwrap_or(0)]; + let info = reader.next_frame(&mut buf).map_err(|e| e.to_string())?; + buf.truncate(info.buffer_size()); + let (w, h) = (info.width.max(1), info.height.max(1)); + let rgba = match info.color_type { + png::ColorType::Rgba => buf, + png::ColorType::Rgb => buf + .as_chunks::<3>() + .0 + .iter() + .flat_map(|p| [p[0], p[1], p[2], 255]) + .collect(), + png::ColorType::GrayscaleAlpha => buf + .as_chunks::<2>() + .0 + .iter() + .flat_map(|p| [p[0], p[0], p[0], p[1]]) + .collect(), + png::ColorType::Grayscale => buf.into_iter().flat_map(|g| [g, g, g, 255]).collect(), + _ => return Err("unsupported PNG color format".into()), + }; + Ok((w, h, rgba)) +} + impl ShaderPack { /// Load and validate the pack in `dir` with the option values in /// `values` (missing ones take their default). pub fn load(dir: &Path, values: &BTreeMap<String, String>) -> Result<Self, String> { let stamp = Stamp::of(dir); let manifest = manifest(dir)?; + let pack_api = manifest.pack.api; if manifest.stage.is_empty() || manifest.stage.len() > MAX_STAGES { return Err(format!("pack.toml: 1 to {MAX_STAGES} stages")); } @@ -244,11 +936,15 @@ impl ShaderPack { .collect::<Result<Vec<_>, _>>()?; let mut stages = Vec::new(); for entry in manifest.stage { - let kind = match entry.kind.as_str() { - "composite" => StageKind::Composite, - other => { + let kind = match (pack_api, entry.kind.as_str()) { + (_, "composite") => StageKind::Composite, + (2.., "shadow") => StageKind::Shadow, + (2.., "gbuffer") => StageKind::Gbuffer, + (2.., "deferred") => StageKind::Deferred, + (2.., "final") => StageKind::Final, + (_, other) => { return Err(format!( - "pack.toml: stage kind `{other}` isn't supported (api {API} has `composite`)" + "pack.toml: stage kind `{other}` isn't supported (api {pack_api} has `composite`)" )); } }; @@ -273,8 +969,22 @@ impl ShaderPack { source, entry: entry_point, scale, + format: entry.format, + mipmap: entry.mipmap, }); } + let mut custom_noise = None; + if let Some(rel) = manifest + .textures + .get("noise") + .or_else(|| manifest.textures.values().next()) + { + if rel.contains("..") { + return Err(format!("pack.toml: texture {rel} is outside the pack")); + } + let bytes = fs::read(dir.join(rel)).map_err(|e| format!("{rel}: {e}"))?; + custom_noise = Some(decode_png_rgba(&bytes).map_err(|e| format!("{rel}: {e}"))?); + } Ok(Self { id: dir .file_name() @@ -283,6 +993,7 @@ impl ShaderPack { info: manifest.pack, stages, options, + custom_noise, java: None, dir: dir.to_path_buf(), stamp, @@ -305,16 +1016,57 @@ impl ShaderPack { .file_name() .map(|n| n.to_string_lossy().into_owned()) .unwrap_or_default(); + let options = PackConfig::load_java(path, &id, values) + .map(|c| c.options) + .unwrap_or_default(); Ok(Self { info: java_info(id.clone()), id, stages: Vec::new(), - options: Vec::new(), + options, + custom_noise: None, java: Some(java), dir: path.to_path_buf(), stamp, }) } + /// Whether this pack requests directional shadow map rendering. + pub fn needs_shadow(&self) -> bool { + if let Some(java) = &self.java { + return java.folders.iter().any(|f| f.shadow_enabled); + } + self.stages.iter().any(|s| { + s.kind == StageKind::Shadow + || s.source.contains("sample_shadow") + || s.source.contains("shadow_depth") + }) + } + /// Shadow map resolution requested by this pack, and shadow distance in blocks. + pub fn shadow_config(&self, dimension: i8) -> (u32, f32, f32) { + if let Some(java) = &self.java + && let Some(idx) = java.folder_for(dimension) + { + let d = &java.folders[idx].directives; + return ( + d.shadow_map_resolution, + d.shadow_distance, + d.sun_path_rotation, + ); + } + let res = self + .options + .iter() + .find(|o| o.key == "shadow_resolution" || o.key == "shadowMapResolution") + .map(|o| (o.value.round() as u32).clamp(256, 4096)) + .unwrap_or(2048); + let dist = self + .options + .iter() + .find(|o| o.key == "shadow_distance" || o.key == "shadowDistance") + .map(|o| (o.value as f32).clamp(16.0, 512.0)) + .unwrap_or(128.0); + (res, dist, 0.0) + } /// The pipeline-overridable constants every stage gets: the option values. pub fn constants(&self) -> Vec<(&str, f64)> { self.options @@ -368,15 +1120,20 @@ fn option( .ok() .filter(|f| f.is_finite()) .map(|f| f.clamp(min, max)), + OptionKind::Choice { .. } => None, }) .unwrap_or(default); Ok(PackOption { - label: entry.label.unwrap_or_else(|| key.clone()), + label: entry.label.unwrap_or_else(|| humanize_identifier(&key)), + description: entry.description, key, kind, values: values_list, default, value, + choices: Vec::new(), + default_choice: String::new(), + current_choice: String::new(), }) } @@ -422,6 +1179,25 @@ pub fn load_values(dir: &Path, id: &str) -> BTreeMap<String, String> { .collect() } +/// Save option values for a pack (`shaderpacks/<id>.txt`, `key=value`). +/// When `values` is empty, removes `<id>.txt` if present. +pub fn save_values(dir: &Path, id: &str, values: &BTreeMap<String, String>) -> Result<(), String> { + if id.is_empty() { + return Ok(()); + } + let path = dir.join(format!("{id}.txt")); + if values.is_empty() { + let _ = fs::remove_file(path); + return Ok(()); + } + fs::create_dir_all(dir).map_err(|e| e.to_string())?; + let mut text = String::new(); + for (k, v) in values { + text.push_str(&format!("{k}={v}\n")); + } + fs::write(&path, text).map_err(|e| format!("{}: {e}", path.display())) +} + #[cfg(test)] mod tests { use super::*; @@ -529,8 +1305,8 @@ override mode: i32 = 1; fn manifests_are_checked() { for (manifest, expected) in [ ( - MANIFEST.replace("api = 1", "api = 2"), - "needs shader pack api 2", + MANIFEST.replace("api = 1", "api = 3"), + "needs shader pack api 3", ), ( MANIFEST.replace("\"composite\"", "\"shadow\""), @@ -556,6 +1332,23 @@ override mode: i32 = 1; } } + #[test] + fn api_2_stages_and_pack_config_work() { + let manifest_v2 = MANIFEST + .replace("api = 1", "api = 2") + .replace("\"composite\"", "\"deferred\""); + let dir = pack(&[("pack.toml", &manifest_v2), ("shaders/grade.wgsl", GRADE)]); + let loaded = ShaderPack::load(&dir, &BTreeMap::new()).unwrap(); + assert_eq!(loaded.stages[0].kind, StageKind::Deferred); + let parent = dir.parent().unwrap(); + let id = dir.file_name().unwrap().to_str().unwrap(); + let mut cfg = PackConfig::load(parent, id).unwrap(); + assert_eq!(cfg.options.len(), 3); + cfg.options[0].cycle(false); + cfg.save(parent).unwrap(); + assert!(loaded.changed(), "saving <id>.txt updates the stamp"); + } + #[test] fn edits_change_the_stamp_and_the_list_shows_every_pack() { let root = scratch(); diff --git a/crates/horizon-client/src/shader_pack_prelude.wgsl b/crates/horizon-client/src/shader_pack_prelude.wgsl index 7b16690f9..ebe3ad4cf 100644 --- a/crates/horizon-client/src/shader_pack_prelude.wgsl +++ b/crates/horizon-client/src/shader_pack_prelude.wgsl @@ -1,6 +1,7 @@ -// Horizon shader pack prelude, api 1 (docs/shader-packs.md): placed before -// every stage's source. Bindings, the Frame uniform, the full-screen vertex -// shader and helpers that hide the renderer's reversed depth. +// Horizon shader pack prelude, api 2 (docs/shader-packs.md): placed before +// every stage's source. Bindings, the Frame and FrameExt uniforms, the +// full-screen vertex shader, G-buffer/shadow accessors and PBR/post helpers +// that hide the renderer's reversed depth. struct Frame { view: mat4x4<f32>, projection: mat4x4<f32>, @@ -19,12 +20,36 @@ struct Frame { view_params: vec4<f32>, dimension: vec4<f32>, } + +struct FrameExt { + previous_view: mat4x4<f32>, + previous_projection: mat4x4<f32>, + shadow_view: mat4x4<f32>, + shadow_projection: mat4x4<f32>, + shadow_inverse_view: mat4x4<f32>, + shadow_inverse_projection: mat4x4<f32>, + // xyz: previous camera world position, w: frame delta time (seconds) + previous_camera: vec4<f32>, + // x: shadow map resolution, y: shadow distance (blocks), z: sun_path_rotation (rad), w: shadow strength + shadow_params: vec4<f32>, + // x: eye block light (0..240), y: eye sky light (0..240), z: smoothed wetness (0..1), w: center linear depth + environment: vec4<f32>, +} + @group(0) @binding(0) var scene_color: texture_2d<f32>; @group(0) @binding(1) var scene_depth: texture_depth_2d; @group(0) @binding(2) var previous: texture_2d<f32>; @group(0) @binding(3) var linear_sampler: sampler; @group(0) @binding(4) var nearest_sampler: sampler; @group(0) @binding(5) var<uniform> frame: Frame; +@group(0) @binding(6) var<uniform> frame_ext: FrameExt; +@group(0) @binding(7) var scene_normal: texture_2d<f32>; +@group(0) @binding(8) var scene_material: texture_2d<f32>; +@group(0) @binding(9) var opaque_depth: texture_depth_2d; +@group(0) @binding(10) var shadow_depth: texture_depth_2d; +@group(0) @binding(11) var shadow_sampler: sampler_comparison; +@group(0) @binding(12) var noise_texture: texture_2d<f32>; +@group(0) @binding(13) var repeat_sampler: sampler; struct StageIn { @builtin(position) position: vec4<f32>, @@ -42,6 +67,10 @@ struct StageIn { fn depth_at(uv: vec2<f32>) -> f32 { return textureSampleLevel(scene_depth, nearest_sampler, uv, 0); } +// The opaque world's depth at `uv` (before translucent water and stained glass). +fn opaque_depth_at(uv: vec2<f32>) -> f32 { + return textureSampleLevel(opaque_depth, nearest_sampler, uv, 0); +} fn is_sky(depth: f32) -> bool { return depth <= 0.0; } @@ -60,6 +89,70 @@ fn view_position(uv: vec2<f32>, depth: f32) -> vec3<f32> { fn world_offset(uv: vec2<f32>, depth: f32) -> vec3<f32> { return (frame.inverse_view * vec4(view_position(uv, depth), 1.0)).xyz; } +// World-space surface normal at `uv` from the G-buffer (or reconstructed from depth). +fn world_normal_at(uv: vec2<f32>) -> vec3<f32> { + let encoded = textureSampleLevel(scene_normal, nearest_sampler, uv, 0.0); + if encoded.w > 0.001 { + return normalize(encoded.xyz * 2.0 - 1.0); + } + let step_uv = frame.resolution.zw; + let d0 = depth_at(uv); + let p0 = world_offset(uv, d0); + let px = world_offset(uv + vec2(step_uv.x, 0.0), depth_at(uv + vec2(step_uv.x, 0.0))) - p0; + let py = world_offset(uv + vec2(0.0, step_uv.y), depth_at(uv + vec2(0.0, step_uv.y))) - p0; + let n = cross(py, px); + let len = length(n); + if len > 1e-6 { + return n / len; + } + return vec3(0.0, 1.0, 0.0); +} +// G-buffer material data at `uv`: r = block light (0..1), g = sky light (0..1), +// b = water/translucent mask (0..1), a = roughness (0..1). +fn material_at(uv: vec2<f32>) -> vec4<f32> { + return textureSampleLevel(scene_material, nearest_sampler, uv, 0.0); +} +// Reproject a camera-relative world position into previous-frame UV and clip depth. +fn reproject_uv(world_rel: vec3<f32>) -> vec3<f32> { + let camera_delta = frame.camera_position.xyz - frame_ext.previous_camera.xyz; + let prev_rel = world_rel + camera_delta; + let clip = frame_ext.previous_projection * (frame_ext.previous_view * vec4(prev_rel, 1.0)); + if clip.w <= 1e-5 { + return vec3(-1.0); + } + let ndc = clip.xyz / clip.w; + return vec3(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5, ndc.z); +} +// Sample the directional sun/moon shadow map with 5-tap PCF and normal offset bias. +// Returns 1.0 in full light and 0.0 in full shadow. +fn sample_shadow(world_rel: vec3<f32>, world_normal: vec3<f32>) -> f32 { + if frame_ext.shadow_params.w <= 0.001 { + return 1.0; + } + let dist = length(world_rel); + let max_dist = max(frame_ext.shadow_params.y, 16.0); + if dist >= max_dist { + return 1.0; + } + let light_dir = normalize(select(frame.moon.xyz, frame.sun.xyz, frame.sun.y >= -0.05)); + let ndotl = max(dot(world_normal, light_dir), 0.0); + let bias_pos = world_rel + world_normal * (0.06 + 0.12 * (1.0 - ndotl)); + let light_clip = frame_ext.shadow_projection * (frame_ext.shadow_view * vec4(bias_pos, 1.0)); + let ndc = light_clip.xyz / max(light_clip.w, 1e-5); + let shadow_uv = vec2(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5); + if any(shadow_uv < vec2(0.002)) || any(shadow_uv > vec2(0.998)) || ndc.z <= 0.0 || ndc.z >= 1.0 { + return 1.0; + } + let texel = 1.0 / max(frame_ext.shadow_params.x, 512.0); + let ref_z = clamp(ndc.z + 0.0008, 0.0, 1.0); + var sum = textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv, ref_z); + sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv + vec2(texel, 0.0), ref_z); + sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv - vec2(texel, 0.0), ref_z); + sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv + vec2(0.0, texel), ref_z); + sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv - vec2(0.0, texel), ref_z); + let fade = smoothstep(max_dist, max_dist * 0.82, dist); + return mix(1.0, sum * 0.2, fade * frame_ext.shadow_params.w); +} fn luminance(c: vec3<f32>) -> f32 { return dot(c, vec3(0.2126, 0.7152, 0.0722)); } @@ -69,3 +162,12 @@ fn srgb_to_linear(c: vec3<f32>) -> vec3<f32> { fn linear_to_srgb(c: vec3<f32>) -> vec3<f32> { return select(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, c <= vec3(0.0031308)); } +// ACES fitted filmic tonemapping curve (linear HDR -> linear 0..1). +fn aces_tonemap(x: vec3<f32>) -> vec3<f32> { + let a = 2.51; + let b = 0.03; + let c = 2.43; + let d = 0.59; + let e = 0.14; + return clamp((x * (a * x + b)) / (x * (c * x + d) + e), vec3(0.0), vec3(1.0)); +} diff --git a/crates/horizon-shaderpack/src/lib.rs b/crates/horizon-shaderpack/src/lib.rs index 71b6abbd3..fa454a134 100644 --- a/crates/horizon-shaderpack/src/lib.rs +++ b/crates/horizon-shaderpack/src/lib.rs @@ -17,7 +17,7 @@ pub mod uniforms; use include::{IncludeGraph, Inlined}; use options::{Annotated, OptionSet, OptionValues}; use preprocess::{Environment, Preprocessed}; -use properties::ShaderProperties; +use properties::{Properties, ShaderProperties}; use source::PackFiles; use std::{ collections::{BTreeMap, BTreeSet}, @@ -154,6 +154,32 @@ impl JavaPack { None => Ok(ShaderProperties::default()), } } + + /// The pack's language translations (`shaders/lang/<code_lower>.lang` or + /// `en_US.lang`), mapping keys such as `option.SHADOW_QUALITY`, + /// `value.SHADOW_QUALITY.2`, `screen.LIGHTING`, and `profile.HIGH` to their + /// display labels. + pub fn translations(&self, lang_code: &str) -> BTreeMap<String, String> { + let mut out = BTreeMap::new(); + let lower = lang_code.to_lowercase(); + let upper = match lower.split_once('_') { + Some((l, r)) => format!("{l}_{}", r.to_uppercase()), + None => lower.clone(), + }; + let mut candidates = vec!["lang/en_US.lang".to_owned(), "lang/en_us.lang".to_owned()]; + if lower != "en_us" { + candidates.push(format!("lang/{lower}.lang")); + candidates.push(format!("lang/{upper}.lang")); + } + for path in candidates { + if let Some(text) = self.files.read(&path) { + for (k, v) in Properties::parse(&text).iter() { + out.insert(k.to_owned(), v.to_owned()); + } + } + } + out + } } /// A program's name in `shaders.properties` (`world-1/composite1.fsh` is diff --git a/crates/horizon-shaderpack/src/pipeline.rs b/crates/horizon-shaderpack/src/pipeline.rs index 7ebb35442..db656e3ae 100644 --- a/crates/horizon-shaderpack/src/pipeline.rs +++ b/crates/horizon-shaderpack/src/pipeline.rs @@ -11,7 +11,7 @@ use crate::{ JavaPack, options::OptionValues, preprocess::Environment, - properties::{LEGACY_TARGETS, ShaderProperties}, + properties::{Blend, LEGACY_TARGETS, ShaderProperties}, translate::{Link, Translated}, }; use std::collections::{BTreeMap, BTreeSet}; @@ -297,6 +297,10 @@ pub struct Pass { pub mipmapped: BTreeSet<u32>, /// `scale.<name>`: the fraction of the screen it draws. pub scale: f32, + /// `blend.<program>` override for all outputs of this pass. + pub blend: Option<Blend>, + /// `blend.<program>.<buffer>` overrides per colour target index. + pub buffer_blends: Vec<(u32, Blend)>, } /// The full-screen passes of one program folder, in order, and the @@ -319,6 +323,8 @@ pub struct Passes { /// next frame starts unflipped. pub flipped_at_end: BTreeSet<u32>, pub directives: Directives, + /// Whether the folder uses shadow mapping (`shadow` program or `shadowtex*`). + pub shadow_enabled: bool, } /// The `const` directives of a program folder that aren't about targets @@ -331,6 +337,28 @@ pub struct Directives { pub sun_path_rotation: f32, /// `eyeBrightnessHalflife`, tenths of a second: `eyeBrightnessSmooth`. pub eye_brightness_half_life: f32, + /// `wetnessHalflife`, tenths of a second: `wetness` smoothing when raining. + pub wetness_half_life: f32, + /// `drynessHalflife`, tenths of a second: `wetness` smoothing when dry. + pub dryness_half_life: f32, + /// `centerDepthHalflife`, tenths of a second: `centerDepthSmooth`. + pub center_depth_half_life: f32, + /// `shadowMapResolution` (or `SHADOW_RES`), in pixels per side. + pub shadow_map_resolution: u32, + /// `shadowDistance`, in blocks. + pub shadow_distance: f32, + /// `shadowDistanceRenderMul` (-1 when unset). + pub shadow_distance_render_mul: f32, + /// `ambientOcclusionLevel` (0.0..=1.0). + pub ambient_occlusion_level: f32, + /// `noiseTextureResolution`, in pixels per side. + pub noise_texture_resolution: u32, + /// `shadowHardwareFiltering` / `shadowHardwareFiltering0..1`. + pub shadow_hardware_filtering: [bool; 2], + /// `shadowtex0Nearest` / `shadowtex1Nearest`. + pub shadow_nearest: [bool; 2], + /// `generateShadowMipmap` / `shadowtex0Mipmap` / `shadowtex1Mipmap`. + pub shadow_mipmap: [bool; 2], } impl Default for Directives { @@ -338,6 +366,17 @@ impl Default for Directives { Self { sun_path_rotation: 0.0, eye_brightness_half_life: 10.0, + wetness_half_life: 600.0, + dryness_half_life: 200.0, + center_depth_half_life: 1.0, + shadow_map_resolution: 2048, + shadow_distance: 128.0, + shadow_distance_render_mul: -1.0, + ambient_occlusion_level: 1.0, + noise_texture_resolution: 256, + shadow_hardware_filtering: [false; 2], + shadow_nearest: [false; 2], + shadow_mipmap: [false; 2], } } } @@ -348,11 +387,66 @@ impl Directives { let mut out = Self::default(); for fragment in fragments { for c in const_directives(fragment) { - // Java's `Float.parseFloat` takes a trailing `f`. - let value = c.value.trim_end_matches(['f', 'F']).parse::<f32>(); - match (c.ty, c.key.as_str(), value) { - ("float", "sunPathRotation", Ok(v)) => out.sun_path_rotation = v, - ("float", "eyeBrightnessHalflife", Ok(v)) => out.eye_brightness_half_life = v, + let raw = c.value.trim_end_matches(['f', 'F']); + let fval = raw.parse::<f32>(); + let ival = raw.parse::<u32>(); + let bval = raw.parse::<bool>(); + match (c.ty, c.key.as_str()) { + ("float", "sunPathRotation") if fval.is_ok() => { + out.sun_path_rotation = fval.unwrap(); + } + ("float", "eyeBrightnessHalflife") if fval.is_ok() => { + out.eye_brightness_half_life = fval.unwrap(); + } + ("float", "wetnessHalflife") if fval.is_ok() => { + out.wetness_half_life = fval.unwrap(); + } + ("float", "drynessHalflife") if fval.is_ok() => { + out.dryness_half_life = fval.unwrap(); + } + ("float", "centerDepthHalflife") if fval.is_ok() => { + out.center_depth_half_life = fval.unwrap(); + } + ("float", "shadowDistance") if fval.is_ok() => { + out.shadow_distance = fval.unwrap().clamp(8.0, 1024.0); + } + ("float", "shadowDistanceRenderMul") if fval.is_ok() => { + out.shadow_distance_render_mul = fval.unwrap(); + } + ("float", "ambientOcclusionLevel") if fval.is_ok() => { + out.ambient_occlusion_level = fval.unwrap().clamp(0.0, 1.0); + } + ("int", "shadowMapResolution") if ival.is_ok() => { + out.shadow_map_resolution = ival.unwrap().clamp(64, 8192); + } + ("int", "noiseTextureResolution") if ival.is_ok() => { + out.noise_texture_resolution = ival.unwrap().clamp(16, 2048); + } + ("bool", "shadowHardwareFiltering") if bval.is_ok() => { + out.shadow_hardware_filtering = [bval.unwrap(); 2]; + } + ("bool", "shadowHardwareFiltering0") if bval.is_ok() => { + out.shadow_hardware_filtering[0] = bval.unwrap(); + } + ("bool", "shadowHardwareFiltering1") if bval.is_ok() => { + out.shadow_hardware_filtering[1] = bval.unwrap(); + } + ("bool", "shadowtexNearest" | "shadowtex0Nearest" | "shadow0MinMagNearest") + if bval.is_ok() => + { + out.shadow_nearest[0] = bval.unwrap(); + } + ("bool", "shadowtex1Nearest" | "shadow1MinMagNearest") if bval.is_ok() => { + out.shadow_nearest[1] = bval.unwrap(); + } + ("bool", "generateShadowMipmap" | "shadowtexMipmap" | "shadowtex0Mipmap") + if bval.is_ok() => + { + out.shadow_mipmap[0] = bval.unwrap(); + } + ("bool", "shadowtex1Mipmap") if bval.is_ok() => { + out.shadow_mipmap[1] = bval.unwrap(); + } _ => {} } } @@ -474,21 +568,43 @@ impl JavaPack { for name in &groups[0..2].concat() { fragments.insert(name.clone(), fragment(name)?); } + let shadow_enabled = ["shadow", "shadow_solid", "shadow_cutout"] + .iter() + .any(|s| exists(s)) + || sources.iter().any(|s| { + s.contains("shadowtex0") + || s.contains("shadowtex1") + || s.contains("watershadow") + || s.contains("shadow2D") + }); let mut out = Passes { targets: target_settings(sources.iter().map(String::as_str), properties), directives: Directives::read(sources.iter().map(String::as_str)), + shadow_enabled, ..Passes::default() }; + let resolve_blends = |prog: &str| { + let blend = properties.blend(prog).and_then(Result::ok); + let buffer_blends: Vec<(u32, Blend)> = properties + .buffer_blends(prog) + .into_iter() + .filter_map(|(i, b)| Some((i, b.ok()?))) + .collect(); + (blend, buffer_blends) + }; + let flips = explicit_flips(properties); let run = |group: &[String], pre: &str, flipped: &mut BTreeSet<u32>| { *flipped = flips_pre(&flips, pre, flipped); let mut passes = Vec::new(); for name in group { let text = &fragments[name]; + let prog = path(name); + let (blend, buffer_blends) = resolve_blends(&prog); let pass = Pass { - program: path(name), - draw_buffers: draw_buffers(text).map_err(|e| format!("{}: {e}", path(name)))?, + program: prog.clone(), + draw_buffers: draw_buffers(text).map_err(|e| format!("{prog}: {e}"))?, reads_alt: flipped.clone(), mipmapped: mipmapped(text), scale: properties @@ -496,6 +612,8 @@ impl JavaPack { .get(&format!("scale.{name}")) .and_then(|v| v.split_whitespace().next()?.parse().ok()) .unwrap_or(1.0), + blend, + buffer_blends, }; *flipped = flip_set(&pass, &flips); passes.push(pass); @@ -511,12 +629,16 @@ impl JavaPack { out.composite = run(&groups[3], "composite_pre", &mut flipped)?; out.flipped_at_end = flipped; if exists("final") { + let prog = path("final"); + let (blend, buffer_blends) = resolve_blends(&prog); out.final_pass = Some(Pass { - program: path("final"), + program: prog, draw_buffers: None, reads_alt: out.flipped_at_end.clone(), mipmapped: mipmapped(&fragment("final")?), scale: 1.0, + blend, + buffer_blends, }); } Ok(out) @@ -736,12 +858,14 @@ mod tests { assert_eq!(Directives::read([]), Directives::default()); assert_eq!(Directives::default().eye_brightness_half_life, 10.0); let d = Directives::read([ - "const float sunPathRotation = 30.0;\nconst float eyeBrightnessHalflife = 4.0f;", + "const float sunPathRotation = 30.0;\nconst float eyeBrightnessHalflife = 4.0f;\nconst int shadowMapResolution = 4096;\nconst float shadowDistance = 192.0;", "const float sunPathRotation = -40.0; // Complementary Unbound", "const int sunPathRotation = 5;", ]); assert_eq!(d.sun_path_rotation, -40.0); assert_eq!(d.eye_brightness_half_life, 4.0); + assert_eq!(d.shadow_map_resolution, 4096); + assert_eq!(d.shadow_distance, 192.0); } #[test] diff --git a/crates/horizon-shaderpack/src/properties.rs b/crates/horizon-shaderpack/src/properties.rs index 3c6ee251c..0e989341a 100644 --- a/crates/horizon-shaderpack/src/properties.rs +++ b/crates/horizon-shaderpack/src/properties.rs @@ -358,8 +358,21 @@ impl Default for SkyDirectives { } } +/// A custom texture bound by `texture.<stage>.<sampler> = <path>` in +/// `shaders.properties`. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CustomTexture { + /// Stage family (`composite`, `deferred`, `gbuffers`, `prepare`, `begin`), + /// or `None` when bound across all stages. + pub stage: Option<String>, + /// Sampler uniform name (`noisetex`, `colortex4`, `customTex`, ...). + pub sampler: String, + /// Path relative to `shaders/` (`textures/noise.png`). + pub path: String, +} + /// A pack's `shaders.properties`. -#[derive(Debug, Default)] +#[derive(Debug, Default, Clone)] pub struct ShaderProperties { /// As written: screens, sliders, profiles, feature flags. pub original: Properties, @@ -535,6 +548,31 @@ impl ShaderProperties { .collect() } + /// `texture.<stage>.<sampler> = <path>` and `texture.<sampler> = <path>`: + /// custom textures defined in `shaders.properties`. + pub fn custom_textures(&self) -> Vec<CustomTexture> { + let mut out = Vec::new(); + for (k, v) in self.preprocessed.iter() { + let Some(rest) = k.strip_prefix("texture.") else { + continue; + }; + let path = v.split_whitespace().next().unwrap_or("").trim(); + if path.is_empty() { + continue; + } + let (stage, sampler) = match rest.split_once('.') { + Some((stage, sampler)) => (Some(stage.to_owned()), sampler.to_owned()), + None => (None, rest.to_owned()), + }; + out.push(CustomTexture { + stage, + sampler, + path: path.to_owned(), + }); + } + out + } + /// `uniform.*` and `variable.*`: the pack's custom uniforms. pub fn custom_uniforms(&self) -> crate::uniforms::CustomUniforms { crate::uniforms::CustomUniforms::parse(self.preprocessed.iter()) @@ -564,23 +602,37 @@ impl ShaderProperties { pub fn blend(&self, program: &str) -> Option<Result<Blend, String>> { self.preprocessed .get(&format!("blend.{program}")) + .or_else(|| { + let short = program.rsplit('/').next()?; + self.preprocessed.get(&format!("blend.{short}")) + }) .map(parse_blend) } /// `blend.<program>.<buffer>`: per colour target overrides, by target index. pub fn buffer_blends(&self, program: &str) -> Vec<(u32, Result<Blend, String>)> { - let prefix = format!("blend.{program}."); - self.preprocessed - .iter() - .filter_map(|(k, v)| { - let buffer = k.strip_prefix(&prefix)?; - let index = match LEGACY_TARGETS.iter().position(|t| *t == buffer) { - Some(i) => i as u32, - None => buffer.strip_prefix("colortex")?.parse().ok()?, - }; - Some((index, parse_blend(v))) - }) - .collect() + let short = program.rsplit('/').next().unwrap_or(program); + let prefixes = [format!("blend.{program}."), format!("blend.{short}.")]; + let mut out = Vec::new(); + for (k, v) in self.preprocessed.iter() { + let Some(buffer) = prefixes.iter().find_map(|p| k.strip_prefix(p.as_str())) else { + continue; + }; + let Some(index) = LEGACY_TARGETS + .iter() + .position(|t| *t == buffer) + .map(|i| i as u32) + .or_else(|| buffer.strip_prefix("colortex")?.parse().ok()) + else { + continue; + }; + if let Some(existing) = out.iter_mut().find(|(i, _)| *i == index) { + existing.1 = parse_blend(v); + } else { + out.push((index, parse_blend(v))); + } + } + out } } @@ -796,6 +848,7 @@ blend.gbuffers_water.gaux2 = off blend.gbuffers_water.colortex9 = ONE ONE ONE ONE size.buffer.colortex4 = 0.50 QUALITY image.lightimg0 = lighttex0 rgba RGBA16F half_float false false 128 64 128 +texture.composite.colortex4 = textures/noise.png # a comment, not a directive iris.features.optional = CUSTOM_IMAGES SSBO "; @@ -823,6 +876,14 @@ iris.features.optional = CUSTOM_IMAGES SSBO p.image_formats(), [("lightimg0".to_owned(), "rgba16f".to_owned())].into() ); + assert_eq!( + p.custom_textures(), + [CustomTexture { + stage: Some("composite".into()), + sampler: "colortex4".into(), + path: "textures/noise.png".into(), + }] + ); assert_eq!(p.features(), (vec![], vec!["CUSTOM_IMAGES", "SSBO"])); // The preprocessed read: #if picked, values expanded, spelling kept. assert!(!p.program_enabled("composite1", &set, &values)); diff --git a/crates/horizon-shaderpack/src/source.rs b/crates/horizon-shaderpack/src/source.rs index 0501661ce..4e4bcd779 100644 --- a/crates/horizon-shaderpack/src/source.rs +++ b/crates/horizon-shaderpack/src/source.rs @@ -63,13 +63,27 @@ impl PackFiles { Ok(Self::Zip(files)) } + /// Raw bytes of a file relative to `shaders/` (leading `/` or `./` stripped), + /// or `None` when it doesn't exist. + pub fn read_bytes(&self, rel: &str) -> Option<Vec<u8>> { + let clean = rel + .trim() + .trim_start_matches("./") + .trim_start_matches('/') + .trim_start_matches("shaders/"); + if clean.is_empty() || clean.contains("..") { + return None; + } + match self { + Self::Folder(root) => fs::read(root.join(clean)).ok(), + Self::Zip(files) => files.get(clean).cloned(), + } + } + /// A text file, or `None` when it doesn't exist. Invalid UTF-8 is /// replaced, as packs are often saved in Latin-1. pub fn read(&self, rel: &str) -> Option<String> { - let bytes = match self { - Self::Folder(root) => fs::read(root.join(rel)).ok()?, - Self::Zip(files) => files.get(rel)?.clone(), - }; + let bytes = self.read_bytes(rel)?; Some(String::from_utf8_lossy(&bytes).into_owned()) } diff --git a/crates/horizon-shaderpack/src/translate.rs b/crates/horizon-shaderpack/src/translate.rs index 8a32795af..623ad760d 100644 --- a/crates/horizon-shaderpack/src/translate.rs +++ b/crates/horizon-shaderpack/src/translate.rs @@ -5,8 +5,9 @@ //! patches do for the core profile, prints GLSL 450 and has naga turn that //! into a validated module and WGSL: //! -//! - `attribute`/`varying` become `in`/`out` with locations; matrix and array -//! varyings are split into vectors (WGSL can pass neither between stages); +//! - `attribute`/`varying` become `in`/`out` with locations; matrix, nested +//! array and struct varyings are split into vectors (WGSL can pass none of +//! them directly between stages); //! - loose uniforms go into one std140 block (`bool`s stored as `int`); //! - `sampler2D` & co. become a texture and a sampler binding, rebuilt as //! `sampler2D(t, s)` where used, also through function parameters, and not @@ -16,13 +17,16 @@ //! (`vaPosition`, `modelViewMatrix`, ...) are declared; //! - legacy texture calls are renamed, `shadow2D` returns a `vec4` again and a //! swizzled shadow lookup is widened first (naga has no scalar swizzle); +//! - vertex and compute `texture(s, uv)` calls without an explicit LOD become +//! `textureLod(s, uv, 0.0)` so naga doesn't reject implicit derivatives; //! - global initialisers run at the start of `main` (drivers accept //! non-constant ones), unsized global arrays are sized from them; //! - `isnan`, `isinf` and `modf` are helper functions (WGSL has none); //! - what naga refuses and drivers accept: `%` goes through overloads (naga -//! won't take `ivec2 % int`), `sqrt` of a negative constant isn't folded, -//! constants naga can't fold (`?:`, `mix`) become globals set in `main`, -//! and 16/8-bit types are their 32-bit ones. +//! won't take `ivec2 % int`), `mat2(vec4)` goes through `iris_mat2`, `1 << 31` +//! shifts as unsigned before casting back to `int`, `sqrt` of a negative +//! constant isn't folded, constants naga can't fold (`?:`, `mix`, `<<`) +//! become globals set in `main`, and 16/8-bit types are their 32-bit ones. //! //! The programs of one pass share a [`Link`], so their locations, bindings and //! uniform block agree. @@ -238,6 +242,18 @@ vec3 iris_modf(vec3 x, out vec3 i) { i = trunc(x); return x - i; } vec4 iris_modf(vec4 x, out vec4 i) { i = trunc(x); return x - i; } "; +/// Overloaded `mat2` constructor helper: drivers accept `mat2(vec4)` (Bloop), +/// which naga's GLSL front end refuses. +const MAT2_HELPERS: &str = "\ +mat2 iris_mat2(float x) { return mat2(x); } +mat2 iris_mat2(vec2 a, vec2 b) { return mat2(a, b); } +mat2 iris_mat2(float a, float b, float c, float d) { return mat2(a, b, c, d); } +mat2 iris_mat2(vec4 v) { return mat2(v.xy, v.zw); } +mat2 iris_mat2(mat2 m) { return m; } +mat2 iris_mat2(mat3 m) { return mat2(m); } +mat2 iris_mat2(mat4 m) { return mat2(m); } +"; + /// A fragment output narrower than four channels (`out vec3 color`, /// Steadfast's `final`): the four-channel type it is written through and the /// epilogue line that fills it, with alpha 1 and the rest 0. `None` when the @@ -376,69 +392,62 @@ pub fn translate( let wgsl = naga::back::wgsl::write_string(&module, &info, naga::back::wgsl::WriterFlags::empty()) .map_err(|e| e.to_string())?; - let interface = std::mem::take(&mut legaliser.interface); Ok(Translated { glsl, module, info, wgsl, - interface, + interface: legaliser.interface, }) } -/// The GLSL built-ins naga's constant evaluator folds (`MathFunction`s it -/// implements), besides type constructors. +/// Built-in functions naga folds in `const` initialisers. const FOLDABLE: &[&str] = &[ - "abs", - "acos", - "acosh", - "asin", - "asinh", - "atan", - "atanh", - "ceil", - "clamp", - "cos", - "cosh", - "cross", + "radians", "degrees", + "sin", + "cos", + "tan", + "asin", + "acos", + "atan", + "pow", + "exp", + "log", + "exp2", + "log2", + "sqrt", + "inversesqrt", + "abs", + "sign", + "floor", + "trunc", + "round", + "ceil", + "fract", + "mod", + "min", + "max", + "clamp", + "step", + "length", "distance", "dot", - "exp", - "exp2", - "floor", - "fma", - "fract", - "inversesqrt", - "length", - "log", - "log2", - "max", - "min", + "cross", "normalize", - "pow", - "radians", - "round", - "sign", - "sin", - "sinh", - "sqrt", - "step", - "tan", - "tanh", - "trunc", ]; -/// Whether a constant's initialisers need what naga can't fold and drivers -/// do: a `?:`, another built-in (Bliss's `mix`), or a constant that had to -/// become a global (`runtime`). +fn constructor(name: &str) -> bool { + ["bool", "int", "uint", "float", "double"].contains(&name) + || ["vec", "ivec", "uvec", "bvec", "dvec", "mat", "dmat"] + .iter() + .any(|p| name.starts_with(p)) +} + +/// Whether `list` has an initialiser naga's constant folder refuses (`?:`, +/// `mix`, `smoothstep`, `1 << 31`, or a reference to a constant already turned +/// into a global). fn needs_runtime(list: &ast::InitDeclaratorList, runtime: &HashSet<String>) -> bool { - let constructor = |name: &str| { - let n = name.trim_start_matches(['i', 'u', 'b', 'd']); - matches!(name, "float" | "int" | "uint" | "bool" | "double") - || n.starts_with("vec") - || n.starts_with("mat") - }; let expr = |e: &ast::Expr| { fn walk(e: &ast::Expr, f: &dyn Fn(&ast::Expr) -> bool) -> bool { use ast::ExprData as E; @@ -454,6 +463,14 @@ fn needs_runtime(list: &ast::InitDeclaratorList, runtime: &HashSet<String>) -> b } walk(e, &|e| match &e.content { ast::ExprData::Ternary(..) => true, + ast::ExprData::Binary(op, _, _) + if matches!( + op.content, + ast::BinaryOpData::LShift | ast::BinaryOpData::RShift + ) => + { + true + } ast::ExprData::Variable(v) => runtime.contains(v.as_str()), ast::ExprData::FunCall(f, _) => { callee(f).is_some_and(|c| !constructor(&c) && !FOLDABLE.contains(&c.as_str())) @@ -503,6 +520,9 @@ enum Local { Sampler(&'static str), } +/// A struct field `(type_name, field_name, array_suffix)`. +type StructField = (String, String, String); + struct Legaliser<'a> { stage: Stage, link: &'a mut Link, @@ -515,6 +535,8 @@ struct Legaliser<'a> { /// User functions → indices of their sampler parameters. sampler_params: HashMap<String, BTreeSet<usize>>, functions: HashSet<String>, + /// User structs → their fields `(ty, name, array)` (for struct varyings). + structs: HashMap<String, Vec<StructField>>, scopes: Vec<HashMap<String, Local>>, /// Declarations before the program (bindings, block, inputs, outputs). header: Vec<String>, @@ -528,10 +550,11 @@ struct Legaliser<'a> { errors: Vec<String>, /// Inside a constant initialiser: no helper calls there. constant: bool, - /// The program uses `%` ([`modulo_helpers`]) or `iris_sqrt`: their - /// helpers go in. + /// The program uses `%` ([`modulo_helpers`]), `iris_sqrt` or `iris_mat2`: + /// their helpers go in. modulo: bool, nan: bool, + mat2_ctor: bool, /// Constants turned into globals ([`needs_runtime`]). runtime_constants: HashSet<String>, } @@ -634,6 +657,38 @@ fn array_text(a: &Option<ast::ArraySpecifier>) -> String { .collect() } +/// Parse one or more `[N]` dimensions (`[9][9]` → `Some(vec![9, 9])`). +fn array_dims(array: &str) -> Option<Vec<usize>> { + if array.is_empty() { + return Some(Vec::new()); + } + let mut dims = Vec::new(); + let mut rest = array.trim(); + while !rest.is_empty() { + let inner = rest.strip_prefix('[')?; + let (num, tail) = inner.split_once(']')?; + dims.push(num.trim().parse::<usize>().ok()?); + rest = tail.trim(); + } + Some(dims) +} + +/// Expand multi-dimensional indices `dims` into `(key_suffix, expr_suffix)` +/// pairs (`[2, 2]` → `("#0#0", "[0][0]")`, `("#0#1", "[0][1]")`, ...). +fn expand_dims(dims: &[usize]) -> Vec<(String, String)> { + let mut out = vec![(String::new(), String::new())]; + for &n in dims { + let mut next = Vec::with_capacity(out.len() * n); + for (k, e) in &out { + for i in 0..n { + next.push((format!("{k}#{i}"), format!("{e}[{i}]"))); + } + } + out = next; + } + out +} + /// The element count of `T[](a, b, c)`. fn constructor_len(init: &Option<ast::Initializer>) -> Option<usize> { match &init.as_ref()?.content { @@ -718,6 +773,7 @@ impl<'a> Legaliser<'a> { sampler_vars: HashSet::new(), sampler_params: HashMap::new(), functions: HashSet::new(), + structs: HashMap::new(), scopes: Vec::new(), header: Vec::new(), prologue: Vec::new(), @@ -728,14 +784,43 @@ impl<'a> Legaliser<'a> { constant: false, modulo: false, nan: false, + mat2_ctor: false, runtime_constants: HashSet::new(), } } + fn record_struct(&mut self, spec: &ast::StructSpecifier) { + let Some(name) = &spec.name else { return }; + let mut fields = Vec::new(); + for field in &spec.fields { + let base_ty = type_text(&field.ty); + let ty_arr = array_text(&field.ty.array_specifier); + for id in &field.identifiers { + let arr = format!("{ty_arr}{}", array_text(&id.array_spec)); + fields.push((base_ty.clone(), id.ident.as_str().to_owned(), arr)); + } + } + self.structs.insert(name.as_str().to_owned(), fields); + } + fn unit(&mut self, unit: &mut ast::TranslationUnit) -> Result<(), String> { - // Functions and their sampler parameters first: calls may precede - // definitions through prototypes. + // Functions, their sampler parameters, and struct definitions first. for ed in &unit.0 { + if let ast::ExternalDeclarationData::Declaration(d) = &ed.content { + match &d.content { + ast::DeclarationData::InitDeclaratorList(list) => { + if let ast::TypeSpecifierNonArrayData::Struct(s) = + &list.head.ty.ty.ty.content + { + self.record_struct(s); + } + } + ast::DeclarationData::TypeOnly(q) => { + let _ = q; + } + _ => {} + } + } let proto = match &ed.content { ast::ExternalDeclarationData::FunctionDefinition(f) => &f.prototype, ast::ExternalDeclarationData::Declaration(d) => match &d.content { @@ -812,6 +897,22 @@ impl<'a> Legaliser<'a> { } fn global_list(&mut self, list: &mut ast::InitDeclaratorList) -> Result<bool, String> { + // If a standalone `struct S { ... };` has no declarator names, keep it + // in the header so varyings of type `S` can declare `S varname;` there. + if list.head.name.is_none() + && list.tail.is_empty() + && matches!( + list.head.ty.ty.ty.content, + ast::TypeSpecifierNonArrayData::Struct(_) + ) + { + let mut text = String::new(); + let decl = ast::DeclarationData::InitDeclaratorList(list.clone()).into_node(); + show_declaration(&mut text, &decl, &mut FormattingState::default()) + .map_err(|e| e.to_string())?; + self.header.push(text.trim().to_owned()); + return Ok(false); + } let qualifier = list.head.ty.qualifier.clone(); let storage = storage(&qualifier); let has = |s: ast::StorageQualifierData| storage.contains(&s); @@ -939,32 +1040,34 @@ impl<'a> Legaliser<'a> { .find(|(k, _)| k == "location") .and_then(|(_, v)| v?.parse().ok()); for (i, (name, array)) in names.iter().enumerate() { - let full = format!("{ty}{ty_array}"); + let full_array = format!("{ty_array}{array}"); if input { let at = Link::location(&mut self.link.attributes, name); - self.header - .push(format!("layout(location = {at}) in {full} {name}{array};")); + self.header.push(format!( + "layout(location = {at}) in {ty} {name}{full_array};" + )); self.interface.attributes.insert(name.clone()); } else if !varying { let at = explicit .map(|l: u32| l + i as u32) .unwrap_or_else(|| self.next_output()); - if let (Some(widened), "") = (widen_output(&full, name), array.as_str()) { + if let (Some(widened), "") = (widen_output(&ty, name), full_array.as_str()) { // GL fills the missing channels of a narrow output; // wgpu wants every channel of the target written. let (wide, fill) = widened; - self.header.push(format!("{full} {name};")); + self.header.push(format!("{ty} {name};")); self.header.push(format!( "layout(location = {at}) out {wide} iris_out_{name};" )); self.epilogue.push(fill); } else { - self.header - .push(format!("layout(location = {at}) out {full} {name}{array};")); + self.header.push(format!( + "layout(location = {at}) out {ty} {name}{full_array};" + )); } self.interface.outputs.insert(at, name.clone()); } else { - self.varying(dir, &interp, &full, name, array); + self.varying(dir, &interp, &ty, name, &full_array); } } return Ok(false); @@ -1001,64 +1104,106 @@ impl<'a> Legaliser<'a> { .unwrap() } - /// One varying: matrices and arrays split into vectors that a private - /// global of the original type is packed from or into. - fn varying(&mut self, dir: &str, interp: &str, ty: &str, name: &str, array: &str) { + /// Emit scalar/vector/matrix varying leaves for an expression `expr_path` + /// with key `key_prefix`. + fn varying_leaf(&mut self, dir: &str, interp: &str, ty: &str, key: &str, expr_path: &str) { + if let Some(fields) = self.structs.get(ty).cloned() { + for (f_ty, f_name, f_arr) in fields { + let sub_key = format!("{key}#{f_name}"); + let sub_expr = format!("{expr_path}.{f_name}"); + self.varying_composite(dir, interp, &f_ty, &sub_key, &sub_expr, &f_arr); + } + return; + } + if let Some((cols, column)) = matrix_columns(ty) { + let flat = if is_integer(&column) && !interp.contains("flat") { + "flat " + } else { + "" + }; + let mut columns = Vec::new(); + for c in 0..cols { + let c_key = format!("{key}#{c}"); + let at = Link::location(&mut self.link.varyings, &c_key); + let part = c_key.replace('#', "_iris"); + self.header.push(format!( + "layout(location = {at}) {flat}{interp}{dir} {column} {part};" + )); + if dir == "out" { + self.epilogue.push(format!("{part} = {expr_path}[{c}];")); + } + columns.push(part); + } + if dir == "in" { + self.prologue + .push(format!("{expr_path} = {ty}({});", columns.join(", "))); + } + return; + } let flat = if is_integer(ty) && !interp.contains("flat") { "flat " } else { "" }; - let count: Option<usize> = array - .strip_prefix('[') - .and_then(|a| a.strip_suffix(']')) - .and_then(|n| n.parse().ok()); - let parts: Vec<(String, String, String)> = match (matrix_columns(ty), count) { - (Some((cols, column)), None) => (0..cols) - .map(|c| { - ( - format!("{name}#{c}"), - column.clone(), - format!("{name}[{c}]"), - ) - }) - .collect(), - (None, Some(n)) => (0..n) - .map(|e| (format!("{name}#{e}"), ty.to_owned(), format!("{name}[{e}]"))) - .collect(), - (None, None) => { - let at = Link::location(&mut self.link.varyings, name); - self.header.push(format!( - "layout(location = {at}) {flat}{interp}{dir} {ty} {name};" - )); - return; - } - (Some(_), Some(_)) => { - self.errors.push(format!( - "varying {name}: arrays of matrices are not supported" - )); - return; - } + let at = Link::location(&mut self.link.varyings, key); + let part = key.replace('#', "_iris"); + self.header.push(format!( + "layout(location = {at}) {flat}{interp}{dir} {ty} {part};" + )); + if dir == "out" { + self.epilogue.push(format!("{part} = {expr_path};")); + } else { + self.prologue.push(format!("{expr_path} = {part};")); + } + } + + fn varying_composite( + &mut self, + dir: &str, + interp: &str, + ty: &str, + key: &str, + expr_path: &str, + array: &str, + ) { + let Some(dims) = array_dims(array) else { + self.errors + .push(format!("varying {expr_path}: unsupported array `{array}`")); + return; }; - self.header.push(format!("{ty} {name}{array};")); - let mut columns = Vec::new(); - for (key, part_ty, element) in &parts { - let at = Link::location(&mut self.link.varyings, key); - let part = key.replace('#', "_iris"); - self.header.push(format!( - "layout(location = {at}) {flat}{interp}{dir} {part_ty} {part};" - )); - if dir == "out" { - self.epilogue.push(format!("{part} = {element};")); - } else if count.is_some() { - self.prologue.push(format!("{element} = {part};")); + if dims.is_empty() { + self.varying_leaf(dir, interp, ty, key, expr_path); + } else { + for (k_suf, e_suf) in expand_dims(&dims) { + self.varying_leaf( + dir, + interp, + ty, + &format!("{key}{k_suf}"), + &format!("{expr_path}{e_suf}"), + ); } - columns.push(part); } - if dir == "in" && count.is_none() { - self.prologue - .push(format!("{name} = {ty}({});", columns.join(", "))); + } + + /// One varying: matrices, arrays (including multi-dimensional `vec3[9][9]`) + /// and structs (`CloudsParameters`) split into vectors that a private + /// global of the original type is packed from or into. + fn varying(&mut self, dir: &str, interp: &str, ty: &str, name: &str, array: &str) { + if array.is_empty() && matrix_columns(ty).is_none() && !self.structs.contains_key(ty) { + let flat = if is_integer(ty) && !interp.contains("flat") { + "flat " + } else { + "" + }; + let at = Link::location(&mut self.link.varyings, name); + self.header.push(format!( + "layout(location = {at}) {flat}{interp}{dir} {ty} {name};" + )); + return; } + self.header.push(format!("{ty} {name}{array};")); + self.varying_composite(dir, interp, ty, name, name, array); } fn sized(&mut self, list: &mut ast::InitDeclaratorList) { @@ -1404,13 +1549,30 @@ impl<'a> Legaliser<'a> { self.expr(a); self.expr(b); self.modulo = true; - let (a, b) = ( - std::mem::replace(&mut **a, var("_")), - std::mem::replace(&mut **b, var("_")), - ); - *e = call("iris_mod", vec![a, b]); + let lhs = std::mem::replace(&mut **a, var("_")); + let rhs = std::mem::replace(&mut **b, var("_")); + *e = call("iris_mod", vec![lhs, rhs]); } - E::Assignment(a, op, b) if op.content == ast::AssignmentOpData::Mod => { + E::Binary(op, a, b) + if op.content == ast::BinaryOpData::LShift + && matches!(a.content, E::IntConst(_)) + && matches!(b.content, E::IntConst(n) if n >= 31) => + { + self.expr(a); + self.expr(b); + let lhs = std::mem::replace(&mut **a, var("_")); + let rhs = std::mem::replace(&mut **b, var("_")); + let shifted = ast::ExprData::Binary( + ast::BinaryOpData::LShift.into_node(), + Box::new(call("uint", vec![lhs])), + Box::new(call("uint", vec![rhs])), + ) + .into_node(); + *e = call("int", vec![shifted]); + } + E::Assignment(a, op, b) + if op.content == ast::AssignmentOpData::Mod && !self.constant => + { self.expr(a); self.expr(b); self.modulo = true; @@ -1538,17 +1700,53 @@ impl<'a> Legaliser<'a> { if self.functions.contains(&name) { return; } + // `mat2(vec4)` (Bloop): naga refuses 1-argument `mat2` from a `vec4`. + if name == "mat2" + && !self.constant + && args.len() == 1 + && !matches!( + args[0].content, + ast::ExprData::FloatConst(_) + | ast::ExprData::IntConst(_) + | ast::ExprData::UIntConst(_) + | ast::ExprData::DoubleConst(_) + ) + { + *f = ast::FunIdentifierData::Expr(Box::new(var("iris_mat2"))).into_node(); + self.mat2_ctor = true; + return; + } // `sqrt(-1.0)`, Bloop's NaN: naga folds it and fails, drivers give NaN. if name == "sqrt" && !self.constant && args.len() == 1 && negative_constant(&args[0]) { *f = ast::FunIdentifierData::Expr(Box::new(var("iris_sqrt"))).into_node(); self.nan = true; return; } + let mut target_name = name.as_str(); if let Some((_, new)) = LEGACY_CALLS.iter().find(|(old, _)| *old == name) { *f = ast::FunIdentifierData::Expr(Box::new(var(new))).into_node(); + target_name = new; } else if let Some((_, new)) = SHADOW_CALLS.iter().find(|(old, _)| *old == name) { let args = std::mem::take(args); *e = call("vec4", vec![call(new, args)]); + return; + } + // In vertex and compute shaders, `texture(sampler, coord)` uses implicit + // derivatives that WGSL/naga forbid outside fragment shaders (Bliss): + // rewrite 2-argument non-shadow `texture(s, uv)` to `textureLod(s, uv, 0.0)`. + if self.stage != Stage::Fragment && target_name == "texture" && args.len() == 2 { + let is_shadow = match &args[0].content { + ast::ExprData::FunCall(g, _) => { + callee(g).and_then(|c| opaque(&c)).is_some_and(|o| o.3) + } + _ => false, + }; + if !is_shadow { + if let ast::ExprData::FunCall(f, args) = &mut e.content { + *f = ast::FunIdentifierData::Expr(Box::new(var("textureLod"))).into_node(); + args.push(ast::ExprData::FloatConst(0.0).into_node()); + } + } } } @@ -1589,6 +1787,9 @@ impl<'a> Legaliser<'a> { if self.nan { out.push_str("float iris_sqrt(float x) { return sqrt(x); }\n"); } + if self.mat2_ctor { + out.push_str(MAT2_HELPERS); + } if !self.link.uniforms.is_empty() { out.push_str("layout(std140, set = 0, binding = 0) uniform IrisUniforms {\n"); for (_, decl) in &self.link.uniforms { diff --git a/crates/horizon-shaderpack/tests/translate.rs b/crates/horizon-shaderpack/tests/translate.rs index 3c71d8546..9198f8b92 100644 --- a/crates/horizon-shaderpack/tests/translate.rs +++ b/crates/horizon-shaderpack/tests/translate.rs @@ -292,14 +292,48 @@ fn reports_errors_with_their_place() { /// What naga refuses and drivers accept: `vec % scalar` (Noble), `sqrt` of /// a negative constant (Bloop's NaN), constants naga can't fold (Bliss's -/// `?:`, `mix`), and 16-bit types (Noble on NVIDIA). +/// `?:`, `mix`), 16-bit types (Noble on NVIDIA), `mat2(vec4)` (Bloop), +/// `1 << 31` (Rethinking Voxels), vertex `texture2D` without LOD (Bliss), +/// nested array varyings (Noble), and struct varyings (Photon). #[test] fn legalises_what_naga_refuses() { let mut link = Link::default(); + let vs = run( + Stage::Vertex, + "uniform sampler2D colortex0; +struct CloudsParameters { + vec3 color; + float density; +}; +varying CloudsParameters clouds; +varying vec3 grid[2][2]; +void main() { + vec4 s = texture2D(colortex0, vec2(0.5)); + clouds.color = s.rgb; + clouds.density = s.a; + grid[0][0] = s.rgb; + grid[0][1] = s.gbr; + grid[1][0] = s.brg; + grid[1][1] = vec3(1.0); + gl_Position = vec4(0.0, 0.0, 0.0, 1.0); +} +", + &mut link, + ) + .unwrap(); + reparse(&vs.wgsl).unwrap(); + let fs = run( Stage::Fragment, "uniform vec2 uv; +struct CloudsParameters { + vec3 color; + float density; +}; +varying CloudsParameters clouds; +varying vec3 grid[2][2]; const int RES = 256 % 100; +const int SIGN_BIT = 1 << 31; const vec3 TARGET = length(vec3(1.0)) < 0.001 ? vec3(0.0) : normalize(vec3(1.0)); const vec3 TINT = mix(TARGET, vec3(1.0), 0.5); const vec3 HALF = TINT * 0.5; @@ -309,7 +343,9 @@ void main() { ivec2 texel = ivec2(uv) % RES; texel %= 7; uint packed = packFloat2x16(f16vec2(HALF.xy)); - gl_FragColor = vec4(vec2(texel), float(pack(packed).x), nan()); + mat2 rot = mat2(vec4(1.0, 0.0, 0.0, 1.0)); + vec2 r = rot * vec2(clouds.density, float(SIGN_BIT != 0)); + gl_FragColor = vec4(vec2(texel) + r + clouds.color.xy + grid[1][0].xy, float(pack(packed).x), nan()); } ", &mut link, @@ -325,6 +361,7 @@ void main() { "uvec2 pack(uint v)", "return iris_sqrt(-1.);", "uint packed = packHalf2x16(vec2(HALF.xy));", + "iris_mat2(", ] { assert!(fs.glsl.contains(wanted), "{wanted}\n{}", fs.glsl); } diff --git a/docs/shader-packs.md b/docs/shader-packs.md index d126d5a2a..0ba8981fb 100644 --- a/docs/shader-packs.md +++ b/docs/shader-packs.md @@ -13,16 +13,16 @@ Both are off by default. With no pack selected the renderer draws exactly what i | Part | State | | --- | --- | | Renderer layout (below) | today's code | -| Horizon shader packs: `composite` stage, uniforms, hot reload, Shader Packs page | done (the page: list, pick, open the folder) | -| Horizon shader packs: `deferred`, `gbuffer`, `shadow` stages, custom textures | planned | -| Java shader packs: preprocessing + GLSL parse coverage | spike done: 450 of 470 programs reach valid WGSL (below) | -| Java shader packs: preprocessor (`crates/horizon-shaderpack`: includes, options, Iris's macros, JCPP's `#if` and `#define` rules) | done: every program of the three test packs preprocesses; ten packs tested (Compatibility, below) | -| Java shader packs: GLSL → WGSL (`horizon_shaderpack::translate`: syntax-tree legaliser, naga) | done: the 464 programs the three test packs enable by default translate (below) | -| Java shader packs: `shaders.properties` (`horizon_shaderpack::properties`: screens, sliders, profiles, `program.*.enabled`, image formats, blend modes) | done, no screen yet: read like Iris for the three test packs | -| Java shader packs: full-screen pass plan (`horizon_shaderpack::pipeline`: `DRAWBUFFERS`/`RENDERTARGETS`, `colortexN` formats and clearing, buffer flips) | done: planned for the three test packs | -| Java shader packs: full-screen passes drawn (`java_pack.rs`, `gfx/java_stages.rs`: `begin`, `prepare`, `deferred*`, `composite*`, `final` over Horizon's world) | first slice: BSL and Complementary run (below) | -| Java shader packs: custom uniforms (`horizon_shaderpack::uniforms`), `sunPathRotation`, `clouds`/`sun`/`moon`, eye light | done for the full-screen passes (below) | -| Java shader packs: `gbuffers_*`, `shadow`, custom textures, images, compute, option screen | planned | +| Horizon shader packs: `composite`, `deferred`, `gbuffer`, `shadow`, `final` stages (API 2), uniforms, custom textures, hot reload | done (`examples/shaderpacks/horizon-ultra` + `horizon-sample`) | +| Shader Packs UI: import (`.zip`/folder dialog + drag-and-drop), profiles, sub-screens, sliders, toggles, reset to defaults | done (Horizon & Classic Video/Graphics settings) | +| Real-time shadow map pass (`"Horizon shadow"`, `shadowtex0/1`, `shadowModelView`, `shadowProjection`) & pre-translucent depth (`depthtex1/2`) | done | +| G-buffer normal & material pass (`"Horizon gbuffer"`, `scene_normal`, `scene_material`, `colortex1..3` initialization) | done | +| Java shader packs: preprocessor (`crates/horizon-shaderpack`: includes, options, Iris's macros, JCPP's `#if` and `#define` rules, `.lang` files) | done: ten packs tested (Compatibility, below) | +| Java shader packs: GLSL → WGSL (`horizon_shaderpack::translate`: syntax-tree legaliser, naga, 2D array & struct varyings, vertex `textureLod`, `mat2(vec4)`, `1 << 31` shifts) | done | +| Java shader packs: `shaders.properties` (`horizon_shaderpack::properties`: screens, sliders, profiles, `program.*.enabled`, image formats, blend modes, custom textures) | done, wired to UI and GPU passes | +| Java shader packs: full-screen pass plan (`horizon_shaderpack::pipeline`: `DRAWBUFFERS`/`RENDERTARGETS`, `colortexN` formats and clearing, buffer flips, blend state) | done | +| Java shader packs: full-screen passes drawn (`java_pack.rs`, `gfx/java_stages.rs`: `begin`, `prepare`, `deferred*`, `composite*`, `final` over Horizon's world) | done: with shadow maps, `depthtex1/2`, custom PNG textures, GL blend modes, `wetness`, `centerDepthSmooth` | +| Java shader packs: custom uniforms (`horizon_shaderpack::uniforms`), `sunPathRotation`, `clouds`/`sun`/`moon`, eye light | done | ## How the renderer draws a frame today diff --git a/examples/shaderpacks/horizon-ultra/LICENSE b/examples/shaderpacks/horizon-ultra/LICENSE new file mode 100644 index 000000000..44c359a50 --- /dev/null +++ b/examples/shaderpacks/horizon-ultra/LICENSE @@ -0,0 +1,13 @@ +MIT License + +Copyright (c) 2026 Horizon contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. diff --git a/examples/shaderpacks/horizon-ultra/pack.toml b/examples/shaderpacks/horizon-ultra/pack.toml new file mode 100644 index 000000000..446115073 --- /dev/null +++ b/examples/shaderpacks/horizon-ultra/pack.toml @@ -0,0 +1,134 @@ +# Horizon Ultra: multi-pass API 2 WGSL shader pack with PCF directional shadows, +# G-buffer GTAO, water SSR & absorption, volumetric godrays, HDR bloom and ACES tonemapping. +[pack] +name = "Horizon Ultra" +description = "PCF sun/moon shadows, GTAO, water reflections, volumetric godrays, bloom and ACES filmic tonemapping." +authors = ["Horizon contributors"] +version = "2.0.0" +license = "MIT" +api = 2 + +[[stage]] +kind = "deferred" +shader = "shaders/deferred_lighting.wgsl" +format = "rgba16float" + +[[stage]] +kind = "composite" +shader = "shaders/water_reflections.wgsl" +format = "rgba16float" + +[[stage]] +kind = "composite" +shader = "shaders/bloom_godrays.wgsl" +scale = 0.5 +format = "rgba16float" +mipmap = true + +[[stage]] +kind = "final" +shader = "shaders/final_tonemap.wgsl" + +[profiles.low] +shadows = false +ao_strength = 0.25 +water_ssr = false +godrays = false +bloom_strength = 0.15 +tonemap_aces = true +vignette = false + +[profiles.medium] +shadows = true +shadow_strength = 0.70 +ao_strength = 0.50 +water_ssr = true +godrays = true +bloom_strength = 0.25 +tonemap_aces = true +vignette = true + +[profiles.high] +shadows = true +shadow_strength = 0.85 +ao_strength = 0.75 +water_ssr = true +godrays = true +bloom_strength = 0.35 +tonemap_aces = true +vignette = true + +[profiles.ultra] +shadows = true +shadow_strength = 1.0 +ao_strength = 1.0 +water_ssr = true +godrays = true +bloom_strength = 0.45 +tonemap_aces = true +vignette = true + +[options.shadows] +label = "Directional Shadows" +description = "Cast real-time sun and moon PCF shadows across terrain and entities." +default = true + +[options.shadow_strength] +label = "Shadow Strength" +description = "Intensity of directional sun and moon shadows." +default = 0.85 +min = 0.0 +max = 1.0 +step = 0.05 + +[options.ao_strength] +label = "Ambient Occlusion (GTAO)" +description = "Screen-space horizon ambient occlusion in corners and crevices." +default = 0.75 +min = 0.0 +max = 1.5 +step = 0.05 + +[options.water_ssr] +label = "Water Reflections & Refraction" +description = "Screen-space sky and terrain reflections on water and translucent surfaces." +default = true + +[options.godrays] +label = "Volumetric Godrays" +description = "Atmospheric light shafts cast through trees and terrain towards the sun." +default = true + +[options.bloom_strength] +label = "HDR Bloom" +description = "Soft glow around bright sky, lava, torches and emissive blocks." +default = 0.35 +min = 0.0 +max = 1.0 +step = 0.05 + +[options.exposure] +label = "Exposure" +description = "Overall scene exposure multiplier before filmic tonemapping." +default = 1.10 +min = 0.5 +max = 2.0 +step = 0.05 + +[options.saturation] +label = "Color Saturation" +description = "Color vibrancy of the final tonemapped image." +default = 1.12 +min = 0.0 +max = 2.0 +step = 0.05 + +[options.tonemap_aces] +label = "ACES Filmic Tonemap" +description = "Apply ACES fitted filmic curve to preserve highlight detail." +default = true + +[options.vignette] +label = "Cinematic Vignette" +description = "Subtle darkening at the edges of the viewport." +default = true diff --git a/examples/shaderpacks/horizon-ultra/shaders/bloom_godrays.wgsl b/examples/shaderpacks/horizon-ultra/shaders/bloom_godrays.wgsl new file mode 100644 index 000000000..534e9d983 --- /dev/null +++ b/examples/shaderpacks/horizon-ultra/shaders/bloom_godrays.wgsl @@ -0,0 +1,61 @@ +// Stage 3 (Composite, half-resolution): HDR bloom extraction + 9-tap tent filter +// and radial volumetric light shafts (godrays) towards the sun/moon. +override godrays: bool = true; +override bloom_strength: f32 = 0.35; + +@fragment fn fs_main(in: StageIn) -> @location(0) vec4<f32> { + let base = textureSampleLevel(previous, linear_sampler, in.uv, 0.0).rgb; + let texel = frame.resolution.zw * 2.0; + + // 9-tap soft bloom filter around bright highlights. + var bloom = vec3(0.0); + if bloom_strength > 0.001 { + let offsets = array<vec2<f32>, 9>( + vec2(0.0, 0.0), + vec2(1.0, 0.0), + vec2(-1.0, 0.0), + vec2(0.0, 1.0), + vec2(0.0, -1.0), + vec2(1.0, 1.0), + vec2(-1.0, 1.0), + vec2(1.0, -1.0), + vec2(-1.0, -1.0), + ); + let weights = array<f32, 9>(0.25, 0.125, 0.125, 0.125, 0.125, 0.0625, 0.0625, 0.0625, 0.0625); + for (var i = 0u; i < 9u; i++) { + let sample_c = textureSampleLevel(previous, linear_sampler, in.uv + offsets[i] * texel, 0.0).rgb; + let lum = luminance(sample_c); + let bright = max(lum - 0.72, 0.0) / max(lum, 1e-4); + bloom += sample_c * bright * weights[i]; + } + } + + // Radial volumetric godrays cast from the sun's screen projection. + var shafts = vec3(0.0); + if godrays && frame.camera_state.x == 0.0 && frame.dimension.y > 0.5 { + let sun_clip = frame.projection * (frame.view * vec4(frame.sun.xyz * 128.0, 1.0)); + if sun_clip.w > 0.0 { + let sun_ndc = sun_clip.xy / sun_clip.w; + let sun_uv = vec2(sun_ndc.x * 0.5 + 0.5, 0.5 - sun_ndc.y * 0.5); + let delta = (sun_uv - in.uv) / 12.0; + var uv_Cursor = in.uv; + var transmittance = 0.0; + var decay = 1.0; + for (var s = 0u; s < 12u; s++) { + uv_Cursor += delta; + let sample_uv = clamp(uv_Cursor, vec2(0.001), vec2(0.999)); + if is_sky(depth_at(sample_uv)) { + transmittance += decay; + } + decay *= 0.92; + } + let ray = normalize(world_offset(in.uv, 1e-5)); + let sun_facing = pow(max(dot(ray, frame.sun.xyz), 0.0), 4.0); + let sunset = smoothstep(-0.1, 0.25, frame.sun.y); + let shaft_color = mix(vec3(1.0, 0.55, 0.25), vec3(1.0, 0.92, 0.75), sunset); + shafts = shaft_color * (transmittance / 12.0) * sun_facing * 0.28 * (1.0 - frame.weather.x); + } + } + + return vec4(base + bloom * bloom_strength + shafts, 1.0); +} diff --git a/examples/shaderpacks/horizon-ultra/shaders/deferred_lighting.wgsl b/examples/shaderpacks/horizon-ultra/shaders/deferred_lighting.wgsl new file mode 100644 index 000000000..3930a5c21 --- /dev/null +++ b/examples/shaderpacks/horizon-ultra/shaders/deferred_lighting.wgsl @@ -0,0 +1,92 @@ +// Stage 1 (Deferred): G-buffer normal reconstruction, multi-tap GTAO ambient +// occlusion, directional sun/moon PCF shadow mapping, and rain puddle wetness. +override shadows: bool = true; +override shadow_strength: f32 = 0.85; +override ao_strength: f32 = 0.75; + +fn compute_gtao(uv: vec2<f32>, depth: f32, view_pos: vec3<f32>) -> f32 { + if ao_strength <= 0.001 { + return 1.0; + } + let step_uv = frame.resolution.zw * 2.5; + let offsets = array<vec2<f32>, 8>( + vec2(1.0, 0.0), + vec2(-1.0, 0.0), + vec2(0.0, 1.0), + vec2(0.0, -1.0), + vec2(0.707, 0.707), + vec2(-0.707, 0.707), + vec2(0.707, -0.707), + vec2(-0.707, -0.707), + ); + var occlusion = 0.0; + for (var i = 0u; i < 8u; i++) { + let sample_uv = clamp(uv + offsets[i] * step_uv, vec2(0.001), vec2(0.999)); + let sd = opaque_depth_at(sample_uv); + if !is_sky(sd) { + let sp = view_position(sample_uv, sd); + let diff = sp - view_pos; + let dist = length(diff); + if dist > 0.02 && dist < 3.5 { + let horizon = clamp(diff.z / dist, 0.0, 1.0); + occlusion += horizon * smoothstep(3.5, 0.2, dist); + } + } + } + return clamp(1.0 - (occlusion * 0.18 * ao_strength), 0.15, 1.0); +} + +@fragment fn fs_main(in: StageIn) -> @location(0) vec4<f32> { + let base_srgb = textureSampleLevel(scene_color, linear_sampler, in.uv, 0.0).rgb; + var color = srgb_to_linear(base_srgb); + let depth = opaque_depth_at(in.uv); + let light_dir = normalize(select(frame.moon.xyz, frame.sun.xyz, frame.sun.y >= -0.05)); + let sun_elevation = clamp(frame.sun.y, -1.0, 1.0); + let day_factor = smoothstep(-0.08, 0.18, sun_elevation); + let sunset_factor = smoothstep(-0.12, 0.05, sun_elevation) * (1.0 - smoothstep(0.05, 0.35, sun_elevation)); + + if is_sky(depth) { + let ray = normalize(world_offset(in.uv, 1e-5)); + let sun_dot = max(dot(ray, frame.sun.xyz), 0.0); + let mie = pow(sun_dot, 12.0) * (0.35 + 0.65 * sunset_factor) * (1.0 - frame.weather.x * 0.8); + let sun_tint = mix(vec3(1.0, 0.88, 0.68), vec3(1.0, 0.45, 0.18), sunset_factor); + color += sun_tint * mie * 0.85; + return vec4(color, 1.0); + } + + let world_rel = world_offset(in.uv, depth); + let view_pos = view_position(in.uv, depth); + let normal = world_normal_at(in.uv); + let mat = material_at(in.uv); + + // Ambient occlusion from depth discontinuity neighborhood. + let ao = compute_gtao(in.uv, depth, view_pos); + + // Directional sun/moon shadow factor. + var shadow = 1.0; + if shadows && frame.dimension.y > 0.5 { + let raw_shadow = sample_shadow(world_rel, normal); + shadow = mix(1.0, raw_shadow, shadow_strength); + } + + let ndotl = max(dot(normal, light_dir), 0.0); + let sun_color = mix( + vec3(0.22, 0.28, 0.48), + mix(vec3(1.05, 0.96, 0.86), vec3(1.18, 0.58, 0.28), sunset_factor), + day_factor, + ); + let sky_ambient = mix(vec3(0.08, 0.11, 0.20), srgb_to_linear(frame.sky_color.rgb) * 0.55, day_factor); + let direct_light = sun_color * ndotl * shadow * (1.0 - frame.weather.x * 0.55); + let bounce_light = sky_ambient * (0.45 + 0.55 * max(normal.y, 0.0)) * ao; + + // Wetness specular sheen during rain on upward-facing surfaces. + let wetness = frame_ext.environment.z; + let view_dir = normalize(-world_rel); + let half_vec = normalize(light_dir + view_dir); + let wet_mask = wetness * smoothstep(0.65, 0.95, normal.y) * mat.g; + let spec = pow(max(dot(normal, half_vec), 0.0), 48.0) * wet_mask * shadow * 0.65; + + let shade_boost = mix(0.68 * ao, 1.0 + 0.35 * ndotl * shadow, 0.65); + color = color * shade_boost + color * direct_light * 0.32 + bounce_light * 0.08 + sun_color * spec; + return vec4(max(color, vec3(0.0)), 1.0); +} diff --git a/examples/shaderpacks/horizon-ultra/shaders/final_tonemap.wgsl b/examples/shaderpacks/horizon-ultra/shaders/final_tonemap.wgsl new file mode 100644 index 000000000..397abafa9 --- /dev/null +++ b/examples/shaderpacks/horizon-ultra/shaders/final_tonemap.wgsl @@ -0,0 +1,29 @@ +// Stage 4 (Final): Combines full-resolution scene with bloom/godrays, applies +// exposure, ACES filmic tonemapping, saturation, and cinematic vignette. +override exposure: f32 = 1.10; +override saturation: f32 = 1.12; +override tonemap_aces: bool = true; +override vignette: bool = true; + +@fragment fn fs_main(in: StageIn) -> @location(0) vec4<f32> { + var hdr = textureSampleLevel(previous, linear_sampler, in.uv, 0.0).rgb * exposure; + + if tonemap_aces { + hdr = aces_tonemap(hdr); + } else { + hdr = clamp(hdr, vec3(0.0), vec3(1.0)); + } + + var srgb = linear_to_srgb(hdr); + let luma = luminance(srgb); + let rain_desat = 1.0 - 0.25 * max(frame.weather.x, frame.weather.y); + srgb = mix(vec3(luma), srgb, saturation * rain_desat); + + if vignette { + let aspect = frame.resolution.x * frame.resolution.w; + let d = length((in.uv - 0.5) * vec2(aspect, 1.0)); + srgb *= 1.0 - 0.26 * smoothstep(0.48, 0.98, d); + } + + return vec4(clamp(srgb, vec3(0.0), vec3(1.0)), 1.0); +} diff --git a/examples/shaderpacks/horizon-ultra/shaders/water_reflections.wgsl b/examples/shaderpacks/horizon-ultra/shaders/water_reflections.wgsl new file mode 100644 index 000000000..853cf78f5 --- /dev/null +++ b/examples/shaderpacks/horizon-ultra/shaders/water_reflections.wgsl @@ -0,0 +1,58 @@ +// Stage 2 (Composite): Screen-space water reflections (SSR), Fresnel Schlick, +// and Beer-Lambert underwater depth absorption using scene_depth vs opaque_depth. +override water_ssr: bool = true; + +@fragment fn fs_main(in: StageIn) -> @location(0) vec4<f32> { + var color = textureSampleLevel(previous, linear_sampler, in.uv, 0.0).rgb; + let surface_depth = depth_at(in.uv); + let floor_depth = opaque_depth_at(in.uv); + let mat = material_at(in.uv); + + // Translucent water/glass layer exists where surface_depth is closer than floor_depth + // (reversed depth: closer = larger value) or where the G-buffer water mask is set. + let is_translucent = (surface_depth > floor_depth + 1e-5) || (mat.b > 0.5); + if !water_ssr || is_sky(surface_depth) || !is_translucent { + return vec4(color, 1.0); + } + + let water_pos = world_offset(in.uv, surface_depth); + let floor_pos = world_offset(in.uv, max(floor_depth, 1e-6)); + let water_column = clamp(length(floor_pos - water_pos), 0.0, 32.0); + + // Beer-Lambert depth absorption in deep water. + let absorption = exp(-vec3(0.22, 0.07, 0.03) * water_column * 0.35); + color *= mix(vec3(1.0), absorption, clamp(water_column * 0.08, 0.0, 0.65)); + + // Wave normal perturbation and Fresnel reflection. + let world_xz = (water_pos.xz + frame.camera_position.xz) * 0.08; + let wave_uv = world_xz + vec2(frame.time.x * 0.015, -frame.time.x * 0.011); + let noise_sample = textureSampleLevel(noise_texture, repeat_sampler, wave_uv, 0.0).rgb * 2.0 - 1.0; + let normal = normalize(vec3(noise_sample.x * 0.06, 1.0, noise_sample.y * 0.06)); + let view_dir = normalize(-water_pos); + let refl_dir = reflect(-view_dir, normal); + let fresnel = clamp(0.04 + 0.96 * pow(1.0 - max(dot(view_dir, normal), 0.0), 4.0), 0.0, 0.85); + + // Ray-march 8 steps in screen space along the reflection ray. + var refl_color = srgb_to_linear(frame.sky_color.rgb); + let sun_spec = pow(max(dot(refl_dir, frame.sun.xyz), 0.0), 96.0) * 2.5 * (1.0 - frame.weather.x); + refl_color += vec3(1.0, 0.9, 0.7) * sun_spec; + + for (var step = 1u; step <= 8u; step++) { + let march_pos = water_pos + refl_dir * (f32(step) * 2.2); + let clip = frame.projection * (frame.view * vec4(march_pos, 1.0)); + if clip.w > 0.0 { + let ndc = clip.xyz / clip.w; + let sample_uv = vec2(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5); + if all(sample_uv >= vec2(0.01)) && all(sample_uv <= vec2(0.99)) { + let scene_d = opaque_depth_at(sample_uv); + if !is_sky(scene_d) && ndc.z <= scene_d && (scene_d - ndc.z) < 0.08 { + refl_color = textureSampleLevel(previous, linear_sampler, sample_uv, 0.0).rgb; + break; + } + } + } + } + + color = mix(color, refl_color, fresnel * 0.55); + return vec4(color, 1.0); +} From 0e36cb4d7a913033a4b179dd03c0d498a0a11579 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 08:11:22 +0200 Subject: [PATCH 39/62] Beds: respawning checks the bed and stands up beside it, else the world spawn A bed sets the respawn point as vanilla's ServerPlayer.startSleepInBed does (once in reach, day or night): a RespawnConfig at the bed's head with the player's yaw, not forced; straw beds never set it (straw_bed_rule). Respawning resolves it through findRespawnAndUseSpawnBlock, which now handles beds: AbstractBedBlock.findStandUpPosition (beside the bed on the side away from the yaw it was set from, around it, then on it; bunk beds too) through DismountHelper, facing the bed. A bed that is gone or boxed in sends the player to the world spawn with "You have no home bed or charged respawn anchor, or it was obstructed", and the point is forgotten: in the window's world, on the server thread and for LAN guests. Leaving the End goes to the bed too (not using it up). Saves keep a bed as the player's `respawn` (resolved through its block when loaded), and a `spawnpoint` in the Overworld as forced. A fallback that is the world spawn follows `setworldspawn` with a bed or anchor set. tools/test_use_item_on_parity.py: respawn cases at a bed's head set from some yaw (intact, bunk, only the foot left or gone, crowded), against vanilla's real findRespawnAndUseSpawnBlock; 4000/4000 and 12000/12000 on two seeds. lan_e2e `beds`: intact, gone and boxed in, host and guest. Fixes #1308 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game.rs | 42 +++++--- crates/horizon-client/src/game/commands.rs | 7 +- .../src/game/dispense_fixture.rs | 12 +-- crates/horizon-client/src/game/end.rs | 21 +++- crates/horizon-client/src/game/lan_actions.rs | 34 ++++++- .../horizon-client/src/game/respawn_anchor.rs | 99 ++++++++++++++++++- .../horizon-client/src/game/server_travel.rs | 31 ++++-- crates/horizon-client/src/save.rs | 18 +++- .../parity/VanillaDispenserOracle.java | 3 +- tools/lan_e2e.py | 65 +++++++++++- tools/test_use_item_on_parity.py | 56 ++++++++++- 11 files changed, 335 insertions(+), 53 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 40a108d40..af495c98f 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9146,31 +9146,41 @@ impl Game<'_> { } else { pos }; - self.spawn = Some(Vec3::new( - f64::from(head[0]) + 0.5, - f64::from(head[1]) + 0.6, - f64::from(head[2]) + 0.5, - )); - // The bed replaces a respawn anchor. - self.respawn_config = None; - self.level.spawn = Some([ - f64::from(head[0]), - f64::from(head[1]) + 1.0, - f64::from(head[2]), - ]); let dist = ((p.position.x - f64::from(head[0]) - 0.5).powi(2) + (p.position.z - f64::from(head[2]) - 0.5).powi(2)) .sqrt(); - if !night { + if dist > 3.0 { self.message = Some(( - "You can sleep only at night or during thunderstorms".into(), + "You may not rest now; the bed is too far away".into(), Instant::now(), )); return; } - if dist > 3.0 { + // In reach (bedInRange), day or night: setRespawnPosition( + // RespawnConfig(the head, the player's yaw), not forced). It replaces + // an anchor or a spawnpoint; respawning checks the bed is still there + // and finds where to stand up (findRespawnAndUseSpawnBlock). + // Straw beds never set it (`straw_bed_rule`). + if self.bed_sets_spawn(state) { + self.respawn_config = Some(respawn_anchor::RespawnConfig::wrapped( + self.dim, head, p.yaw, false, + )); + // The fallback becomes the world spawn: a guest's is none of its + // own, so it follows `setworldspawn`. + self.spawn = if self.lan_acting.is_some() { + None + } else { + self.level + .world_spawn + .map(|[x, y, z]| { + Vec3::new(f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5) + }) + .or(self.spawn) + }; + } + if !night { self.message = Some(( - "You may not rest now; the bed is too far away".into(), + "You can sleep only at night or during thunderstorms".into(), Instant::now(), )); return; diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index d4ff91a49..fb1e57ad6 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -2340,10 +2340,11 @@ impl Game<'_> { // LevelData.setRespawnData: the world's spawn (level.dat `spawn`). let old = self.level.world_spawn.replace(pos); self.level.world_spawn_angle = rot; - // A player whose respawn point is the world spawn (no bed, anchor or - // spawnpoint of its own) respawns at the new one. + // A player whose fallback is the world spawn (no spawnpoint of its + // own; a bed or an anchor that is gone falls back to it) respawns at + // the new one. let floor = |s: Vec3| [s.x.floor() as i32, s.y.floor() as i32, s.z.floor() as i32]; - if self.respawn_config.is_none() && self.spawn.map(floor) == old { + if self.spawn.map(floor) == old { self.spawn = Some(Vec3::new( f64::from(pos[0]) + 0.5, f64::from(pos[1]), diff --git a/crates/horizon-client/src/game/dispense_fixture.rs b/crates/horizon-client/src/game/dispense_fixture.rs index 3de4341ad..752785084 100644 --- a/crates/horizon-client/src/game/dispense_fixture.rs +++ b/crates/horizon-client/src/game/dispense_fixture.rs @@ -291,12 +291,12 @@ impl Game<'_> { used = self.fixture_use_item(origin, op)?; } else if let Some(op) = case.get("respawn_at") { // ServerPlayer.findRespawnAndUseSpawnBlock for a respawn point at the origin. - let config = super::respawn_anchor::RespawnConfig { - dim: self.dim, - pos: [origin.x, origin.y, origin.z], - yaw: 0.0, - forced: op["forced"].as_bool().unwrap_or(false), - }; + let config = super::respawn_anchor::RespawnConfig::wrapped( + self.dim, + [origin.x, origin.y, origin.z], + op["yaw"].as_f64().map_or(0.0, |v| v as f32), + op["forced"].as_bool().unwrap_or(false), + ); let found = self.find_respawn_and_use(config, op["consume"].as_bool().unwrap_or(true))?; used.push(match found { diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs index c3f34ebd3..d62c8ccc2 100644 --- a/crates/horizon-client/src/game/end.rs +++ b/crates/horizon-client/src/game/end.rs @@ -416,7 +416,15 @@ impl Game<'_> { f64::from(END_SPAWN[2]) + 0.5, )); } - // Leaving the End: the respawn position (the world spawn here). + // Leaving the End: the respawn position, a bed's found once it has + // loaded (findRespawnPositionAndUseSpawnBlock, not using it up). + if let Some(c) = self.respawn_config.filter(|c| c.dim == target) { + return Some(Vec3::new( + f64::from(c.pos[0]) + 0.5, + f64::from(c.pos[1]), + f64::from(c.pos[2]) + 0.5, + )); + } let s = self.level.spawn.unwrap_or([0.0, 64.0, 0.0]); Some(Vec3::new(s[0].floor() + 0.5, s[1], s[2].floor() + 0.5)) } @@ -487,7 +495,16 @@ impl Game<'_> { // Direction.WEST.toYRot(). return Ok((target, Some(90.0))); } - // ServerPlayer.findRespawnPositionAndUseSpawnBlock: onto the spawn column. + // ServerPlayer.findRespawnPositionAndUseSpawnBlock: where the bed or + // anchor puts the player, facing it; else onto the spawn column. + let mut target = target; + if let Some(c) = self.respawn_config.filter(|c| c.dim == self.dim) { + if let Some((at, yaw)) = self.find_respawn_and_use(c, false)? { + return Ok((at, Some(yaw))); + } + let s = self.level.spawn.unwrap_or([0.0, 64.0, 0.0]); + target = Vec3::new(s[0].floor() + 0.5, s[1], s[2].floor() + 0.5); + } let y = self .land_column(target.x.floor() as i32, target.z.floor() as i32) .map_or(target.y, f64::from); diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 540f857d3..0527e30a0 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -1507,11 +1507,22 @@ impl Game<'_> { // or another one's anchor or forced point, which its block resolves // once the level has loaded around it. let server = self.options.dedicated.is_some(); - let elsewhere = host.hub.guests[i] + let own = host.hub.guests[i] .respawn_elsewhere .as_ref() - .filter(|_| server) .map(RespawnConfig::from_saved); + let elsewhere = own.filter(|_| server); + // In the window's world a guest has no level of its own to wait in: + // its bed is resolved at once when its chunk is there, else it + // comes back on the bed. + let in_frame_bed = own.filter(|c| !server && c.dim == super::Dim::Overworld); + let spawn = in_frame_bed.map_or(spawn, |c| { + [ + f64::from(c.pos[0]) + 0.5, + f64::from(c.pos[1]) + 0.6, + f64::from(c.pos[2]) + 0.5, + ] + }); let level = elsewhere.map_or(super::Dim::Overworld, |c| c.dim); let spawn = elsewhere.map_or(spawn, |c| { [ @@ -1569,6 +1580,25 @@ impl Game<'_> { if let Some(config) = elsewhere { self.respawn_trip(conn, config); } + if let Some(c) = in_frame_bed + && self.dim == super::Dim::Overworld + && self.world.loaded(c.pos[0], c.pos[2]) + { + let found = self + .as_guest(host, conn, |g| g.resolve_server_respawn(c)) + .flatten(); + let world = self + .level + .world_spawn + .map_or([0.5, 80.0, 0.5], |[x, y, z]| { + [f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5] + }); + let at = found.map_or(world, |(at, yaw)| { + host.hub.guests[i].yaw = yaw; + [at.x, at.y, at.z] + }); + host.hub.teleport(i, Some(at)); + } if away && let Err(e) = self.enter_level(Some(host), back) { log::error!("could not reopen {}: {e}", back.id()); } diff --git a/crates/horizon-client/src/game/respawn_anchor.rs b/crates/horizon-client/src/game/respawn_anchor.rs index 9b6ecc203..392a53964 100644 --- a/crates/horizon-client/src/game/respawn_anchor.rs +++ b/crates/horizon-client/src/game/respawn_anchor.rs @@ -36,6 +36,15 @@ pub(super) struct RespawnConfig { pub(super) type SavedRespawn = (String, [i32; 3], f32, bool); impl RespawnConfig { + /// `RespawnData.of`: the yaw wrapped to [-180, 180). + pub(super) fn wrapped(dim: Dim, pos: [i32; 3], yaw: f32, forced: bool) -> Self { + Self { + dim, + pos, + yaw: wrap_degrees(f64::from(yaw)) as f32, + forced, + } + } pub(super) fn from_saved((dim, pos, yaw, forced): &SavedRespawn) -> Self { Self { dim: Dim::from_id(dim), @@ -80,7 +89,7 @@ pub(super) enum AnchorUse { } impl Game<'_> { - fn is_anchor(&self, state: BlockStateId) -> bool { + pub(super) fn is_anchor(&self, state: BlockStateId) -> bool { &*self.res.facts().get(state).name == "minecraft:respawn_anchor" } fn anchor_charges(&self, state: BlockStateId) -> i32 { @@ -456,9 +465,87 @@ impl Game<'_> { } None } + /// `AbstractBedBlock.findStandUpPosition` for a bed whose head is at + /// `pos`, facing `forward`, set from `yaw`: beside the bed on the side + /// the player faced away from, around it, then on it; a safe spot + /// first, else any spot (a bunk bed: around it, a block lower, then on + /// it). + pub(super) fn bed_stand_up(&self, pos: [i32; 3], forward: [i32; 3], yaw: f32) -> Option<Vec3> { + // Direction.getClockWise. + let right = [-forward[2], 0, forward[0]]; + // Direction.isFacingAngle. + let radians = yaw * 0.017_453_292; + let (dx, dz) = ( + -horizon_core::geometry::trig::sin(f64::from(radians)), + horizon_core::geometry::trig::cos(f64::from(radians)), + ); + let facing = right[0] as f32 * dx + right[2] as f32 * dz > 0.0; + let side = if facing { + [-right[0], 0, -right[2]] + } else { + right + }; + let (f, s) = ([forward[0], forward[2]], [side[0], side[2]]); + // bedSurroundStandUpOffsets and bedAboveStandUpOffsets. + let surround = [ + [s[0], s[1]], + [s[0] - f[0], s[1] - f[1]], + [s[0] - f[0] * 2, s[1] - f[1] * 2], + [-f[0] * 2, -f[1] * 2], + [-s[0] - f[0] * 2, -s[1] - f[1] * 2], + [-s[0] - f[0], -s[1] - f[1]], + [-s[0], -s[1]], + [-s[0] + f[0], -s[1] + f[1]], + [f[0], f[1]], + [s[0] + f[0], s[1] + f[1]], + ]; + let above = [[0, 0], [-f[0], -f[1]]]; + let at = |base: [i32; 3], offsets: &[[i32; 2]], check: bool| { + offsets.iter().find_map(|o| { + self.safe_dismount_location([base[0] + o[0], base[1], base[2] + o[1]], check) + }) + }; + let below = [pos[0], pos[1] - 1, pos[2]]; + // isBunkBed: a bed below. + if self.is_bed(self.world.block(below[0], below[1], below[2])) { + return at(pos, &surround, true) + .or_else(|| at(below, &surround, true)) + .or_else(|| at(pos, &above, true)) + .or_else(|| at(pos, &surround, false)) + .or_else(|| at(below, &surround, false)) + .or_else(|| at(pos, &above, false)); + } + let all: Vec<[i32; 2]> = surround.into_iter().chain(above).collect(); + at(pos, &all, true).or_else(|| at(pos, &all, false)) + } + pub(super) fn is_bed(&self, state: BlockStateId) -> bool { + self.res.facts().get(state).name.ends_with("_bed") + } + /// The bed's `facing`, as a step. + fn bed_forward(&self, state: BlockStateId) -> [i32; 3] { + let facing = self + .pack + .assets + .registry + .state(state) + .and_then(|s| s.properties.get("facing").cloned()); + match facing.as_deref() { + Some("south") => [0, 0, 1], + Some("west") => [-1, 0, 0], + Some("east") => [1, 0, 0], + _ => [0, 0, -1], + } + } + /// `BedRule.canSetSpawn` of the bed's rule attribute (`bed_rule`, + /// `straw_bed_rule`): only the Overworld's beds set the spawn, straw + /// beds never. + pub(super) fn bed_sets_spawn(&self, state: BlockStateId) -> bool { + self.dim == Dim::Overworld && &*self.res.facts().get(state).name != "minecraft:straw_bed" + } /// `ServerPlayer.findRespawnAndUseSpawnBlock` for a config in the loaded - /// dimension: the position and yaw, using an anchor's charge. A forced - /// point (`spawnpoint`) that is no anchor holds if a player fits in it. + /// dimension: the position and yaw, using an anchor's charge; a bed's + /// stand-up spot. A forced point (`spawnpoint`) that is no anchor or bed + /// holds if a player fits in it; anything else is gone. pub(super) fn find_respawn_and_use( &mut self, c: RespawnConfig, @@ -469,6 +556,12 @@ impl Game<'_> { && (c.forced || self.anchor_charges(state) > 0) && self.anchor_works()) { + // A bed where its bed rule lets it set the spawn. + if self.is_bed(state) && self.bed_sets_spawn(state) { + let facing = self.bed_forward(state); + let stand = self.bed_stand_up(c.pos, facing, c.yaw); + return Ok(stand.map(|p| (p, look_at_yaw(p, c.pos)))); + } let [x, y, z] = c.pos; let free = c.forced && !self.is_anchor(state) diff --git a/crates/horizon-client/src/game/server_travel.rs b/crates/horizon-client/src/game/server_travel.rs index 1b1ec3a6d..1e94ec995 100644 --- a/crates/horizon-client/src/game/server_travel.rs +++ b/crates/horizon-client/src/game/server_travel.rs @@ -193,11 +193,16 @@ impl Game<'_> { _ => 1.0, }; self.end_portal_travel = end; - let scaled = self.end_destination(target).unwrap_or(Vec3::new( - from.x * scale, - from.y, - from.z * scale, - )); + // Leaving the End: the player's own respawn point. + let own = if end { + self.as_guest(host, conn, |g| g.end_destination(target)) + .flatten() + } else { + None + }; + let scaled = own + .or_else(|| self.end_destination(target)) + .unwrap_or(Vec3::new(from.x * scale, from.y, from.z * scale)); self.end_portal_travel = false; if let Err(e) = self.enter_level(Some(host), target) { log::error!("could not open {}: {e}", target.id()); @@ -244,13 +249,15 @@ impl Game<'_> { } /// `findRespawnAndUseSpawnBlock` for the player in place, at its point - /// in the level in place: where it stands up, facing the anchor, with - /// the deplete sound; else the point is forgotten + /// in the level in place: where it stands up, facing the anchor (with + /// the deplete sound) or the bed; else the point is forgotten /// (`block.minecraft.spawn.not_valid`). - fn resolve_server_respawn(&mut self, config: RespawnConfig) -> Option<(Vec3, f32)> { + pub(super) fn resolve_server_respawn(&mut self, config: RespawnConfig) -> Option<(Vec3, f32)> { + let [x, y, z] = config.pos; + let anchor = self.is_anchor(self.world.block(x, y, z)); match self.find_respawn_and_use(config, true) { Ok(Some((at, yaw))) => { - if !config.forced { + if !config.forced && anchor { let [x, y, z] = config.pos.map(f64::from); self.audio.play( "minecraft:block.respawn_anchor.deplete", @@ -357,7 +364,11 @@ impl Game<'_> { } } } else if trip.end { - match self.end_arrival(trip.target) { + let arrival = match self.as_guest(host, trip.conn, |g| g.end_arrival(trip.target)) { + Some(arrival) => arrival, + None => self.end_arrival(trip.target), + }; + match arrival { Ok((at, turned)) => (at, turned.unwrap_or(yaw)), Err(e) => { log::error!("End arrival: {e}"); diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 056f38e1c..dd86c8f9c 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -2258,10 +2258,12 @@ pub struct Level { pub game_mode: i32, pub time: i64, pub day_time: i64, - /// The player's respawn point (bed, or the world spawn). + /// Where the player respawns when it has no bed or anchor: its forced + /// Overworld point (`spawnpoint`), or the world spawn. pub spawn: Option<[f64; 3]>, - /// A respawn point in another dimension than the Overworld (a respawn - /// anchor): dimension, block, yaw and `forced`. + /// A respawn point resolved through its block when the player respawns + /// (a bed, a respawn anchor, a forced point outside the Overworld): + /// dimension, block, yaw and `forced`. pub respawn_elsewhere: Option<(String, [i32; 3], f32, bool)>, pub position: Option<[f64; 3]>, pub rotation: [f32; 2], @@ -2495,14 +2497,17 @@ impl Level { { let dimension = text(respawn.get("dimension")).unwrap_or_else(|| "minecraft:overworld".into()); - if dimension == "minecraft:overworld" { + let forced = number(respawn.get("forced")).is_some_and(|v| v != 0); + // A forced point in the Overworld (`spawnpoint`) is where the + // player respawns; anything else (a bed, an anchor) is resolved + // through its block then. + if dimension == "minecraft:overworld" && forced { self.spawn = Some([f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])]); } else { let yaw = match respawn.get("yaw") { Some(Tag::Float(b)) => f32::from_bits(*b), _ => 0.0, }; - let forced = number(respawn.get("forced")).is_some_and(|v| v != 0); self.respawn_elsewhere = Some((dimension, [pos[0], pos[1], pos[2]], yaw, forced)); } } @@ -2719,6 +2724,8 @@ impl Level { s[1].floor() as i32, s[2].floor() as i32, ]; + // A point of the player's own in the Overworld other than a bed + // (`respawn_elsewhere`): `spawnpoint`'s, forced. if Some(block) != self.world_spawn { entries.push(( "respawn", @@ -2727,6 +2734,7 @@ impl Level { ("pos", Tag::IntArray(block.to_vec())), ("yaw", Tag::Float(0f32.to_bits())), ("pitch", Tag::Float(0f32.to_bits())), + ("forced", Tag::Byte(1)), ]), )); } diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java index 43ec6d65a..a529ae6ac 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java @@ -655,7 +655,8 @@ public final class VanillaDispenserOracle { */ static List<String> respawnAt(VanillaBlockUpdateOracle.World w, BlockPos pos, JsonObject op) throws Exception { var config = new net.minecraft.server.level.ServerPlayer.RespawnConfig( - net.minecraft.world.level.storage.LevelData.RespawnData.of(w.dimension(), pos, 0.0F, 0.0F), op.get("forced").getAsBoolean()); + net.minecraft.world.level.storage.LevelData.RespawnData.of(w.dimension(), pos, + op.has("yaw") ? op.get("yaw").getAsFloat() : 0.0F, 0.0F), op.get("forced").getAsBoolean()); Method find = net.minecraft.server.level.ServerPlayer.class.getDeclaredMethod("findRespawnAndUseSpawnBlock", ServerLevel.class, net.minecraft.server.level.ServerPlayer.RespawnConfig.class, boolean.class); find.setAccessible(true); diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 8a6cbbb4e..4d250b7a6 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -144,8 +144,11 @@ address. The script then checks, from both sides, what a guest's game used to ge than in the air on their own client as on the server, and it breaks (#1254). - worldspawn: the host moves the world spawn (`setworldspawn`): the host and the guest, with no bed, respawn there (#1310). -- shield: the host axes the guest's raised shield, then the guest the host's: it stays disabled - for 5 s on that player's own cooldown, then blocks again (#1316). +- shield: a vindicator's axe disables the host's, then the guest's, raised shield: the server + counts its 5 s cooldown down once a tick (#1316). +- beds: the host and the guest each set their respawn point at a bed and die elsewhere: they + stand up beside the bed, or, when the bed is gone or boxed in by stone, come back at + the world spawn (#1308). - deathmining: the host and the guest each die while breaking obsidian and let go on the death screen: once respawned, the obsidian stays (#1315). - contacts: the host and the guest each stand on magma (and sneak on it), stand on a lit campfire, @@ -198,7 +201,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts', 'worldspawn', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater'] class Game: @@ -2842,6 +2845,60 @@ def check_world_spawn(host, guest, out): return seen +def check_beds(host, guest, out): + """A bed sets the respawn point (day or night): respawning stands the player up beside it; a bed + that is gone, or boxed in by stone so there is nowhere to stand up, sends the player to the world + spawn instead (#1308). The host, then the guest, each for the three beds.""" + hx, hy, hz = (int(v // 1) for v in pos_of(host)) + host('command', command='gamerule respawn_radius 0') + host('command', command=f'setworldspawn {hx} {hy} {hz}') + host('command', command='time set 1000') + seen = {} + try: + for game, dz in ((host, -6), (guest, 6)): + game('command', command='gamemode survival') + x, y, z = hx + 12, hy, hz + dz + for case in ('intact', 'gone', 'boxed'): + game('command', command=f'fill {x - 3} {y - 1} {z - 3} {x + 4} {y - 1} {z + 3} minecraft:stone') + game('command', command=f'fill {x - 3} {y} {z - 3} {x + 4} {y + 3} {z + 3} minecraft:air') + game('command', command=f'setblock {x} {y} {z} minecraft:red_bed[facing=east,part=foot]') + game('command', command=f'setblock {x + 1} {y} {z} minecraft:red_bed[facing=east,part=head]') + game('command', command=f'tp @s {x + 0.5} {y} {z + 1.5}') + game.wait(20) + game.raw('interact', x + 1, y, z) + game.wait(10) + # Die elsewhere, by the world spawn. + game('command', command=f'tp @s {hx + 0.5} {hy} {hz + 3.5}') + game.wait(10) + if case == 'gone': + game('command', command=f'fill {x} {y} {z} {x + 1} {y} {z} minecraft:air') + elif case == 'boxed': + game('command', command=f'fill {x - 2} {y} {z - 2} {x + 3} {y + 2} {z + 2} minecraft:stone replace minecraft:air') + game.wait(5) + game('command', command='kill @s') + game.wait(20) + respawn_when_ready(game) + game.wait(60) + at = [round(v, 2) for v in pos_of(game)] + seen[f'{game.name}-{case}'] = {'at': at, 'bed': [x + 1, y, z], 'health': own(game)['health']} + game.shot(out, f'beds-{case}') + finally: + host('command', command='gamerule respawn_radius 10') + host('command', command='time set 1000') + for game in (host, guest): + game('command', command=f'tp @s {hx + 0.5} {hy} {hz + 0.5}') + guest.wait(20) + for case, s in seen.items(): + (px, py, pz), (bx, by, bz) = s['at'], s['bed'] + if case.endswith('intact'): + near = ((px - bx - 0.5) ** 2 + (pz - bz - 0.5) ** 2) ** 0.5 + assert near < 2.6 and abs(py - by) < 0.6, f'{case}: not beside its bed: {seen}' + else: + assert abs(px - (hx + 0.5)) < 1 and abs(pz - (hz + 0.5)) < 1, f'{case}: not at the world spawn: {seen}' + assert s['health'] > 0, f'{case}: died again after respawning: {seen}' + return seen + + def check_death_mining(host, guest, out): """A player who dies while breaking obsidian, and lets go of attack on the death screen, doesn't break it once respawned: death forgets the digging (#1315).""" @@ -3759,7 +3816,7 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts, - 'worldspawn': check_world_spawn, 'shield': check_shield, 'deathmining': check_death_mining, + 'worldspawn': check_world_spawn, 'beds': check_beds, 'shield': check_shield, 'deathmining': check_death_mining, 'contacts': check_contacts, 'absorption': check_absorption, 'breath': check_breath, 'lava': check_lava, 'levels': check_levels, 'drops': check_drops, 'underwater': check_underwater} diff --git a/tools/test_use_item_on_parity.py b/tools/test_use_item_on_parity.py index 398f55a92..d6e5f899f 100644 --- a/tools/test_use_item_on_parity.py +++ b/tools/test_use_item_on_parity.py @@ -23,7 +23,9 @@ explode elsewhere (`RespawnAnchorBlock`, through the stand-in level's real `ServerExplosion`, with water at the anchor). Respawn cases call `ServerPlayer.findRespawnAndUseSpawnBlock` on an anchor among blocks (`RespawnAnchorBlock.findStandUpPosition` through `DismountHelper`): the -position, the yaw that faces the anchor and the charge it uses. Beds and straw +position, the yaw that faces the anchor and the charge it uses; others on a +bed's head set from some yaw (`AbstractBedBlock.findStandUpPosition`: intact, +bunk, only the foot left or gone, crowded around and on top). Beds and straw beds clicked (head or foot, whole or broken) in the Nether and the End blow up or fall apart (`AbstractBedBlock.useWithoutItem` under the dimension's `bed_rule`: `BedBlock.destroyOnUse`, `StrawBedBlock.destroyBed`). Horizon runs @@ -90,6 +92,52 @@ BED_COLORS = ['red', 'white', 'black', 'cyan', 'lime'] FACINGS = {'north': (0, -1), 'south': (0, 1), 'west': (-1, 0), 'east': (1, 0)} +def bed_respawn_case(rng, states, case): + """Respawning at a bed's head set from some yaw: intact, a bunk bed, only the foot left or + gone, with blocks around and on it, in the Overworld (and a few in the Nether or the End).""" + name = 'straw_bed' if rng.random() < 0.15 else rng.choice(BED_COLORS) + '_bed' + facing = rng.choice(list(FACINGS)) + fx, fz = FACINGS[facing] + bed = {} + kept = rng.random() + if kept < 0.75: + bed[(0, 0, 0)] = states.get(name, facing=facing, part='head', occupied='false') + elif kept < 0.85: + bed[(0, 0, 0)] = states.get(rng.choice(['stone', 'white_carpet', 'oak_slab'])) + if kept < 0.9 or rng.random() < 0.5: + bed[(-fx, 0, -fz)] = states.get(name, facing=facing, part='foot', occupied='false') + if rng.random() < 0.2: + # A bunk bed: another bed below. + bed[(0, -1, 0)] = states.get(name, facing=facing, part='head', occupied='false') + bed[(-fx, -1, -fz)] = states.get(name, facing=facing, part='foot', occupied='false') + crowd = rng.choice([0.0, 0.1, 0.3, 0.6, 0.95]) + cells = [[*k, v] for k, v in bed.items()] + if (0, 0, 0) not in bed: + cells.insert(0, [0, 0, 0, states.get('air')]) + for dy in (-2, -1, 0, 1, 2): + for dx in range(-3, 4): + for dz in range(-3, 4): + if (dx, dy, dz) in bed or (dx, dy, dz) == (0, 0, 0): + continue + if dy == -1 and (dx, 0, dz) in bed: + name2 = 'stone' + elif dy < 0: + name2 = rng.choice(['stone'] * 8 + STAND) + elif rng.random() < crowd: + name2 = rng.choice(['stone'] * 4 + STAND) + else: + continue + if name2 == 'air': + continue + state = states.any(rng, name2) if name2 in ('oak_trapdoor', 'oak_slab', 'snow', 'campfire', 'water', 'ladder') else states.get(name2) + cells.append([dx, dy, dz, state]) + if rng.random() < 0.1: + case['dim'] = rng.choice(['nether', 'end']) + yaw = rng.choice([0.0, 90.0, -90.0, 180.0, round(rng.uniform(-720, 720), rng.choice([0, 2]))]) + case['respawn_at'] = {'forced': rng.random() < 0.15, 'consume': rng.random() < 0.8, 'yaw': yaw} + case['cells'] = cells + + def bed_case(rng, states, case): """A bed (or straw bed) clicked in the Nether or the End, among blocks.""" name = 'straw_bed' if rng.random() < 0.25 else rng.choice(BED_COLORS) + '_bed' @@ -224,6 +272,12 @@ def cases(facts, count, seed): case['mode'] = 'dispense' yield case continue + if rng.random() < 0.1: + bed_respawn_case(rng, states, case) + case['items'] = [] + case['mode'] = 'dispense' + yield case + continue if rng.random() < 0.15: anchor_case(rng, states, case) case['items'] = [] From 39438efd767c09f3b12f202917fccff1de855156 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 08:36:16 +0200 Subject: [PATCH 40/62] lan_e2e contacts: sneak before landing on magma, read health before letting go The sneaking case read the health after releasing Shift and waiting 10 ticks on the magma, so a hit from standing up counted (and one could land between the first reading and the key press). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- tools/lan_e2e.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 8f9703ddc..12921861a 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -2634,18 +2634,25 @@ def check_contacts(host, guest, out): for dx, dy, block in blocks: game('command', command=f'setblock {x + dx} {y + dy} {z} {block}') stand = 0.5 if case == 'campfire' else 0.0 + # Sneaking from before the player lands on the magma. + held = ['shift'] if case == 'sneaking' else [] + for k in held: + game.raw('key', k, 'down') + game.wait(5) game('command', command=f'tp @s {x + 0.5} {y + stand} {z + 0.5}') game.raw('look-at', f'{x + 10:.2f}', f'{y + 1.6:.2f}', f'{z + 0.5:.2f}') game.wait(30) before = own(game)['health'] - keys = (['shift'] if case == 'sneaking' else []) + (['w'] if walk else []) + keys = ['w'] if walk else [] for k in keys: game.raw('key', k, 'down') game.wait(60) - for k in keys: + # Read before letting go: standing up on the magma would hurt. + after = own(game)['health'] + for k in keys + held: game.raw('key', k, 'up') game.wait(10) - seen[f'{game.name}-{case}'] = (before, own(game)['health']) + seen[f'{game.name}-{case}'] = (before, after) game.shot(out, f'contacts-{case}') host('command', command=f'fill {x - 1} {y} {z - 1} {x + 5} {y + 2} {z + 1} minecraft:air') finally: From d522d8fe50bcd275e95629886e17be406bc40bce Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 08:38:58 +0200 Subject: [PATCH 41/62] Saved state: burning, air and falling survive a reopen; InLove for every animal - Guests' player data saves Fire, Air and fall_distance and puts them back on their body when they come back (single player's players are guests of the integrated server), so a burning player still burns after a reopen (#1323); the old single player's level.dat keeps fall_distance too (#1327). - Every Animal saves and loads InLove, so a fed animal stays in love across a reopen and is not fed again (#1396). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/entity_nbt.rs | 8 +- crates/horizon-client/src/game.rs | 1 + crates/horizon-client/src/game/lan_actions.rs | 6 ++ crates/horizon-client/src/lan/guest.rs | 29 +++++++ crates/horizon-client/src/lan/playerdata.rs | 80 ++++++++++++++++++- crates/horizon-client/src/mobs/rabbit.rs | 12 +++ crates/horizon-client/src/motion.rs | 1 + 7 files changed, 135 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index aaccdd844..7faa94e21 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -175,12 +175,15 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { for (key, value) in [ ("Age", Tag::Int(0)), ("ForcedAge", Tag::Int(0)), - ("InLove", Tag::Int(0)), ("AgeLocked", Tag::Byte(0)), ] { map.entry(key.into()).or_insert(value); } } + // Animal.addAdditionalSaveData: the love ticks left, whatever the save had. + if m.kind.flags.animal { + map.insert("InLove".into(), Tag::Int(m.extra.in_love.max(0))); + } match id { "minecraft:creeper" => { for (key, value) in [("Fuse", Tag::Short(30)), ("ExplosionRadius", Tag::Byte(3))] { @@ -621,6 +624,9 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) - m.extra.forced_age = number(tag.get("ForcedAge")).unwrap_or(0) as i32; m.extra.age_locked = flag(tag, "AgeLocked"); } + if m.kind.flags.animal { + m.extra.in_love = number(tag.get("InLove")).unwrap_or(0) as i32; + } m.name_visible = flag(tag, "CustomNameVisible"); m.no_ai = flag(tag, "NoAI"); m.no_gravity = flag(tag, "NoGravity"); diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 0faca0ab4..6a2ebcf25 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9534,6 +9534,7 @@ impl Game<'_> { ); map.insert("Air".into(), horizon_world::nbt::Tag::Short(p.air as i16)); } + level.fall_distance = p.fall_distance; level.food = p.health.food.food; level.saturation = p.health.food.saturation; diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 67764c090..77d68c6b9 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -217,6 +217,12 @@ impl Game<'_> { host.hub.guests[i].position[2], ); host.hub.guests[i].motion = PlayerMotion::new(self.motion, p).ok().map(Box::new); + // The first body after joining burns, breathes and falls on as saved. + if let Some(saved) = host.hub.guests[i].loaded_body.take() + && let Some(m) = host.hub.guests[i].motion.as_mut() + { + saved.apply(m); + } let kept = host.hub.guests[i].logs_kept.take(); if let (Some(m), Some((hurts, attacks))) = (host.hub.guests[i].motion.as_mut(), kept) { m.hurt_log = hurts; diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs index 948de7e20..227cd4335 100644 --- a/crates/horizon-client/src/lan/guest.rs +++ b/crates/horizon-client/src/lan/guest.rs @@ -18,6 +18,31 @@ pub const CREATIVE: i32 = 1; pub const ADVENTURE: i32 = 2; pub const SPECTATOR: i32 = 3; +/// The body state a player's file keeps that lives on `PlayerMotion`. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct SavedBody { + pub fire_ticks: i32, + pub air: i32, + pub fall_distance: f64, +} + +impl SavedBody { + /// The body state of `motion`, to save. + pub fn of(motion: &PlayerMotion) -> Self { + Self { + fire_ticks: motion.fire_ticks, + air: motion.air, + fall_distance: motion.fall_distance, + } + } + /// Put it on a new body. + pub fn apply(self, motion: &mut PlayerMotion) { + motion.fire_ticks = self.fire_ticks; + motion.air = self.air; + motion.fall_distance = self.fall_distance; + } +} + /// An effect as last sent in ClientboundUpdateMobEffectPacket. #[derive(Clone, Debug, PartialEq)] pub struct SentEffect { @@ -133,6 +158,9 @@ pub struct Guest { pub tracker: Tracker, // Player state the gameplay code reads and writes. pub motion: Option<Box<PlayerMotion>>, + /// What the player's file says of the body (`Entity.load`: the fire + /// and air ticks and the fall distance), for the first body it gets. + pub loaded_body: Option<SavedBody>, /// The hurt and attack logs of the body it had before it respawned, /// until the new body takes them over (the control socket's `hurtlog` /// reads across a death). @@ -275,6 +303,7 @@ impl Guest { batch_quota: 0.0, tracker: Tracker::default(), motion: None, + loaded_body: None, logs_kept: None, inventory: vec![None; 36], armor: [None, None, None, None], diff --git a/crates/horizon-client/src/lan/playerdata.rs b/crates/horizon-client/src/lan/playerdata.rs index 24a4a9d65..180074f84 100644 --- a/crates/horizon-client/src/lan/playerdata.rs +++ b/crates/horizon-client/src/lan/playerdata.rs @@ -1,6 +1,6 @@ //! Guests' saved state: `players/data/<uuid>.dat` in the vanilla player //! compound, through the same code that saves the host. -use super::guest::Guest; +use super::guest::{Guest, SavedBody}; use crate::{ items::ItemStack, save::{Level, read_dat, write_dat}, @@ -74,6 +74,17 @@ pub fn apply(guest: &mut Guest, level: &Level) { guest.spawn = level.spawn.map(|s| [s[0] + 0.5, s[1], s[2] + 0.5]); guest.respawn_elsewhere = level.respawn_elsewhere.clone(); guest.saved = level.player_extra.clone(); + let extra = level.player_extra.as_ref(); + let short = |key: &str, default: i64| { + extra + .and_then(|t| crate::save::number(t.get(key))) + .unwrap_or(default) as i32 + }; + guest.loaded_body = Some(SavedBody { + fire_ticks: short("Fire", -20), + air: short("Air", 300), + fall_distance: level.fall_distance, + }); guest.recipe_book = level.recipe_book.clone(); guest.dimension = match level.dimension.as_str() { d @ ("minecraft:the_nether" | "minecraft:the_end") => d.to_owned(), @@ -139,6 +150,24 @@ pub fn store(guest: &Guest, level: &mut Level) { level.respawn_elsewhere = guest.respawn_elsewhere.clone(); level.on_ground = guest.on_ground; level.player_extra = guest.saved.clone(); + // The live body's fire, air and fall distance (Entity.saveWithoutId), + // or what the file had while the player has no body yet. + let body = guest + .motion + .as_deref() + .map(SavedBody::of) + .or(guest.loaded_body); + if let Some(body) = body { + level.fall_distance = body.fall_distance; + let extra = level + .player_extra + .get_or_insert_with(|| horizon_world::nbt::Tag::Compound(Default::default())); + if let horizon_world::nbt::Tag::Compound(map) = extra { + let short = |v: i32| horizon_world::nbt::Tag::Short(v.clamp(-32768, 32767) as i16); + map.insert("Fire".into(), short(body.fire_ticks)); + map.insert("Air".into(), short(body.air)); + } + } level.recipe_book = guest.recipe_book.clone(); level.ender_items = guest.ender_items.clone(); level.inventory.clear(); @@ -162,3 +191,52 @@ pub fn store(guest: &Guest, level: &mut Level) { put(100, &guest.armor[3]); put(150, &guest.offhand); } + +#[cfg(test)] +mod tests { + use super::*; + use crate::lan::{Joined, PlayerSender}; + use horizon_protocol::packets::configuration::ClientInformation; + use std::sync::{Arc, atomic::AtomicI32, mpsc}; + + fn guest() -> Guest { + let (tx, _rx) = mpsc::channel(); + Guest::new( + Joined { + conn: 2, + uuid: 2, + name: "Alex".into(), + properties: Vec::new(), + info: ClientInformation::new(8), + brand: "test".into(), + sender: PlayerSender::new(tx, Arc::default()), + latency: Arc::new(AtomicI32::new(0)), + address: "127.0.0.1:25565".parse().unwrap(), + }, + 2, + [0.0, 64.0, 0.0], + 8, + ) + } + + #[test] + fn a_saved_burn_and_fall_come_back() { + // A player saved burning in mid-fall (#1323, #1327): Entity.saveWithoutId's + // Fire, Air and fall_distance, read back for the next body. + let mut g = guest(); + g.loaded_body = Some(SavedBody { + fire_ticks: 96, + air: 250, + fall_distance: 9.5, + }); + let mut level = Level::default(); + store(&g, &mut level); + let tag = level.player_tag(); + let mut read = Level::default(); + read.read_player(&tag); + read.player_extra = Some(tag); + let mut back = guest(); + apply(&mut back, &read); + assert_eq!(back.loaded_body, g.loaded_body); + } +} diff --git a/crates/horizon-client/src/mobs/rabbit.rs b/crates/horizon-client/src/mobs/rabbit.rs index 05ab0e390..a2ab6e95c 100644 --- a/crates/horizon-client/src/mobs/rabbit.rs +++ b/crates/horizon-client/src/mobs/rabbit.rs @@ -310,6 +310,18 @@ mod tests { } } + #[test] + fn love_ticks_survive_a_save() { + // Animal.addAdditionalSaveData / readAdditionalSaveData: "InLove" (#1396). + let mut m = rabbit(); + m.extra.in_love = 570; + let tag = crate::entity_nbt::mob_to_nbt(&m, [0, 0, 0, 1], None); + assert_eq!(tag.get("InLove"), Some(&horizon_world::nbt::Tag::Int(570))); + let types = HashMap::from([(m.kind.id.clone(), m.kind.clone())]); + let back = crate::entity_nbt::mob_from_nbt(&tag, &types, 2).unwrap(); + assert_eq!(back.extra.in_love, 570); + } + #[test] fn landing_waits_then_real_hop_clock_moves_the_model() { let mut m = rabbit(); diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs index 1920026b9..381cf8f88 100644 --- a/crates/horizon-client/src/motion.rs +++ b/crates/horizon-client/src/motion.rs @@ -337,6 +337,7 @@ impl PlayerMotion { self.air = extra .and_then(|t| crate::save::number(t.get("Air"))) .unwrap_or(300) as i32; + self.fall_distance = level.fall_distance; self.set_health(level.health, false)?; self.health.food.food = level.food; self.health.food.saturation = level.saturation; From 06b4c7faf52df6b3c12c40e75f7a3e5bba40103d Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 08:38:58 +0200 Subject: [PATCH 42/62] Rules: crits, mending, phantoms, per-level health rules, /item with air, frozen potions - Critical hits also need the attacker out of water, not blind and not riding (Player.canCriticalAttack) (#1393). - Mending repairs the off hand too: candidates in EquipmentSlot order, main hand, off hand, then the armour (#1349). - Phantoms spawn only in the Overworld with spawn_mobs, spawn_monsters and spawn_phantoms on, near every player (the local one and each guest in the level, with their own time since rest), with vanilla's draw order (#1388, #1387). - A level entered by a portal or a dimension change keeps the world's natural_health_regeneration (#1339). - /item replace ... with air empties the slot, and counts it as changed as vanilla's SlotAccess.set does (#1332). - Thrown potions stay where they are on frozen ticks (/tick freeze) and land once the game runs again (#1364). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game.rs | 18 +++-- .../horizon-client/src/game/commands/items.rs | 5 +- .../src/game/enchant_effects.rs | 67 +++++++++++-------- crates/horizon-client/src/game/levels.rs | 3 + crates/horizon-client/src/game/potions.rs | 10 ++- crates/horizon-client/src/game/stats.rs | 67 ++++++++++++++----- 6 files changed, 117 insertions(+), 53 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 0faca0ab4..93f90faf5 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4292,7 +4292,7 @@ impl Game<'_> { /// world's entities and blocks, and the network hub. fn tick_world(&mut self, running: bool) -> Result<()> { self.update_chunk_tickets(); - horizon_client::spans::time("tick_effects", || self.tick_effects()); + horizon_client::spans::time("tick_effects", || self.tick_effects(running)); horizon_client::spans::time("tick_using", || self.tick_using()); horizon_client::spans::time("tick_hud", || self.tick_hud()); // The player's digging comes in with its packets, before the level @@ -7020,10 +7020,16 @@ impl Game<'_> { // Item.getAttackDamageBonus (a mace's smash), before the critical hit. amount += self.smash_damage_bonus(target_kind); let player = self.player.as_ref(); - // Player.canCriticalAttack: falling, off the ground, not sprinting. - let falling = - player.is_some_and(|p| !p.ground.on_ground && p.fall_distance > 0.0 && !p.sprinting); - let crit = scale > 0.9 && falling; + // Player.canCriticalAttack: falling, off the ground, not in water, + // not blind (isMobilityRestricted), not riding, not sprinting. + let falling = player.is_some_and(|p| { + !p.ground.on_ground + && p.fall_distance > 0.0 + && !p.fluids.was_touching_water + && !p.sprinting + }); + let restricted = self.potions.effects.get("blindness").is_some() || self.riding.is_some(); + let crit = scale > 0.9 && falling && !restricted; if crit { amount *= 1.5; } @@ -7632,6 +7638,8 @@ impl Game<'_> { world.game_time = self.world.game_time; world.day_time = self.world.day_time; world.weather = self.world.weather; + // The game rules and the difficulty hold in every dimension. + world.health_rules = self.world.health_rules; // An open hub keeps hearing the new level's block changes. world.block_log = self.world.block_log.as_ref().map(|_| Vec::new()); world.light_log = self.world.light_log.as_ref().map(|_| Default::default()); diff --git a/crates/horizon-client/src/game/commands/items.rs b/crates/horizon-client/src/game/commands/items.rs index b5c6e63d9..ab2d9000b 100644 --- a/crates/horizon-client/src/game/commands/items.rs +++ b/crates/horizon-client/src/game/commands/items.rs @@ -810,7 +810,10 @@ impl Game<'_> { None => break, }, }; - if self.slot_get(slot) != item && self.slot_set(slot, item) { + // ItemStack.isEmpty: air (or a count of 0) is an empty slot. + // SlotAccess.set counts every slot it sets, the same item too. + let item = item.filter(|s| &*s.item != "minecraft:air" && s.count > 0); + if self.slot_set(slot, item) { changed += 1; } } diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs index 16bd38904..8593e2b98 100644 --- a/crates/horizon-client/src/game/enchant_effects.rs +++ b/crates/horizon-client/src/game/enchant_effects.rs @@ -8,6 +8,15 @@ use super::Game; use horizon_client::{enchant::EffectContext, items::ItemStack}; use horizon_core::random::RandomSource; +/// Where Mending found a damaged item (`EnchantedItemInUse.inSlot`). +#[derive(Clone, Copy)] +enum MendSlot { + Main, + Off, + /// An `armor` index (head first). + Armor(usize), +} + impl Game<'_> { /// `Player.getDestroySpeed` after the tool speed: mining efficiency, haste /// and mining fatigue. @@ -314,36 +323,29 @@ impl Game<'_> { pub(super) fn mending(&mut self, amount: u32) -> u32 { let mut amount = amount; loop { - // EnchantmentHelper.getRandomItemWith(REPAIR_WITH_XP, damaged): held and armor. - let mut candidates: Vec<(bool, usize)> = Vec::new(); - if let Some(s) = &self.inventory[self.selected] - && s.damage > 0 - && s.enchantment_level("minecraft:mending") > 0 - { - candidates.push((false, self.selected)); - } - for (i, s) in self.armor.iter().enumerate() { - if let Some(s) = s - && s.damage > 0 - && s.enchantment_level("minecraft:mending") > 0 - { - candidates.push((true, i)); - } - } + // EnchantmentHelper.getRandomItemWith(REPAIR_WITH_XP, damaged), in + // EquipmentSlot order: the main hand, the off hand, then feet, legs, + // chest and head (`armor` holds head first). + let mending = |s: &Option<ItemStack>| { + s.as_ref() + .is_some_and(|s| s.damage > 0 && s.enchantment_level("minecraft:mending") > 0) + }; + let candidates: Vec<MendSlot> = [MendSlot::Main, MendSlot::Off] + .into_iter() + .chain((0..self.armor.len()).rev().map(MendSlot::Armor)) + .filter(|&slot| mending(self.mend_slot(slot))) + .collect(); if candidates.is_empty() { return amount; } - let (armor, i) = candidates[self + let slot = candidates[self .world .random .next_int_bound(candidates.len() as i32) .unwrap_or(0) as usize]; - let stack = if armor { - self.armor[i].clone() - } else { - self.inventory[i].clone() + let Some(stack) = self.mend_slot(slot).clone() else { + return amount; }; - let Some(stack) = stack else { return amount }; let ctx = EffectContext { items: Some(self.res.items()), ..Default::default() @@ -356,12 +358,7 @@ impl Game<'_> { amount as f32, ) as u32; let repaired = to_repair_xp.min(stack.damage); - let slot = if armor { - &mut self.armor[i] - } else { - &mut self.inventory[i] - }; - if let Some(s) = slot.as_mut() { + if let Some(s) = self.mend_slot_mut(slot).as_mut() { s.damage -= repaired; } if repaired == 0 || to_repair_xp == 0 { @@ -374,6 +371,20 @@ impl Game<'_> { amount = remaining; } } + fn mend_slot(&self, slot: MendSlot) -> &Option<ItemStack> { + match slot { + MendSlot::Main => &self.inventory[self.selected], + MendSlot::Off => &self.offhand, + MendSlot::Armor(i) => &self.armor[i], + } + } + fn mend_slot_mut(&mut self, slot: MendSlot) -> &mut Option<ItemStack> { + match slot { + MendSlot::Main => &mut self.inventory[self.selected], + MendSlot::Off => &mut self.offhand, + MendSlot::Armor(i) => &mut self.armor[i], + } + } /// Bow enchantments at release: (extra base damage, infinity keeps the arrow). pub(super) fn bow_enchantments(&mut self) -> (f64, bool) { let Some(bow) = self.inventory[self.selected].clone() else { diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs index 3b73a2e20..895cda08c 100644 --- a/crates/horizon-client/src/game/levels.rs +++ b/crates/horizon-client/src/game/levels.rs @@ -232,6 +232,9 @@ impl Game<'_> { p.world.game_time = self.world.game_time; p.world.day_time = self.world.day_time; p.world.weather = self.world.weather; + // The game rules and the difficulty are the server's, not a + // level's: natural regeneration holds in every dimension. + p.world.health_rules = self.world.health_rules; // The sculk tables' watched blocks are built once per game. p.world.watched = std::mem::take(&mut self.world.watched); self.swap_level(&mut p); diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs index 72c8fe885..7b466b3bb 100644 --- a/crates/horizon-client/src/game/potions.rs +++ b/crates/horizon-client/src/game/potions.rs @@ -297,10 +297,14 @@ impl Game<'_> { } } /// The local player's effects (`tick_mob_effects`), then the potions - /// in flight, which a server without a local player still has. - pub(super) fn tick_effects(&mut self) { + /// in flight, which a server without a local player still has. A frozen + /// tick (`/tick freeze`) leaves the potions where they are + /// (`TickRateManager.isEntityFrozen`); players' effects still run. + pub(super) fn tick_effects(&mut self, running: bool) { self.tick_mob_effects(); - self.tick_thrown_potions(); + if running { + self.tick_thrown_potions(); + } } /// `LivingEntity.tickEffects` (server side) for `self.player`, the local /// player or a guest acting (`as_guest`), then its attribute modifiers diff --git a/crates/horizon-client/src/game/stats.rs b/crates/horizon-client/src/game/stats.rs index 7a97416ca..7f64c6bb2 100644 --- a/crates/horizon-client/src/game/stats.rs +++ b/crates/horizon-client/src/game/stats.rs @@ -306,9 +306,18 @@ impl Game<'_> { } } /// `PhantomSpawner.tick`: tired players under an open night sky draw - /// phantoms. + /// phantoms. A custom spawner ticks only while `spawn_mobs` is on + /// (`ServerChunkCache.tickChunks`), and this one only spawns enemies + /// (`ServerLevel.isSpawningMonsters`: `spawn_monsters` too). Every + /// player of the level counts: the game's own and the hosted ones (a + /// server thread's players are all hosted). pub(super) fn spawn_phantoms(&mut self) { - if !self.ui.rules.bool("spawn_phantoms") || self.dim != Dim::Overworld { + let rules = &self.ui.rules; + if !rules.bool("spawn_mobs") + || !rules.bool("spawn_monsters") + || !rules.bool("spawn_phantoms") + || self.dim != Dim::Overworld + { return; } self.stats.phantom_tick -= 1; @@ -317,16 +326,42 @@ impl Game<'_> { } let r = &mut self.world.random; self.stats.phantom_tick += (60 + r.next_int_bound(60).unwrap_or(0)) * 20; - if self.sky_darken() < 5 || self.spectator() { + if self.sky_darken() < 5 { return; } - let Some(p) = self.player.as_ref() else { - return; - }; + let rest = |s: &Stats| s.get("custom", "minecraft:time_since_rest"); + // `level.players()`: (block position, time since rest) of each player + // who isn't a spectator. + let mut players = Vec::new(); + if let Some(p) = self.player.as_ref() + && !self.spectator() + { + players.push((p.position, rest(&self.stats))); + } + if let Some(host) = self.lan.as_ref() { + let level = self.dim.id(); + for g in host.hub.guests.iter().filter(|g| { + g.placed + && g.dimension == level + && g.game_mode != horizon_client::lan::guest::SPECTATOR + }) { + let since = host.play.get(&g.conn).map_or(0, |p| rest(&p.stats)); + players.push(( + Vec3::new(g.position[0], g.position[1], g.position[2]), + since, + )); + } + } + for (position, since) in players { + self.spawn_phantoms_near(position, since); + } + } + /// One player's turn of `PhantomSpawner.tick`. + fn spawn_phantoms_near(&mut self, position: Vec3, since_rest: i32) { let pos = [ - p.position.x.floor() as i32, - p.position.y.floor() as i32, - p.position.z.floor() as i32, + position.x.floor() as i32, + position.y.floor() as i32, + position.z.floor() as i32, ]; if pos[1] < 63 || !self.can_see_sky(pos) { return; @@ -336,15 +371,15 @@ impl Game<'_> { if r.next_float() * 3.0 >= 2.0 { return; } - let rest = self.stats.get("custom", "minecraft:time_since_rest").max(1); - if r.next_int_bound(rest).unwrap_or(0) < 72000 { + if r.next_int_bound(since_rest.max(1)).unwrap_or(0) < 72000 { return; } - let at = [ - pos[0] - 10 + r.next_int_bound(21).unwrap_or(10), - pos[1] + 20 + r.next_int_bound(15).unwrap_or(0), - pos[2] - 10 + r.next_int_bound(21).unwrap_or(10), - ]; + // `playerPos.above(20 + nextInt(15)).east(-10 + nextInt(21)).south(...)`: + // the height is drawn first. + let up = 20 + r.next_int_bound(15).unwrap_or(0); + let east = -10 + r.next_int_bound(21).unwrap_or(10); + let south = -10 + r.next_int_bound(21).unwrap_or(10); + let at = [pos[0] + east, pos[1] + up, pos[2] + south]; if !self .res .facts() From 7e5e469783dc63de53e88a21d7925a75fc8b3197 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 09:19:48 +0200 Subject: [PATCH 43/62] InLove only for vanilla's Animal subclasses (not allays) save_roundtrip found an allay saved with InLove 0: Horizon's `animal` flag is broader than vanilla's Animal class. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/entity_nbt.rs | 45 +++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index 7faa94e21..298b54088 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -89,6 +89,47 @@ impl Base<'_> { } /// `LivingEntity` + `Mob` (+ `AgeableMob`, creeper and skeleton specifics). +/// The mobs whose class extends vanilla's `Animal` (and so save `InLove`): +/// not allays, villagers, golems, dolphins or fish. +fn is_animal(id: &str) -> bool { + matches!( + id.strip_prefix("minecraft:").unwrap_or(id), + "pig" + | "cow" + | "mooshroom" + | "sheep" + | "chicken" + | "rabbit" + | "horse" + | "donkey" + | "mule" + | "zombie_horse" + | "skeleton_horse" + | "llama" + | "trader_llama" + | "goat" + | "panda" + | "polar_bear" + | "fox" + | "wolf" + | "cat" + | "ocelot" + | "parrot" + | "bee" + | "turtle" + | "armadillo" + | "frog" + | "axolotl" + | "hoglin" + | "strider" + | "camel" + | "camel_husk" + | "sniffer" + | "happy_ghast" + | "nautilus" + | "zombie_nautilus" + ) +} pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { let base = Base { id: &m.kind.id, @@ -181,7 +222,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { } } // Animal.addAdditionalSaveData: the love ticks left, whatever the save had. - if m.kind.flags.animal { + if is_animal(id) { map.insert("InLove".into(), Tag::Int(m.extra.in_love.max(0))); } match id { @@ -624,7 +665,7 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) - m.extra.forced_age = number(tag.get("ForcedAge")).unwrap_or(0) as i32; m.extra.age_locked = flag(tag, "AgeLocked"); } - if m.kind.flags.animal { + if is_animal(&m.kind.id) { m.extra.in_love = number(tag.get("InLove")).unwrap_or(0) as i32; } m.name_visible = flag(tag, "CustomNameVisible"); From c35ea9568f4771e360cf353df64034237612daef Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 07:31:31 +0200 Subject: [PATCH 44/62] Server's mobs: babies, wool, collars, fire, slime sizes and health reach its clients A client of a server (single player on its server thread, a LAN guest, a dedicated server's player) only applied a rabbit's baby flag and a creeper's swell from SetEntityData. It now reads the synched data vanilla's entities read in onSyncedDataUpdated: Entity's on-fire flag, LivingEntity's health (the wither's boss bar follows it), the baby flag of every ageable mob, Sheep.DATA_WOOL_ID, TamableAnimal's sitting and tame flags, the wolf's and the cat's collar colour, and the cube mobs' size. A remote wolf or cat starts with vanilla's red collar. The server sends the wolf's and cat's collar colour. Pairing still carries only the values that differ from the defaults; a mob's state now lists the defaults of the entries that can go back to theirs (health, the baby flag, the wool, the collar), and the tracker sends that default when one does: a calf growing up or a sheep's white wool growing back reach the clients. Sheep saves wrote the colour and shearing they were loaded with (0 unless the save had them) and loads ignored both: they now save and load the wool as it is (Sheep.add/readAdditionalSaveData). lan_e2e's new `looks` check summons the mobs and changes them on both sides. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/entity_nbt.rs | 47 +++++- crates/horizon-client/src/game.rs | 1 + crates/horizon-client/src/game/creatures.rs | 4 + crates/horizon-client/src/game/dragon.rs | 1 + crates/horizon-client/src/game/lan.rs | 31 +++- .../horizon-client/src/game/lan_entities.rs | 1 + crates/horizon-client/src/game/remote.rs | 8 +- .../src/game/remote_mob_data.rs | 136 ++++++++++++++++++ crates/horizon-client/src/lan/entity.rs | 34 ++++- crates/horizon-client/src/lan/hub.rs | 1 + crates/horizon-client/tests/lan_bot.rs | 1 + tools/lan_e2e.py | 83 ++++++++++- 12 files changed, 331 insertions(+), 17 deletions(-) create mode 100644 crates/horizon-client/src/game/remote_mob_data.rs diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index aaccdd844..dbddb274b 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -445,10 +445,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { map.entry(key.into()).or_insert(value); } } + // Sheep.addAdditionalSaveData: its wool as it is now. "minecraft:sheep" => { - for (key, value) in [("Color", Tag::Byte(0)), ("Sheared", Tag::Byte(0))] { - map.entry(key.into()).or_insert(value); - } + map.insert("Color".into(), Tag::Byte((m.extra.color & 15) as i8)); + map.insert("Sheared".into(), Tag::Byte(i8::from(m.extra.sheared))); } // CopperGolem.addAdditionalSaveData. "minecraft:copper_golem" => { @@ -832,6 +832,11 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) - } m.extra.egg_time = number(tag.get("life_ticks")).map_or(-1, |v| v as i32); } + // Sheep.readAdditionalSaveData: white and unsheared when absent. + if m.species() == crate::mobs::Species::Sheep { + m.extra.color = number(tag.get("Color")).map_or(0, |c| (c as u8) & 15); + m.extra.sheared = flag(tag, "Sheared"); + } if m.species() == crate::mobs::Species::Shulker { m.extra.variant3 = number(tag.get("AttachFace")).unwrap_or(0).clamp(0, 5) as u8; m.extra.counter = number(tag.get("Peek")).unwrap_or(0).clamp(0, 100) as i32; @@ -2051,3 +2056,39 @@ mod axolotl_nbt_tests { assert_eq!(mm.temptation_cooldown_ticks.value(), Some(42)); } } + +#[cfg(test)] +mod sheep_nbt_tests { + use super::*; + #[test] + fn a_sheep_keeps_its_dyed_and_sheared_wool() { + let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client") + .join(horizon_core::VANILLA_VERSION); + if !root.join("items.json").exists() { + return; + } + let data = crate::mobs::MobTypes::load(&root).unwrap(); + let mut m = Mob::new( + 1, + Arc::new(data.types["minecraft:sheep"].clone()), + Vec3::new(0.0, 4.0, 0.0), + 0.0, + ); + // Summoned white, then dyed red and sheared: the save has it now. + let raw = Tag::compound([("Color", Tag::Byte(0)), ("Sheared", Tag::Byte(0))]); + (m.extra.color, m.extra.sheared) = (14, true); + let tag = mob_to_nbt(&m, [1, 2, 3, 4], Some(&raw)); + assert_eq!( + (number(tag.get("Color")), number(tag.get("Sheared"))), + (Some(14), Some(1)) + ); + let types: HashMap<String, Arc<MobType>> = data + .types + .iter() + .map(|(k, v)| (k.clone(), Arc::new(v.clone()))) + .collect(); + let back = mob_from_nbt(&tag, &types, 2).unwrap(); + assert_eq!((back.extra.color, back.extra.sheared), (14, true)); + } +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index b307d71dc..27ac5f259 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -121,6 +121,7 @@ mod pumpkin; mod raids; mod recipe_book; mod remote; +mod remote_mob_data; mod remote_objects; mod remote_projectiles; mod remote_stations; diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 969543601..442c37237 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -343,8 +343,12 @@ impl Game<'_> { "on_ground": m.on_ground, "variant": m.extra.variant, "color": m.extra.color, + "sheared": m.extra.sheared, + "burning": m.fire_ticks > 0, + "size": m.extra.size, "leash": m.extra.leash.map(|h| format!("{h:?}")), "tame": m.extra.tame, + "sitting": m.extra.sitting, "temper": m.extra.variant3, "chested": m.extra.chested, "head": m.extra.head.as_deref(), diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index 6dd02893d..d5cc5d9bf 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -2697,6 +2697,7 @@ impl Game<'_> { velocity: [d.velocity.x, d.velocity.y, d.velocity.z], data: 0, meta, + defaults: Vec::new(), equipment: Vec::new(), attributes: Vec::new(), precise: false, diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index bdbfa3fc6..b5d0db5f1 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -91,7 +91,7 @@ pub(super) fn entity_uuid(id: u32) -> u128 { /// The SynchedEntityData index of the baby flag: AgeableMob.DATA_BABY_ID and /// Zombie.DATA_BABY_ID are both the first entry after Mob's (16); Piglin's /// comes after AbstractPiglin's zombification flag (17). -fn baby_index(kind: &str) -> Option<u8> { +pub(super) fn baby_index(kind: &str) -> Option<u8> { match kind { "minecraft:piglin" => Some(17), "minecraft:cow" @@ -139,7 +139,13 @@ fn baby_index(kind: &str) -> Option<u8> { /// A mob's synched data as ServerEntity sends it (only the values that differ /// from the defaults the client constructs), with vanilla's entry indices: /// Entity 0..=7, LivingEntity 8..=14, Mob 15, then the subclasses. -fn mob_meta(m: &Mob, hub: &Hub, meta: &mut Vec<(u8, i32, Value)>) { +/// `defaults` gets the defaults of the entries that can go back to theirs. +fn mob_meta( + m: &Mob, + hub: &Hub, + meta: &mut Vec<(u8, i32, Value)>, + defaults: &mut Vec<(u8, i32, Value)>, +) { let kind = m.kind.id.as_str(); if m.fire_ticks > 0 { meta.push((0, serializer::BYTE, Value::Byte(1))); @@ -159,15 +165,18 @@ fn mob_meta(m: &Mob, hub: &Hub, meta: &mut Vec<(u8, i32, Value)>) { if health != 1.0 { meta.push((9, serializer::FLOAT, Value::Float(health))); } + defaults.push((9, serializer::FLOAT, Value::Float(1.0))); // Mob.DATA_MOB_FLAGS_ID: no AI 1, left-handed 2. let flags = i8::from(m.no_ai) | i8::from(m.extra.left_handed) << 1; if flags != 0 { meta.push((15, serializer::BYTE, Value::Byte(flags))); } - if m.is_baby() - && let Some(index) = baby_index(kind) - { - meta.push((index, serializer::BOOLEAN, Value::Bool(true))); + // AgeableMob.DATA_BABY_ID (and Zombie's, Piglin's). + if let Some(index) = baby_index(kind) { + if m.is_baby() { + meta.push((index, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((index, serializer::BOOLEAN, Value::Bool(false))); } let e = &m.extra; let id = |registry: &str, name: &str| hub.registry_id(registry, &format!("minecraft:{name}")); @@ -178,6 +187,7 @@ fn mob_meta(m: &Mob, hub: &Hub, meta: &mut Vec<(u8, i32, Value)>) { if value != 0 { meta.push((18, serializer::BYTE, Value::Byte(value as i8))); } + defaults.push((18, serializer::BYTE, Value::Byte(0))); } "minecraft:cat" | "minecraft:wolf" => { // TamableAnimal.DATA_FLAGS_ID: sitting 1, tame 4. @@ -200,6 +210,13 @@ fn mob_meta(m: &Mob, hub: &Hub, meta: &mut Vec<(u8, i32, Value)>) { if let Some(v) = id(registry, name) { meta.push((index, serializer, Value::Id(v))); } + // Wolf.DATA_COLLAR_COLOR and Cat's, red by default. + let collar = if kind == "minecraft:cat" { 23 } else { 21 }; + let red = i32::from(horizon_client::mobs::tame::RED); + if i32::from(e.color & 15) != red { + meta.push((collar, serializer::INT, Value::Int(i32::from(e.color & 15)))); + } + defaults.push((collar, serializer::INT, Value::Int(red))); } "minecraft:horse" | "minecraft:donkey" @@ -766,7 +783,7 @@ impl Game<'_> { e.on_ground = m.on_ground; e.velocity = [m.velocity.x, m.velocity.y, m.velocity.z]; e.needs_sync = m.needs_sync; - mob_meta(m, hub, &mut e.meta); + mob_meta(m, hub, &mut e.meta, &mut e.defaults); mob_equipment(m, hub, &mut e.equipment); self.mob_attributes(m, &mut e.attributes); } diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs index 631498edd..6342e921c 100644 --- a/crates/horizon-client/src/game/lan_entities.rs +++ b/crates/horizon-client/src/game/lan_entities.rs @@ -36,6 +36,7 @@ fn state(id: u32, kind: &str, position: [f64; 3], yaw: f32, on_ground: bool) -> velocity: [0.0; 3], data: 0, meta: Vec::new(), + defaults: Vec::new(), equipment: Vec::new(), attributes: Vec::new(), precise: false, diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 8e18c1ff4..19306efd7 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -1334,6 +1334,7 @@ impl Game<'_> { } if let Some(t) = mob_type { let mut mob = Mob::new(id as u32, t, at, head); + super::remote_mob_data::client_defaults(&mut mob); (mob.yaw, mob.previous_yaw) = (yaw, yaw); (mob.head_pitch, mob.previous_head_pitch) = (pitch, pitch); mob.persistent = true; @@ -1909,13 +1910,12 @@ impl Game<'_> { && m.species() == horizon_client::mobs::Species::Rabbit { for (index, _, value) in &p.values { - match (index, value) { - (15, Value::Byte(flags)) => m.no_ai = flags & 1 != 0, - (16, Value::Bool(baby)) => m.extra.age = if *baby { -1 } else { 0 }, - _ => {} + if let (15, Value::Byte(flags)) = (index, value) { + m.no_ai = flags & 1 != 0; } } } + self.remote_mob_data(p.id, &p.values); if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) && m.species() == horizon_client::mobs::Species::Creeper { diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs new file mode 100644 index 000000000..a84998934 --- /dev/null +++ b/crates/horizon-client/src/game/remote_mob_data.rs @@ -0,0 +1,136 @@ +//! A server's mobs as their synched data has them +//! (ClientPacketListener.handleSetEntityData, then each entity's +//! `onSyncedDataUpdated`): what a client draws from it rather than from its +//! own simulation, which a client of a server doesn't run. +use super::Game; +use horizon_client::mobs::{Mob, Species, tame}; +use horizon_protocol::entity_data::Value; + +/// The values `apply` takes from one SetEntityData packet, by vanilla's entry +/// indices (Entity 0..=7, LivingEntity 8..=14, Mob 15, then the subclasses). +fn apply(m: &mut Mob, values: &[(u8, i32, Value)]) { + let species = m.species(); + let baby = super::lan::baby_index(&m.kind.id); + for (index, _, value) in values { + match (*index, value) { + // Entity.DATA_SHARED_FLAGS_ID's FLAG_ONFIRE: Entity.isOnFire on a + // client, which draws the flames. A client doesn't count the + // fire down: the flag goes off when the server's fire is out. + (0, Value::Byte(flags)) => m.fire_ticks = i32::from(flags & 1), + // LivingEntity.DATA_HEALTH_ID: the boss bars and the death + // animation follow it. + (9, Value::Float(health)) => m.health = *health, + (i, Value::Bool(b)) if Some(i) == baby => m.extra.age = if *b { -1 } else { 0 }, + _ => {} + } + match (species, *index, value) { + // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 sheared. + (Species::Sheep, 18, Value::Byte(wool)) => { + m.extra.color = (*wool & 15) as u8; + m.extra.sheared = wool & 16 != 0; + } + // TamableAnimal.DATA_FLAGS_ID: sitting 1, tame 4. + (Species::Wolf | Species::Cat | Species::Parrot, 18, Value::Byte(flags)) => { + m.extra.sitting = flags & 1 != 0; + m.extra.tame = flags & 4 != 0; + } + // Wolf.DATA_COLLAR_COLOR and Cat's. + (Species::Wolf, 21, Value::Int(c)) | (Species::Cat, 23, Value::Int(c)) => { + m.extra.color = (*c & 15) as u8; + } + // AbstractCubeMob.ID_SIZE: its size and box (refreshDimensions). + (Species::Slime | Species::MagmaCube, 18, Value::Int(size)) => { + m.extra.size = (*size).clamp(1, 127); + } + _ => {} + } + } +} + +impl Game<'_> { + /// SetEntityData for a mob of the server's. + pub(super) fn remote_mob_data(&mut self, id: i32, values: &[(u8, i32, Value)]) { + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id as u32) { + apply(m, values); + } + } +} + +/// A mob as a client constructs it before its data arrives: the synched +/// defaults the server leaves out (`getNonDefaultValues`) that differ from +/// what `Mob::new` gives, such as a wolf's and a cat's red collar. +pub(super) fn client_defaults(m: &mut Mob) { + if matches!(m.species(), Species::Wolf | Species::Cat) { + m.extra.color = tame::RED; + } +} + +#[cfg(test)] +mod tests { + use super::*; + use horizon_protocol::entity_data::serializer as s; + + /// A mob of the prepared resources' type `kind`, as a client spawns it + /// (None without the resources). + fn mob(kind: &str) -> Option<Mob> { + let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client") + .join(horizon_core::VANILLA_VERSION); + let types = horizon_client::mobs::MobTypes::load(&root).ok()?; + let t = std::sync::Arc::new(types.types.get(kind)?.clone()); + let mut m = Mob::new(1, t, horizon_core::geometry::Vec3::ZERO, 0.0); + client_defaults(&mut m); + Some(m) + } + + #[test] + fn a_sheep_takes_its_wool_and_a_calf_its_size() { + let Some(mut m) = mob("minecraft:sheep") else { + return; + }; + apply(&mut m, &[(18, s::BYTE, Value::Byte(14 | 16))]); + assert_eq!((m.extra.color, m.extra.sheared), (14, true)); + apply(&mut m, &[(18, s::BYTE, Value::Byte(0))]); + assert_eq!((m.extra.color, m.extra.sheared), (0, false)); + let mut calf = mob("minecraft:cow").unwrap(); + apply(&mut calf, &[(16, s::BOOLEAN, Value::Bool(true))]); + assert!(calf.is_baby()); + apply(&mut calf, &[(16, s::BOOLEAN, Value::Bool(false))]); + assert!(!calf.is_baby()); + } + + #[test] + fn a_wolf_takes_its_owner_flags_and_collar() { + let Some(mut m) = mob("minecraft:wolf") else { + return; + }; + assert_eq!(m.extra.color, tame::RED); + apply( + &mut m, + &[ + (18, s::BYTE, Value::Byte(4 | 1)), + (21, s::INT, Value::Int(11)), + ], + ); + assert!(m.extra.tame && m.extra.sitting); + assert_eq!(m.extra.color, 11); + } + + #[test] + fn fire_health_and_size_follow_the_server() { + let Some(mut m) = mob("minecraft:slime") else { + return; + }; + apply( + &mut m, + &[ + (0, s::BYTE, Value::Byte(1)), + (9, s::FLOAT, Value::Float(12.5)), + (18, s::INT, Value::Int(4)), + ], + ); + assert_eq!((m.fire_ticks, m.health, m.extra.size), (1, 12.5, 4)); + apply(&mut m, &[(0, s::BYTE, Value::Byte(0))]); + assert_eq!(m.fire_ticks, 0); + } +} diff --git a/crates/horizon-client/src/lan/entity.rs b/crates/horizon-client/src/lan/entity.rs index 86fea8b65..9bdb037f7 100644 --- a/crates/horizon-client/src/lan/entity.rs +++ b/crates/horizon-client/src/lan/entity.rs @@ -50,6 +50,10 @@ pub struct EntityState { pub data: i32, /// SynchedEntityData entries that differ from the defaults. pub meta: Vec<(u8, i32, Value)>, + /// The defaults of entries `meta` leaves out while they are at them, + /// sent when one goes back to its default (a calf grown up, a mob healed + /// back to 1, wool grown back white) beyond Entity's own below. + pub defaults: Vec<(u8, i32, Value)>, /// EquipmentSlot ordinals (0 main hand, 1 off hand, 2 feet, 3 legs, /// 4 chest, 5 head, 6 body, 7 saddle) and their stacks. pub equipment: Vec<(u8, Option<Stack>)>, @@ -78,6 +82,7 @@ impl EntityState { self.velocity = [0.0; 3]; self.data = 0; self.meta.clear(); + self.defaults.clear(); self.equipment.clear(); self.attributes.clear(); self.precise = false; @@ -469,7 +474,10 @@ impl ServerEntity { (0, serializer::BYTE) => Value::Byte(0), (6, serializer::POSE) => Value::Id(0), (14, serializer::OPTIONAL_BLOCK_POS) => Value::OptPos(None), - _ => continue, + _ => match e.defaults.iter().find(|d| (d.0, d.1) == (*index, *kind)) { + Some(d) => d.2.clone(), + None => continue, + }, }; if !e.meta.iter().any(|m| m.0 == *index) { changed.push((*index, *kind, default)); @@ -855,6 +863,7 @@ mod tests { velocity: [0.0; 3], data: 0, meta: Vec::new(), + defaults: Vec::new(), equipment: Vec::new(), attributes: Vec::new(), precise: false, @@ -1075,6 +1084,29 @@ mod tests { assert!(changes(&mut s, &e).is_empty()); } + #[test] + fn a_value_back_at_a_listed_default_is_sent() { + let mut e = state(0.0); + e.defaults = vec![(16, serializer::BOOLEAN, Value::Bool(false))]; + // A calf: paired with its baby flag, then grown up. + e.meta = vec![(16, serializer::BOOLEAN, Value::Bool(true))]; + let mut s = added(&e); + changes(&mut s, &e); + e.meta.clear(); + let data = changes(&mut s, &e) + .into_iter() + .find_map(|p| match p { + play::Clientbound::SetEntityData(d) => Some(d), + _ => None, + }) + .expect("growing up is sent"); + assert_eq!( + data.values, + vec![(16, serializer::BOOLEAN, Value::Bool(false))] + ); + assert!(changes(&mut s, &e).is_empty()); + } + #[test] fn metadata_and_equipment_send_only_the_changes() { let mut e = state(0.0); diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index c31b3c929..1330b0ae4 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -1559,6 +1559,7 @@ impl Hub { velocity: [0.0; 3], data: 0, meta, + defaults: Vec::new(), equipment, attributes, precise: false, diff --git a/crates/horizon-client/tests/lan_bot.rs b/crates/horizon-client/tests/lan_bot.rs index 4f5f17a3b..4b8bbc897 100644 --- a/crates/horizon-client/tests/lan_bot.rs +++ b/crates/horizon-client/tests/lan_bot.rs @@ -430,6 +430,7 @@ fn guests_see_each_other_and_the_world_entities() { velocity: [0.0; 3], data: 0, meta: Vec::new(), + defaults: Vec::new(), equipment: Vec::new(), attributes: Vec::new(), precise: false, diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index a50e97764..de8c78dc3 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -24,6 +24,11 @@ address. The script then checks, from both sides, what a guest's game used to ge - arrows: the guest and the host shoot each other with a bow; with the pvp game rule off, nothing (#484); +- looks: mobs look on both sides as the server has them (their synched data): a calf is a + baby, a red sheep is sheared, a size 4 slime, a tamed wolf sits with its blue collar, a + cow on fire burns and goes out; then the wither's health drops when it is hurt, the + sheep is dyed blue with its wool back and the calf grows up (#1367, #1368, #1370, + #1371, #1385, #1390); - respawn: a player killed is drawn dead by the other side, and alive again once it respawns (the respawned player is a new entity to the others); the host dies, and on the server thread the guest too; @@ -201,7 +206,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'looks', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater'] class Game: @@ -1147,6 +1152,79 @@ def check_hurt(host, guest, out): return seen +def mob_looks(game, centre): + """What `check_looks` compares of each mob around `centre`, by kind and column.""" + found = {} + for m in game.raw('mobs', 32).get('near', []): + if abs(m['pos'][0] - centre[0]) > 12 or abs(m['pos'][2] - centre[2]) > 14: + continue + key = f"{m['kind'].removeprefix('minecraft:')}@{round(m['pos'][0] - centre[0])}" + found[key] = {'baby': m['baby'], 'color': m['color'], 'sheared': m['sheared'], 'size': m['size'], + 'tame': m['tame'], 'sitting': m['sitting'], 'burning': m['burning'], + 'health': round(m['health'])} + return found + + +def check_looks(host, guest, out): + x, y, z = (int(v // 1) for v in pos_of(host)) + centre = (x + 0.5, y, z + 0.5) + # Each mob in a column of its own (the key), standing on the stone floor. + looks = { + 'cow@-5': ('{NoAI:1b,Fire:80s}', {'burning': True}), + 'cow@-3': ('{NoAI:1b,Age:-24000}', {'baby': True}), + 'cow@-1': ('{NoAI:1b}', {'baby': False}), + 'sheep@1': ('{NoAI:1b,Color:14b,Sheared:1b}', {'color': 14, 'sheared': True}), + 'slime@3': ('{NoAI:1b,Size:3}', {'size': 4}), + 'wolf@5': ('{NoAI:1b,Owner:[I;1,2,3,4],Sitting:1b,CollarColor:11b}', + {'tame': True, 'sitting': True, 'color': 11}), + } + sides = {'host': host, 'guest': guest} + seen = {} + try: + for key, (tag, _) in looks.items(): + kind, dx = key.split('@') + host('command', command=f'summon minecraft:{kind} {centre[0] + int(dx)} {y} {z + 4.5} {tag}') + host('command', command=f'summon minecraft:wither {centre[0]} {y + 3} {z + 10.5} {{NoAI:1b,Invul:0}}') + host.wait(30) + seen['spawned'] = {name: mob_looks(g, centre) for name, g in sides.items()} + # Changes after the spawn: the wither hurt, the sheep dyed and grown back, the calf grown up. + host('command', command='damage @e[type=minecraft:wither,limit=1] 150 minecraft:generic') + for kind, dx, tag in (('sheep', 1, '{Color:11b,Sheared:0b}'), ('cow', -3, '{Age:0}')): + host('command', command=f'data merge entity @e[type=minecraft:{kind},x={centre[0] + dx},y={y},' + f'z={z + 4.5},distance=..0.5,limit=1] {tag}') + guest.raw('look-at', centre[0], y + 1, z + 4.5) + host.raw('look-at', centre[0], y + 1, z + 4.5) + # The fire (80 ticks) goes out in the meantime. + host.wait(80) + for name, g in sides.items(): + g.shot(out, 'looks') + seen['later'] = {name: mob_looks(g, centre) for name, g in sides.items()} + finally: + # A killed slime splits: shrink it first so no children are left hopping into the next check. + host('command', command=f'data merge entity @e[type=minecraft:slime,x={centre[0] + 3},y={y},z={z + 4.5},' + f'distance=..2,limit=1] {{Size:0}}') + host('command', command=f'kill @e[type=!minecraft:player,x={x - 12},y={y - 2},z={z - 2},dx=24,dy=12,dz=16]') + wrong = [] + for name in sides: + spawned, later = seen['spawned'][name], seen['later'][name] + for key, (_, want) in looks.items(): + got = spawned.get(key) + if got is None or any(got[k] != v for k, v in want.items()): + wrong.append(f'{name} {key}: {got}, wants {want}') + if later.get('cow@-5', {}).get('burning') is not False: + wrong.append(f"{name}: the cow's fire never went out: {later.get('cow@-5')}") + if [later.get('sheep@1', {}).get(k) for k in ('color', 'sheared')] != [11, False]: + wrong.append(f"{name}: the sheep dyed blue with its wool back: {later.get('sheep@1')}") + if later.get('cow@-3', {}).get('baby') is not False: + wrong.append(f"{name}: the calf grown up: {later.get('cow@-3')}") + withers = [v['health'] for k, v in spawned.items() if k.startswith('wither')] + hurt = [v['health'] for k, v in later.items() if k.startswith('wither')] + if withers != [300] or hurt != [150]: + wrong.append(f"{name}: the wither's health {withers} then {hurt}, wants [300] then [150]") + assert not wrong, '\n'.join(wrong) + return seen['later']['guest'] + + def container_items(game): """The open container's stacks by slot (Horizon's container slots are 300 and up) and its size.""" slots = [s for s in game('screen').get('slots', []) if s.get('slot', 0) >= 300] @@ -3826,7 +3904,8 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'worldspawn': check_world_spawn, 'beds': check_beds, 'shield': check_shield, 'deathmining': check_death_mining, 'contacts': check_contacts, 'absorption': check_absorption, 'breath': check_breath, 'lava': check_lava, 'levels': check_levels, 'drops': check_drops, - 'underwater': check_underwater} + 'underwater': check_underwater, + 'looks': check_looks} def run(ctl, out, resources, checks): From 0d8249e124ad6e3d945730d7e5ddf18b5507bec8 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 07:50:04 +0200 Subject: [PATCH 45/62] Leads: a server's clients draw the rope (ClientboundSetEntityLinkPacket) A server never told its clients who holds a mob's lead, so on single player's server thread, a LAN guest's or a dedicated server's client the lead was used up and the mob tied, but no rope showed. The tracker now sends ClientboundSetEntityLinkPacket as vanilla does: in ServerEntity.sendPairingData for a leashed entity, and when the lead is tied or comes off (Leashable.setLeashedTo / dropLeash, the holder 0). The holder is the player the mob sees (a guest, else the host) or a mob; a fence knot isn't an entity on Horizon's server yet. The client sets the mob's holder from it: itself, another player or a mob. lan_e2e's new `leads` check ties and unties a cow on both sides. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game/dragon.rs | 1 + crates/horizon-client/src/game/lan.rs | 27 ++++++++++-- .../horizon-client/src/game/lan_entities.rs | 1 + crates/horizon-client/src/game/remote.rs | 13 ++++++ crates/horizon-client/src/lan/entity.rs | 44 ++++++++++++++++++- crates/horizon-client/src/lan/hub.rs | 1 + crates/horizon-client/tests/lan_bot.rs | 1 + crates/horizon-protocol/src/packets/play.rs | 7 +++ tools/lan_e2e.py | 44 ++++++++++++++++++- 9 files changed, 131 insertions(+), 8 deletions(-) diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index d5cc5d9bf..c6f5d419b 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -2702,6 +2702,7 @@ impl Game<'_> { attributes: Vec::new(), precise: false, needs_sync: false, + leash: None, }) } } diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index b5d0db5f1..8467b6d3a 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -14,7 +14,7 @@ use horizon_client::{ hub::{HostEvent, HostState, Hub, HubConfig, TickCtx}, playerdata, }, - mobs::Mob, + mobs::{Mob, leash::Holder}, text::Text, }; use horizon_core::geometry::Vec3; @@ -774,9 +774,27 @@ impl Game<'_> { } /// The entities guests track: mobs, items and the rest (game/lan_entities.rs). - fn lan_entities(&self, host_entity: Option<i32>, hub: &mut Hub, out: &mut States) { + /// `mob_players` is the guest each mob sees as its player (game/lan_mobs.rs). + fn lan_entities( + &self, + host_entity: Option<i32>, + mob_players: &HashMap<u32, u32>, + hub: &mut Hub, + out: &mut States, + ) { out.clear(); for m in self.mobs.iter().filter(|m| !m.removed) { + // The lead's holder: the player the mob sees (a guest, else the + // host) or another mob. A fence knot isn't an entity here. + let leash = m.extra.leash.and_then(|h| match h { + Holder::Player => mob_players + .get(&m.id) + .and_then(|conn| hub.guest(*conn)) + .map(|g| g.entity_id) + .or(host_entity), + Holder::Mob(id) => Some(id as i32), + Holder::Knot(_) => None, + }); let e = out.add(m.id as i32, entity_uuid(m.id), m.kind.id.as_str()); e.position = [m.position.x, m.position.y, m.position.z]; (e.yaw, e.pitch, e.head_yaw) = (m.yaw, m.head_pitch, m.head_yaw); @@ -786,6 +804,7 @@ impl Game<'_> { mob_meta(m, hub, &mut e.meta, &mut e.defaults); mob_equipment(m, hub, &mut e.equipment); self.mob_attributes(m, &mut e.attributes); + e.leash = leash; } for d in &self.dropped { let stack = hub.stack(&Some(d.stack.clone())); @@ -847,7 +866,7 @@ impl Game<'_> { .filter_map(|g| Some((g.vehicle?, g.entity_id))) .collect(); self.lan_riding(host_entity, &guests, &mut host.hub.riding); - self.lan_entities(host_entity, &mut host.hub, &mut states); + self.lan_entities(host_entity, &host.mob_players, &mut host.hub, &mut states); } else { states.clear(); } @@ -1035,7 +1054,7 @@ impl Game<'_> { return; } // A dedicated server has no host player. - self.lan_entities(None, &mut host.hub, &mut theirs); + self.lan_entities(None, &host.mob_players, &mut host.hub, &mut theirs); theirs.as_slice() } else { entities diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs index 6342e921c..f3098408c 100644 --- a/crates/horizon-client/src/game/lan_entities.rs +++ b/crates/horizon-client/src/game/lan_entities.rs @@ -41,6 +41,7 @@ fn state(id: u32, kind: &str, position: [f64; 3], yaw: f32, on_ground: bool) -> attributes: Vec::new(), precise: false, needs_sync: false, + leash: None, } } diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 19306efd7..dfde08d7f 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -1874,6 +1874,19 @@ impl Game<'_> { ); } C::SetPassengers(p) => self.remote_set_passengers(p.vehicle, &p.passengers), + // ClientPacketListener.handleEntityLinkPacket: who holds a mob's + // lead (this player, another player or a mob), for the rope. + C::SetEntityLink(p) => { + let me = self.remote.as_ref().map(|r| r.entity_id); + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.source as u32) { + use horizon_client::mobs::leash::Holder; + m.extra.leash = match p.dest { + 0 => None, + d if Some(d) == me => Some(Holder::Player), + d => Some(Holder::Mob(d as u32)), + }; + } + } C::MoveVehicle(p) => self.remote_move_vehicle(p.position, p.yaw), // ClientPacketListener.handleRotateMob: lerpHeadTo(yHeadRot, 3). C::RotateHead(p) => { diff --git a/crates/horizon-client/src/lan/entity.rs b/crates/horizon-client/src/lan/entity.rs index 9bdb037f7..676fd0adc 100644 --- a/crates/horizon-client/src/lan/entity.rs +++ b/crates/horizon-client/src/lan/entity.rs @@ -12,8 +12,8 @@ use horizon_protocol::{ item::Stack, packets::play::{ self, AddEntity, AttributeSnapshot, EntityPositionSync, MoveEntity, MoveEntityPos, - MoveEntityPosRot, MoveEntityRot, PositionPath, RotateHead, SetEntityData, SetEntityMotion, - SetEquipment, SetPassengers, UpdateAttributes, VecDelta, + MoveEntityPosRot, MoveEntityRot, PositionPath, RotateHead, SetEntityData, SetEntityLink, + SetEntityMotion, SetEquipment, SetPassengers, UpdateAttributes, VecDelta, }, }; @@ -65,6 +65,8 @@ pub struct EntityState { pub precise: bool, /// `Entity.needsSync`: send its changes this tick, due or not. pub needs_sync: bool, + /// `Leashable.getLeashHolder`: the entity holding its lead. + pub leash: Option<i32>, } impl EntityState { @@ -87,6 +89,7 @@ impl EntityState { self.attributes.clear(); self.precise = false; self.needs_sync = false; + self.leash = None; } } @@ -219,6 +222,8 @@ struct ServerEntity { /// and the first update after it dismounts is a full position sync. passengers: Vec<i32>, was_riding: bool, + /// The lead's holder the clients were told of. + leash: Option<i32>, /// The level tick it was last seen in, its place in that tick's list, and /// whether it was added in it (its first update is the next tick's). seen: u32, @@ -262,6 +267,7 @@ impl ServerEntity { teleport_delay: 0, passengers: riding.passengers(e.id).to_vec(), was_riding: false, + leash: e.leash, seen: 0, index: 0, added: true, @@ -314,6 +320,13 @@ impl ServerEntity { if let Some(&vehicle) = riding.vehicle.get(&e.id) { out.push(riding.set_passengers(vehicle)); } + // A leashed entity: who holds its lead. + if let Some(dest) = e.leash { + out.push(play::Clientbound::SetEntityLink(SetEntityLink { + source: e.id, + dest, + })); + } } /// Changes since the last update (ServerEntity.sendChanges): movement and @@ -327,6 +340,14 @@ impl ServerEntity { self.passengers.clear(); self.passengers.extend_from_slice(passengers); } + // Leashable.setLeashedTo / dropLeash: sendToTrackingPlayers at once. + if e.leash != self.leash { + out.push(play::Clientbound::SetEntityLink(SetEntityLink { + source: e.id, + dest: e.leash.unwrap_or(0), + })); + self.leash = e.leash; + } // SynchedEntityData.isDirty: once for every client. let dirty = e.meta != self.meta; let due = self.interval != 0 && self.tick.is_multiple_of(self.interval); @@ -868,6 +889,7 @@ mod tests { attributes: Vec::new(), precise: false, needs_sync: false, + leash: None, } } @@ -1132,6 +1154,24 @@ mod tests { assert_eq!(eq.slots, vec![(0, None)]); } + #[test] + fn a_lead_tied_and_untied_reaches_the_clients() { + let link = |out: &[play::Clientbound]| { + out.iter().find_map(|p| match p { + play::Clientbound::SetEntityLink(l) => Some((l.source, l.dest)), + _ => None, + }) + }; + let mut e = state(0.0); + let mut s = added(&e); + changes(&mut s, &e); + e.leash = Some(7); + assert_eq!(link(&changes(&mut s, &e)), Some((e.id, 7))); + assert_eq!(link(&changes(&mut s, &e)), None); + e.leash = None; + assert_eq!(link(&changes(&mut s, &e)), Some((e.id, 0))); + } + /// Two clients at the origin; the chunks they hold. struct Clients { chunks: crate::fast_hash::FxHashSet<(i32, i32)>, diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index 1330b0ae4..c8f2e980d 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -1564,6 +1564,7 @@ impl Hub { attributes, precise: false, needs_sync: false, + leash: None, } } diff --git a/crates/horizon-client/tests/lan_bot.rs b/crates/horizon-client/tests/lan_bot.rs index 4b8bbc897..fdafcbb68 100644 --- a/crates/horizon-client/tests/lan_bot.rs +++ b/crates/horizon-client/tests/lan_bot.rs @@ -435,6 +435,7 @@ fn guests_see_each_other_and_the_world_entities() { attributes: Vec::new(), precise: false, needs_sync: false, + leash: None, }; let first = thread::spawn(move || { let mut bot = connect(port, "Alex", false)?; diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs index 24eec6a05..23ba00699 100644 --- a/crates/horizon-protocol/src/packets/play.rs +++ b/crates/horizon-protocol/src/packets/play.rs @@ -671,6 +671,11 @@ packet!(SetCursorItem { item: Option<Stack> => Slot }); packet!(SetDefaultSpawnPosition { pos: GlobalPos => GlobalPos, yaw: f32 => Float, pitch: f32 => Float }); packet!(SetEntityData { id: i32 => VarInt, values: Vec<(u8, i32, Value)> => EntityData }); packet!(SetEntityMotion { id: i32 => VarInt, velocity: [f64; 3] => LpVec3 }); +packet!( + /// ClientboundSetEntityLinkPacket: the entity holding a leashed entity's + /// lead, 0 when none (Leashable.setDelayedLeashHolderId). + SetEntityLink { source: i32 => Int, dest: i32 => Int } +); packet!( /// ClientboundSetPassengersPacket: a vehicle and every entity riding it. SetPassengers { vehicle: i32 => VarInt, passengers: Vec<i32> => List<VarInt> } @@ -1532,6 +1537,7 @@ packet_enum!(Clientbound, crate::ids::play::clientbound { SetDisplayObjective(SetDisplayObjective) = SET_DISPLAY_OBJECTIVE, SetEntityData(SetEntityData) = SET_ENTITY_DATA, SetEntityMotion(SetEntityMotion) = SET_ENTITY_MOTION, + SetEntityLink(SetEntityLink) = SET_ENTITY_LINK, SetEquipment(SetEquipment) = SET_EQUIPMENT, SetExperience(SetExperience) = SET_EXPERIENCE, SetHealth(SetHealth) = SET_HEALTH, @@ -2263,6 +2269,7 @@ mod tests { vehicle: 2, passengers: vec![3, 300], }), + Clientbound::SetEntityLink(SetEntityLink { source: 2, dest: 0 }), Clientbound::ProjectilePower(ProjectilePower { id: 4, power: 0.1 }), Clientbound::SetEquipment(SetEquipment { id: 2, diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index de8c78dc3..b3dae9ef4 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -29,6 +29,8 @@ address. The script then checks, from both sides, what a guest's game used to ge cow on fire burns and goes out; then the wither's health drops when it is hurt, the sheep is dyed blue with its wool back and the calf grows up (#1367, #1368, #1370, #1371, #1385, #1390); +- leads: the host and the guest each tie a cow to a lead and untie it: the rope shows on both + sides, held by the player who tied it, and goes on both (#1360); - respawn: a player killed is drawn dead by the other side, and alive again once it respawns (the respawned player is a new entity to the others); the host dies, and on the server thread the guest too; @@ -206,7 +208,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'looks', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater'] class Game: @@ -1225,6 +1227,43 @@ def check_looks(host, guest, out): return seen['later']['guest'] +def check_leads(host, guest, out): + spots = apart(host, guest) + result = {} + for label, player, other in (('host', host, guest), ('guest', guest, host)): + x, y, z = spots[label] + at = (x + 0.5, y, z + 2.5) + + def cow(game): + found = [m for m in game.raw('mobs', 32).get('near', []) if m['kind'] == 'minecraft:cow' + and abs(m['pos'][0] - at[0]) < 1 and abs(m['pos'][2] - at[2]) < 1] + assert found, f'{game.name} sees no cow at {at}' + return found[0] + player('command', command='gamemode survival') + player('command', command=f'summon minecraft:cow {at[0]} {y} {at[2]} {{NoAI:1b}}') + player('command', command='item replace entity @s weapon.mainhand with minecraft:lead') + player.wait(30) + try: + player.raw('look-at', f'{at[0]:.2f}', f'{y + 0.7:.2f}', f'{at[2]:.2f}') + player.raw('mouse', 'right', 'click') + player.wait(20) + tied = {'own': cow(player)['leash'], 'other': cow(other)['leash']} + player.shot(out, 'leads-' + label) + other.shot(out, f'leads-{label}-seen') + # An empty hand unties it (the lead was used up). + player.raw('mouse', 'right', 'click') + player.wait(20) + untied = {'own': cow(player)['leash'], 'other': cow(other)['leash']} + finally: + player('command', command=f'kill @e[type=!minecraft:player,x={at[0]},y={y},z={at[2]},distance=..6]') + player('command', command='clear @s') + result[label] = {'tied': tied, 'untied': untied} + # The other side draws it held by the player who tied it (another player to it). + assert tied['own'] == 'Player' and tied['other'], f"the {label}'s cow on its lead: {tied}" + assert untied == {'own': None, 'other': None}, f"the {label}'s cow untied: {untied}" + return result + + def container_items(game): """The open container's stacks by slot (Horizon's container slots are 300 and up) and its size.""" slots = [s for s in game('screen').get('slots', []) if s.get('slot', 0) >= 300] @@ -3905,7 +3944,8 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'contacts': check_contacts, 'absorption': check_absorption, 'breath': check_breath, 'lava': check_lava, 'levels': check_levels, 'drops': check_drops, 'underwater': check_underwater, - 'looks': check_looks} + 'looks': check_looks, + 'leads': check_leads} def run(ctl, out, resources, checks): From 6049012b52f3e3675fd45f8a7f767015aea11534 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 10:54:42 +0200 Subject: [PATCH 46/62] Single player runs in the frame by default again; the server thread is opt-in Players on the Alpha channel report single player as broken since v0.2.1 (#1265 made the integrated server thread the default again). On v0.2.11's server thread, placed signs open no editor (#1380), held books don't open (#1366), a totem doesn't save its holder (#1292) and death keeps the inventory with keep_inventory off (#1284); the in-frame world and Stable v0.2.0 do all four right. About 45 more [server-thread] issues are open. `--server-thread` or HORIZON_SERVER_THREAD=1 turns it on, as before #1114; `--no-server-thread` and HORIZON_SERVER_THREAD=0 still work. LAN guests and dedicated servers are untouched. Temporary until the server thread reaches parity (FEATURES 4zg). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- crates/horizon-client/src/game.rs | 12 +++++++----- crates/horizon-client/src/game/integrated.rs | 9 ++++++--- docs/server-levels.md | 7 ++++--- 3 files changed, 17 insertions(+), 11 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index b307d71dc..b67cf2263 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -282,9 +282,11 @@ struct Options { benchmark: Option<String>, /// `--dev-mod PATH` (repeatable): mods always on and reloaded when rebuilt. dev_mods: Vec<PathBuf>, - /// Single player runs on an integrated server thread (game/integrated.rs), - /// as vanilla's does: the default. `--no-server-thread` or - /// `HORIZON_SERVER_THREAD=0` runs the world in the frame instead. + /// `--server-thread` or `HORIZON_SERVER_THREAD=1`: single player runs on an + /// integrated server thread (game/integrated.rs), as vanilla's does. Off by + /// default again until a server's players reach parity with the in-frame + /// world (signs, books, totems, keep_inventory...); `--no-server-thread` + /// keeps it off. server_thread: bool, /// Set on the integrated server's own options: it draws nothing, so it skips meshing. integrated: bool, @@ -342,7 +344,7 @@ impl Options { dev_mods: Vec::new(), // The command harness (HORIZON_COMMAND_SCRIPT) drives the world // itself, without the event loop: it stays in the frame. - server_thread: std::env::var("HORIZON_SERVER_THREAD").map_or(true, |v| v != "0") + server_thread: std::env::var("HORIZON_SERVER_THREAD").is_ok_and(|v| v == "1") && std::env::var_os("HORIZON_COMMAND_SCRIPT").is_none(), integrated: false, }; @@ -352,7 +354,7 @@ impl Options { match arg.as_str() { "--help" | "-h" => { println!( - "Horizon — Minecraft Java Edition {} in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --width N, --height N Window size (default 1280 x 720)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --world-frames N Exit after N frames drawn in the world (testing)\n --smoke-report PATH Write a JSON report on exit\n --benchmark SCENARIO Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n --session-file PATH Signed-in account from the launcher (read once, then deleted)\n --dev-mod PATH A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n --no-server-thread Run single player's world in the frame, not on its server thread\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.", + "Horizon — Minecraft Java Edition {} in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --width N, --height N Window size (default 1280 x 720)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --world-frames N Exit after N frames drawn in the world (testing)\n --smoke-report PATH Write a JSON report on exit\n --benchmark SCENARIO Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n --session-file PATH Signed-in account from the launcher (read once, then deleted)\n --dev-mod PATH A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n --server-thread Run single player's world on its server thread (not at parity yet)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.", horizon_core::VANILLA_VERSION ); return Ok(None); diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index ef5775174..49266a855 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -6,9 +6,12 @@ //! the world's options) with [`Integrated::call`], as vanilla's client calls //! into its `IntegratedServer`. //! -//! On by default. `--no-server-thread` or `HORIZON_SERVER_THREAD=0` runs -//! the world in the frame instead (the escape hatch while the network -//! player's side catches up with the in-frame one). +//! Opt-in again (`--server-thread` or `HORIZON_SERVER_THREAD=1`) until a +//! server's players reach parity with the in-frame world: on the server +//! thread, signs open no editor, books don't open, a totem doesn't save its +//! holder and death keeps the inventory (#1380, #1366, #1292, #1284 and the +//! other `[server-thread]` issues). LAN guests and dedicated servers use the +//! same code either way. use super::{ Game, Options, PackResources, Resources, UiResources, lan::{LanSettings, Owner}, diff --git a/docs/server-levels.md b/docs/server-levels.md index a44f290c4..cc21a52ab 100644 --- a/docs/server-levels.md +++ b/docs/server-levels.md @@ -26,9 +26,10 @@ the other dimensions' levels as `Parked` values and swaps one into place (`enter The packets of a guest are read in its own level's pass (`Hub::tick_level`), so its actions and commands run with its level in place. -The window's own game (`--no-server-thread`, `HORIZON_SERVER_THREAD=0`, and the command harness) keeps -one level, which follows its player (`enter_dimension`). LAN guests of a world run that way stay in the -host's dimension. That mode is the escape hatch now, so it gets no multi-level work. +The window's own game (single player's default, `--no-server-thread`, `HORIZON_SERVER_THREAD=0`, and the +command harness) keeps one level, which follows its player (`enter_dimension`). LAN guests of a world run +that way stay in the host's dimension. It is the default again only until the server thread reaches parity +(`--server-thread` or `HORIZON_SERVER_THREAD=1` opts in), so it gets no multi-level work. ## One code path for both From 0e65e8587825144712e797bd9f5ac399ec94cd24 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 11:53:00 +0200 Subject: [PATCH 47/62] Releases: one channel, every release is the latest once its checks pass Ludovic's decision (2026-10-23): no more Alpha and Stable. release.yml publishes every game release as the release and GitHub's latest instead of a pre-release that promote.yml made stable once a day. The checks that gated a promotion run in the release itself: `decide` holds the train while an issue labelled release-blocker is open (forced runs too), and the publish job runs `release_train.py gate` right before publishing: the Mac mini's smoke-test.json must be there and show a world was drawn, and no blocker may be open. Otherwise nothing is published. Notes cover everything since the last release that is not a pre-release, so the first single-channel release lists all of it since v0.2.0. promote.yml, tools/release_channels.py and its tests are deleted. The cadence is unchanged (5 minutes of settling, 20 at most, release-now at once). Docs and site: one channel in release-flow, versioning, security, the FAQ, install, the home page and the Releases page (Game / Launcher filter); no player-facing Alpha wording left. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --- .github/CODEOWNERS | 1 - .github/workflows/promote.yml | 55 --------- .github/workflows/release.yml | 35 ++++-- docs/release-flow.md | 107 ++++++---------- docs/security.md | 21 ++-- docs/versioning.md | 16 +-- tests/test_release_channels.py | 147 ---------------------- tests/test_release_train.py | 28 ++++- tools/release_channels.py | 220 --------------------------------- tools/release_train.py | 99 ++++++++++----- website/build.mjs | 7 +- website/docs/faq.md | 2 +- website/docs/index.md | 2 +- website/docs/install.md | 13 +- website/docs/multiplayer.md | 2 +- website/docs/settings.md | 4 +- website/src/index.html | 2 +- website/src/main.js | 8 +- website/src/releases.html | 7 +- website/src/releases.js | 6 +- website/src/style.css | 5 +- 21 files changed, 208 insertions(+), 579 deletions(-) delete mode 100644 .github/workflows/promote.yml delete mode 100644 tests/test_release_channels.py delete mode 100644 tools/release_channels.py diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 8d8687753..5567eb184 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -6,7 +6,6 @@ /.github/ @ludovic111 /tools/ci/ @ludovic111 /tools/release_train.py @ludovic111 -/tools/release_channels.py @ludovic111 /crates/horizon-release-sign/ @ludovic111 /crates/horizon-server/src/update.rs @ludovic111 /crates/horizon-server/Cargo.toml @ludovic111 diff --git a/.github/workflows/promote.yml b/.github/workflows/promote.yml deleted file mode 100644 index 3966f571b..000000000 --- a/.github/workflows/promote.yml +++ /dev/null @@ -1,55 +0,0 @@ -name: promote -# Beta game releases become stable once a day (docs/release-flow.md, "Channels"): at 20:00 UTC (21:00 in Paris in -# winter time, 22:00 in summer) tools/release_channels.py promotes the newest beta that had been out 6 hours by then, -# passed its release smoke test and isn't covered by an issue labelled release-blocker. Launchers on the Alpha -# channel install every beta when it is published; Stable gets the day's promotion. The later runs of the evening are -# retries for a run GitHub starts late or skips: they promote the same beta, so stable still moves once. -# By hand, from GitHub's app too (Actions > promote > Run workflow): -# gh workflow run promote -f tag=v0.2.3 # that beta now, without waiting for 20:00 -# gh workflow run promote -f tag=v0.2.3 -f force=true # even blocked or without its smoke test -# gh workflow run promote -f dry_run=true # say what would be promoted -# Holding betas back: label an issue release-blocker. While it is open it holds every beta; closed as completed it -# still holds the betas published before it closed. The issue's text is never read (its author could edit it). -# When the oldest waiting beta is 30 hours old (it missed a promotion it was due for), an issue "Promotion to stable -# has stalled" says so; it closes itself after the next promotion. -on: - schedule: - - cron: '7,37 20-21 * * *' - workflow_dispatch: - inputs: - tag: - description: The beta to promote now (empty = the newest beta that is due) - type: string - default: '' - force: - description: Promote that tag even if a release-blocker covers it or its smoke test didn't run - type: boolean - default: false - dry_run: - description: Say what would be promoted, change nothing - type: boolean - default: false -permissions: - contents: write - issues: write -concurrency: - group: promote - cancel-in-progress: false -jobs: - promote: - runs-on: ubuntu-latest - timeout-minutes: 10 - steps: - - uses: actions/checkout@v4 - with: - # The notes of a promoted release cover every pull request since the last stable one. - fetch-depth: 0 - # gh uses GH_TOKEN below; nothing needs git credentials on disk. - persist-credentials: false - - name: Promote - env: - GH_TOKEN: ${{ github.token }} - TAG: ${{ inputs.tag }} - FORCE: ${{ inputs.force && 'yes' || '' }} - DRY_RUN: ${{ (inputs.dry_run || github.ref != 'refs/heads/main') && 'yes' || '' }} - run: python3 tools/release_channels.py promote ${TAG:+--tag "$TAG"} ${FORCE:+--force} ${DRY_RUN:+--dry-run} diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index b19ba9ce5..95a2fec64 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -3,12 +3,15 @@ name: release # release waiting for merges to settle goes out without another merge) and by hand, tools/release_train.py decides: # a release when pull requests merged since the last one changed what players run and the newest merged 5 minutes # ago (the oldest 20 minutes ago, if merges never pause), or at once for a pull request labelled release-now. -# RELEASES_PAUSED=1 (repository variable) stops them. +# RELEASES_PAUSED=1 (repository variable) stops them; so does an open issue labelled release-blocker, forced runs too. # Builds Linux (an older Ubuntu, so the binary runs on any recent distribution and on NixOS through nix-ld) and # Windows on GitHub, macOS on the Mac mini's runner (MAC_RUNNER=macos-latest sends it to GitHub), then # publishes vX.Y.Z on the release line in .github/release-line.txt (docs/versioning.md; without it, the dated -# vYYYY.MM.DD[.N] from before 0.2) with notes from the merged pull requests, as a beta (a pre-release) that promote.yml makes -# stable in its daily promotion. macOS: with the repository variable MACOS_SIGN_IDENTITY set, the programs are signed with +# vYYYY.MM.DD[.N] from before 0.2) with notes from the merged pull requests, as the release and GitHub's latest: one +# channel, which launchers, `horizon-server update` and install.sh follow at once. So it is published only after the +# checks that used to gate a promotion pass in this run: the Mac mini's smoke test drew a world, and no release-blocker +# is open (tools/release_train.py gate); otherwise nothing is published. macOS: with the repository variable +# MACOS_SIGN_IDENTITY set, the programs are signed with # Developer ID and the hardened runtime and the zip is notarized, from the runner's signing keychain # (packaging/macos/README.md); unset (forks), ad hoc. # gh workflow run release --ref <branch> # dry run: builds and notes, publishes nothing @@ -32,6 +35,8 @@ on: default: false permissions: contents: read + # The open release-blocker issues (decide). + issues: read concurrency: group: game-release cancel-in-progress: false @@ -203,7 +208,7 @@ jobs: or not report.get("meshed_sections") or not report.get("player"): sys.exit("the smoke run did not draw a world") EOF - # Published with the release: a beta becomes stable only with it (tools/release_channels.py). + # Published with the release; the publish job checks it again before it publishes anything. cp "$home/smoke.json" "$RUNNER_TEMP/smoke-test.json" - uses: actions/upload-artifact@v4 if: runner.environment == 'self-hosted' @@ -319,6 +324,7 @@ jobs: timeout-minutes: 15 permissions: contents: write + issues: read steps: - uses: actions/checkout@v4 with: @@ -341,6 +347,17 @@ jobs: run: | key=(); [[ -n "$EPHEMERAL" ]] && key=(--key "$(cat dist/ephemeral.pub)") cargo run --locked --quiet -p horizon-release-sign -- verify --tag "$TAG" --publishing "${key[@]}" dist + - name: Ready to publish (the smoke test passed, no release-blocker is open) + # Right before publishing: an issue labelled while the builds ran still holds this release. A dry run only + # reports what a real run would do. + env: + GH_TOKEN: ${{ github.token }} + DRY_RUN: ${{ needs.decide.outputs.dry_run }} + run: | + if ! python3 tools/release_train.py gate --kind game --smoke dist/smoke-test.json --blockers; then + [[ "$DRY_RUN" == true ]] || { echo "::error::Nothing published"; exit 1; } + echo "::warning::A real run would publish nothing" + fi - name: Publish ${{ needs.decide.outputs.tag }} if: needs.decide.outputs.dry_run != 'true' env: @@ -348,17 +365,15 @@ jobs: TAG: ${{ needs.decide.outputs.tag }} run: | signature=(); [[ -f dist/SHA256SUMS.sig ]] && signature=(dist/SHA256SUMS.sig) - smoke=(); [[ -f dist/smoke-test.json ]] && smoke=(dist/smoke-test.json) - # A beta (pre-release), the Alpha channel's: promote.yml makes it stable and latest in its daily promotion - # (docs/release-flow.md). + # The release and the latest at once: there is one channel (docs/release-flow.md). gh release create "$TAG" --target "${{ needs.decide.outputs.head }}" --title "$(cat notes/title.txt)" \ - --notes-file notes/body.md --prerelease --latest=false dist/horizon-linux-x86_64.tar.gz \ + --notes-file notes/body.md --latest dist/horizon-linux-x86_64.tar.gz \ dist/horizon-windows-x64.zip dist/horizon-macos-arm64.zip dist/horizon-server-linux-x86_64.tar.gz \ - dist/SHA256SUMS "${signature[@]}" "${smoke[@]}" + dist/SHA256SUMS "${signature[@]}" dist/smoke-test.json - name: Dry run, the release that would be published if: needs.decide.outputs.dry_run == 'true' run: | - echo "Would publish ${{ needs.decide.outputs.tag }} at ${{ needs.decide.outputs.head }}: $(cat notes/title.txt)" + echo "Would publish ${{ needs.decide.outputs.tag }} at ${{ needs.decide.outputs.head }} as the release and latest: $(cat notes/title.txt)" ls -l dist - uses: actions/upload-artifact@v4 with: diff --git a/docs/release-flow.md b/docs/release-flow.md index 6cc4bcd3c..72a5c53a9 100644 --- a/docs/release-flow.md +++ b/docs/release-flow.md @@ -2,9 +2,8 @@ How a change gets from a pull request to players: the checks a pull request passes, how it merges, and the automatic releases that follow. Releases are automatic and frequent so the latest Horizon is always playable. -Each one goes out as an **alpha** build, which launchers on the **Alpha** channel install at once, and becomes **stable** in -the next daily promotion unless something holds it back ([Channels](#channels)): launchers and servers install -stable builds unless their owner picks Alpha. +There is one channel ([One channel](#one-channel)): each release is published as the release and GitHub's *latest* +once its smoke test passed and no `release-blocker` is open, and launchers and servers install it at once. ## Pull request checks @@ -101,12 +100,11 @@ flowchart LR windows["Windows x64<br/>GitHub windows-latest"] mac["macOS arm64<br/>Mac mini runner<br/>+ offscreen game run"] end - build --> publish["publish vX.Y.Z as an alpha<br/>notes from the merged PRs"] - publish --> alpha(["launchers on Alpha install it"]) - publish --> promote{"promote.yml, daily at 20:00 UTC:<br/>6 h old by then, smoke test, no release-blocker"} - promote --> stable["stable and latest<br/>notes since the last stable"] - stable --> launcher(["every launcher and server installs it"]) - stable --> kira(["Kira posts it;<br/>pings only with ### New"]) + build --> gate{"gate: the smoke test drew a world,<br/>no release-blocker is open"} + gate -- no --> nothing(["nothing is published"]) + gate -- yes --> publish["publish vX.Y.Z as the release and latest<br/>notes from the merged PRs"] + publish --> launcher(["every launcher and server installs it"]) + publish --> kira(["Kira posts it; the first release<br/>after 20:00 UTC pings, once a day"]) ``` ### When it releases @@ -121,9 +119,10 @@ commits) since the last **published** game release: - It releases when at least one pull request counts and the newest of them merged at least 5 minutes ago, so a wave of merges becomes one release; if merges never pause, it releases once the oldest has waited 20 minutes. There is no minimum time between releases: every settled player-facing change ships, limited only by the release already - building. That is the Alpha channel, many releases a day. + building: many releases a day. - A pull request labelled `release-now` (a crash or a blocker) releases at once. - A pull request labelled `skip-release` (work players don't see) doesn't count and isn't listed in the notes. +- An open issue labelled `release-blocker` holds every game release, forced ones too (`held by release-blocker #N`). - One release at a time (concurrency group `game-release`); a run that finds nothing new does nothing. - A scheduled or hand-started run releases main's newest commit whose `checks` passed; after `checks`, the commit they passed on. @@ -137,7 +136,7 @@ How releases are numbered, and how installs from before 0.2 reach it: [versionin the patch after the newest release tagged on that line (`v0.2.0` first). A `feature` label doesn't change the line: only that file does, by pull request. - Without the file (every release before 0.2), `vYYYY.MM.DD`, then `.01`, `.02`… the same UTC day. -- Every reader (`release_train.py`, `release_channels.py`, the launcher, `horizon-server update`, the website) ranks +- Every reader (`release_train.py`, the launcher, `horizon-server update`, the website) ranks every `vX.Y.Z` tag above every dated one. ### Labels @@ -149,7 +148,7 @@ How releases are numbered, and how installs from before 0.2 reach it: [versionin | `skip-release` | Doesn't trigger a release and isn't listed in the notes | | `run-parity` | Runs the parity job once on a fork's pull request | | `parity-regression` | Opened by the nightly audit for a harness that fails on main | -| `release-blocker` | On an issue: holds every beta back from stable while it is open ([Channels](#channels)) | +| `release-blocker` | On an issue: no game release is published while it is open ([One channel](#one-channel)) | Pull requests without `feature` are listed under **Fixed**. Titles are written for players, since they become the notes. @@ -180,63 +179,38 @@ runs the game: GitHub's runners have neither a GPU worth the name nor the game f - `### Known issues`: the bullets of [docs/known-issues.md](known-issues.md); - thanks to outside contributors, how to install, the disclaimer. -Kira posts every release in Discord's #releases. An Alpha build (a game pre-release) is posted silently: no ping and -Discord's @silent flag, so nobody gets a notification. When the same release becomes Stable it is posted again, and -that post pings the releases role when the notes have a `### New` section (at most once every 6 hours). Launcher -releases post without a ping. +Kira posts every release once in Discord's #releases. It pings the releases role at most once a day: the first game +release published after 20:00 UTC, with a short list of what came out since its last ping. Every other post is +silent (no ping and Discord's @silent flag). Launcher releases post without a ping. -### Channels +### One channel -Every game release is published as an **alpha** build, a GitHub pre-release (the workflows, tools and labels -call it a *beta*: `release-blocker` holds every beta), so GitHub's *latest* release stays the last -**stable** one. The launcher's Settings has an **Updates** choice of two channels (`update_channel` in its -`settings.json`, `horizon-launcher update-channel`): +Since 2026-10-23 there is one channel. Every game release is published as the release, never a pre-release, and +marked GitHub's *latest*: the launcher, `horizon-server update` and `install.sh` take it at once. Because nothing +promotes it later, the checks that used to gate a promotion run in the release itself, and the publish job +(`tools/release_train.py gate`) publishes nothing unless both pass: -- **Stable**, the default: a tested build about once a day, the alpha builds promoted below. -- **Alpha**: every alpha build as soon as it is built, many times a day; it can break. "Alpha" is the project's - word for builds that are still being tested (the whole of Horizon is in beta); Stable is the tested ones. An open - launcher looks for releases every 30 minutes on Alpha (4 hours on Stable). Launchers from before 0.2 had a "Beta - builds" switch instead; on, it reads as Alpha. +- the release smoke test: the macOS build runs the game offscreen on the Mac mini and keeps its report, + `smoke-test.json`, only when the game drew a world. The gate reads the report again before publishing, and the + release carries it. A run whose macOS build went to GitHub (`MAC_RUNNER=macos-latest`) has no report, so it + publishes nothing; +- no open issue labelled `release-blocker`. `decide` checks first, so a blocked train builds nothing; the gate checks + again right before publishing, so an issue labelled while the builds ran still holds the release. Only the label + and the issue's state count, never its text: whoever opened the issue can edit the text after a maintainer + labels it. Close the issue (or remove the label) and the next run releases everything waiting, with notes + covering all of it. -`horizon-server update` installs stable builds (`--version <tag>` takes an alpha build by name). In Discord's #releases every -Alpha is posted silently and only Stable posts notify (above). +A failed gate fails the run; the next run (10 minutes later) decides again. Nothing older than the latest release is +ever published: tags only count up. -`.github/workflows/promote.yml` runs `tools/release_channels.py promote` once a day at 20:00 UTC (21:00 in Paris in -winter time, 22:00 in summer), with retries until 21:37 for a run GitHub starts late or skips. It promotes the newest -beta that +The launcher has no channel setting any more and looks for releases every 30 minutes. The game pre-releases of the +old Alpha channel (v0.2.1 on, published before this change) stay listed for anyone who wants one by hand, but no +launcher installs them as an update, and `release_train.py` ignores them: the first release of the single channel +lists everything since the last release that was not a pre-release (v0.2.0). Launchers from before this change keep +updating either way: with Alpha (or 0.17's "Beta builds") on they take every release, pre-release or not; with it +off, every release that is not a pre-release, which is now every new one. -- is newer than the stable release, -- had been out 6 hours at 20:00 UTC (published by 14:00 UTC that day; one published later waits for the next day), - so every run of the evening picks the same beta and stable moves once a day, -- passed its release smoke test: the macOS build attaches `smoke-test.json` (the offscreen game run's report) only - when the game drew a world on the Mac mini, so a release built while `MAC_RUNNER` sends macOS to GitHub waits - for a hand, -- and isn't covered by an issue labelled `release-blocker`. An open blocker holds every beta; closed as completed - it still holds the betas published before it closed (they have the bug); closed as not planned it holds - nothing. Only the label and the issue's state count, never its text: whoever opened the issue can edit the - text after a maintainer labels it, so it can't pick which betas go out. - -Nothing older than the stable release is ever promoted, not even with `force`: GitHub's latest release is what -`horizon-server update` and `install.sh` download, so it only moves forward. - -When the oldest beta newer than the stable release has waited 30 hours (it missed a daily promotion it was due for; -on a normal day a beta waits at most that long and is promoted), promote.yml opens an issue titled -"Promotion to stable has stalled" with the reason from the last check (a blocker left open, smoke tests not -running). It closes itself after the next promotion. - -Promoting marks the beta stable and latest and rewrites its notes to list everything since the previous stable -release (`release_train.py notes --stable`), so players who skipped the betas see all of it. Older betas stay -betas. By hand, from a phone too (GitHub app: Actions, promote, Run workflow): - -```sh -gh workflow run promote -f tag=v0.2.3 # that beta now: no wait for 20:00, still no blocker -gh workflow run promote -f tag=v0.2.3 -f force=true # even blocked or without a smoke test -gh workflow run promote -f dry_run=true # what would be promoted now -``` - -An alpha build's notes cover only what changed since the release before it (alpha or stable), and say it is an alpha build. -`release_train.py decide` counts pull requests from the newest release of either channel, so betas don't -release the same changes again. +`promote.yml` and `tools/release_channels.py` (the daily promotion at 20:00 UTC) are gone. ### Signed checksums @@ -298,7 +272,8 @@ gh variable set RELEASES_PAUSED --body 1 # no automatic game or launcher rel gh variable delete RELEASES_PAUSED # back on; the next hourly run catches up ``` -While paused, runs still decide and say why in their summary; `force=true` still releases. +While paused, runs still decide and say why in their summary; `force=true` still releases, but never past an open +`release-blocker`. ### Rolling back @@ -308,8 +283,8 @@ A bad release is withdrawn by turning it back into a draft: gh release edit v0.2.3 --draft ``` -A beta that is not promoted yet needs no rollback: label an issue about it `release-blocker`. For a stable -release: launchers list only published releases, so the previous version becomes the newest one again, launchers that +To stop the next releases while a problem is fixed, label an issue about it `release-blocker`. For the bad +release itself: launchers list only published releases, so the previous version becomes the newest one again, launchers that didn't install the bad one won't, and players who did can pick the previous version in the launcher's version list (`launcher/src/backend.rs` tests `withdrawn_release_is_never_offered`). The tag stays, so the next release that day takes the next number, and its notes start from the last *published* release, so they list the diff --git a/docs/security.md b/docs/security.md index 175e5d21d..886f149d5 100644 --- a/docs/security.md +++ b/docs/security.md @@ -38,7 +38,7 @@ and some are waiting for Ludovic: | Private vulnerability reporting | **Live** (see the end of this page). | | Signed checksums on releases | **Live** for new releases (#1011): the `release` environment holds the key, and its public half is in `release-keys.txt` (#1023). Releases from before then are unsigned. | | Launchers and servers checking signatures | **Not yet**: #1014 waits as a draft until a signed stable game release and a signed launcher release exist. Until then they trust GitHub's checksum, as before. | -| Alpha, then stable | **Live** (#1012): every release is first an alpha build. The launcher's Updates setting picks Stable (the default) or Alpha (the pre-releases). | +| Smoke test and release-blocker before publishing | **Live**: since 2026-10-23 every release is the latest at once (one channel, Ludovic's decision), so it is published only after its smoke test passed and while no `release-blocker` is open. The 6-hour beta of the old Alpha, then stable flow (#1012) is gone. | | Reports marked suspicious | **Partly**: the scan of Discord for agents does it. Kira's issues do it once its pull request merges. | | Code owners' review of the pipeline | **Not yet**: `.github/CODEOWNERS` and its protection (#1015) wait for the App, below. Until then pipeline changes merge like any other once `verify` passes. | | Agents on their own GitHub App | **Not yet**: prepared, waiting for Ludovic to create it. Agents still use his account. | @@ -53,11 +53,10 @@ and some are waiting for Ludovic: - **`verify` always runs.** Labels no longer start the checks, and the required `verify` job has no condition, so the only `verify` a change can have is one that ran. Main requires it, from GitHub Actions only, for everyone, admins included. -- **Alpha, then stable.** Every release is first an **alpha** build (a GitHub pre-release). It becomes **stable**, the version launchers and - servers install by themselves, in the daily promotion (20:00 UTC), only after it has been out 6 hours and passed its - smoke test (the game started and drew a world on the Mac mini), and only while no issue labelled `release-blocker` - is open. If a beta misses a promotion it was due for, an issue says so. Players who want the newest builds at once - pick **Alpha** under Updates in the launcher's Settings. Discord announces stable releases only. +- **Checked before it is published.** Every release is published as the latest, which launchers and servers + install by themselves, so the release run publishes it only after its smoke test passed (the game started and + drew a world on the Mac mini) and only while no issue labelled `release-blocker` is open; otherwise nothing is + published. - **Signed updates.** Each release carries a list of its files' checksums, signed with Horizon's release key. The launcher (for the game and for itself) and `horizon-server update` check that signature against the public key built into them, then check the download against the list. Anything unsigned, signed with another key, signed @@ -78,9 +77,8 @@ and some are waiting for Ludovic: ## What still needs Ludovic - **Approving pipeline changes** (rare): a pull request touching a file in `.github/CODEOWNERS`. -- **Holding a release back or speeding one up**, from his phone if he likes. Label an issue `release-blocker` to - hold every beta until it is closed. Run the `promote` workflow (GitHub app: Actions, - promote, Run workflow) to make a beta stable at once. +- **Holding releases back or speeding one up**, from his phone if he likes. Label an issue `release-blocker` to + hold every release until it is closed; label a pull request `release-now` to release it as soon as it merges. - **Creating the GitHub App**: one link, "Create GitHub App", then "Install". His login, his clicks. - **Fork pull requests**: their checks run only after a maintainer approves them, and they run on the Mac mini only after a maintainer has read them and added `run-parity`. @@ -90,8 +88,9 @@ and some are waiting for Ludovic: ## What this doesn't solve - **Code that merges is code that ships.** Signing proves a build came from Horizon's pipeline, not that the code - is good. Against a bad change, the safety nets are the checks and harnesses, review, the 6-hour beta and the - release-blocker label. + is good. Against a bad change, the safety nets are the checks and harnesses, review, the release smoke test and + the release-blocker label. Since the single channel there is no 6-hour beta: a change reaches every player + within minutes of merging. - **Until agents switch to the App**, they still work with Ludovic's own account, so nothing technical tells his actions from theirs. Code owners' reviews are switched on together with the App. - **The Mac mini** builds the macOS release and also runs pull requests' parity checks: a pull request from this diff --git a/docs/versioning.md b/docs/versioning.md index 6032b54a1..4ed0484e1 100644 --- a/docs/versioning.md +++ b/docs/versioning.md @@ -22,10 +22,10 @@ game and the launcher of the 0.2 line. 0.2. A `feature` label no longer bumps anything: it only lists the change under **New**. - **Patch releases** are every release the train makes: the patch after the newest release tagged on the line, game and launcher counted separately (the game releases more often, so `v0.2.14` can go with `launcher@0.2.3`). -- **Alpha builds** are not separate tags. As before, every game release is published as a GitHub pre-release (an alpha build, what - the launcher's Alpha channel installs) under its final tag and promoted in place to stable in the daily - promotion at 20:00 UTC, once it has been out 6 hours ([Channels](release-flow.md#channels)). `v0.2.4` is the same - build whether it is still a beta or already stable. +- **One channel** (since 2026-10-23): every game release is published under its final tag as the release and + GitHub's latest, once its smoke test passed and no `release-blocker` is open + ([One channel](release-flow.md#one-channel)). The game pre-releases from before (v0.2.1 on, the old Alpha + channel) keep their tags and stay pre-releases. - **Pre-release tags** (`v0.3.0-rc.1`, `v0.3.0-beta.2`) are semver's and are reserved for a hand-made preview of a new line; the train never makes them. Every reader orders them before their release and after the release before (`v0.2.9` < `v0.3.0-beta.1` < `v0.3.0-rc.1` < `v0.3.0`). @@ -43,7 +43,7 @@ Every 0.2 tag is newer than every tag from before 0.2. Within each: A tag is a 0.2 tag when it is `v` or `launcher@` followed by exactly three numbers (and an optional `-PRE`) with a major below 1000; a date's first number is a year, so `v2026.10.21` never is. The rule is written once per language, with the same tests: `crates/horizon-server/src/update.rs` (`newer`), `launcher/src/backend.rs` -(`release_order`), `tools/release_train.py` (`tag_key`, also used by `tools/release_channels.py`) and +(`release_order`), `tools/release_train.py` (`tag_key`) and `website/src/versions.js`. ## The workflows @@ -55,9 +55,6 @@ language, with the same tests: `crates/horizon-server/src/update.rs` (`newer`), - **`launcher.yml`**: `decide --kind launcher` picks `launcher@0.2.N`; the build gets `HORIZON_LAUNCHER_VERSION` (`0.2.N`) and `HORIZON_LAUNCHER_TAG` (`launcher@0.2.N`). The tag tells the launcher which line it is on: a release built with only the version (every launcher before 0.2) is a `launcher-v` one. -- **`promote.yml`**: `tools/release_channels.py` promotes the newest due beta, never one older than the stable - release; with the shared order, `v0.2.0` follows the last dated stable release and no dated beta can follow - `v0.2.0`. - **Notes**: a line's first release (`X.Y.0`) opens with a paragraph saying so; `v0.2.0`'s and `launcher@0.2.0`'s say that releases are numbered from now on, and tell server owners to run `horizon-server update` (or, if their server says it is up to date, `horizon-server update --version v0.2.0`). @@ -98,6 +95,9 @@ the fleet's `release-kick` and the orchestrator's heartbeat prompts. ## The day Ludovic says go +Done on 2026-10-22; kept as the record of how 0.2 went out. `promote.yml` and `tools/release_channels.py`, which +it uses, are gone since the single channel (2026-10-23, [One channel](release-flow.md#one-channel)). + Run by the orchestrator, in this order. Until step 3, nothing is published. 1. Merge, in order: this page, the `horizon-server update` order, the launcher order, the release line (train, diff --git a/tests/test_release_channels.py b/tests/test_release_channels.py deleted file mode 100644 index 288fa7939..000000000 --- a/tests/test_release_channels.py +++ /dev/null @@ -1,147 +0,0 @@ -import datetime as dt -import unittest - -from tools import release_channels as channels -from tools import release_train as train - -# Just after the daily promotion (PROMOTE_AT, 20:00 UTC): a beta is due when it had been out 6 hours by 20:00. -NOW = dt.datetime(2026, 10, 19, 20, 30, tzinfo=dt.timezone.utc) - - -def release(tag, hours_ago, prerelease=True, smoke=True, draft=False): - published = (NOW - dt.timedelta(hours=hours_ago)).isoformat().replace("+00:00", "Z") - assets = [{"name": "horizon-linux-x86_64.tar.gz"}] + ([{"name": channels.SMOKE_ASSET}] if smoke else []) - return {"tag_name": tag, "published_at": published, "prerelease": prerelease, "draft": draft, "assets": assets} - - -def blocker(number, title, body="", state="open", reason=None, closed_hours_ago=None): - closed = None if closed_hours_ago is None else (NOW - dt.timedelta(hours=closed_hours_ago)).isoformat() - return {"number": number, "title": title, "body": body, "state": state, "state_reason": reason, "closed_at": closed} - - -STABLE = release("v2026.10.18.04", 30, prerelease=False) - - -class ReleaseChannelTests(unittest.TestCase): - def test_the_newest_beta_out_six_hours_with_a_smoke_test_is_promoted(self): - releases = [STABLE, release("v2026.10.19", 9), release("v2026.10.19.01", 7), release("v2026.10.19.02", 2)] - chosen, why = channels.choose(releases, [], NOW) - self.assertEqual(chosen["tag_name"], "v2026.10.19.01") - self.assertIn("6 h", why) - - def test_nothing_is_due_before_six_hours(self): - chosen, why = channels.choose([STABLE, release("v2026.10.19", 6)], [], NOW) - self.assertIsNone(chosen, "out 5 h 30 min at 20:00") - self.assertIn("the one at 2026-10-20 20:00 UTC takes it", why) - late = channels.choose([STABLE, release("v2026.10.19", 0.5)], [], NOW)[1] - self.assertIn("the one at 2026-10-20 20:00 UTC takes it", late, "out after 20:00: 6 h by the next one") - - def test_stable_moves_once_a_day_whenever_the_run_starts(self): - hour = dt.timedelta(hours=1) - releases = [STABLE, release("v2026.10.19", 9), release("v2026.10.19.01", 6)] - # Before 20:00 nothing new is due, even what has been out 6 hours by now. - before = channels.choose(releases, [], NOW - hour) - self.assertIsNone(before[0], before[1]) - # The 20:00 run and a late one or a retry pick the same beta; once it is stable, the evening's later runs - # promote nothing, though v2026.10.19.01 has been out 6 hours by then. - for late in (0, 1, 3): - self.assertEqual(channels.choose(releases, [], NOW + late * hour)[0]["tag_name"], "v2026.10.19") - promoted = [release("v2026.10.19", 9, prerelease=False), releases[2]] - self.assertIsNone(channels.choose(promoted, [], NOW + 3 * hour)[0]) - # A run GitHub skipped is caught up by the next one, at any hour before the next day's promotion. - self.assertEqual(channels.choose(releases, [], NOW + 20 * hour)[0]["tag_name"], "v2026.10.19") - # The next day's promotion takes the one that came out too late for today's. - self.assertEqual(channels.choose(promoted, [], NOW + 24 * hour)[0]["tag_name"], "v2026.10.19.01") - self.assertEqual(channels.promotion_time(NOW), dt.datetime(2026, 10, 19, 20, 0, tzinfo=dt.timezone.utc)) - self.assertEqual(channels.promotion_time(NOW - hour), dt.datetime(2026, 10, 18, 20, 0, tzinfo=dt.timezone.utc)) - - def test_a_beta_without_its_smoke_test_waits_for_a_hand(self): - releases = [STABLE, release("v2026.10.19", 8, smoke=False)] - self.assertIsNone(channels.choose(releases, [], NOW)[0]) - self.assertIsNone(channels.choose(releases, [], NOW, tag="v2026.10.19")[0]) - self.assertEqual(channels.choose(releases, [], NOW, tag="v2026.10.19", force=True)[0]["tag_name"], "v2026.10.19") - - def test_by_hand_skips_the_wait_but_not_a_blocker(self): - releases = [STABLE, release("v2026.10.19.02", 1)] - self.assertEqual(channels.choose(releases, [], NOW, tag="v2026.10.19.02")[0]["tag_name"], "v2026.10.19.02") - blocked = [blocker(5, "Crash on start in 2026.10.19.2")] - chosen, why = channels.choose(releases, blocked, NOW, tag="v2026.10.19.02") - self.assertIsNone(chosen) - self.assertIn("#5", why) - self.assertIsNotNone(channels.choose(releases, blocked, NOW, tag="v2026.10.19.02", force=True)[0]) - - def test_stable_releases_and_drafts_are_never_promoted(self): - self.assertIsNone(channels.choose([STABLE], [], NOW, tag=STABLE["tag_name"])[0]) - withdrawn = release("v2026.10.19", 9, draft=True) - self.assertIsNone(channels.choose([STABLE, withdrawn], [], NOW)[0]) - older = release("v2026.10.18.03", 40) - self.assertIsNone(channels.choose([STABLE, older], [], NOW)[0]) - - def test_an_open_blocker_holds_every_beta_whatever_its_text_says(self): - releases = [STABLE, release("v2026.10.19", 12), release("v2026.10.19.01", 10), release("v2026.10.19.02", 8)] - # The issue's author can edit its text after it is labelled: naming a later version must not free a beta. - for text in ("Something is badly wrong", "Only in v2099.01.01", "Since v2026.10.19.01 the chests…"): - chosen, why = channels.choose(releases, [blocker(7, text, body=text)], NOW) - self.assertIsNone(chosen, text) - self.assertIn("release-blocker #7", why) - - def test_a_fixed_blocker_still_holds_the_betas_published_before_the_fix(self): - fixed = blocker(9, "Crash", state="closed", reason="completed", closed_hours_ago=7.5) - releases = [STABLE, release("v2026.10.19", 12), release("v2026.10.19.01", 7)] - self.assertEqual(channels.choose(releases, [fixed], NOW)[0]["tag_name"], "v2026.10.19.01") - self.assertIsNone(channels.choose(releases[:2], [fixed], NOW)[0]) - not_planned = blocker(10, "Crash", state="closed", reason="not_planned", closed_hours_ago=1) - self.assertEqual(channels.choose(releases[:2], [not_planned], NOW)[0]["tag_name"], "v2026.10.19") - - def test_force_never_moves_latest_backwards(self): - # horizon-server update and install.sh download GitHub's latest: an older beta must never become it. - older = release("v2026.10.18.03", 40, smoke=False) - chosen, why = channels.choose([STABLE, older], [blocker(3, "x")], NOW, tag="v2026.10.18.03", force=True) - self.assertIsNone(chosen) - self.assertIn("not newer than the stable v2026.10.18.04", why) - same = release("v2026.10.18.04", 30, prerelease=False) - self.assertIsNone(channels.choose([same], [], NOW, tag="v2026.10.18.04", force=True)[0]) - - def test_0_2_follows_the_dated_releases(self): - bridge = release("v2026.10.21", 30, prerelease=False) - first = release("v0.2.0", 7) - chosen, why = channels.choose([bridge, first], [], NOW) - self.assertEqual(chosen["tag_name"], "v0.2.0", why) - stable = release("v0.2.0", 30, prerelease=False) - older = release("v2026.10.22", 8) - self.assertIsNone(channels.choose([stable, older], [], NOW)[0], "a dated beta never follows 0.2") - chosen, why = channels.choose([stable, older], [], NOW, tag="v2026.10.22", force=True) - self.assertIsNone(chosen) - self.assertIn("not newer than the stable v0.2.0", why) - patch = release("v0.2.1", 7) - self.assertEqual(channels.choose([stable, older, patch], [], NOW)[0]["tag_name"], "v0.2.1") - self.assertEqual(channels.stable([stable, bridge])["tag_name"], "v0.2.0") - launcher = release("launcher@0.2.0", 7) - self.assertIsNone(channels.choose([bridge, launcher], [], NOW)[0], "launcher releases are never game betas") - - def test_a_stall_is_reported_once_the_oldest_waiting_beta_missed_a_daily_promotion(self): - # Out at 14:31 yesterday: just too late for yesterday's 20:00, so 29 h 59 min of waiting is a normal day. - self.assertIsNone(channels.stalled([STABLE, release("v2026.10.19", 29.99), release("v2026.10.19.01", 2)], NOW)) - releases = [STABLE, release("v2026.10.19", 31), release("v2026.10.19.01", 2)] - oldest, age = channels.stalled(releases, NOW) - self.assertEqual(oldest["tag_name"], "v2026.10.19") - title, body = channels.stall_issue(releases, (oldest, age), "no beta is due (release-blocker #4)") - self.assertEqual(title, "Promotion to stable has stalled: v2026.10.19 has waited 31 h") - self.assertIn("v2026.10.18.04", body) - self.assertIn("release-blocker #4", body) - # Betas older than the stable release are contained in it: they aren't waiting. - self.assertIsNone(channels.stalled([STABLE, release("v2026.10.18.03", 40)], NOW)) - self.assertIsNone(channels.stalled([STABLE], NOW)) - - def test_beta_notes_say_so_and_stable_notes_do_not(self): - pr = {"number": 1, "title": "Fix a thing", "labels": [], "paths": ["crates/x.rs"], "issues": [], "author": "ludovic111"} - _, beta = train.notes("game", "v2026.10.19", [pr], [], beta=True) - _, stable = train.notes("game", "v2026.10.19", [pr], [], beta=False) - self.assertIn("This is an alpha build: launchers on the Alpha channel", beta) - self.assertNotIn("alpha", stable.lower()) - _, launcher = train.notes("launcher", "launcher-v0.9.0", [pr], [], beta=True) - self.assertNotIn("alpha", launcher.lower()) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/test_release_train.py b/tests/test_release_train.py index 2a41ae810..298077352 100644 --- a/tests/test_release_train.py +++ b/tests/test_release_train.py @@ -104,7 +104,7 @@ class ReleaseTrainTests(unittest.TestCase): self.assertFalse(train.decision("game", [], NOW)[0]) def test_the_first_release_of_0_2_says_what_changed(self): - title, body = train.notes("game", "v0.2.0", [pr(1)], [], beta=True, previous="v2026.10.21") + title, body = train.notes("game", "v0.2.0", [pr(1)], [], previous="v2026.10.21") self.assertTrue(title.startswith("Horizon 0.2.0: "), title) self.assertTrue(body.startswith("Horizon is numbered from now on: this is Horizon 0.2.0, the release after 2026.10.21.")) self.assertIn("`horizon-server update --version v0.2.0`", body) @@ -132,6 +132,32 @@ class ReleaseTrainTests(unittest.TestCase): self.assertFalse(decide([pr(1)], paused=True)) self.assertTrue(decide([], paused=True, force=True)) + def test_an_open_release_blocker_holds_every_release_even_forced(self): + release, why = train.decision("game", [pr(1, labels=["release-now"])], NOW, blockers=[7, 9]) + self.assertFalse(release) + self.assertEqual(why, "held by release-blocker #7, release-blocker #9") + self.assertFalse(train.decision("game", [], NOW, force=True, blockers=[7])[0]) + self.assertFalse(train.decision("game", [], NOW, new_line="0.3", blockers=[7])[0]) + self.assertTrue(train.decision("game", [pr(1)], NOW, blockers=[])[0]) + + def test_a_release_is_published_only_after_its_smoke_test_and_with_no_blocker(self): + drew = {"error": None, "frames": 12710, "chunks": 81, "meshed_sections": 550, "player": [160.5, 71.0, 156.5]} + self.assertIsNone(train.gate(drew, [])) + self.assertEqual(train.gate(drew, [4]), "release-blocker #4 is open") + self.assertEqual(train.gate(None, []), "no smoke-test.json: the release smoke test did not run") + self.assertEqual(train.gate(None, [4]), + "no smoke-test.json: the release smoke test did not run; release-blocker #4 is open") + self.assertEqual(train.smoke_problem({**drew, "error": "device lost"}), "the smoke run failed: device lost") + for broken in ({**drew, "frames": 1499}, {**drew, "chunks": 0}, {**drew, "meshed_sections": 0}, + {**drew, "player": None}, {}): + self.assertEqual(train.smoke_problem(broken), "the smoke run did not draw a world", broken) + + def test_notes_never_call_a_release_alpha_or_beta(self): + _, body = train.notes("game", "v0.2.12", [pr(1)], []) + self.assertNotIn("alpha", body.lower()) + self.assertNotIn("beta", body.lower()) + self.assertNotIn("Stable", body) + def test_notes(self): prs = [pr(5, "Nether portals: vanilla timing and linking (fixes #94)", issues=[94]), pr(6, "Controllers: gilrs input layer and gameplay", labels=["feature"], author="cosmic"), diff --git a/tools/release_channels.py b/tools/release_channels.py deleted file mode 100644 index 869127c5c..000000000 --- a/tools/release_channels.py +++ /dev/null @@ -1,220 +0,0 @@ -#!/usr/bin/env python3 -"""Promotes Horizon's beta game releases to stable once a day (.github/workflows/promote.yml, docs/release-flow.md). - - python3 tools/release_channels.py promote # the newest beta that is due, if any - python3 tools/release_channels.py promote --tag v2026.10.19.03 # that beta now (by hand) - python3 tools/release_channels.py promote --tag v2026.10.19.03 --force # even if blocked or untested - python3 tools/release_channels.py promote --dry-run # say what would happen, change nothing - -Every game release goes out as a beta (a GitHub pre-release): launchers on the Alpha channel install it at once. -Stable moves once a day, at PROMOTE_AT (20:00 UTC). A beta is due for stable when: -- it is newer than the stable release (GitHub's "latest", which launchers and servers install by default), -- it had been out PROMOTE_AFTER (6 hours) at the day's promotion time, so every run until the next one picks the - same beta and a run GitHub starts late (or a second try) never promotes twice; by hand (--tag) skips the wait, -- its release smoke test passed: release.yml attaches smoke-test.json only after the Mac mini ran the game, -- and no issue labelled release-blocker covers it. An open blocker holds every beta; one closed as completed keeps - holding the betas published before it closed (they still have the bug); one closed as not planned holds nothing. - Only people who can triage the repository can add the label, and the issue's text is never read: whoever wrote - the issue could edit it afterwards, so it can't decide which betas go out. - -The newest due beta is promoted: marked stable and latest, with notes covering everything since the previous -stable release (tools/release_train.py notes --stable). Older betas stay betas: the stable one contains them. -Nothing older than the current stable release is ever promoted, even with --force: GitHub's "latest" is what -horizon-server update and install.sh download, and it only moves forward. - -When the oldest beta newer than the stable release has waited STALL_AFTER (30 hours: past one daily promotion it -was due for, so a normal day never trips it), promotion has stalled -(blocked, smoke tests not running, the schedule off): an issue says so, and is closed once a beta is promoted. -""" - -import argparse -import datetime as dt -import json -import os -from pathlib import Path -import subprocess -import sys -import tempfile - -ROOT = Path(__file__).resolve().parents[1] -sys.path.insert(0, str(ROOT)) -from tools.release_train import is_game_tag, tag_key # noqa: E402 (vYYYY.MM.DD[.N] and v0.2.0: docs/versioning.md) - -REPO = os.environ.get("GITHUB_REPOSITORY", "ludovic111/horizon") -PROMOTE_AFTER = dt.timedelta(hours=6) -# The daily promotion (21:00 in Paris in winter time, 22:00 in summer); promote.yml's schedule runs just after it. -PROMOTE_AT = dt.time(20, 0) -SMOKE_ASSET = "smoke-test.json" -BLOCKER = "release-blocker" -STALL_AFTER = dt.timedelta(hours=30) -STALLED = "Promotion to stable has stalled" - - -def parse_time(text): - return dt.datetime.fromisoformat(text.replace("Z", "+00:00")) if text else None - - -def covers(blocker, release): - """Whether a release-blocker issue holds this beta back. Only its state and dates count, never its text.""" - if blocker.get("state") != "closed": - return True - closed = parse_time(blocker.get("closed_at")) - return blocker.get("state_reason") == "completed" and bool(closed) and parse_time(release["published_at"]) < closed - - -def promotion_time(now): - """The last daily promotion time (PROMOTE_AT, UTC) at or before now.""" - now = now.astimezone(dt.timezone.utc) - at = dt.datetime.combine(now.date(), PROMOTE_AT, dt.timezone.utc) - return at if at <= now else at - dt.timedelta(days=1) - - -def stable(releases): - """The newest stable (non pre-release) game release.""" - stables = [r for r in releases if not r["prerelease"]] - return max(stables, key=lambda r: tag_key(r["tag_name"]), default=None) - - -def reasons_against(release, current, blockers, now, by_hand=False): - """Why this beta can't become stable now: an empty list when it can.""" - reasons = [] - if not release["prerelease"]: - reasons.append("it is already stable") - if current and tag_key(release["tag_name"]) <= tag_key(current["tag_name"]): - reasons.append(f"it is not newer than the stable {current['tag_name']}") - ready = parse_time(release["published_at"]) + PROMOTE_AFTER - if not by_hand and ready > promotion_time(now): - due = promotion_time(ready) - due += dt.timedelta(days=1 if due < ready else 0) - reasons.append(f"it had not been out {PROMOTE_AFTER.seconds // 3600} h at a daily promotion yet: " - f"the one at {due:%Y-%m-%d %H:%M} UTC takes it") - if not any(asset["name"] == SMOKE_ASSET for asset in release.get("assets", [])): - reasons.append(f"it has no {SMOKE_ASSET}: the release smoke test did not run") - for blocker in blockers: - if covers(blocker, release): - reasons.append(f"release-blocker #{blocker['number']}") - return reasons - - -def choose(releases, blockers, now, tag=None, force=False): - """(the beta to promote or None, a line saying why) for the game releases `releases`.""" - games = [r for r in releases if not r["draft"] and is_game_tag(r["tag_name"])] - current = stable(games) - if tag: - release = next((r for r in games if r["tag_name"] == tag), None) - if not release: - return None, f"no published game release is tagged {tag}" - reasons = reasons_against(release, current, blockers, now, by_hand=True) - if force: - # Even forced, "latest" only moves forward: horizon-server update and install.sh follow it. - reasons = [r for r in reasons if r == "it is already stable" or r.startswith("it is not newer")] - if reasons: - return None, f"{tag} stays a beta: " + "; ".join(reasons) - return release, f"{tag} promoted by hand" + (" with force" if force else "") - betas = sorted((r for r in games if r["prerelease"]), key=lambda r: tag_key(r["tag_name"]), reverse=True) - held = [] - for release in betas: - reasons = reasons_against(release, current, blockers, now) - if not reasons: - return release, f"{release['tag_name']} had been out {PROMOTE_AFTER.seconds // 3600} h at the daily promotion, " \ - "passed its smoke test and no release-blocker covers it" - held.append(f"{release['tag_name']}: " + "; ".join(reasons)) - return None, "no beta is due" + (" (" + " / ".join(held[:3]) + ")" if held else "") - - -def stalled(releases, now): - """(the oldest beta newer than the stable release, how long it has waited) once that is STALL_AFTER, else None.""" - games = [r for r in releases if not r["draft"] and is_game_tag(r["tag_name"])] - current = stable(games) - waiting = [r for r in games if r["prerelease"] and (not current or tag_key(r["tag_name"]) > tag_key(current["tag_name"]))] - if not waiting: - return None - oldest = min(waiting, key=lambda r: parse_time(r["published_at"])) - age = now - parse_time(oldest["published_at"]) - return (oldest, age) if age >= STALL_AFTER else None - - -def stall_issue(releases, stall, reason): - """The title and body of the issue saying promotion has stalled.""" - oldest, age = stall - current = stable([r for r in releases if not r["draft"] and is_game_tag(r["tag_name"])]) - hours = int(age.total_seconds() // 3600) - body = (f"Opened by .github/workflows/promote.yml, not by a person.\n\n" - f"No beta has become stable for {hours} hours: {oldest['tag_name']} has waited since " - f"{oldest['published_at']}, and launchers, servers and install.sh still get " - f"{current['tag_name'] if current else 'no stable release'}.\n\n" - f"The last check said: {reason}\n\n" - "Usual causes: an open `release-blocker` issue (it holds every beta until it is closed), the Mac mini's " - "release smoke test not running (no smoke-test.json on the betas), or the promote workflow disabled. " - "To promote a beta by hand: `gh workflow run promote -f tag=<tag>` (add `-f force=true` to skip the " - "smoke test and blockers). This issue closes itself once a beta is promoted.") - return f"{STALLED}: {oldest['tag_name']} has waited {hours} h", body - - -def gh(*arguments, capture=True): - result = subprocess.run(["gh", *arguments], cwd=ROOT, capture_output=capture, text=True) - if result.returncode: - raise SystemExit(f"gh {' '.join(arguments)}: {(result.stderr or '').strip()}") - return result.stdout - - -def gh_pages(path): - return [item for page in json.loads(gh("api", path, "--paginate", "--slurp") or "[]") for item in page] - - -def promote(release): - """Marks the beta stable and latest, with notes covering everything since the previous stable release.""" - tag = release["tag_name"] - with tempfile.TemporaryDirectory() as out: - subprocess.run([sys.executable, str(ROOT / "tools" / "release_train.py"), "notes", "--kind", "game", "--tag", tag, - "--head", tag, "--stable", "--out", out], cwd=ROOT, check=True, stdout=subprocess.DEVNULL) - title = (Path(out) / "title.txt").read_text().strip() - gh("release", "edit", tag, "--repo", REPO, "--prerelease=false", "--latest", "--title", title, - "--notes-file", str(Path(out) / "body.md")) - - -def main(): - parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - parser.add_argument("command", choices=["promote"]) - parser.add_argument("--tag", help="promote this beta now (by hand: no wait for the daily promotion)") - parser.add_argument("--force", action="store_true", help="with --tag: even without a smoke test or with a blocker") - parser.add_argument("--dry-run", action="store_true", help="say what would be promoted, change nothing") - parser.add_argument("--now", help="the time to decide at (ISO 8601; default now)") - args = parser.parse_args() - if args.force and not args.tag: - parser.error("--force needs --tag: only a named beta is forced") - now = dt.datetime.fromisoformat(args.now) if args.now else dt.datetime.now(dt.timezone.utc) - now = now if now.tzinfo else now.replace(tzinfo=dt.timezone.utc) - releases = gh_pages(f"repos/{REPO}/releases?per_page=100") - blockers = [issue for issue in gh_pages(f"repos/{REPO}/issues?labels={BLOCKER}&state=all&per_page=100") - if "pull_request" not in issue] - release, reason = choose(releases, blockers, now, args.tag, args.force) - if release and not args.dry_run: - promote(release) - line = ("Would promote: " if release and args.dry_run else "") + reason - print(line) - if os.environ.get("GITHUB_STEP_SUMMARY"): - with open(os.environ["GITHUB_STEP_SUMMARY"], "a") as summary: - summary.write(f"### {line}\n") - report_stall(releases, release, reason, now, args.dry_run) - return 1 if args.tag and not release else 0 - - -def report_stall(releases, promoted, reason, now, dry_run): - """Opens the stalled-promotion issue when one is due and none is open; closes it after a promotion.""" - open_issues = [issue for issue in gh_pages(f"repos/{REPO}/issues?state=open&per_page=100") - if "pull_request" not in issue and issue["title"].startswith(STALLED)] - stall = None if promoted else stalled(releases, now) - if stall and not open_issues: - title, body = stall_issue(releases, stall, reason) - print(("Would open: " if dry_run else "Opening: ") + title) - if not dry_run: - gh("issue", "create", "--repo", REPO, "--title", title, "--body", body) - if promoted and not dry_run: - for issue in open_issues: - gh("issue", "close", str(issue["number"]), "--repo", REPO, "--comment", - f"{promoted['tag_name']} is stable now (promote.yml).") - - -if __name__ == "__main__": - sys.exit(main()) diff --git a/tools/release_train.py b/tools/release_train.py index 0cc37eef7..b8d6468bb 100644 --- a/tools/release_train.py +++ b/tools/release_train.py @@ -4,13 +4,14 @@ python3 tools/release_train.py decide --kind game [--head SHA] [--force] python3 tools/release_train.py decide --kind launcher python3 tools/release_train.py notes --kind game --tag v2026.10.15 --out dist/notes - python3 tools/release_train.py notes --kind game --tag v2026.10.15 --head v2026.10.15 --stable # at promotion + python3 tools/release_train.py gate --kind game --smoke dist/smoke-test.json [--blockers] # before publishing A kind releases when a pull request merged into main since its last published release changed one of its player-facing paths (GAME_PATHS, LAUNCHER_PATHS) and the newest of them merged at least DEBOUNCE ago (a burst of merges becomes one release), or the oldest at least MAX_WAIT ago (merges that never pause still ship), or when one of those pull requests is labelled release-now. Pull requests labelled skip-release (work players don't see) don't count -towards a release and aren't listed in the notes. RELEASES_PAUSED=1 (a repository variable) stops automatic releases. +towards a release and aren't listed in the notes. RELEASES_PAUSED=1 (a repository variable) stops automatic releases, +and an open issue labelled release-blocker stops game releases, even forced ones, until it is closed. Tags (docs/versioning.md): with a release line in .github/release-line.txt (MAJOR.MINOR, e.g. 0.2), game releases are vMAJOR.MINOR.PATCH and launcher releases launcher@MAJOR.MINOR.PATCH, each the patch after the last tag of its kind @@ -19,9 +20,11 @@ file, the tags from before 0.2: vYYYY.MM.DD, then .01, .02 the same UTC day, and the last launcher tag or the next minor when a merged pull request is labelled feature. Every 0.2 tag is newer than every tag from before (tag_key). Notes: "### New" lists the pull requests labelled feature, "### Fixed" the others, "### Known issues" the bullets of -docs/known-issues.md. Game releases go out as betas (GitHub pre-releases) and tools/release_channels.py promotes -them to stable; a beta's notes cover what changed since the release before it (beta or stable), a promoted -release's (--stable) everything since the last stable one. See docs/release-flow.md. +docs/known-issues.md. Every release is published as the release, GitHub's latest, which launchers, servers and +install.sh take at once; one channel, no promotion. A game release is published only after `gate`: its smoke test +passed and no release-blocker is open. Notes cover everything since the last published release; the game +pre-releases of the old Alpha channel (v0.2.1 on) don't count, so the first release after them lists all of +it since v0.2.0. See docs/release-flow.md. Prints the decision as JSON and writes it to $GITHUB_OUTPUT when set. Needs git history and the gh CLI. """ @@ -37,7 +40,7 @@ import sys ROOT = Path(__file__).resolve().parents[1] REPO = os.environ.get("GITHUB_REPOSITORY", "ludovic111/horizon") -# Alpha builds ship constantly: a merge starts a release within minutes, once its wave of merges has settled. +# Releases ship constantly: a merge starts a release within minutes, once its wave of merges has settled. DEBOUNCE = dt.timedelta(minutes=5) MAX_WAIT = dt.timedelta(minutes=20) # Kept as typed in release titles, where the clauses after the first are lowercased. @@ -72,12 +75,13 @@ LAUNCHER_IGNORED = ["launcher/links.json", "launcher/docs/", "launcher/tests/"] FOOTER = { "game": "Install or update it from the Horizon launcher: it installs new versions by itself. " "New here? Get the launcher at https://playhorizon.dev. You need your own copy of Minecraft: Java Edition.", - "beta": "This is an alpha build: launchers on the Alpha channel (Settings, Updates) install it now; Stable gets it " - "in the next daily update if it holds up.", "launcher": "Your launcher updates itself. New here? Download the archive for your system below, extract it, " "and run `horizon-launcher`. Website: https://playhorizon.dev", } DISCLAIMER = "Not an official Minecraft product. Not approved by or associated with Mojang or Microsoft." +# An open issue with this label holds every game release (docs/release-flow.md). Only people who can triage the +# repository can add it, and the issue's text is never read: its author could edit it afterwards. +BLOCKER = "release-blocker" def run(*command, check=True): @@ -225,11 +229,37 @@ def pull_request(number): } -def published_releases(betas=True): - """Published (not draft) releases with their tags and dates; without betas (pre-releases) when betas is False.""" +def published_releases(): + """Published releases with their tags and dates: no drafts, and no pre-releases (the old Alpha channel's).""" releases = gh_json("api", f"repos/{REPO}/releases?per_page=100", "--paginate", "--slurp") flat = [release for page in releases for release in page] - return [release for release in flat if not release["draft"] and (betas or not release["prerelease"])] + return [release for release in flat if not release["draft"] and not release["prerelease"]] + + +def open_blockers(): + """The numbers of the open issues labelled release-blocker (pull requests left out).""" + issues = gh_json("api", f"repos/{REPO}/issues?labels={BLOCKER}&state=open&per_page=100", "--paginate", "--slurp") + return sorted(issue["number"] for page in issues for issue in page if "pull_request" not in issue) + + +def smoke_problem(report): + """Why a release smoke test's report (the game's --smoke-report) fails, or None when the game drew a world.""" + if report is None: + return "no smoke-test.json: the release smoke test did not run" + if report.get("error") is not None: + return f"the smoke run failed: {report['error']}" + if report.get("frames", 0) < 1500 or not report.get("chunks") or not report.get("meshed_sections") \ + or not report.get("player"): + return "the smoke run did not draw a world" + return None + + +def gate(report, blockers): + """Why a built game release must not be published, or None: it is published as the latest at once, so its + smoke test must have passed and no release-blocker may be open.""" + problems = [problem for problem in [smoke_problem(report)] if problem] + problems += [f"release-blocker #{number} is open" for number in blockers] + return "; ".join(problems) or None def last_release(releases, kind): @@ -238,13 +268,16 @@ def last_release(releases, kind): return max(ours, key=lambda release: tag_key(release["tag_name"]), default=None) -def decision(kind, prs, now, paused=False, force=False, new_line=None): +def decision(kind, prs, now, paused=False, force=False, new_line=None, blockers=()): """Whether to release now, and why. prs: the merged pull requests since the last release, each with the files it changed under "paths" (player-facing ones only) and when it merged ("merged_at"). new_line: the - release line ("0.2") when it has no release of this kind yet; its first goes out at once.""" + release line ("0.2") when it has no release of this kind yet; its first goes out at once. blockers: the open + release-blocker issues; they hold every release, forced ones too.""" counted = [pr for pr in prs if pr["paths"] and "skip-release" not in pr["labels"]] urgent = [pr for pr in counted if "release-now" in pr["labels"]] merged = [pr["merged_at"] for pr in counted if pr.get("merged_at")] + if blockers: + return False, "held by " + ", ".join(f"release-blocker #{number}" for number in blockers) if force: return True, "started by hand with force" if paused: @@ -323,9 +356,8 @@ def line_intro(kind, version, previous): f"`horizon-server update --version {version}`.") -def notes(kind, version, prs, issues, beta=False, previous=None): - """(title, body) of a release; a game beta's say it is one. previous: the release before it, for a line's - first release.""" +def notes(kind, version, prs, issues, previous=None): + """(title, body) of a release. previous: the release before it, for a line's first release.""" shown = [pr for pr in prs if pr["paths"] and "skip-release" not in pr["labels"]] new = [pr for pr in shown if "feature" in pr["labels"]] fixed = [pr for pr in shown if "feature" not in pr["labels"]] @@ -346,17 +378,15 @@ def notes(kind, version, prs, issues, beta=False, previous=None): contributors = sorted({pr["author"] for pr in shown if pr["author"] and pr["author"] != REPO.split("/")[0]}) if contributors: parts.append("Thanks to " + ", ".join(f"@{name}" for name in contributors) + ".") - if beta and kind == "game": - parts.append(FOOTER["beta"]) parts.append(FOOTER[kind]) parts.append(DISCLAIMER) return title, "\n\n".join(parts) + "\n" -def gather(kind, head, releases=None, betas=True): - """The last published release of this kind (stable only when betas is False) and the pull requests merged - since, with their player-facing paths.""" - releases = published_releases(betas) if releases is None else releases +def gather(kind, head, releases=None): + """The last published release of this kind and the pull requests merged since, with their player-facing + paths.""" + releases = published_releases() if releases is None else releases last = last_release(releases, kind) base = last["tag_name"] if last else run("git", "rev-list", "--max-parents=0", head).split()[0] exporter_paths = exporters() @@ -387,18 +417,29 @@ def write_outputs(values): def main(): parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - parser.add_argument("command", choices=["decide", "notes"]) + parser.add_argument("command", choices=["decide", "notes", "gate"]) parser.add_argument("--kind", choices=["game", "launcher"], required=True) parser.add_argument("--head", help="the commit to release (default: the newest commit on main whose checks passed)") parser.add_argument("--tag", help="notes: the release's tag") parser.add_argument("--force", action="store_true", help="release even without player-facing changes, before merges settle or while paused") parser.add_argument("--out", type=Path, help="notes: write title.txt and body.md here") parser.add_argument("--now", help="the time to decide at (ISO 8601; default now)") - parser.add_argument("--stable", action="store_true", - help="notes: for promoting a beta to stable, so since the last stable release, without the beta line") + parser.add_argument("--smoke", type=Path, help="gate: the release smoke test's report (smoke-test.json)") + parser.add_argument("--blockers", action="store_true", help="gate: also check that no release-blocker is open") args = parser.parse_args() now = dt.datetime.fromisoformat(args.now) if args.now else dt.datetime.now(dt.timezone.utc) + if args.command == "gate": + report = json.loads(args.smoke.read_text()) if args.smoke and args.smoke.exists() else None + problem = gate(report, open_blockers() if args.blockers else []) + line = f"Not publishing: {problem}" if problem else "Ready to publish: the smoke test passed" + ( + " and no release-blocker is open" if args.blockers else "") + print(json.dumps(report) if report else "", line, sep="\n") + if os.environ.get("GITHUB_STEP_SUMMARY"): + with open(os.environ["GITHUB_STEP_SUMMARY"], "a") as summary: + summary.write(f"### {line}\n") + return 1 if problem else 0 + head = args.head or green_main_head() if not head: result = {"release": False, "reason": "main's latest checks did not pass"} @@ -406,11 +447,11 @@ def main(): write_outputs({"release": "false", "reason": result["reason"]}) return 0 head = run("git", "rev-parse", head).strip() - last, prs = gather(args.kind, head, betas=not args.stable) + last, prs = gather(args.kind, head) if args.command == "notes": version = args.tag or "unreleased" previous = last["tag_name"] if last and last["tag_name"] != version else None - title, body = notes(args.kind, version, prs, known_issues(), beta=not args.stable, previous=previous) + title, body = notes(args.kind, version, prs, known_issues(), previous=previous) if args.out: args.out.mkdir(parents=True, exist_ok=True) (args.out / "title.txt").write_text(title + "\n") @@ -422,7 +463,9 @@ def main(): line = release_line() prefix = GAME_PREFIX if args.kind == "game" else LAUNCHER_PREFIX new_line = f"{line[0]}.{line[1]}" if line and first_on_line(tags, prefix, line) else None - release, reason = decision(args.kind, prs, now, os.environ.get("RELEASES_PAUSED") == "1", args.force, new_line) + blockers = open_blockers() if args.kind == "game" else [] + release, reason = decision(args.kind, prs, now, os.environ.get("RELEASES_PAUSED") == "1", args.force, new_line, + blockers) minor = any("feature" in pr["labels"] for pr in prs if pr["paths"]) tag = next_game_tag(tags, now.date(), line) if args.kind == "game" else next_launcher_tag(tags, minor, line) result = { diff --git a/website/build.mjs b/website/build.mjs index a47a40a79..781e838bb 100644 --- a/website/build.mjs +++ b/website/build.mjs @@ -55,7 +55,8 @@ try { if (batch.length < 100) break; } if (!res.ok) console.warn(`releases: ${res.status} from GitHub; the pages will load them themselves`); - // A day of betas can push the stable release out of the newest 100: it is GitHub's "latest" (betas never are). + // Pre-releases of the old Alpha channel could push the newest release out of the newest 100: it is GitHub's + // "latest" (pre-releases never are). if (res.ok && !releases.some((r) => isGame(r.tag_name) && !r.prerelease)) { const latest = await fetch(`https://api.github.com/repos/${REPO}/releases/latest`, { headers: githubHeaders, signal: AbortSignal.timeout(15000) }); if (latest.ok) releases.push(await latest.json()); @@ -121,8 +122,8 @@ const parityHeadline = matching === body.length ? "Every subsystem matches vanil // --- The releases ---------------------------------------------------------------------- -// Newest first by tag: every 0.2 tag is newer than the dated ones (src/versions.js). Alpha builds are GitHub -// pre-releases, Stable the others (docs/release-flow.md, "Channels"). +// Newest first by tag: every 0.2 tag is newer than the dated ones (src/versions.js). One channel since 2026-10-23 +// (docs/release-flow.md, "One channel"); the old Alpha channel's pre-releases stay listed. const byTag = (a, b) => newestFirst(a.tag_name, b.tag_name); const ours = releases.filter((r) => isGame(r.tag_name) || isLauncher(r.tag_name)).sort(byTag); const game = ours.filter((r) => isGame(r.tag_name)); diff --git a/website/docs/faq.md b/website/docs/faq.md index 6793c7e8f..666766c6b 100644 --- a/website/docs/faq.md +++ b/website/docs/faq.md @@ -60,7 +60,7 @@ Only if you say yes, and each kind has its own switch. Everything is off by defa ## How often does it update? -Often. Every change players can see is released automatically after it is merged, so new versions can come out several times a day. On the **Alpha** channel the launcher installs each one as soon as it is built; on **Stable**, the default, it installs a tested build about once a day. See [Install](/docs/install#updating). +Often. Every change players can see is released automatically after it is merged, so new versions can come out several times a day. Each one is tested before it goes out (the game has to start and draw a world), and the launcher installs it as soon as it is out. There is one version for everyone. See [Install](/docs/install#updating). ## What do the version numbers mean? diff --git a/website/docs/index.md b/website/docs/index.md index e146e520c..2b16c4db9 100644 --- a/website/docs/index.md +++ b/website/docs/index.md @@ -7,7 +7,7 @@ Horizon is Minecraft: Java Edition 26.3 rewritten in Rust. You install it with a - **A new game program, not a mod.** Horizon is written from scratch in Rust. It reads the same worlds, plays by the same rules and generates the same terrain as the Java game. - **Checked against vanilla.** {{HARNESSES}} automated tests ("harnesses") feed the same inputs to Horizon and to the real game, then compare the results. Today every subsystem matches in every harness that compares it. That is {{PERCENT}} of what the harnesses compare, which is not proof that nothing else differs. The [status table](/#parity) lists what is covered. - **Light and fast.** It starts quickly, uses little memory and draws efficiently. See [Performance](/docs/performance) for what is measured and what is not. -- **A few things vanilla doesn't have.** Its own settings, added to vanilla's menus the way mods add theirs, graphics presets, distant terrain, controller support, optional extras such as zoom, a minimap and dynamic lights (dynamic lights are in Alpha builds for now), an invite code to play your world with friends, and a server you can run without Java. +- **A few things vanilla doesn't have.** Its own settings, added to vanilla's menus the way mods add theirs, graphics presets, distant terrain, controller support, optional extras such as zoom, a minimap and dynamic lights, an invite code to play your world with friends, and a server you can run without Java. ## What Horizon is not diff --git a/website/docs/install.md b/website/docs/install.md index b6ecdff7d..c1a65f3ee 100644 --- a/website/docs/install.md +++ b/website/docs/install.md @@ -34,19 +34,14 @@ The game opens on vanilla's title screen. Your worlds, options and logs live in ## Updating -- **Horizon.** The launcher looks for a new release when it starts and every four hours while it is open. With **Install new versions automatically** on (the default), it installs one and moves you to it if you were on the newest. New releases come out many times a day, and old versions stay installed until you remove them on the **Versions** page. +- **Horizon.** The launcher looks for a new release when it starts and every 30 minutes while it is open. With **Install new versions automatically** on (the default), it installs one and moves you to it if you were on the newest. New releases come out many times a day, and old versions stay installed until you remove them on the **Versions** page. - **The launcher.** It updates itself from its own releases, then shows **Restart** in its footer. A launcher from before 0.2 (0.16 or older) updates twice in a row: first to 0.17, then to 0.2. Then it installs Horizon 0.2 like any update. -## Stable and Alpha +## One version for everyone -> **Next launcher release.** The Updates switch below is merged but not in a launcher release yet. Launcher 0.17 has a **Beta builds** switch in Settings instead, which installs every new build at once, as Alpha does. +There is one channel: every release is the version everyone gets. Before a release goes out, the game has to start and draw a world on our test machine, and nothing goes out while a serious problem is open. New releases come out many times a day, and you can install any older version by hand on the **Versions** page. -In **Settings**, **Updates** picks which builds install by themselves: - -- **Stable** (the default): a tested build about once a day. -- **Alpha**: every change as soon as it is built, several times a day. It can break. A launcher left open looks for new builds every 30 minutes, instead of every four hours. - -Every new release is an Alpha build first. Once a day (20:00 UTC, 21:00 in Paris in winter), the newest one that has been out for six hours, passed its smoke test and has no known blocker becomes Stable. Alpha builds come out many times a day, and Horizon as a whole is still in beta; Stable is the tested ones. The **Versions** page shows each version's channel, and you can install any of them by hand. +Launchers from before this change still show an **Updates** choice in Settings. Either option now gets every new release, and the choice goes away once the launcher has updated itself. ## The Versions page diff --git a/website/docs/multiplayer.md b/website/docs/multiplayer.md index b45ece0a9..e344c8fbc 100644 --- a/website/docs/multiplayer.md +++ b/website/docs/multiplayer.md @@ -20,7 +20,7 @@ There is no Horizon server in the middle. The code holds the host's addresses an Guests join with the name their game uses. There is no account check, so only share the code with people you trust. -In Alpha builds, guests can also use the host's workstations: the crafter, loom, stonecutter, grindstone, anvil, smithing table, enchanting table, beacon, lectern and cartography table. Stable gets this once it has passed. +Guests can also use the host's workstations: the crafter, loom, stonecutter, grindstone, anvil, smithing table, enchanting table, beacon, lectern and cartography table. ## Open to LAN diff --git a/website/docs/settings.md b/website/docs/settings.md index e1860cd4a..b3566ff2f 100644 --- a/website/docs/settings.md +++ b/website/docs/settings.md @@ -46,7 +46,7 @@ Shader packs are **experimental**. Put a pack's folder in the `shaderpacks` fold Horizon can run the full-screen effects of Java shader packs (OptiFine and Iris packs: colour grading, bloom, sky and fog effects). It does not run their geometry and shadow passes yet, so packs do not look as they do in Iris. Horizon also has its own shader pack format, in WGSL, with a `pack.toml` manifest, options and hot reload. It has full-screen passes too; stages that draw the world's terrain and shadows are planned. The details are in the [shader pack notes](https://github.com/ludovic111/horizon/blob/main/docs/shader-packs.md). -In Alpha builds, the **Shader Packs** page shows the full path of the `shaderpacks` folder with an **Open Folder** button, then one switch per pack. Turning a pack on picks it, and turning it off gives the vanilla picture. Packs tested so far: BSL, Complementary Reimagined, Steadfast and Sildur's Vibrant Extreme draw their full-screen passes; Bliss, Bloop, Noble, Photon and Rethinking Voxels do not load yet. To find packs, the launcher's **Mods** page installs shader packs from Modrinth (see [Mods and data packs](/docs/mods#finding-resource-packs-shader-packs-and-modpacks)). +The **Shader Packs** page shows the full path of the `shaderpacks` folder with an **Open Folder** button, then one switch per pack. Turning a pack on picks it, and turning it off gives the vanilla picture. Packs tested so far: BSL, Complementary Reimagined, Steadfast and Sildur's Vibrant Extreme draw their full-screen passes; Bliss, Bloop, Noble, Photon and Rethinking Voxels do not load yet. To find packs, the launcher's **Mods** page installs shader packs from Modrinth (see [Mods and data packs](/docs/mods#finding-resource-packs-shader-packs-and-modpacks)). ## Resource packs @@ -67,7 +67,7 @@ Horizon plays with PlayStation (DualShock 4 and DualSense), Xbox (360, One and S ## Extras -**Options, Horizon Settings, Extras** holds small, optional conveniences. Every one is off by default, so a fresh install behaves like vanilla: fullbright, zoom, a minimap, an FPS counter, a keystroke display, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. In Alpha builds there is one more, **dynamic lights**: a torch, lantern or other light source that you hold, that lies dropped as an item, or a burning mob, lights the blocks around it. It is client-side only, so other players do not see it. +**Options, Horizon Settings, Extras** holds small, optional conveniences. Every one is off by default, so a fresh install behaves like vanilla: fullbright, zoom, a minimap, an FPS counter, a keystroke display, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. One more is **dynamic lights**: a torch, lantern or other light source that you hold, that lies dropped as an item, or a burning mob, lights the blocks around it. It is client-side only, so other players do not see it. ## Where your settings are stored diff --git a/website/src/index.html b/website/src/index.html index 9c7c3ca3e..29d32d5ba 100644 --- a/website/src/index.html +++ b/website/src/index.html @@ -202,7 +202,7 @@ <div class="section-head"> <p class="kicker reveal"><span>05</span>Releases</p> <h2 id="recent-title" class="title reveal">Recently added</h2> - <p class="lede reveal">Alpha builds come out many times a day, as changes land; about once a day the tested ones become Stable, the launcher's default. The newest, and what they added:</p> + <p class="lede reveal">New versions come out many times a day, as changes land, and the launcher installs each one once it has passed its test. The newest, and what they added:</p> </div> <div class="recent reveal" id="recent-releases" aria-live="polite"> {{RECENT}} diff --git a/website/src/main.js b/website/src/main.js index 4298cf1fd..7a0714d1b 100644 --- a/website/src/main.js +++ b/website/src/main.js @@ -17,9 +17,9 @@ const reducedMotion = matchMedia("(prefers-reduced-motion: reduce)").matches; const isLauncher = (r) => isLauncherTag(r.tag_name) && !r.prerelease; -// The newest 100 releases (GitHub's most per page). Game betas come out several times a day, so the stable game -// release and the newest launcher release can both be older than all of them. The stable game release is then -// GitHub's "latest" (betas and launcher releases are never marked latest); the launcher release is looked up by its +// The newest 100 releases (GitHub's most per page). The newest game release that is not a pre-release (the old +// Alpha channel's, docs/release-flow.md) and the newest launcher release can be older than all of them. The game +// release is then GitHub's "latest" (pre-releases and launcher releases never are); the launcher release is looked up by its // tag (the newest launcher@ tag with a published release, or launcher-v before 0.2: docs/versioning.md). async function loadReleases() { const list = (await get(`https://api.github.com/repos/${REPO}/releases?per_page=100`)).filter((r) => !r.draft).map(slim); @@ -83,7 +83,7 @@ async function setUpDownload() { // --- Recently added and the links from main --------------------------------- -// "Recently added": the newest game releases, Alpha and Stable. +// "Recently added": the newest game releases. async function setUpRecent() { const html = recentHtml((await releases).filter((r) => isGame(r.tag_name))); if (html) document.getElementById("recent-releases").innerHTML = html; diff --git a/website/src/releases.html b/website/src/releases.html index f0e4b2de4..989164653 100644 --- a/website/src/releases.html +++ b/website/src/releases.html @@ -4,7 +4,7 @@ <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover"> <title>Releases · Horizon - + @@ -30,11 +30,10 @@

ReleasesEvery version, newest first

What's new in Horizon

-

Each release lists what it adds and fixes, then its full notes and its downloads. Alpha builds come out many times a day as changes land and can break; about once a day the tested ones become Stable, what the launcher installs unless you pick Alpha in its Settings. The launcher has its own releases.

+

Each release lists what it adds and fixes, then its full notes and its downloads. New versions come out many times a day as changes land, and the launcher installs each one once it has passed its test. The launcher has its own releases.

- - +

{{RELEASE_COUNT}}

diff --git a/website/src/releases.js b/website/src/releases.js index 2e6a2e524..de59c8fef 100644 --- a/website/src/releases.js +++ b/website/src/releases.js @@ -1,13 +1,13 @@ // The release notes on the site: the home page's "Recently added" block and the Releases page (every release, // newest first). Shared by build.mjs (baked into the pages) and the pages' scripts (refreshed from GitHub). // Tags: the game's vX.Y.Z and the launcher's launcher@X.Y.Z from 0.2, vYYYY.MM.DD[.N] and launcher-vX.Y.Z before -// (src/versions.js). Alpha is a game pre-release, Stable a game release (docs/release-flow.md, "Channels"). +// (src/versions.js). One channel (docs/release-flow.md, "One channel"): a release is the game's or the launcher's. import { markdown, inline, escape } from "./markdown.js"; import { isLauncher, launcherVersion, newestFirst } from "./versions.js"; const REPO = "ludovic111/horizon"; -export const channel = (r) => (isLauncher(r.tag_name) ? "Launcher" : r.prerelease ? "Alpha" : "Stable"); +export const channel = (r) => (isLauncher(r.tag_name) ? "Launcher" : "Game"); const anchor = (r) => `release-${r.tag_name.replace(/[^\w.-]/g, "-")}`; // "Horizon 0.2.3: Cave culling, weather" (before 0.2, "Horizon 2026.10.13: …") reads as the version and its line. @@ -90,7 +90,7 @@ export function recentHtml(list, { rows = 5, picks = 3 } = {}) { }) .join(""); // What landed last: the "New" items of the newest releases with the highest pull request numbers (a release's - // notes list everything since the last Stable, oldest first). + // notes list everything since the release before it, oldest first). const pr = (item) => Math.max(0, ...[...item.matchAll(/#(\d+)/g)].map((m) => Number(m[1]))); const seen = new Set(); const picked = game diff --git a/website/src/style.css b/website/src/style.css index 8517a2f43..323cd6e83 100644 --- a/website/src/style.css +++ b/website/src/style.css @@ -630,14 +630,13 @@ code { border-radius: 0; background: var(--well); box-shadow: 0 0 0 1px var(--ou .page-main > .container > .lede { font-size: var(--text-body); } .page-main .disclaimer { margin-top: 48px; } -/* Channel and source badges: small square tags. */ +/* Release and source badges: small square tags. */ .badge { display: inline-flex; align-items: center; height: 22px; padding: 0 8px; margin-right: 10px; vertical-align: 2px; font: 500 12px / 1 var(--pixel); letter-spacing: 0.02em; text-transform: uppercase; white-space: nowrap; border: var(--block-outline) solid var(--outline); background: var(--well); color: var(--ink-soft); } -.badge-stable { background: color-mix(in srgb, var(--success) 22%, var(--panel)); color: var(--ink); } -.badge-alpha { background: color-mix(in srgb, var(--warn) 24%, var(--panel)); color: var(--ink); } +.badge-game { background: color-mix(in srgb, var(--success) 22%, var(--panel)); color: var(--ink); } .badge-launcher { background: color-mix(in srgb, var(--accent) 20%, var(--panel)); color: var(--ink); } .badge-us { background: color-mix(in srgb, var(--accent) 20%, var(--panel)); color: var(--ink); } .badge-players { background: color-mix(in srgb, var(--success) 22%, var(--panel)); color: var(--ink); } From 630f5210722059eb1d50d64f79e12fc21bac4f47 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 11:53:00 +0200 Subject: [PATCH 48/62] Launcher: one update channel, and the menu entry is never taken over Every release is now published as the release (one channel, Ludovic's decision of 2026-10-23), so the launcher drops its Stable/Alpha choice: the Updates row in Settings, `horizon-launcher update-channel` and its MCP tool, the channel on the Versions page, in `versions` and in the footer. It updates to the newest game release that is not a pre-release (GitHub's latest) and looks every 30 minutes. The pre-releases of the old Alpha channel stay listed and installable by hand, never as an update. Old `update_channel` / `beta_builds` keys in settings.json are ignored. On Linux a release build that starts no longer rewrites the applications-menu entry to point at itself. It writes the entry only when there is none, or when the program it starts (TryExec, else Exec) no longer exists; turning the Settings switch on or `desktop-entry` still points it at this launcher, and HORIZON_LAUNCHER_DESKTOP_EXEC is still honored. A test build started with the real HOME took over a working entry and then left it broken when its target/ was deleted (2026-10-23). Co-Authored-By: Claude Opus 5.5 --- docs/agent-control.md | 3 +- docs/launcher-commands.md | 10 - launcher/README.md | 30 +-- launcher/src/backend.rs | 233 +++++------------- launcher/src/backend/release_loading_tests.rs | 4 - launcher/src/cli.rs | 26 +- launcher/src/cli_tools.rs | 1 - launcher/src/desktop.rs | 147 ++++++++++- launcher/src/main.rs | 63 +---- website/docs/agents.md | 2 +- 10 files changed, 230 insertions(+), 289 deletions(-) diff --git a/docs/agent-control.md b/docs/agent-control.md index 5383cc03c..9d5db2597 100644 --- a/docs/agent-control.md +++ b/docs/agent-control.md @@ -71,7 +71,6 @@ passes on without checking it). | Dedicated server here: start, console, log, stop | Servers | yes | yes | yes | yes | `server`; MCP `server`, `server_command`, `server_log`, `server_stop` | | Hosted servers: list, create, set up, run a command, forget | Servers | yes | no | yes | yes | `servers ...`; `servers_forget` needs `confirm` | | Accounts: list, sign in, sign out, select, offline | Settings | yes | part | yes | yes | names and UUIDs only; sign-in is a device code; `account_offline` was missing | -| Update channel (Alpha, Stable) | Settings | yes | yes | yes | yes | | | Game folder, server folder, install new versions, opening animation | Settings | no | no | yes | yes | `settings [KEY VALUE]` | | Extra game arguments | Settings | yes | no | yes | yes | `game-args` | | Applications menu entry (Linux) | Settings | yes | no | yes | yes | `desktop-entry` | @@ -148,7 +147,7 @@ The switch is in three places: Settings > AI in the launcher, Horizon Settings i | Companion (#1068) | uses the same switch (see horizon-parity companion-notes.md) | Every other launcher command stays usable: versions, install, remove, prepare, play, server, -notes, links, account, update-channel, settings, game-args, logs, update, desktop-entry, data, +notes, links, account, settings, game-args, logs, update, desktop-entry, data, modpack, mods, servers, no-ai and benchmark. None of them drives the game for an agent. The launcher itself, packagers, the docs and players' scripts need them, and `no-ai` has to stay to turn the switch off. diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md index 579659e68..9e09cd00b 100644 --- a/docs/launcher-commands.md +++ b/docs/launcher-commands.md @@ -130,16 +130,6 @@ Play offline, without an account. MCP: `account_offline`. -## `horizon-launcher update-channel` - -Show or set which Horizon releases install by themselves: stable (a tested build about once a day) or alpha (every release as soon as it is built; can break). - - horizon-launcher update-channel [CHANNEL] - -- `CHANNEL` (stable, alpha): Omit to show the current channel - -MCP: `update_channel`. - ## `horizon-launcher settings` Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off. diff --git a/launcher/README.md b/launcher/README.md index e12ed2439..16ef197c7 100644 --- a/launcher/README.md +++ b/launcher/README.md @@ -78,16 +78,13 @@ page `servers.json` (the list), `servers//` (the servers created there) an `server-runtime/` (the programs and game files they run). - **Settings**: install new Horizon versions automatically (on unless you turn it off; the - selected version only moves to the new one if you were on the newest), which ones (Updates, - below), the opening animation, the game's extra command-line arguments, and the launcher's own - version and update state. -- **Updates**: **Stable** (the default) installs a tested build about once a day, the betas that - `promote.yml` makes stable; **Alpha** installs every release as soon as it is built, several - times a day, and can break (docs/release-flow.md, "Channels"). While it is open, the launcher - looks for new releases every 4 hours on Stable and every 30 minutes on Alpha. Kept as `update_channel` in - `settings.json`; a `beta_builds: true` from launchers before 0.2 reads as Alpha (so does a `nightly` from the channel's first name). - `horizon-launcher update-channel [stable|alpha]` shows or sets it. The **Versions** page - shows each release's channel. The launcher's own updates don't depend on it. + selected version only moves to the new one if you were on the newest), the opening animation, + the game's extra command-line arguments, and the launcher's own version and update state. +- **Updates**: there is one channel. Every release is published as the release, GitHub's latest, + once its smoke test passed (docs/release-flow.md), and the launcher installs it. The game + pre-releases of the old Alpha channel (v0.2.1 on) stay on the Versions page to install + by hand, but are never installed as an update. The `update_channel` and `beta_builds` keys + older launchers wrote in `settings.json` are ignored and dropped on the next save. - **Game arguments**: extra arguments added to the game's command line (for example `--server-thread`), one line where quotes group a word with spaces. They are appended after the launcher's own arguments, kept as `game_args` in `settings.json`, and apply the next time the @@ -102,7 +99,7 @@ their content overflows. Drag the thumb or click the track to navigate without a ## Updates -The launcher looks for a newer Horizon release when it starts and every four hours while it +The launcher looks for a newer Horizon release when it starts and every 30 minutes while it is open, and shows a small "available, Install" line on Play. It also updates itself from GitHub releases tagged `launcher@X.Y.Z` (Horizon's own are `vX.Y.Z`; @@ -111,8 +108,14 @@ every 0.2 tag counts as newer than all of those (docs/versioning.md). It downloa own binary, and offers "Restart" in the footer. Development builds and `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` never replace themselves. +On Linux a release build that starts writes its applications-menu entry only when there is +none, or when the program the entry starts (its `TryExec`, else its `Exec`) no longer exists. +An entry pointing at another launcher that works is left alone, so a test or development build +never takes it over. Turning the Settings switch on, or `horizon-launcher desktop-entry`, +points the entry at this launcher whatever is there. + Linux packagers can set `HORIZON_LAUNCHER_DESKTOP_EXEC` to a wrapper's absolute path. -Menu entries created by Settings or `desktop-entry` then start that wrapper, which can +Menu entries the launcher writes then start that wrapper, which can set `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` to keep launcher updates with the package manager. Launcher releases are automatic (docs/release-flow.md in the repository): when main changes the @@ -134,7 +137,6 @@ The same binary is a command-line tool; without a subcommand it opens the window horizon-launcher server [--dir ] [--version ] [--accept-eula] horizon-launcher notes [] patch notes as plain text horizon-launcher links the Discord, sponsor and website links - horizon-launcher update-channel [stable|alpha] show or set which releases install by themselves horizon-launcher game-args [] show or set the extra arguments the game starts with horizon-launcher update [--check] Horizon and the launcher horizon-launcher logs [--lines N] [--crash] the end of the game's log, or its newest crash report @@ -168,7 +170,7 @@ The same binary is a command-line tool; without a subcommand it opens the window horizon-launcher data benchmark upload a benchmark report, printed first `--json` prints JSON where there is something to report (`versions`, `install`, `notes`, -`next`, `links`, `update-channel`, `game-args`, `update --check`, `logs`, `account`, `benchmark`, `data`, `modpack`). Errors go to stderr with exit code 1. `server` runs in the terminal, +`next`, `links`, `game-args`, `update --check`, `logs`, `account`, `benchmark`, `data`, `modpack`). Errors go to stderr with exit code 1. `server` runs in the terminal, so lines you type reach its console. `HORIZON_LAUNCHER_HOME` replaces the data folder (for scripts and tests). diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index f88171c4e..87034c43f 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -37,8 +37,9 @@ pub struct Release { pub body: String, pub date: String, pub asset: Option<(String, u64)>, - /// A beta: a game release not promoted to stable yet (a GitHub pre-release, docs/release-flow.md). - pub beta: bool, + /// A GitHub pre-release: the Alpha builds from before every release went out as the release + /// (v0.2.1 on, docs/release-flow.md). Listed and installed by hand, never as an update. + pub prerelease: bool, } #[cfg(all(target_os = "linux", target_arch = "x86_64"))] @@ -264,7 +265,7 @@ fn parse_releases( .take(10) .collect(), asset: found, - beta: r["prerelease"].as_bool().unwrap_or(false), + prerelease: r["prerelease"].as_bool().unwrap_or(false), }); } out.sort_by(|a, b| compare_versions(&b.tag, &a.tag)); @@ -348,75 +349,14 @@ pub fn latest(releases: &[Release]) -> Option<&Release> { releases.iter().find(|r| r.asset.is_some()) } -/// The releases a launcher installs by itself: stable ones, and betas too on the Alpha channel. -pub fn channel(releases: &[Release], channel: UpdateChannel) -> Vec { - releases - .iter() - .filter(|r| channel.takes(r)) - .cloned() - .collect() +/// The releases a launcher installs by itself: every one that is published as a release, so +/// GitHub's latest when it comes out. The pre-releases of the old Alpha channel are left out. +pub fn installable_updates(releases: &[Release]) -> Vec { + releases.iter().filter(|r| !r.prerelease).cloned().collect() } -/// Which game releases install by themselves (Settings, "Updates"; docs/release-flow.md, "Channels"). -#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)] -#[serde(rename_all = "lowercase")] -pub enum UpdateChannel { - /// A tested build about once a day: the betas promote.yml makes stable. - #[default] - Stable, - /// Every release as soon as it is built, pre-releases included. It was called "nightly" - /// while the channels were new: that name is still read. - #[serde(alias = "nightly")] - Alpha, -} - -impl UpdateChannel { - pub fn name(self) -> &'static str { - match self { - UpdateChannel::Stable => "stable", - UpdateChannel::Alpha => "alpha", - } - } - - /// Its name in Settings and on the Versions page. - pub fn label(self) -> &'static str { - match self { - UpdateChannel::Stable => "Stable", - UpdateChannel::Alpha => "Alpha", - } - } - - pub fn parse(name: &str) -> Option { - match name { - "stable" => Some(UpdateChannel::Stable), - "alpha" | "nightly" => Some(UpdateChannel::Alpha), - _ => None, - } - } - - /// Whether this channel installs `release`: betas only reach Alpha. - pub fn takes(self, release: &Release) -> bool { - self == UpdateChannel::Alpha || !release.beta - } - - /// How often a launcher left open looks for new releases: Alpha's come many times a day, - /// Stable's once. - pub fn check_every(self) -> std::time::Duration { - std::time::Duration::from_secs(match self { - UpdateChannel::Stable => 4 * 3600, - UpdateChannel::Alpha => 30 * 60, - }) - } - - /// The channel a release is on when it is listed: betas are Alpha's only. - pub fn of(release: &Release) -> Self { - if release.beta { - UpdateChannel::Alpha - } else { - UpdateChannel::Stable - } - } -} +/// How often a launcher left open looks for new releases: they come out several times a day. +pub const CHECK_EVERY: std::time::Duration = std::time::Duration::from_secs(30 * 60); /// The community, sponsor and website links, from `launcher/links.json` on main, so they can change /// without a launcher release. An empty address hides its button. @@ -1745,17 +1685,10 @@ fn launcher_update_from(releases: &[Release], own: &str) -> Option { pub fn releases_and_updates( on_releases: impl FnOnce(Result, String>), ) -> Result { - releases_and_updates_with( - Settings::load().update_channel, - release_list, - installed, - launcher_releases_in, - on_releases, - ) + releases_and_updates_with(release_list, installed, launcher_releases_in, on_releases) } fn releases_and_updates_with( - update_channel: UpdateChannel, load: impl FnOnce() -> Result, installed: impl FnOnce() -> Vec, launchers: impl FnOnce(&serde_json::Value) -> Vec, @@ -1769,7 +1702,7 @@ fn releases_and_updates_with( } }; let releases = parse_releases(&list, ASSET, is_game_tag); - let horizon = horizon_update(&channel(&releases, update_channel), &installed()); + let horizon = horizon_update(&installable_updates(&releases), &installed()); on_releases(Ok(releases)); Ok(Updates { horizon, @@ -1791,15 +1724,14 @@ pub fn select_after_update(selected: Option<&str>, installed_before: &[String]) } } -/// Installs `tag` (or with "latest" the newest release of the player's channel), then updates the selection as +/// Installs `tag` (or with "latest" the newest release, pre-releases left out), then updates the selection as /// `select_after_update` says when `as_update`, or always selects it otherwise. pub fn install_tag(tag: &str, as_update: bool, progress: impl Fn(f32)) -> Result { let releases = releases()?; let release = if tag == "latest" { - let update_channel = Settings::load().update_channel; releases .iter() - .find(|r| r.asset.is_some() && update_channel.takes(r)) + .find(|r| r.asset.is_some() && !r.prerelease) .ok_or("No release has a build for this platform yet.")? } else { releases @@ -2262,10 +2194,6 @@ pub struct Settings { /// default. Appended after the launcher's own arguments, so they can add to or override them. #[serde(default, skip_serializing_if = "String::is_empty")] pub game_args: String, - /// Which releases install by themselves: Stable by default. Launchers before 0.2 had a "Beta - /// builds" switch instead; [`Settings::parse`] reads its `beta_builds: true` as Alpha. - #[serde(default)] - pub update_channel: UpdateChannel, /// Dark, Light, or the system's: the launcher's look. Dark by default. #[serde(default)] pub appearance: Appearance, @@ -2284,20 +2212,7 @@ impl Settings { return Self::default(); }; if let Some(fields) = value.as_object_mut() { - // The switch from before 0.2: on meant every release at once, the Alpha channel. - if fields.remove("beta_builds") == Some(serde_json::Value::Bool(true)) { - fields - .entry("update_channel") - .or_insert_with(|| UpdateChannel::Alpha.name().into()); - } - // A channel this launcher doesn't know is Stable, not a reason to lose every setting. - if fields - .get("update_channel") - .is_some_and(|c| c.as_str().and_then(UpdateChannel::parse).is_none()) - { - fields.remove("update_channel"); - } - // The same for an appearance from a newer launcher. + // An appearance from a newer launcher is Dark, not a reason to lose every setting. if fields .get("appearance") .is_some_and(|a| serde_json::from_value::(a.clone()).is_err()) @@ -2517,41 +2432,35 @@ mod tests { assert_eq!(offered(&["v2026.10.15.1", "v2026.10.14"]), None); } - /// Betas (GitHub pre-releases) install by themselves only on the Alpha channel; Stable waits - /// for promote.yml's daily promotion (docs/release-flow.md, "Channels"). + /// Every release is published as the release, and launchers update to it. The pre-releases + /// of the old Alpha channel (v0.2.1 on) are only installed by hand: a launcher that + /// had one installed waits for the next release instead of going back. #[test] - fn updates_follow_the_stable_channel_unless_alpha_is_picked() { + fn updates_follow_every_release_and_leave_the_old_alpha_ones_out() { let asset = ASSET.unwrap_or("horizon-linux-x86_64.tar.gz"); let list = serde_json::json!([ - {"tag_name": "v2026.10.19.02", "prerelease": true, "assets": [{"name": asset, "browser_download_url": "b", "size": 1}]}, - {"tag_name": "v2026.10.19.01", "assets": [{"name": asset, "browser_download_url": "s", "size": 1}]}, + {"tag_name": "v0.2.13", "assets": [{"name": asset, "browser_download_url": "n", "size": 1}]}, + {"tag_name": "v0.2.12", "prerelease": true, "assets": [{"name": asset, "browser_download_url": "a", "size": 1}]}, + {"tag_name": "v0.2.0", "assets": [{"name": asset, "browser_download_url": "s", "size": 1}]}, ]); let releases = parse_releases(&list, Some(asset), is_game_tag); assert_eq!( - releases.iter().map(|r| r.beta).collect::>(), - [true, false] + releases.iter().map(|r| r.prerelease).collect::>(), + [false, true, false] ); - let offered = |alpha: bool, installed: &[&str]| { + let offered = |releases: &[Release], installed: &[&str]| { let installed: Vec = installed.iter().map(|t| t.to_string()).collect(); - let on = if alpha { - UpdateChannel::Alpha - } else { - UpdateChannel::Stable - }; - horizon_update(&channel(&releases, on), &installed).map(|r| r.tag) + horizon_update(&installable_updates(releases), &installed).map(|r| r.tag) }; - assert_eq!(offered(false, &[]), Some("v2026.10.19.01".into())); - assert_eq!( - offered(true, &["v2026.10.19.01"]), - Some("v2026.10.19.02".into()) - ); - assert_eq!(offered(false, &["v2026.10.19.01"]), None); - // A beta installed earlier is never "updated" to an older stable build. - assert_eq!(offered(false, &["v2026.10.19.02"]), None); - assert_eq!( - releases.iter().map(UpdateChannel::of).collect::>(), - [UpdateChannel::Alpha, UpdateChannel::Stable] - ); + assert_eq!(offered(&releases, &[]), Some("v0.2.13".into())); + assert_eq!(offered(&releases, &["v0.2.0"]), Some("v0.2.13".into())); + assert_eq!(offered(&releases, &["v0.2.12"]), Some("v0.2.13".into())); + assert_eq!(offered(&releases, &["v0.2.13"]), None); + // Before the first release of the single channel: the old Alpha one stays where it is. + let before = &releases[1..]; + assert_eq!(offered(before, &["v0.2.0"]), None); + assert_eq!(offered(before, &["v0.2.12", "v0.2.0"]), None); + assert_eq!(CHECK_EVERY.as_secs(), 30 * 60); } #[test] @@ -2573,48 +2482,20 @@ mod tests { } #[test] - fn the_update_channel_is_stored_by_name_and_the_old_beta_switch_reads_as_alpha() { - let read = |text: &str| Settings::parse(text).update_channel; - assert_eq!(read(""), UpdateChannel::Stable); - assert_eq!(read("{}"), UpdateChannel::Stable); - assert_eq!( - read(r#"{"update_channel": "stable"}"#), - UpdateChannel::Stable - ); - assert_eq!(read(r#"{"update_channel": "alpha"}"#), UpdateChannel::Alpha); - // The channel's first name, from launchers built while it was called Nightly. - assert_eq!( - read(r#"{"update_channel": "nightly"}"#), - UpdateChannel::Alpha - ); - assert_eq!(UpdateChannel::parse("nightly"), Some(UpdateChannel::Alpha)); - // Launchers before 0.2: "Beta builds" on is Alpha, off is Stable. - assert_eq!(read(r#"{"beta_builds": true}"#), UpdateChannel::Alpha); - assert_eq!(read(r#"{"beta_builds": false}"#), UpdateChannel::Stable); - // Once a channel is picked, it wins over a switch left behind. - let both = r#"{"beta_builds": true, "update_channel": "stable"}"#; - assert_eq!(read(both), UpdateChannel::Stable); - // An unknown channel is Stable, and the rest of the settings survive it. - let odd = - Settings::parse(r#"{"update_channel": "beta", "game_args": "--x", "beta_builds": 1}"#); - assert_eq!(odd.update_channel, UpdateChannel::Stable); - assert_eq!(odd.game_args, "--x"); - // Saved as a name, without the old switch. - let mut settings = Settings::parse(r#"{"selected": "v0.2.0", "beta_builds": true}"#); - let saved = serde_json::to_value(&settings).unwrap(); - assert_eq!(saved["update_channel"], "alpha"); - assert!(saved.get("beta_builds").is_none()); - assert_eq!(saved["selected"], "v0.2.0"); - settings.update_channel = UpdateChannel::Stable; - let text = serde_json::to_string(&settings).unwrap(); - assert_eq!(read(&text), UpdateChannel::Stable); - for c in [UpdateChannel::Stable, UpdateChannel::Alpha] { - assert_eq!(UpdateChannel::parse(c.name()), Some(c)); + fn the_old_update_channel_settings_are_dropped_and_the_rest_kept() { + for old in [ + r#"{"update_channel": "alpha", "game_args": "--x", "selected": "v0.2.0"}"#, + r#"{"update_channel": "stable", "game_args": "--x", "selected": "v0.2.0"}"#, + r#"{"beta_builds": true, "game_args": "--x", "selected": "v0.2.0"}"#, + r#"{"beta_builds": false, "update_channel": "nightly", "game_args": "--x", "selected": "v0.2.0"}"#, + ] { + let settings = Settings::parse(old); + assert_eq!(settings.game_args, "--x", "{old}"); + assert_eq!(settings.selected.as_deref(), Some("v0.2.0"), "{old}"); + let saved = serde_json::to_value(&settings).unwrap(); + assert!(saved.get("update_channel").is_none(), "{old}"); + assert!(saved.get("beta_builds").is_none(), "{old}"); } - // An open launcher looks again every 4 hours on Stable, every 30 minutes on Alpha. - let minutes = |c: UpdateChannel| c.check_every().as_secs() / 60; - assert_eq!(minutes(UpdateChannel::Stable), 240); - assert_eq!(minutes(UpdateChannel::Alpha), 30); } #[test] @@ -2635,7 +2516,7 @@ mod tests { body: String::new(), date: String::new(), asset: Some(("u".into(), 1)), - beta: false, + prerelease: false, }; assert!(launcher_update(&[r(own_tag())]).is_none()); assert_eq!(launcher_version(&own_tag()), Some(VERSION)); @@ -2675,7 +2556,7 @@ mod tests { body: String::new(), date: String::new(), asset: Some(("u".into(), 1)), - beta: false, + prerelease: false, }; let mut list = vec![ r("launcher-v0.16.0"), @@ -2744,10 +2625,14 @@ mod tests { ]); let releases = parse_releases(&list, Some(asset), is_game_tag); let installed = ["v2026.10.19.15".to_string(), "v2026.10.12".to_string()]; - let offered = |on| horizon_update(&channel(&releases, on), &installed).map(|r| r.tag); - // A beta 0.2.0 reaches launchers on Alpha; Stable ones wait for its promotion. - assert_eq!(offered(UpdateChannel::Alpha), Some("v0.2.0".into())); - assert_eq!(offered(UpdateChannel::Stable), None); + // A pre-release 0.2.0 is not an update; once published as the release, it is one. + let offered = |releases: &[Release]| { + horizon_update(&installable_updates(releases), &installed).map(|r| r.tag) + }; + assert_eq!(offered(&releases), None); + let mut released = releases.clone(); + released[0].prerelease = false; + assert_eq!(offered(&released), Some("v0.2.0".into())); let mut sorted = vec![ "v2026.10.19.15".to_string(), "v0.2.1".into(), @@ -2837,7 +2722,7 @@ mod tests { body: String::new(), date: String::new(), asset: Some(("u".into(), 1)), - beta: false, + prerelease: false, }; let releases = [r("v2026.10.13"), r("v2026.10.12")]; assert_eq!( diff --git a/launcher/src/backend/release_loading_tests.rs b/launcher/src/backend/release_loading_tests.rs index 4aaa616a2..d7f839bde 100644 --- a/launcher/src/backend/release_loading_tests.rs +++ b/launcher/src/backend/release_loading_tests.rs @@ -45,7 +45,6 @@ fn baseline(load: impl Fn() -> Result) -> (Vec Result) -> (Vec, Updates) { let mut releases = None; let updates = releases_and_updates_with( - UpdateChannel::Stable, load, installed_fixture, |list| parse_releases(list, LAUNCHER_ASSET, is_launcher_tag), @@ -82,7 +81,6 @@ fn errors_reach_releases_and_updates_without_fallback() { ] { let mut published = None; let result = releases_and_updates_with( - UpdateChannel::Stable, || Err(error.into()), || panic!("no installed scan after failure"), |_| panic!("no fallback after failure"), @@ -97,7 +95,6 @@ fn errors_reach_releases_and_updates_without_fallback() { fn publish_games_before_older_launcher_fallback() { let events = RefCell::new(Vec::new()); let result = releases_and_updates_with( - UpdateChannel::Stable, || Ok(serde_json::json!([{"tag_name": "v2026.10.14", "assets": []}])), Vec::new, |list| { @@ -132,7 +129,6 @@ fn failed_launcher_fallback_keeps_game_result_and_checks_stay_fresh() { for day in [14, 15] { let mut published = None; let updates = releases_and_updates_with( - UpdateChannel::Stable, || { requests.fetch_add(1, Ordering::Relaxed); Ok(serde_json::json!([{"tag_name": format!("v2026.10.{day}")}])) diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs index 732aa872b..9d8e51d93 100644 --- a/launcher/src/cli.rs +++ b/launcher/src/cli.rs @@ -287,13 +287,6 @@ enum Cmd { #[command(subcommand)] action: Option, }, - /// Show or set which Horizon releases install by themselves: stable (a tested build about once - /// a day) or alpha (every release as soon as it is built; can break) - UpdateChannel { - /// Omit to show the current channel - #[arg(value_parser = ["stable", "alpha"])] - channel: Option, - }, /// Show the launcher's settings, or set one (the Settings page): selected-version TAG, /// minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions /// on|off, opening-animation on|off @@ -435,7 +428,6 @@ fn settings_json(s: &backend::Settings) -> serde_json::Value { "server_dir": backend::server_dir(None), "install_new_versions": s.install_new_versions.unwrap_or(true), "opening_animation": !s.skip_opening, - "update_channel": s.update_channel.name(), "game_args": s.game_args, "desktop_entry": s.desktop_entry.unwrap_or(true), "no_ai": backend::no_ai(), @@ -504,7 +496,7 @@ fn attached(mut cmd: Command) -> Result<(), String> { fn release_json(r: &Release) -> serde_json::Value { serde_json::json!({ - "tag": r.tag, "name": r.name, "date": r.date, "channel": backend::UpdateChannel::of(r).name(), + "tag": r.tag, "name": r.name, "date": r.date, "prerelease": r.prerelease, "available_here": r.asset.is_some(), "installed": backend::installed().contains(&r.tag), }) } @@ -555,8 +547,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> { (false, true) => "", (false, false) => "no build for this platform", }; - let channel = backend::UpdateChannel::of(r).name(); - println!("{:<15} {} {:<7} {}", r.tag, r.date, channel, state); + println!("{:<15} {} {}", r.tag, r.date, state); } } Cmd::Install { tag } => { @@ -733,19 +724,6 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> { } } } - Cmd::UpdateChannel { channel } => { - let mut settings = backend::Settings::load(); - if let Some(channel) = channel.as_deref().and_then(backend::UpdateChannel::parse) { - settings.update_channel = channel; - settings.save(); - } - let channel = settings.update_channel.name(); - if as_json { - json(serde_json::json!({ "update_channel": channel })); - } else { - println!("Update channel: {channel}"); - } - } Cmd::GameArgs { args } => { let mut settings = backend::Settings::load(); if let Some(line) = args { diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs index 307f17dba..7653311ac 100644 --- a/launcher/src/cli_tools.rs +++ b/launcher/src/cli_tools.rs @@ -366,7 +366,6 @@ mod tests { "prepare", "notes", "update", - "update_channel", "game_args", "settings", "logs", diff --git a/launcher/src/desktop.rs b/launcher/src/desktop.rs index 1c9fe931e..281850cb6 100644 --- a/launcher/src/desktop.rs +++ b/launcher/src/desktop.rs @@ -2,8 +2,12 @@ //! `applications/horizon-launcher.desktop` (pointing at wherever the binary is now) and Horizon's //! icon into the `hicolor` theme, under `$XDG_DATA_HOME` (`~/.local/share` by default), so no root //! is needed; `horizon.desktop` (hidden from menus) gives the game's window its icon on Wayland. -//! A release build does this when it starts, and again whenever the binary has moved; the -//! Settings switch and `horizon-launcher desktop-entry --remove` take it all away again. +//! A release build writes it when it starts only if there is no entry yet or the one there starts +//! a program that is gone ([`repair`]), so a development or test build never takes over a working +//! entry. Turning the Settings switch on (or `horizon-launcher desktop-entry`) points it at this +//! binary whatever is there ([`install`]); the switch off and `desktop-entry --remove` take it all +//! away again. +use std::ffi::OsStr; use std::fs; use std::io; use std::path::{Path, PathBuf}; @@ -153,15 +157,85 @@ pub fn remove_in(data: &Path) -> io::Result<()> { Ok(()) } -/// Registers the launcher, using a distributor's wrapper when one is configured. -/// Both GUI registration (including the settings switch) and the CLI use this path. +/// The program an entry starts: its `TryExec`, else the first word of its `Exec` (unquoted as +/// [`quote`] writes it). None when the entry names neither. +fn entry_target(entry: &str) -> Option { + let mut in_main = false; + let (mut exec, mut try_exec) = (None, None); + for line in entry.lines().map(str::trim) { + if line.starts_with('[') { + in_main = line == "[Desktop Entry]"; + } else if let Some((key, value)) = line.split_once('=').filter(|_| in_main) { + match key.trim() { + "TryExec" if try_exec.is_none() => try_exec = Some(value.trim()), + "Exec" if exec.is_none() => exec = Some(value.trim()), + _ => {} + } + } + } + if let Some(program) = try_exec.filter(|p| !p.is_empty()) { + return Some(program.to_string()); + } + let exec = exec?; + let program = match exec.strip_prefix('"') { + Some(rest) => { + let (mut out, mut chars) = (String::new(), rest.chars()); + while let Some(c) = chars.next() { + match c { + '"' => break, + '\\' => out.extend(chars.next()), + c => out.push(c), + } + } + out + } + None => exec.split_whitespace().next()?.to_string(), + }; + (!program.is_empty()).then_some(program) +} + +/// Whether an entry's program is there: a path that exists, or a bare name found on `path` +/// (`$PATH`), as menus look `TryExec` up. +fn target_exists(program: &str, path: Option<&OsStr>) -> bool { + if program.contains('/') { + return Path::new(program).exists(); + } + path.is_some_and(|dirs| std::env::split_paths(dirs).any(|dir| dir.join(program).is_file())) +} + +/// Whether the launcher may write its entry by itself: there is none under `data`, or the one +/// there starts a program that no longer exists. An entry pointing at another launcher that +/// still works is left alone. +pub fn needs_repair_in(data: &Path, path: Option<&OsStr>) -> bool { + match fs::read_to_string(data.join("applications").join(LAUNCHER_ENTRY)) { + Ok(entry) => !entry_target(&entry).is_some_and(|p| target_exists(&p, path)), + Err(e) => e.kind() == io::ErrorKind::NotFound, + } +} + +/// What the entry starts: a distributor's wrapper (`HORIZON_LAUNCHER_DESKTOP_EXEC`) when one is +/// configured, else the binary at `exe`. +fn target(exe: &Path) -> PathBuf { + std::env::var_os("HORIZON_LAUNCHER_DESKTOP_EXEC") + .filter(|path| !path.is_empty()) + .map_or_else(|| exe.to_path_buf(), PathBuf::from) +} + +/// Registers the launcher whatever entry is there: for the player turning it on (the Settings +/// switch, `horizon-launcher desktop-entry`). pub fn install(exe: &Path) -> Result { let data = data_home().ok_or("No home folder to put the menu entry in.")?; - let wrapper = std::env::var_os("HORIZON_LAUNCHER_DESKTOP_EXEC") - .filter(|path| !path.is_empty()) - .map(PathBuf::from); - install_in(&data, wrapper.as_deref().unwrap_or(exe)) - .map_err(|e| format!("{}: {e}", data.display())) + install_in(&data, &target(exe)).map_err(|e| format!("{}: {e}", data.display())) +} + +/// At start: registers the launcher only when [`needs_repair_in`] says so. Returns whether it +/// wrote anything. +pub fn repair(exe: &Path) -> Result { + let data = data_home().ok_or("No home folder to put the menu entry in.")?; + if !needs_repair_in(&data, std::env::var_os("PATH").as_deref()) { + return Ok(false); + } + install_in(&data, &target(exe)).map_err(|e| format!("{}: {e}", data.display())) } pub fn remove() -> Result<(), String> { @@ -206,4 +280,59 @@ mod tests { remove_in(&data).unwrap(); let _ = fs::remove_dir_all(&data); } + + #[test] + fn the_target_is_try_exec_else_the_first_word_of_exec() { + let ours = launcher_entry(Path::new("/opt/a b/horizon \"x\"/horizon-launcher")); + assert_eq!( + entry_target(&ours).as_deref(), + Some("/opt/a b/horizon \"x\"/horizon-launcher") + ); + let without_try = ours.replace("TryExec=", "X-Old="); + assert_eq!( + entry_target(&without_try).as_deref(), + Some("/opt/a b/horizon \"x\"/horizon-launcher") + ); + let wrapper = "[Desktop Entry]\nExec=flatpak run dev.horizon.Launcher %U\n"; + assert_eq!(entry_target(wrapper).as_deref(), Some("flatpak")); + // Only the main group counts: an action's Exec is not the launcher. + let action = "[Desktop Action play]\nExec=/a\n[Desktop Entry]\nExec=/b --x\n"; + assert_eq!(entry_target(action).as_deref(), Some("/b")); + assert_eq!(entry_target("[Desktop Entry]\nName=Horizon\n"), None); + assert_eq!(entry_target("[Desktop Entry]\nExec=\nTryExec=\n"), None); + } + + /// A build that starts never takes over an entry that works (a test or development build + /// started on a player's machine, 2026-10-23); it writes one only when there is none or the + /// program it starts is gone. + #[test] + fn a_start_writes_the_entry_only_when_none_works() { + let root = + std::env::temp_dir().join(format!("horizon-desktop-repair-{}", std::process::id())); + let _ = fs::remove_dir_all(&root); + let (data, bin) = (root.join("data"), root.join("bin")); + fs::create_dir_all(&bin).unwrap(); + let installed = bin.join("horizon-launcher"); + fs::write(&installed, b"").unwrap(); + let entry = data.join("applications").join(LAUNCHER_ENTRY); + let path = Some(bin.as_os_str()); + + // No entry: write one. + assert!(needs_repair_in(&data, path)); + install_in(&data, &installed).unwrap(); + // Ours works: a build elsewhere leaves it alone. + assert!(!needs_repair_in(&data, path)); + // So does one another launcher wrote, found on PATH or by its path. + fs::write(&entry, "[Desktop Entry]\nExec=horizon-launcher %U\n").unwrap(); + assert!(!needs_repair_in(&data, path)); + assert!(needs_repair_in(&data, None)); + // The program is gone (a deleted target/ folder, a moved binary): write it again. + install_in(&data, &installed).unwrap(); + fs::remove_file(&installed).unwrap(); + assert!(needs_repair_in(&data, path)); + // An entry that starts nothing is broken too. + fs::write(&entry, "[Desktop Entry]\nName=Horizon\n").unwrap(); + assert!(needs_repair_in(&data, path)); + let _ = fs::remove_dir_all(&root); + } } diff --git a/launcher/src/main.rs b/launcher/src/main.rs index 128bf1bcf..18e8295b1 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -238,15 +238,16 @@ impl Launcher { if settings.minecraft_dir.is_none() { settings.minecraft_dir = backend::default_minecraft_dir(); } - // Release builds on Linux keep their entry in the applications menu up to date (a moved - // binary changes it); `HORIZON_LAUNCHER_DESKTOP_ENTRY=1` does it in a development build. + // Release builds on Linux put their entry back in the applications menu when there is + // none or it starts a program that is gone (a moved or deleted binary), never over one + // that works; `HORIZON_LAUNCHER_DESKTOP_ENTRY=1` does it in a development build. if cfg!(target_os = "linux") && settings.desktop_entry() && (!cfg!(debug_assertions) || std::env::var_os("HORIZON_LAUNCHER_DESKTOP_ENTRY").is_some()) { std::thread::spawn(|| { - let _ = horizon_launcher::desktop::install(backend::exe_path()); + let _ = horizon_launcher::desktop::repair(backend::exe_path()); }); } let installed = backend::installed(); @@ -658,8 +659,10 @@ impl Launcher { changed = true; } } - let every = self.settings.update_channel.check_every(); - if self.checked.is_some_and(|at| at.elapsed() > every) { + if self + .checked + .is_some_and(|at| at.elapsed() > backend::CHECK_EVERY) + { self.check_updates(); } if changed { @@ -1698,14 +1701,10 @@ impl Launcher { )); } foot = foot.child( - caps(format!( - "Launcher {} · {}", - backend::VERSION, - self.settings.update_channel.label() - )) - .px(px(8.)) - .pt(px(6.)) - .text_color(t.muted), + caps(format!("Launcher {}", backend::VERSION)) + .px(px(8.)) + .pt(px(6.)) + .text_color(t.muted), ); div() .id("sidebar") @@ -2339,25 +2338,6 @@ impl Launcher { cx.notify(); }), ); - use backend::UpdateChannel::{Alpha, Stable}; - let this = cx.entity().downgrade(); - let update_channel = segments( - "update-channel", - &[(Stable, Stable.label()), (Alpha, Alpha.label())], - self.settings.update_channel, - &t, - move |picked, _, cx| { - let _ = this.update(cx, |this, cx| { - if this.settings.update_channel != picked { - this.settings.update_channel = picked; - this.settings.save(); - // What counts as new changed: check again (and install it if that is on). - this.check_updates(); - } - cx.notify(); - }); - }, - ); let opening = switch("opening", !self.settings.skip_opening, &t).on_click(cx.listener( |this, _: &ClickEvent, _, cx| { this.settings.skip_opening = !this.settings.skip_opening; @@ -2487,22 +2467,6 @@ impl Launcher { Some(toggle.into_any_element()), &t, )) - .child(index_row( - n + 2, - "Updates", - Some( - div() - .flex() - .flex_col() - .child("Stable: a tested build about once a day.") - .child( - "Alpha: every change as soon as it is built, several times a day; can break.", - ) - .into_any_element(), - ), - Some(update_channel.into_any_element()), - &t, - )) .child(group("Launcher", "monitor")) .child(index_row( n + 3, @@ -2955,8 +2919,7 @@ impl Launcher { let tag = release.tag.clone(); let installed = self.installed.contains(&tag); let selected = self.selected() == Some(&tag); - let channel = backend::UpdateChannel::of(&release).label(); - let mut meta = vec![channel.to_string(), release.date.clone()]; + let mut meta = vec![release.date.clone()]; if let Some((_, size)) = release.asset { meta.push(megabytes(size)); } diff --git a/website/docs/agents.md b/website/docs/agents.md index 32ba58362..02042be4d 100644 --- a/website/docs/agents.md +++ b/website/docs/agents.md @@ -9,7 +9,7 @@ Everything you can do with the mouse and keyboard, through commands instead of c - **In the launcher:** - install, remove and prepare versions; - start the game, alone or with a world, or a server; - - your settings, the update channel and the extra game arguments; + - your settings and the extra game arguments; - the mod browser (mods, resource packs, shader packs, modpacks), imported modpacks and hosted servers; - your accounts (names only), logs and crash reports, patch notes, the data collection settings and the benchmark. - **In the game:** From 9fcf91e4bce67dce335874e97fa8eb3fbc05dfec Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 11:09:56 +0200 Subject: [PATCH 49/62] Metal: occlusion culling of solid sections, the depth test in the shader GPU occlusion culling ran on Vulkan only: its test needs early fragment tests, which naga's Metal backend does not emit. On Metal the boxes are tested in a pass of their own: phase 1's depth is bound read-only as the attachment and as a texture, and the fragment shader compares its own depth with it (reversed Z, greater or equal), as the fixed-function test would. HORIZON_GPU_CULL=shader takes this path on Vulkan too, for checks. Frames drawn flat (the default on Apple GPUs at high render distances) still skip culling here. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx.rs | 64 +++++-- crates/horizon-client/src/gfx/cull.rs | 213 ++++++++++++++++++++---- crates/horizon-client/src/gfx/cull.wgsl | 28 +++- 3 files changed, 246 insertions(+), 59 deletions(-) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index e379ace7c..183f7823e 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -316,7 +316,8 @@ pub struct Renderer { flat: Option, /// `flat` draws this frame's sections (off: the per-section draws). flat_on: bool, - /// Occlusion culling of solid section draws, where multi-draw is native. + /// Occlusion culling of solid section draws, where the GPU's instance + /// counts reach a multi-draw's entries (Vulkan, Metal). cull: Option, cull_on: bool, sky: wgpu::RenderPipeline, @@ -1408,7 +1409,6 @@ impl Renderer { usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }); - let depth = Self::depth(&device, &config); let (atlas_pixels, atlas_width, atlas_height) = hud_atlas; let atlas = device.create_texture_with_data( &queue, @@ -2112,14 +2112,22 @@ impl Renderer { .features() .contains(wgpu::Features::INDIRECT_FIRST_INSTANCE); // HORIZON_GPU_CULL=0 turns occlusion culling off, `all` culls every - // frame however little it hides (A/B checks). + // frame however little it hides, `shader` tests in the shader as on + // Metal (A/B checks). let cull_env = std::env::var("HORIZON_GPU_CULL"); - let cull = (cull_env.as_deref() != Ok("0") && cull::Cull::supported(&adapter, &device)) - .then(|| { - let mut cull = cull::Cull::new(&device, config.format.remove_srgb_suffix()); + let cull = cull::Cull::supported(&adapter, &device) + .filter(|_| cull_env.as_deref() != Ok("0")) + .map(|depth_test| match cull_env.as_deref() { + Ok("shader") => cull::DepthTest::InShader, + _ => depth_test, + }) + .map(|depth_test| { + let mut cull = + cull::Cull::new(&device, config.format.remove_srgb_suffix(), depth_test); cull.always = cull_env.as_deref() == Ok("all"); cull }); + let depth = Self::depth(&device, &config, cull.as_ref()); let world_post = world_post::Post::new(&device, config.format.remove_srgb_suffix()); let uploads = upload::Uploads::new(&device); let section_uploads = upload::Uploads::with_chunk(&device, SECTION_UPLOAD_CHUNK); @@ -2327,7 +2335,13 @@ impl Renderer { self.surface = Some(surface); Ok(()) } - fn depth(device: &wgpu::Device, config: &wgpu::SurfaceConfiguration) -> wgpu::TextureView { + /// The world's depth, which occlusion culling's test may read. + fn depth( + device: &wgpu::Device, + config: &wgpu::SurfaceConfiguration, + cull: Option<&cull::Cull>, + ) -> wgpu::TextureView { + let read = cull.is_some_and(|c| c.depth_test() == cull::DepthTest::InShader); device .create_texture(&wgpu::TextureDescriptor { label: Some("Horizon depth"), @@ -2340,7 +2354,11 @@ impl Renderer { sample_count: 1, dimension: wgpu::TextureDimension::D2, format: wgpu::TextureFormat::Depth32Float, - usage: wgpu::TextureUsages::RENDER_ATTACHMENT, + usage: if read { + wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING + } else { + wgpu::TextureUsages::RENDER_ATTACHMENT + }, view_formats: &[], }) .create_view(&Default::default()) @@ -2391,7 +2409,7 @@ impl Renderer { } else { self.offscreen = Some(Self::offscreen_target(&self.device, &self.config)); } - self.depth = Self::depth(&self.device, &self.config); + self.depth = Self::depth(&self.device, &self.config, self.cull.as_ref()); } /// Whether sections are drawn as one index list per frame (`flat`). pub fn flat_draws(&self) -> bool { @@ -3096,16 +3114,18 @@ impl Renderer { .inverse() .transform_point3(Vec3::ZERO); // Occlusion culling leaves the sections its last result did not see - // to phase 2, after the others, with instance counts of 0. + // to phase 2, after the others, with instance counts of 0. Frames + // drawn flat are not culled (phase 2's counts reach only per-section + // draws): those with as many draws as the last frame drew flat. + let flat_likely = self.flat_on + && self + .flat + .as_ref() + .is_some_and(|f| self.section_draws >= f.min_draws); let mut cull = self .cull .as_mut() - .filter(|_| { - self.cull_on - && !frame.title - && self.multi_draw - && !(self.flat_on && self.flat.is_some()) - }) + .filter(|_| self.cull_on && !frame.title && self.multi_draw && !flat_likely) .and_then(|cull| cull.begin(&self.device).then_some(cull)); self.phase2_draws.clear(); self.phase2_pages.clear(); @@ -3493,7 +3513,10 @@ impl Renderer { ); let flat_frame = match &mut self.flat { Some(flat) - if self.flat_on && !self.draws.is_empty() && self.draws.len() >= flat.min_draws => + if self.flat_on + && !culling + && !self.draws.is_empty() + && self.draws.len() >= flat.min_draws => { let sections = &self.sections; let lods = &self.lods; @@ -3567,6 +3590,9 @@ impl Renderer { Some((color, depth)) => (color, depth), None => (&view_target, &self.depth), }; + if culling && let Some(cull) = &mut self.cull { + cull.bind_depth(&self.device, world_depth); + } let cull = self.cull.as_ref().filter(|_| culling && solid_draws > 0); { let attachments = [Some(wgpu::RenderPassColorAttachment { @@ -3659,12 +3685,14 @@ impl Renderer { pass.set_vertex_buffer(1, self.instances.slice(..)); match cull { Some(cull) => { - // Phase 1 and the boxes against its depth, then + // Phase 1 and the boxes against its depth (in + // its pass, or one of their own on Metal), then // what they found in sight, in a pass that loads // both targets (it reads the test's results). self.draw_sections(&mut pass, &self.indirect, 0, 0, phase1_draws); cull.test(&mut pass); drop(pass); + cull.test_pass(&mut encoder); let attachments = [Some(wgpu::RenderPassColorAttachment { view: world_view, resolve_target: None, diff --git a/crates/horizon-client/src/gfx/cull.rs b/crates/horizon-client/src/gfx/cull.rs index bcb738de3..77574e850 100644 --- a/crates/horizon-client/src/gfx/cull.rs +++ b/crates/horizon-client/src/gfx/cull.rs @@ -22,8 +22,16 @@ //! Every solid draw is an entry of one of the two lists, so the CPU records //! as many draws as without culling: drivers that unroll an indirect //! multi-draw on the CPU (Mesa's on Intel Gen9) pay per entry. Phase 2's -//! counts come from the GPU, which needs a native multi-draw and forced -//! early depth tests: Vulkan. Translucent draws are not culled. +//! counts come from the GPU, which reads them from the draws themselves: +//! Vulkan's native multi-draw, and Metal's, which wgpu replays as one +//! indirect draw per entry. Translucent draws are not culled. +//! +//! Metal cannot force the depth test before a fragment shader that writes +//! storage (naga writes no `[[early_fragment_tests]]`), so there the boxes +//! are drawn in a pass of their own between the phases, which reads phase +//! 1's depth as a texture and makes the same comparison in the shader: the +//! fragment's depth against the stored one, greater or equal passing. The +//! same fragments pass, so the same sections are seen. use std::num::NonZeroU64; use std::sync::{ Arc, @@ -74,10 +82,40 @@ struct Group { group: wgpu::BindGroup, } +/// Where the boxes' depth test runs. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum DepthTest { + /// Forced before the fragment shader, in phase 1's pass (Vulkan). + Early, + /// In the fragment shader, against phase 1's depth read as a texture, + /// in a pass of its own (Metal). + InShader, +} + +/// The Vulkan entry point: the depth test forced early, which naga cannot +/// write for Metal (so it is not in `cull.wgsl`, which every backend takes). +const EARLY_TEST: &str = " +@fragment +@early_depth_test(force) +fn fs_box_early(in: Box) -> @location(0) vec4 { + see(in.test); + return vec4(0.0); +} +"; + +/// The test's depth texture binding (`InShader`), for the view it was made with. +struct DepthGroup { + view: wgpu::TextureView, + group: wgpu::BindGroup, +} + pub struct Cull { pipeline: wgpu::RenderPipeline, layout: wgpu::BindGroupLayout, group: Option, + depth_test: DepthTest, + depth_layout: Option, + depth_group: Option, params: wgpu::Buffer, /// Phase 2's draws: the solid draws after phase 1's in the frame's list. pub phase2: wgpu::Buffer, @@ -134,20 +172,33 @@ impl Cull { pub fn features(adapter: &wgpu::Adapter) -> wgpu::Features { adapter.features() & wgpu::Features::SHADER_EARLY_DEPTH_TEST } - /// Whether the device draws an indirect multi-draw natively and runs - /// fragment shaders that write storage only past an early depth test. - pub fn supported(adapter: &wgpu::Adapter, device: &wgpu::Device) -> bool { - adapter.get_info().backend == wgpu::Backend::Vulkan - && device.features().contains( - wgpu::Features::SHADER_EARLY_DEPTH_TEST | wgpu::Features::INDIRECT_FIRST_INSTANCE, - ) + /// Where the device can run the test, if it can: Vulkan with early + /// depth tests, or Metal, both drawing an indirect multi-draw's entries + /// with the instance counts the GPU wrote, with fragment shaders that + /// write storage. + pub fn supported(adapter: &wgpu::Adapter, device: &wgpu::Device) -> Option { + let depth_test = match adapter.get_info().backend { + wgpu::Backend::Vulkan + if device + .features() + .contains(wgpu::Features::SHADER_EARLY_DEPTH_TEST) => + { + DepthTest::Early + } + wgpu::Backend::Metal => DepthTest::InShader, + _ => return None, + }; + (device + .features() + .contains(wgpu::Features::INDIRECT_FIRST_INSTANCE) && adapter.get_downlevel_capabilities().flags.contains( wgpu::DownlevelFlags::VERTEX_STORAGE | wgpu::DownlevelFlags::FRAGMENT_WRITABLE_STORAGE, - ) + )) + .then_some(depth_test) } /// `color` is the world pass's colour format. - pub fn new(device: &wgpu::Device, color: wgpu::TextureFormat) -> Self { + pub fn new(device: &wgpu::Device, color: wgpu::TextureFormat, depth_test: DepthTest) -> Self { let entry = |binding, visibility, ty| wgpu::BindGroupLayoutEntry { binding, visibility, @@ -180,13 +231,41 @@ impl Cull { }); let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("Section culling"), - source: wgpu::ShaderSource::Wgsl(include_str!("cull.wgsl").into()), + source: wgpu::ShaderSource::Wgsl(source(depth_test).into()), + }); + let depth_layout = (depth_test == DepthTest::InShader).then(|| { + device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + label: Some("Section culling depth"), + entries: &[entry( + 0, + fragment, + wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Depth, + view_dimension: wgpu::TextureViewDimension::D2, + multisampled: false, + }, + )], + }) }); let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("Section culling"), - bind_group_layouts: &[Some(&layout)], + bind_group_layouts: &[Some(&layout), depth_layout.as_ref()], ..Default::default() }); + // In the shader: no colour target, and phase 1's depth attached read + // only (a pass needs an attachment), its test left to the shader. + let (fragment_entry, targets, depth_compare) = match depth_test { + DepthTest::Early => ( + "fs_box_early", + &[Some(wgpu::ColorTargetState { + format: color, + blend: None, + write_mask: wgpu::ColorWrites::empty(), + })][..], + wgpu::CompareFunction::GreaterEqual, + ), + DepthTest::InShader => ("fs_box", &[][..], wgpu::CompareFunction::Always), + }; let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some("Section culling"), layout: Some(&pipeline_layout), @@ -204,20 +283,16 @@ impl Cull { depth_stencil: Some(wgpu::DepthStencilState { format: wgpu::TextureFormat::Depth32Float, depth_write_enabled: Some(false), - depth_compare: Some(wgpu::CompareFunction::GreaterEqual), + depth_compare: Some(depth_compare), stencil: Default::default(), bias: Default::default(), }), multisample: Default::default(), fragment: Some(wgpu::FragmentState { module: &module, - entry_point: Some("fs_box"), + entry_point: Some(fragment_entry), compilation_options: Default::default(), - targets: &[Some(wgpu::ColorTargetState { - format: color, - blend: None, - write_mask: wgpu::ColorWrites::empty(), - })], + targets, }), multiview_mask: None, cache: None, @@ -226,6 +301,9 @@ impl Cull { pipeline, layout, group: None, + depth_test, + depth_layout, + depth_group: None, params: buffer( device, "Section culling parameters", @@ -399,17 +477,69 @@ impl Cull { } } - /// In the world pass after phase 1: draw the tested boxes against its - /// depth. Leaves the pass's pipeline and group 0 changed. + pub fn depth_test(&self) -> DepthTest { + self.depth_test + } + + /// In the world pass after phase 1 (`Early`): draw the tested boxes + /// against its depth. Leaves the pass's pipeline and group 0 changed. pub fn test(&self, pass: &mut wgpu::RenderPass<'_>) { let Some(Group { group, .. }) = &self.group else { return; }; + if self.depth_test != DepthTest::Early || self.test_data.is_empty() { + return; + } + pass.set_pipeline(&self.pipeline); + pass.set_bind_group(0, group, &[]); + pass.draw(0..36, 0..self.test_data.len() as u32); + } + + /// Before the world pass (`InShader`): the binding of the depth the + /// world is drawn with this frame. + pub fn bind_depth(&mut self, device: &wgpu::Device, depth: &wgpu::TextureView) { + let Some(layout) = &self.depth_layout else { + return; + }; + if self.depth_group.as_ref().is_none_or(|g| g.view != *depth) { + self.depth_group = Some(DepthGroup { + view: depth.clone(), + group: device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("Section culling depth"), + layout, + entries: &[wgpu::BindGroupEntry { + binding: 0, + resource: wgpu::BindingResource::TextureView(depth), + }], + }), + }); + } + } + + /// Between the phases (`InShader`): draw the tested boxes in a pass of + /// their own that reads phase 1's depth, bound by `bind_depth`. + pub fn test_pass(&self, encoder: &mut wgpu::CommandEncoder) { + let (Some(Group { group, .. }), Some(DepthGroup { view, group: depth })) = + (&self.group, &self.depth_group) + else { + return; + }; if self.test_data.is_empty() { return; } + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some("Section culling"), + color_attachments: &[], + depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { + view, + depth_ops: None, + stencil_ops: None, + }), + ..Default::default() + }); pass.set_pipeline(&self.pipeline); pass.set_bind_group(0, group, &[]); + pass.set_bind_group(1, depth, &[]); pass.draw(0..36, 0..self.test_data.len() as u32); } @@ -498,16 +628,33 @@ impl Cull { } } -#[cfg(test)] -mod tests { - #[test] - fn shader_validates() { - let module = naga::front::wgsl::parse_str(include_str!("cull.wgsl")).unwrap(); - naga::valid::Validator::new( - naga::valid::ValidationFlags::all(), - naga::valid::Capabilities::all(), - ) - .validate(&module) - .unwrap(); +/// The test's shader for `depth_test`. +fn source(depth_test: DepthTest) -> String { + let common = include_str!("cull.wgsl"); + match depth_test { + DepthTest::Early => format!("{common}{EARLY_TEST}"), + DepthTest::InShader => common.to_owned(), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn shaders_validate() { + for (depth_test, capabilities) in [ + (DepthTest::Early, naga::valid::Capabilities::all()), + // What wgpu's Metal backend allows: no early depth test. + ( + DepthTest::InShader, + naga::valid::Capabilities::all() - naga::valid::Capabilities::EARLY_DEPTH_TEST, + ), + ] { + let module = naga::front::wgsl::parse_str(&source(depth_test)).unwrap(); + naga::valid::Validator::new(naga::valid::ValidationFlags::all(), capabilities) + .validate(&module) + .unwrap_or_else(|e| panic!("{depth_test:?}: {e:?}")); + } } } diff --git a/crates/horizon-client/src/gfx/cull.wgsl b/crates/horizon-client/src/gfx/cull.wgsl index faa495caf..b06d4ccc2 100644 --- a/crates/horizon-client/src/gfx/cull.wgsl +++ b/crates/horizon-client/src/gfx/cull.wgsl @@ -86,16 +86,28 @@ fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> Box return out; } -// Runs only for fragments that pass the depth test (forced early). -@fragment -@early_depth_test(force) -fn fs_box(in: Box) -> @location(0) vec4 { - if results[in.test] != params.stamp { - results[in.test] = params.stamp; - let test = tests[in.test]; +// The box is seen at this fragment: store the stamp, and give its phase 2 +// draws their instance. +fn see(t: u32) { + if results[t] != params.stamp { + results[t] = params.stamp; + let test = tests[t]; for (var k = 0u; k < test.z; k++) { phase2[(test.y + k) * 5u + 1u] = 1u; } } - return vec4(0.0); +} + +// Phase 1's depth, where the test runs in the shader (gfx/cull.rs). +@group(1) @binding(0) var depth: texture_depth_2d; + +// The world pass's reversed depth test, greater or equal passing, made here: +// where it cannot be forced before a shader that writes storage, a fragment +// that fails it would still write. Where it can, `fs_box_early` (cull.rs) +// runs only for the fragments that pass it. +@fragment +fn fs_box(in: Box) { + if in.position.z >= textureLoad(depth, vec2(in.position.xy), 0) { + see(in.test); + } } From 14be6ca3943944c6a80ff9f747375e6c363fe7b5 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 12:03:25 +0200 Subject: [PATCH 50/62] Metal: occlusion culling with flat draws too Flat draws (one index list per frame, the default on Apple GPUs at high render distances) turned occlusion culling off. Now phase 2's draws are flattened after the test, by a compute pass that copies only the sections the test saw, and each page run is drawn indirectly with the count it reached. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx.rs | 132 +++-- crates/horizon-client/src/gfx/flat.rs | 587 ++++++++++++++++----- crates/horizon-client/src/gfx/flatten.wgsl | 47 +- 3 files changed, 577 insertions(+), 189 deletions(-) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 183f7823e..91da4f616 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -83,6 +83,40 @@ mod world_post; const COMPLETE_COLUMN: u32 = (1 << (crate::chunk::HEIGHT / 16)) - 1; /// A section's instance: its camera-relative origin and, in `w`, the step of /// its fixed-point UVs (`terrain.wgsl`'s `terrain_uv`). +/// The world pass again after occlusion culling's test: it loads both +/// targets (phase 2 draws over phase 1, reading the test's results). +fn world_pass_after_culling<'e>( + encoder: &'e mut wgpu::CommandEncoder, + view: &wgpu::TextureView, + depth: &wgpu::TextureView, + pack: bool, +) -> wgpu::RenderPass<'e> { + encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some("Horizon world, after culling"), + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view, + resolve_target: None, + depth_slice: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Load, + store: wgpu::StoreOp::Store, + }, + })], + depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { + view: depth, + depth_ops: Some(wgpu::Operations { + load: wgpu::LoadOp::Load, + store: if pack { + wgpu::StoreOp::Store + } else { + wgpu::StoreOp::Discard + }, + }), + stencil_ops: None, + }), + ..Default::default() + }) +} fn section_instance(origin: [f32; 3]) -> [f32; 4] { [ origin[0], @@ -3114,18 +3148,11 @@ impl Renderer { .inverse() .transform_point3(Vec3::ZERO); // Occlusion culling leaves the sections its last result did not see - // to phase 2, after the others, with instance counts of 0. Frames - // drawn flat are not culled (phase 2's counts reach only per-section - // draws): those with as many draws as the last frame drew flat. - let flat_likely = self.flat_on - && self - .flat - .as_ref() - .is_some_and(|f| self.section_draws >= f.min_draws); + // to phase 2, after the others, with instance counts of 0. let mut cull = self .cull .as_mut() - .filter(|_| self.cull_on && !frame.title && self.multi_draw && !flat_likely) + .filter(|_| self.cull_on && !frame.title && self.multi_draw) .and_then(|cull| cull.begin(&self.device).then_some(cull)); self.phase2_draws.clear(); self.phase2_pages.clear(); @@ -3511,16 +3538,24 @@ impl Renderer { frame.hud, [self.config.width, self.config.height], ); + if culling && let Some(cull) = &mut self.cull { + cull.upload( + &self.device, + &mut self.uploads, + &mut encoder, + &self.draws[phase1_draws as usize..solid_draws as usize], + &self.instances, + &self.globals, + ); + } let flat_frame = match &mut self.flat { Some(flat) - if self.flat_on - && !culling - && !self.draws.is_empty() - && self.draws.len() >= flat.min_draws => + if self.flat_on && !self.draws.is_empty() && self.draws.len() >= flat.min_draws => { let sections = &self.sections; let lods = &self.lods; let sorted = &self.sorted_indices; + let phase2 = self.cull.as_ref().filter(|_| culling).map(|c| &c.phase2); crate::spans::time("flatten", || { flat.prepare( &self.device, @@ -3528,7 +3563,9 @@ impl Renderer { &mut self.uploads, &self.draws, &self.draw_pages, + phase1_draws as usize, solid_draws as usize, + phase2, visible .iter() .filter_map(|v| { @@ -3563,16 +3600,6 @@ impl Renderer { 0, bytemuck::cast_slice(&self.draws), ); - if culling && let Some(cull) = &mut self.cull { - cull.upload( - &self.device, - &mut self.uploads, - &mut encoder, - &self.draws[phase1_draws as usize..solid_draws as usize], - &self.instances, - &self.globals, - ); - } } let view_target = target_texture.create_view(&wgpu::TextureViewDescriptor { format: Some(self.config.format.remove_srgb_suffix()), @@ -3673,9 +3700,28 @@ impl Renderer { match self.flat.as_ref().filter(|_| flat_frame) { Some(flat) => { pass.set_pipeline(&flat.solid); - flat.draw(&mut pass, &flat.calls[..flat.solid_calls], |p| { - self.arena.buffer(p) - }); + let vertices = |p| self.arena.buffer(p); + match cull { + // As below: phase 1, the test, then phase 2's draws + // that the test saw, copied after it. + Some(cull) => { + flat.draw(&mut pass, &flat.calls[..flat.phase1_calls], vertices); + cull.test(&mut pass); + drop(pass); + cull.test_pass(&mut encoder); + flat.flatten_phase2(&mut encoder); + pass = world_pass_after_culling( + &mut encoder, + world_view, + world_depth, + pack, + ); + pass.set_bind_group(0, &self.group, &[]); + pass.set_pipeline(&flat.solid); + flat.draw_phase2(&mut pass, vertices); + } + None => flat.draw(&mut pass, &flat.calls[..flat.solid_calls], vertices), + } pass.set_bind_group(0, &self.group, &[]); pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); } @@ -3693,34 +3739,12 @@ impl Renderer { cull.test(&mut pass); drop(pass); cull.test_pass(&mut encoder); - let attachments = [Some(wgpu::RenderPassColorAttachment { - view: world_view, - resolve_target: None, - depth_slice: None, - ops: wgpu::Operations { - load: wgpu::LoadOp::Load, - store: wgpu::StoreOp::Store, - }, - })]; - pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { - label: Some("Horizon world, after culling"), - color_attachments: &attachments, - depth_stencil_attachment: Some( - wgpu::RenderPassDepthStencilAttachment { - view: world_depth, - depth_ops: Some(wgpu::Operations { - load: wgpu::LoadOp::Load, - store: if pack { - wgpu::StoreOp::Store - } else { - wgpu::StoreOp::Discard - }, - }), - stencil_ops: None, - }, - ), - ..Default::default() - }); + pass = world_pass_after_culling( + &mut encoder, + world_view, + world_depth, + pack, + ); pass.set_bind_group(0, &self.group, &[]); pass.set_pipeline(&self.solid); pass.set_index_buffer( diff --git a/crates/horizon-client/src/gfx/flat.rs b/crates/horizon-client/src/gfx/flat.rs index a1ae20d09..2d0a8d27c 100644 --- a/crates/horizon-client/src/gfx/flat.rs +++ b/crates/horizon-client/src/gfx/flat.rs @@ -11,11 +11,37 @@ //! so each block names one section: its id here, which indexes the frame's //! camera-relative origins (computed on the CPU exactly as for the instance //! attribute). +//! +//! With occlusion culling (`cull`), phase 1's draws and the translucent ones +//! are copied before the world pass, as without it. Phase 2's draws are +//! copied after the test, which tells which ones it saw: each run of a page +//! reserves room for all of its draws, the copy packs the seen ones at its +//! start, and the run is drawn indirectly with the count the copy reached. use super::arena::GRAIN; /// One section draw for `flatten.wgsl`: index count, first sorted index (or -/// `QUADS` for a solid draw), base vertex, first index in the list. +/// `QUADS` for a solid draw; phase 2: its entry in phase 2's draws), base +/// vertex, first index in the list (phase 2: its draw call in phase 2). type Range = [u32; 4]; + +/// Where a group of ranges takes its indices. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Source { + /// Solid draws: quads. + Quads, + /// Occlusion culling's phase 2: quads, of the sections its test saw. + Seen, + /// Translucent draws: this sorted index page. + Sorted(u32), +} + +/// The frame's draw calls, as `plan` lays them out. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +struct Plan { + phase1_calls: usize, + solid_calls: usize, + total: u64, +} const QUADS: u32 = u32::MAX; const GROUP_LIMIT: u32 = 65535; @@ -38,6 +64,15 @@ pub struct Flat { pub translucent: wgpu::RenderPipeline, flatten: wgpu::ComputePipeline, compute_layout: wgpu::BindGroupLayout, + flatten_seen: wgpu::ComputePipeline, + seen_layout: wgpu::BindGroupLayout, + /// Phase 2's draw calls (`DrawIndexedIndirectArgs`), whose index counts + /// `flatten_seen` makes. + phase2_calls: wgpu::Buffer, + phase2_call_capacity: u64, + phase2_call_data: Vec<[u32; 5]>, + /// The copy of phase 2's draws, and its ranges. + phase2_group: Option<(wgpu::BindGroup, u32)>, draw_layout: wgpu::BindGroupLayout, blocks_per_page: u64, pages: Vec>, @@ -52,12 +87,14 @@ pub struct Flat { ranges: wgpu::Buffer, range_capacity: u64, range_data: Vec, - /// Segments of `range_data` by index source: (sorted index page or - /// `None` for solid draws, first range, ranges). - segments: Vec<(Option, u64, u64)>, + /// Segments of `range_data` by index source: (source, first range, + /// ranges). + segments: Vec<(Source, u64, u64)>, empty: wgpu::Buffer, - /// This frame's draw calls: solid ones, then translucent ones. + /// This frame's draw calls: solid ones (phase 1's, then phase 2's when + /// culling), then translucent ones. pub calls: Vec, + pub phase1_calls: usize, pub solid_calls: usize, /// Frames with fewer section draws keep the per-section draws. pub min_draws: usize, @@ -121,42 +158,60 @@ fn buffer( /// Lays out the frame's index list: each draw's range (destinations in draw /// order) grouped by index source into `ranges`, every group padded to /// `align` entries for binding, with `segments` naming each group; and the -/// draw calls, one per run of draws in the same vertex page, solid and -/// translucent apart. Returns the first translucent call and the list's -/// length. +/// draw calls, one per run of draws in the same vertex page, phase 1's solid +/// ones, phase 2's (draws `phase1_draws..solid_draws`) and translucent ones +/// apart. A phase 2 range names its draw in phase 2 and its call in phase 2 +/// instead of a destination: the call's room holds all of its draws. fn plan( draws: &[[u32; 5]], pages: &[(u32, Option)], + phase1_draws: usize, solid_draws: usize, align: u64, calls: &mut Vec, ranges: &mut Vec, - segments: &mut Vec<(Option, u64, u64)>, -) -> (usize, u64) { + segments: &mut Vec<(Source, u64, u64)>, +) -> Plan { calls.clear(); ranges.clear(); segments.clear(); - let mut solid_calls = None; + let (mut phase1_calls, mut solid_calls) = (None, None); let mut total = 0u64; - let mut by_source: Vec<(Option, Vec)> = Vec::new(); + let mut by_source: Vec<(Source, Vec)> = Vec::new(); for (i, (d, &(page, sorted))) in draws.iter().zip(pages).enumerate() { - let first = if sorted.is_some() { d[2] } else { QUADS }; - let range = [d[0], first, d[3], total as u32]; - match by_source.iter_mut().find(|(s, _)| *s == sorted) { - Some((_, list)) => list.push(range), - None => by_source.push((sorted, vec![range])), + if i == phase1_draws { + phase1_calls.get_or_insert(calls.len()); } if i == solid_draws { solid_calls = Some(calls.len()); } match calls.last_mut() { - Some(last) if last.page == page && i != solid_draws => last.count += d[0], + Some(last) if last.page == page && i != phase1_draws && i != solid_draws => { + last.count += d[0] + } _ => calls.push(Call { page, first: total as u32, count: d[0], }), } + let (source, range) = match sorted { + Some(p) => (Source::Sorted(p), [d[0], d[2], d[3], total as u32]), + None if (phase1_draws..solid_draws).contains(&i) => ( + Source::Seen, + [ + d[0], + (i - phase1_draws) as u32, + d[3], + (calls.len() - 1 - phase1_calls.unwrap_or(0)) as u32, + ], + ), + None => (Source::Quads, [d[0], QUADS, d[3], total as u32]), + }; + match by_source.iter_mut().find(|(s, _)| *s == source) { + Some((_, list)) => list.push(range), + None => by_source.push((source, vec![range])), + } total += u64::from(d[0]); } for (source, list) in by_source { @@ -165,7 +220,12 @@ fn plan( let padded = (ranges.len() as u64).next_multiple_of(align); ranges.resize(padded as usize, [0; 4]); } - (solid_calls.unwrap_or(calls.len()), total) + let solid_calls = solid_calls.unwrap_or(calls.len()); + Plan { + phase1_calls: phase1_calls.unwrap_or(calls.len()).min(solid_calls), + solid_calls, + total, + } } impl Flat { @@ -201,24 +261,37 @@ impl Flat { storage(2, compute, false), ], }); + let seen_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + label: Some("Flatten phase 2 section draws"), + entries: &[ + storage(0, compute, true), + storage(2, compute, false), + storage(3, compute, true), + storage(4, compute, false), + ], + }); let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("Flatten section draws"), source: wgpu::ShaderSource::Wgsl(include_str!("flatten.wgsl").into()), }); - let flatten = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { - label: Some("Flatten section draws"), - layout: Some( - &device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { - label: Some("Flatten section draws"), - bind_group_layouts: &[Some(&compute_layout)], - ..Default::default() - }), - ), - module: &module, - entry_point: Some("flatten"), - compilation_options: Default::default(), - cache: None, - }); + let compute_pipeline = |layout: &wgpu::BindGroupLayout, entry| { + device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { + label: Some("Flatten section draws"), + layout: Some( + &device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { + label: Some("Flatten section draws"), + bind_group_layouts: &[Some(layout)], + ..Default::default() + }), + ), + module: &module, + entry_point: Some(entry), + compilation_options: Default::default(), + cache: None, + }) + }; + let flatten = compute_pipeline(&compute_layout, "flatten"); + let flatten_seen = compute_pipeline(&seen_layout, "flatten_seen"); let storage_usage = wgpu::BufferUsages::STORAGE; Self { solid: pipeline(&layout, "Terrain solid (flat)", "fs_solid", None), @@ -230,6 +303,17 @@ impl Flat { ), flatten, compute_layout, + flatten_seen, + seen_layout, + phase2_calls: buffer( + device, + "Flat section draw calls, phase 2", + 20, + wgpu::BufferUsages::INDIRECT | storage_usage, + ), + phase2_call_capacity: 1, + phase2_call_data: Vec::new(), + phase2_group: None, draw_layout, blocks_per_page: page_vertices.div_ceil(GRAIN), pages: Vec::new(), @@ -251,6 +335,7 @@ impl Flat { segments: Vec::new(), empty: buffer(device, "No sorted indices", 16, storage_usage), calls: Vec::new(), + phase1_calls: 0, solid_calls: 0, min_draws: if std::env::var("HORIZON_FLAT_DRAWS").as_deref() == Ok("1") { 0 @@ -321,6 +406,9 @@ impl Flat { /// the origins of the sections they draw by id. Records the copy into /// `encoder`; `calls` then lists the frame's draw calls. False when the /// frame cannot be drawn flat (the per-section draws then apply). + /// + /// When culling, the solid draws from `phase1_draws` are phase 2's, which + /// `phase2` holds as the test leaves them: `flatten_phase2` copies them. #[allow(clippy::too_many_arguments)] pub fn prepare( &mut self, @@ -329,10 +417,18 @@ impl Flat { uploads: &mut super::upload::Uploads, draws: &[[u32; 5]], pages: &[(u32, Option)], + phase1_draws: usize, solid_draws: usize, + phase2: Option<&wgpu::Buffer>, origins: impl Iterator, sorted_page: impl Fn(u32) -> wgpu::Buffer, ) -> bool { + self.phase2_group = None; + let phase1_draws = if phase2.is_some() { + phase1_draws + } else { + solid_draws + }; // Origins by section id. self.origin_data.clear(); for (id, o) in origins { @@ -362,18 +458,25 @@ impl Flat { bytemuck::cast_slice(&self.origin_data), ); } - let (solid_calls, total) = plan( + let Plan { + phase1_calls, + solid_calls, + total, + } = plan( draws, pages, + phase1_draws, solid_draws, self.range_align, &mut self.calls, &mut self.range_data, &mut self.segments, ); + self.phase1_calls = phase1_calls; self.solid_calls = solid_calls; if total == 0 || total * 4 > device.limits().max_storage_buffer_binding_size { self.calls.clear(); + self.phase1_calls = 0; self.solid_calls = 0; return false; } @@ -401,22 +504,82 @@ impl Flat { 0, bytemuck::cast_slice(&self.range_data), ); + // Phase 2's calls start empty, each at the start of its room. + self.phase2_call_data.clear(); + self.phase2_call_data.extend( + self.calls[phase1_calls..solid_calls] + .iter() + .map(|c| [0, 1, c.first, 0, 0]), + ); + let phase2_calls = self.phase2_call_data.len() as u64; + if phase2_calls > self.phase2_call_capacity { + self.phase2_call_capacity = phase2_calls.next_power_of_two(); + self.phase2_calls = buffer( + device, + "Flat section draw calls, phase 2", + self.phase2_call_capacity * 20, + wgpu::BufferUsages::INDIRECT | wgpu::BufferUsages::STORAGE, + ); + } + if phase2_calls > 0 { + uploads.buffer( + encoder, + &self.phase2_calls, + 0, + bytemuck::cast_slice(&self.phase2_call_data), + ); + } + let ranges_at = |first: u64, count: u64| { + wgpu::BindingResource::Buffer(wgpu::BufferBinding { + buffer: &self.ranges, + offset: first * 16, + size: wgpu::BufferSize::new(count * 16), + }) + }; + if let (Some(phase2), Some(&(_, first, count))) = ( + phase2, + self.segments.iter().find(|(s, ..)| *s == Source::Seen), + ) { + let group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("Flatten phase 2 section draws"), + layout: &self.seen_layout, + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: ranges_at(first, count), + }, + wgpu::BindGroupEntry { + binding: 2, + resource: self.indices.as_entire_binding(), + }, + wgpu::BindGroupEntry { + binding: 3, + resource: phase2.as_entire_binding(), + }, + wgpu::BindGroupEntry { + binding: 4, + resource: self.phase2_calls.as_entire_binding(), + }, + ], + }); + self.phase2_group = Some((group, count as u32)); + } let groups: Vec<(wgpu::BindGroup, u32)> = self .segments .iter() - .map(|&(source, first, count)| { - let sorted = source.map(&sorted_page); + .filter_map(|&(source, first, count)| { + let sorted = match source { + Source::Quads => None, + Source::Seen => return None, + Source::Sorted(page) => Some(sorted_page(page)), + }; let group = device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("Flatten section draws"), layout: &self.compute_layout, entries: &[ wgpu::BindGroupEntry { binding: 0, - resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding { - buffer: &self.ranges, - offset: first * 16, - size: wgpu::BufferSize::new(count * 16), - }), + resource: ranges_at(first, count), }, wgpu::BindGroupEntry { binding: 1, @@ -428,7 +591,7 @@ impl Flat { }, ], }); - (group, count as u32) + Some((group, count as u32)) }) .collect(); let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { @@ -464,6 +627,19 @@ impl Flat { } true } + /// After occlusion culling's test: copies the phase 2 draws it saw. + pub fn flatten_phase2(&self, encoder: &mut wgpu::CommandEncoder) { + let Some((group, count)) = &self.phase2_group else { + return; + }; + let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { + label: Some("Flatten phase 2 section draws"), + timestamp_writes: None, + }); + pass.set_pipeline(&self.flatten_seen); + pass.set_bind_group(0, group, &[]); + pass.dispatch_workgroups((*count).min(GROUP_LIMIT), count.div_ceil(GROUP_LIMIT), 1); + } /// Draws `calls` with a flat pipeline set and `vertices` giving each /// page's vertex buffer. pub fn draw<'a>( @@ -474,15 +650,38 @@ impl Flat { ) { pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); for call in calls { - let table = self.pages[call.page as usize] - .as_ref() - .and_then(|t| t.group.as_ref()) - .expect("prepared page"); - pass.set_vertex_buffer(0, vertices(call.page).slice(..)); - pass.set_bind_group(1, table, &[]); + self.bind_page(pass, call.page, &vertices); pass.draw_indexed(call.first..call.first + call.count, 0, 0..1); } } + /// Draws phase 2's calls, as `flatten_phase2` left them. + pub fn draw_phase2<'a>( + &self, + pass: &mut wgpu::RenderPass<'_>, + vertices: impl Fn(u32) -> &'a wgpu::Buffer, + ) { + pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); + for (k, call) in self.calls[self.phase1_calls..self.solid_calls] + .iter() + .enumerate() + { + self.bind_page(pass, call.page, &vertices); + pass.draw_indexed_indirect(&self.phase2_calls, k as u64 * 20); + } + } + fn bind_page<'a>( + &self, + pass: &mut wgpu::RenderPass<'_>, + page: u32, + vertices: &impl Fn(u32) -> &'a wgpu::Buffer, + ) { + let table = self.pages[page as usize] + .as_ref() + .and_then(|t| t.group.as_ref()) + .expect("prepared page"); + pass.set_vertex_buffer(0, vertices(page).slice(..)); + pass.set_bind_group(1, table, &[]); + } } #[cfg(test)] @@ -516,16 +715,22 @@ mod tests { fn plan_draws_runs_of_a_page_in_order() { let (draws, pages, solid) = sample(); let (mut calls, mut ranges, mut segments) = (Vec::new(), Vec::new(), Vec::new()); - let (solid_calls, total) = plan( + let Plan { + phase1_calls, + solid_calls, + total, + } = plan( &draws, &pages, solid, + solid, 4, &mut calls, &mut ranges, &mut segments, ); assert_eq!(total, 6 * 13); + assert_eq!(phase1_calls, solid_calls); let call = |page, first, count| Call { page, first, count }; // Pages 0, 0 | 1 | 0, then translucent 0, 0 (never merged with solid). assert_eq!( @@ -539,16 +744,65 @@ mod tests { ); assert_eq!(solid_calls, 3); // Solid ranges, then each sorted page's, every group padded to 4. - assert_eq!(segments, [(None, 0, 4), (Some(0), 4, 1), (Some(1), 8, 1)]); + assert_eq!( + segments, + [ + (Source::Quads, 0, 4), + (Source::Sorted(0), 4, 1), + (Source::Sorted(1), 8, 1) + ] + ); assert_eq!(ranges[3], [24, QUADS, 1024, 36]); assert_eq!(ranges[4], [12, 6, 768, 60]); assert_eq!(ranges[8], [6, 0, 40, 72]); assert_eq!(ranges.len(), 12); } + /// Phase 2's draws (here the third and fourth) get calls of their own, + /// each with room for all of its draws, and ranges naming their draw + /// and call in phase 2. + #[test] + fn plan_gives_phase_2_calls_of_its_own() { + let (draws, pages, solid) = sample(); + let (mut calls, mut ranges, mut segments) = (Vec::new(), Vec::new(), Vec::new()); + let plan = plan( + &draws, + &pages, + 2, + solid, + 4, + &mut calls, + &mut ranges, + &mut segments, + ); + assert_eq!( + plan, + Plan { + phase1_calls: 1, + solid_calls: 3, + total: 6 * 13 + } + ); + let call = |page, first, count| Call { page, first, count }; + // Phase 1: page 0 | phase 2: page 1, page 0 | translucent: page 0. + assert_eq!( + calls, + [ + call(0, 0, 30), + call(1, 30, 6), + call(0, 36, 24), + call(0, 60, 18) + ] + ); + assert_eq!(segments[1], (Source::Seen, 4, 2)); + assert_eq!(ranges[4], [6, 0, 256, 0]); + assert_eq!(ranges[5], [24, 1, 1024, 1]); + } + /// The compute pass writes exactly the indices the per-section draws /// read: quads 0 1 2 0 2 3 for solid draws, sorted indices otherwise, - /// plus the base vertex. + /// plus the base vertex. With culling, phase 2's runs hold the indices + /// of the draws the test saw, in order, and their calls count them. #[test] fn flatten_writes_the_indices_of_the_per_section_draws() { let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); @@ -564,101 +818,170 @@ mod tests { use wgpu::util::DeviceExt; let (draws, pages, solid) = sample(); let align = (u64::from(device.limits().min_storage_buffer_offset_alignment) / 16).max(1); - let (mut calls, mut ranges, mut segments) = (Vec::new(), Vec::new(), Vec::new()); - let (_, total) = plan( - &draws, - &pages, - solid, - align, - &mut calls, - &mut ranges, - &mut segments, - ); let sorted: [Vec; 2] = [ (0..32).map(|i| (i * 7) % 32).collect(), (0..8).rev().collect(), ]; - let mut expected = Vec::new(); - for (d, (_, page)) in draws.iter().zip(&pages) { - for k in 0..d[0] { - let i = match page { - None => (k / 6) * 4 + [0, 1, 2, 0, 2, 3][(k % 6) as usize], - Some(p) => sorted[*p as usize][(d[2] + k) as usize], - }; - expected.push(d[3] + i); - } - } - let storage = |entries: &[u32]| { + let indices = |d: &[u32; 5], sorted_page: Option| -> Vec { + (0..d[0]) + .map(|k| { + d[3] + match sorted_page { + None => (k / 6) * 4 + [0, 1, 2, 0, 2, 3][(k % 6) as usize], + Some(p) => sorted[p as usize][(d[2] + k) as usize], + } + }) + .collect() + }; + let storage = |entries: &[u32], usage| { device.create_buffer_init(&wgpu::util::BufferInitDescriptor { label: None, contents: bytemuck::cast_slice(entries), - usage: wgpu::BufferUsages::STORAGE, + usage: wgpu::BufferUsages::STORAGE | usage, }) }; - let range_buffer = storage(bytemuck::cast_slice(&ranges)); - let sorted_buffers = [storage(&sorted[0]), storage(&sorted[1]), storage(&[0; 4])]; - let out = device.create_buffer(&wgpu::BufferDescriptor { - label: None, - size: total * 4, - usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC, - mapped_at_creation: false, - }); - let read = device.create_buffer(&wgpu::BufferDescriptor { - label: None, - size: total * 4, - usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, - mapped_at_creation: false, - }); + let none = wgpu::BufferUsages::empty(); + let sorted_buffers = [ + storage(&sorted[0], none), + storage(&sorted[1], none), + storage(&[0; 4], none), + ]; let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: None, source: wgpu::ShaderSource::Wgsl(include_str!("flatten.wgsl").into()), }); - let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { - label: None, - layout: None, - module: &module, - entry_point: Some("flatten"), - compilation_options: Default::default(), - cache: None, - }); - let mut encoder = device.create_command_encoder(&Default::default()); - { - let mut pass = encoder.begin_compute_pass(&Default::default()); - pass.set_pipeline(&pipeline); - for &(source, first, count) in &segments { - let group = device.create_bind_group(&wgpu::BindGroupDescriptor { - label: None, - layout: &pipeline.get_bind_group_layout(0), - entries: &[ - wgpu::BindGroupEntry { - binding: 0, - resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding { - buffer: &range_buffer, - offset: first * 16, - size: wgpu::BufferSize::new(count * 16), - }), - }, - wgpu::BindGroupEntry { - binding: 1, - resource: sorted_buffers[source.map_or(2, |p| p as usize)] - .as_entire_binding(), - }, - wgpu::BindGroupEntry { - binding: 2, - resource: out.as_entire_binding(), - }, - ], - }); - pass.set_bind_group(0, &group, &[]); - pass.dispatch_workgroups(count as u32, 1, 1); + let pipeline = |entry| { + device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { + label: None, + layout: None, + module: &module, + entry_point: Some(entry), + compilation_options: Default::default(), + cache: None, + }) + }; + let (flatten, flatten_seen) = (pipeline("flatten"), pipeline("flatten_seen")); + let read_back = |buffer: &wgpu::Buffer, words: u64| -> Vec { + let read = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: words * 4, + usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let mut encoder = device.create_command_encoder(&Default::default()); + encoder.copy_buffer_to_buffer(buffer, 0, &read, 0, words * 4); + queue.submit([encoder.finish()]); + read.slice(..).map_async(wgpu::MapMode::Read, |_| {}); + device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); + bytemuck::cast_slice(&read.slice(..).get_mapped_range().unwrap()).to_vec() + }; + // Without culling, then with the third and fourth draws in phase 2, + // of which the test saw only the fourth. + for phase1 in [solid, 2] { + let (mut calls, mut ranges, mut segments) = (Vec::new(), Vec::new(), Vec::new()); + let plan = plan( + &draws, + &pages, + phase1, + solid, + align, + &mut calls, + &mut ranges, + &mut segments, + ); + // Phase 2's draws as the test leaves them: instance counts of 0, + // 1 where it saw the section. + let mut phase2: Vec<[u32; 5]> = draws[phase1..solid] + .iter() + .map(|&[count, _, first, base, instance]| [count, 0, first, base, instance]) + .collect(); + if let Some(last) = phase2.last_mut() { + last[1] = 1; + } + let phase2_calls: Vec<[u32; 5]> = calls[plan.phase1_calls..plan.solid_calls] + .iter() + .map(|c| [0, 1, c.first, 0, 0]) + .collect(); + let range_buffer = storage(bytemuck::cast_slice(&ranges), none); + let phase2_buffer = storage( + bytemuck::cast_slice(&[phase2.as_slice(), &[[0; 5]]].concat()), + none, + ); + let calls_buffer = storage( + bytemuck::cast_slice(&[phase2_calls.as_slice(), &[[0; 5]]].concat()), + wgpu::BufferUsages::COPY_SRC, + ); + let out = storage(&vec![0; plan.total as usize], wgpu::BufferUsages::COPY_SRC); + let mut encoder = device.create_command_encoder(&Default::default()); + { + let mut pass = encoder.begin_compute_pass(&Default::default()); + for &(source, first, count) in &segments { + let ranges = wgpu::BindingResource::Buffer(wgpu::BufferBinding { + buffer: &range_buffer, + offset: first * 16, + size: wgpu::BufferSize::new(count * 16), + }); + let entry = |binding, resource| wgpu::BindGroupEntry { binding, resource }; + let (pipeline, entries) = match source { + Source::Seen => ( + &flatten_seen, + vec![ + entry(0, ranges), + entry(2, out.as_entire_binding()), + entry(3, phase2_buffer.as_entire_binding()), + entry(4, calls_buffer.as_entire_binding()), + ], + ), + Source::Quads | Source::Sorted(_) => { + let page = match source { + Source::Sorted(p) => p as usize, + _ => 2, + }; + ( + &flatten, + vec![ + entry(0, ranges), + entry(1, sorted_buffers[page].as_entire_binding()), + entry(2, out.as_entire_binding()), + ], + ) + } + }; + let group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: None, + layout: &pipeline.get_bind_group_layout(0), + entries: &entries, + }); + pass.set_pipeline(pipeline); + pass.set_bind_group(0, &group, &[]); + pass.dispatch_workgroups(count as u32, 1, 1); + } + } + queue.submit([encoder.finish()]); + let got = read_back(&out, plan.total); + // Phase 1's and the translucent calls: each of their draws, in order. + let expected: Vec = (0..draws.len()) + .filter(|i| !(phase1..solid).contains(i)) + .flat_map(|i| indices(&draws[i], pages[i].1)) + .collect(); + let drawn: Vec = calls + .iter() + .enumerate() + .filter(|(c, _)| !(plan.phase1_calls..plan.solid_calls).contains(c)) + .flat_map(|(_, c)| got[c.first as usize..(c.first + c.count) as usize].to_vec()) + .collect(); + assert_eq!(drawn, expected); + // Phase 2: page 1's run drew nothing; page 0's holds the fourth + // draw's indices. + if phase1 < solid { + let counts = read_back(&calls_buffer, phase2_calls.len() as u64 * 5); + assert_eq!(counts[0], 0); + assert_eq!(counts[5], draws[3][0]); + let run = &calls[plan.phase1_calls + 1]; + assert_eq!( + got[run.first as usize..(run.first + draws[3][0]) as usize], + indices(&draws[3], None) + ); } } - encoder.copy_buffer_to_buffer(&out, 0, &read, 0, total * 4); - queue.submit([encoder.finish()]); - read.slice(..).map_async(wgpu::MapMode::Read, |_| {}); - device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); - let got: Vec = - bytemuck::cast_slice(&read.slice(..).get_mapped_range().unwrap()).to_vec(); - assert_eq!(got, expected); } } diff --git a/crates/horizon-client/src/gfx/flatten.wgsl b/crates/horizon-client/src/gfx/flatten.wgsl index 2f57f8775..d722d7b9f 100644 --- a/crates/horizon-client/src/gfx/flatten.wgsl +++ b/crates/horizon-client/src/gfx/flatten.wgsl @@ -4,9 +4,11 @@ // translucent ones read their sorted indices. struct Range { count: u32, - // First sorted index, or QUADS for a solid draw. + // First sorted index, or QUADS for a solid draw (`flatten_seen`: its + // entry in occlusion culling's phase 2 draws). first: u32, base: u32, + // First index in the list (`flatten_seen`: its draw call). dst: u32, } const QUADS: u32 = 0xffffffffu; @@ -14,6 +16,13 @@ const GROUP: u32 = 64u; @group(0) @binding(0) var ranges: array; @group(0) @binding(1) var sorted: array; @group(0) @binding(2) var out: array; + +// Index `k` of a solid draw: quad k / 6's vertices 0 1 2 0 2 3. +fn quad(k: u32) -> u32 { + let c = k % 6u; + return (k / 6u) * 4u + select(select(c - 2u, 0u, c == 3u), c, c < 3u); +} + @compute @workgroup_size(64) fn flatten(@builtin(workgroup_id) group: vec3, @builtin(local_invocation_index) lane: u32) { @@ -25,11 +34,43 @@ fn flatten(@builtin(workgroup_id) group: vec3, for (var k = lane; k < d.count; k += GROUP) { var i: u32; if d.first == QUADS { - let c = k % 6u; - i = (k / 6u) * 4u + select(select(c - 2u, 0u, c == 3u), c, c < 3u); + i = quad(k); } else { i = sorted[d.first + k]; } out[d.dst + k] = d.base + i; } } + +// Occlusion culling's phase 2 (gfx/cull.rs), after its test: the draws as +// the test left them (`DrawIndexedIndirectArgs`, the instance count 1 where +// it saw the section), and phase 2's draw calls, whose index counts start +// at 0. A draw the test saw takes the next indices of its call's run. +@group(0) @binding(3) var draws: array; +@group(0) @binding(4) var calls: array>; +const UNSEEN: u32 = 0xffffffffu; +var start: u32; + +@compute @workgroup_size(64) +fn flatten_seen(@builtin(workgroup_id) group: vec3, + @builtin(local_invocation_index) lane: u32) { + let r = group.y * 65535u + group.x; + if r >= arrayLength(&ranges) { + return; + } + let d = ranges[r]; + if lane == 0u { + var s = UNSEEN; + if draws[d.first * 5u + 1u] != 0u { + s = atomicLoad(&calls[d.dst * 5u + 2u]) + atomicAdd(&calls[d.dst * 5u], d.count); + } + start = s; + } + let s = workgroupUniformLoad(&start); + if s == UNSEEN { + return; + } + for (var k = lane; k < d.count; k += GROUP) { + out[s + k] = d.base + quad(k); + } +} From 1d81c67b7b4a2ae05fc20bd6e8fc0b9691238df9 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 12:13:58 +0200 Subject: [PATCH 51/62] Build naga once for the game, its tests and its examples horizon-client's dev-dependency on naga added the hlsl-out feature for the gfx.rs test that translates every shader for DirectX 12. With resolver 2 a dev-dependency's features apply only to tests and examples, so Cargo kept two builds of naga, wgpu-hal, wgpu-core, wgpu, horizon-shaderpack and the horizon-client lib, and rebuilt them on the first example or test after a game build. Measured on the Mac mini (cargo build of the game, then one example): the example took 37.3 s and recompiled that whole stack before, 1.2 s and only its own crate after; the target dir is 1 GB smaller (4.9 to 3.9 GB). The game binary is the same size: nothing calls the HLSL writer, so the linker drops it. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/Cargo.toml | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/Cargo.toml b/crates/horizon-client/Cargo.toml index 48e2e57d4..cd5d86fe7 100644 --- a/crates/horizon-client/Cargo.toml +++ b/crates/horizon-client/Cargo.toml @@ -30,7 +30,9 @@ serde = { version = "1", features = ["derive"] } serde_json = { version = "1.0.151", features = ["raw_value"] } # Shader packs: pack.toml, and WGSL checked before it reaches wgpu. toml = "1.1" -naga = { version = "30.0.1", features = ["wgsl-in"] } +# hlsl-out: the gfx.rs tests translate every shader as wgpu's DirectX 12 backend does. A normal feature, +# not a dev-dependency's, so builds, tests and examples share one build of naga, wgpu and this crate. +naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out"] } # Java (OptiFine/Iris) shader packs, translated to WGSL. horizon-shaderpack = { path = "../horizon-shaderpack" } # Sound (ALSA on Linux); the `audio` feature. @@ -81,7 +83,3 @@ rng-trace = ["horizon-core/rng-trace"] [lints] workspace = true - -[dev-dependencies] -# Every WGSL shader translated as wgpu's DirectX 12 backend does (gfx.rs tests). -naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out"] } From 660407fa58d03fa6e41fe2edc7d4ae3658841233 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 13:22:10 +0200 Subject: [PATCH 52/62] Metal: cull only frames with 4,096 section draws or more On Apple's GPUs the passes the test adds cost a fixed share of the frame (it is stored and reloaded at each), which the hidden sections repay only at high render distances: at 12 culling cost an M4 Pro 0.05 ms of GPU time a frame, at 32 it saved 0.25 to 1.6 ms. Other backends keep culling every frame; HORIZON_GPU_CULL=all culls every frame on Metal too. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx.rs | 14 ++++++++++---- crates/horizon-client/src/gfx/cull.rs | 10 ++++++++++ 2 files changed, 20 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 91da4f616..022d14dcd 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -2146,8 +2146,8 @@ impl Renderer { .features() .contains(wgpu::Features::INDIRECT_FIRST_INSTANCE); // HORIZON_GPU_CULL=0 turns occlusion culling off, `all` culls every - // frame however little it hides, `shader` tests in the shader as on - // Metal (A/B checks). + // frame however few its draws and little it hides, `shader` tests in + // the shader as on Metal (A/B checks). let cull_env = std::env::var("HORIZON_GPU_CULL"); let cull = cull::Cull::supported(&adapter, &device) .filter(|_| cull_env.as_deref() != Ok("0")) @@ -2159,6 +2159,9 @@ impl Renderer { let mut cull = cull::Cull::new(&device, config.format.remove_srgb_suffix(), depth_test); cull.always = cull_env.as_deref() == Ok("all"); + if !cull.always && adapter.get_info().backend == wgpu::Backend::Metal { + cull.min_draws = cull::TILED_MIN_DRAWS; + } cull }); let depth = Self::depth(&device, &config, cull.as_ref()); @@ -3148,11 +3151,14 @@ impl Renderer { .inverse() .transform_point3(Vec3::ZERO); // Occlusion culling leaves the sections its last result did not see - // to phase 2, after the others, with instance counts of 0. + // to phase 2, after the others, with instance counts of 0. Whether + // the frame has draws enough goes by the last one's. let mut cull = self .cull .as_mut() - .filter(|_| self.cull_on && !frame.title && self.multi_draw) + .filter(|c| { + self.cull_on && !frame.title && self.multi_draw && self.section_draws >= c.min_draws + }) .and_then(|cull| cull.begin(&self.device).then_some(cull)); self.phase2_draws.clear(); self.phase2_pages.clear(); diff --git a/crates/horizon-client/src/gfx/cull.rs b/crates/horizon-client/src/gfx/cull.rs index 77574e850..57049eb4d 100644 --- a/crates/horizon-client/src/gfx/cull.rs +++ b/crates/horizon-client/src/gfx/cull.rs @@ -46,6 +46,13 @@ const RETEST: u32 = 8; /// more than they save. Else one frame in `PROBE` tests every section. const MIN_SHARE: f32 = 0.1; const PROBE: u32 = 64; +/// On Metal, section draws from which a frame culls. Apple's GPUs store and +/// reload the whole frame at each of the passes the test adds, a fixed cost +/// that the sections it hides repay only at high render distances: on an M4 +/// Pro at 1080p and render distance 12 (1,000–1,600 draws) culling added +/// about 0.05 ms of GPU time while hiding 15–30% of the solid indices; at +/// 32 (drawn flat, over this many draws) it saved 0.25–1.6 ms. +pub const TILED_MIN_DRAWS: usize = 4096; /// Boxes over more than this share of the screen count as seen untested. const BIG: f32 = 0.25; /// Results read back at once, some frames late so the CPU never waits. @@ -141,6 +148,8 @@ pub struct Cull { pub hidden: ([usize; 2], f32), /// Cull every frame, whatever the hidden share (A/B checks). pub always: bool, + /// Frames with fewer section draws than this do not cull. + pub min_draws: usize, } fn buffer( @@ -337,6 +346,7 @@ impl Cull { stamp: 0, hidden: ([0; 2], 1.0), always: false, + min_draws: 0, } } From eafe97da7468315d1bd159ccee038a8cee72e62d Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 14:02:12 +0200 Subject: [PATCH 53/62] Shader packs: keep what Iris does, drop what doesn't work, apply settings on Done Review fixes for #1414 (contribution gate): - Java packs no longer get Horizon's shadow map: it was mirrored in y and reversed in depth against the GL conventions the packs sample with, had no distortion and only the camera's sections, so BSL drew no shadows while the pass cost 0.65 ms (MakeUp, M4 Pro). shadowtex* stays a far depth, as on main; the packs' own shadow programs are #1326. - Invented uniforms removed (centerDepthSmooth fixed at 0.5, ambientOcclusionLevel and shadowMapResolution as uniforms, constant temp/rainfall/biome/held items); an unknown uniform stays zero as before. wetness keeps its Iris smoothing. Unused directives removed. - texture.. is scoped to Iris's stages (final reads the composite ones) instead of overriding the sampler in every pass; texture.noise replaces noisetex. One noise generator and one RGBA upload for both pack kinds. - The G-buffer pass, the opaque-depth copy and the shadow pass run only for a pack that reads them (naga's per-entry-point binding use, not a text search): every pack paid all three before. - Api 2's prelude additions go in their own file after api 1's, so api 1 packs keep the names they declare (aces_tonemap, material_at...). - Stage kinds shadow, gbuffer, deferred and final ran as composite: only composite is accepted; api 2 adds formats (validated), profiles, option descriptions and a noise texture. - Shader Pack Settings applies once when the page closes, as Iris's Done (each click or slider step rebuilt the pack: 2.7 s per click, 12.7 s for one drag with BSL). Labels follow Iris (.lang, else the name). A pack whose options can't be read isn't read again every frame. - Saved option values an option doesn't list are ignored, as OptiFine's ShaderOption.setValue (a stale file broke BSL's compile). - Import: the blocking file dialog (osascript/zenity/kdialog/PowerShell on the event loop) is gone; a pack dropped on the Shader Packs page is copied and picked, as Iris's onFilesDrop. Drops elsewhere do nothing, an existing pack isn't overwritten, links aren't followed. - Docs and the example say what the code does (SSAO, not GTAO). Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 2 +- crates/horizon-client/src/game/options.rs | 3 - crates/horizon-client/src/game/packs.rs | 54 ---- .../horizon-client/src/game/shader_packs.rs | 29 +- .../horizon-client/src/game/startup_menu.rs | 29 +- crates/horizon-client/src/gfx.rs | 28 +- crates/horizon-client/src/gfx/java_stages.rs | 190 +++--------- crates/horizon-client/src/gfx/pack_stages.rs | 111 ++++--- crates/horizon-client/src/gfx/world_post.rs | 37 +-- crates/horizon-client/src/java_pack.rs | 67 +++-- crates/horizon-client/src/options_ui.rs | 221 +++++++++----- crates/horizon-client/src/shader_pack.rs | 281 ++++++++++-------- .../src/shader_pack_prelude.wgsl | 108 +------ .../src/shader_pack_prelude_api2.wgsl | 108 +++++++ crates/horizon-shaderpack/src/options.rs | 18 +- crates/horizon-shaderpack/src/pipeline.rs | 112 +------ crates/horizon-shaderpack/src/translate.rs | 19 +- docs/shader-packs.md | 74 ++++- examples/shaderpacks/horizon-ultra/pack.toml | 15 +- .../horizon-ultra/shaders/bloom_godrays.wgsl | 4 +- .../shaders/deferred_lighting.wgsl | 6 +- 21 files changed, 732 insertions(+), 784 deletions(-) create mode 100644 crates/horizon-client/src/shader_pack_prelude_api2.wgsl diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index c763bd58a..ae7b182b4 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -10728,7 +10728,7 @@ impl ApplicationHandler for Game<'_> { self.pending_save.as_mut().unwrap().quit = true; } WindowEvent::DroppedFile(path) => { - self.import_shader_pack_path(&path); + self.drop_shader_pack(&path); } WindowEvent::Focused(focused) => { self.focused = focused; diff --git a/crates/horizon-client/src/game/options.rs b/crates/horizon-client/src/game/options.rs index c715b4d1a..d422f0218 100644 --- a/crates/horizon-client/src/game/options.rs +++ b/crates/horizon-client/src/game/options.rs @@ -243,9 +243,6 @@ impl Game<'_> { super::packs::open_folder(&dir); } Event::Credits => self.open_win_screen(false, super::win::Finish::Options), - Event::ImportShaderPack => { - self.import_shader_pack_dialog(); - } Event::ReloadShaderPack => { self.load_shader_pack(); } diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs index 13de550e1..94e61d948 100644 --- a/crates/horizon-client/src/game/packs.rs +++ b/crates/horizon-client/src/game/packs.rs @@ -34,60 +34,6 @@ pub fn open_folder(dir: &Path) { log::warn!("Horizon: could not open {}: {e}", dir.display()); } } -/// Open a native file dialog to pick a shader pack `.zip` or folder, falling -/// back to opening `dir` in the system file manager when no dialog helper is present. -pub fn pick_shader_pack(dir: &Path) -> Option { - let _ = std::fs::create_dir_all(dir); - let output = if cfg!(target_os = "windows") { - std::process::Command::new("powershell") - .args([ - "-NoProfile", - "-Command", - "Add-Type -AssemblyName System.Windows.Forms; $f = New-Object System.Windows.Forms.OpenFileDialog; $f.Filter = 'Shader Packs (*.zip;pack.toml)|*.zip;pack.toml|All Files (*.*)|*.*'; if ($f.ShowDialog() -eq 'OK') { Write-Output $f.FileName }", - ]) - .output() - .ok() - } else if cfg!(target_os = "macos") { - std::process::Command::new("osascript") - .args([ - "-e", - "POSIX path of (choose file with prompt \"Select Shader Pack (.zip)\")", - ]) - .output() - .ok() - } else { - std::process::Command::new("zenity") - .args([ - "--file-selection", - "--title=Import Shader Pack (.zip)", - "--file-filter=Shader Packs (*.zip) | *.zip", - ]) - .output() - .ok() - .filter(|o| o.status.success()) - .or_else(|| { - std::process::Command::new("kdialog") - .args(["--getopenfilename", ".", "*.zip|Shader Packs (*.zip)"]) - .output() - .ok() - }) - }; - if let Some(out) = output - && out.status.success() - { - let raw = String::from_utf8_lossy(&out.stdout).trim().to_owned(); - if !raw.is_empty() { - let p = PathBuf::from(raw); - if p.file_name().is_some_and(|n| n == "pack.toml") { - return p.parent().map(Path::to_path_buf); - } - return Some(p); - } - return None; - } - open_folder(dir); - None -} /// The resource root to load from, given the vanilla root and the selection. pub fn startup_root(vanilla: &Path, selected: &[String]) -> std::io::Result { let all = packs::discover(vanilla, &packs_dir()); diff --git a/crates/horizon-client/src/game/shader_packs.rs b/crates/horizon-client/src/game/shader_packs.rs index d7ec206ec..a501543bd 100644 --- a/crates/horizon-client/src/game/shader_packs.rs +++ b/crates/horizon-client/src/game/shader_packs.rs @@ -101,30 +101,19 @@ impl Game<'_> { self.load_shader_pack(); } } - /// Import a shader pack from `source` into `shaderpacks/`, activate it, and reload. - pub(super) fn import_shader_pack_path(&mut self, source: &std::path::Path) { - let dest = dir(); - match shader_pack::import_pack(source, &dest) { - Ok(id) => { - self.ui.options.shader_packs = Default::default(); - self.ui.options.shader_packs.poll(dest); - self.settings.horizon.shader_pack = id; - self.ui.options.shader_pack_config = None; - self.ui.options.sync_shader_pack_config(&self.settings); + /// A file dropped on the window: a shader pack while the Shader Packs + /// page shows (`OptionsUi::drop_shader_pack`). + pub(super) fn drop_shader_pack(&mut self, path: &std::path::Path) { + match self.ui.options.drop_shader_pack(&mut self.settings, path) { + Some(Ok(())) => { self.settings.save(&Self::options_path()); self.load_shader_pack(); } - Err(e) => { - log::warn!("Horizon: shader pack import failed: {e}"); - self.system_message(Text::literal(format!("Shader pack import: {e}"))); + Some(Err(e)) => { + log::warn!("Horizon: shader pack {}: {e}", path.display()); + self.system_message(Text::literal(format!("Shader pack: {e}"))); } - } - } - /// Open the system file picker (or `shaderpacks/` folder) to import a shader pack. - pub(super) fn import_shader_pack_dialog(&mut self) { - let dest = dir(); - if let Some(chosen) = super::packs::pick_shader_pack(&dest) { - self.import_shader_pack_path(&chosen); + None => {} } } fn shader_pack_error(&mut self, id: &str, error: &str) { diff --git a/crates/horizon-client/src/game/startup_menu.rs b/crates/horizon-client/src/game/startup_menu.rs index e01dd6dc6..ebf062a83 100644 --- a/crates/horizon-client/src/game/startup_menu.rs +++ b/crates/horizon-client/src/game/startup_menu.rs @@ -387,19 +387,6 @@ impl Loading { self.menu.win = Some((screen, Instant::now())); } } - Event::ImportShaderPack => { - let dir = horizon_client::shader_pack::folder(); - if let Some(chosen) = packs::pick_shader_pack(&dir) - && let Ok(id) = horizon_client::shader_pack::import_pack(&chosen, &dir) - { - self.menu.options.shader_packs = Default::default(); - self.menu.options.shader_packs.poll(dir); - self.settings.horizon.shader_pack = id; - self.menu.options.shader_pack_config = None; - self.menu.options.sync_shader_pack_config(&self.settings); - self.save_menu_settings(); - } - } Event::ReloadShaderPack => { self.save_menu_settings(); } @@ -469,14 +456,14 @@ impl Loading { self.apply_menu_settings(); } WindowEvent::DroppedFile(path) => { - let dir = horizon_client::shader_pack::folder(); - if let Ok(id) = horizon_client::shader_pack::import_pack(&path, &dir) { - self.menu.options.shader_packs = Default::default(); - self.menu.options.shader_packs.poll(dir); - self.settings.horizon.shader_pack = id; - self.menu.options.shader_pack_config = None; - self.menu.options.sync_shader_pack_config(&self.settings); - self.save_menu_settings(); + match self + .menu + .options + .drop_shader_pack(&mut self.settings, &path) + { + Some(Ok(())) => self.save_menu_settings(), + Some(Err(e)) => log::warn!("Horizon: shader pack {}: {e}", path.display()), + None => {} } } WindowEvent::RedrawRequested => self.draw(), diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 38a3e0521..255f4dd0a 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -3679,14 +3679,16 @@ impl Renderer { } // The world's targets: the screen, or the scaled target of `post`. let pack = self.pack.is_some() && !frame.title; - let shadow_cfg = if pack { - self.pack.as_ref().and_then(|p| match p { - Pack::Horizon(s) if s.needs_shadow => Some((s.shadow_res, s.shadow_dist)), - Pack::Java(s) if s.needs_shadow() => Some(s.shadow_config(frame.shader.dimension)), - _ => None, - }) - } else { - None + // What the pack reads beyond the world's colour and depth: each costs + // a pass (the shadow map, the G-buffer) or a copy (the opaque depth). + let (shadow_cfg, gbuffer, opaque_depth) = match self.pack.as_ref().filter(|_| pack) { + Some(Pack::Horizon(s)) => ( + s.needs_shadow.then_some((s.shadow_res, s.shadow_dist)), + s.needs_gbuffer, + s.needs_opaque_depth, + ), + Some(Pack::Java(s)) => (None, false, s.reads_opaque_depth), + None => (None, false, false), }; if let Some((shadow_res, shadow_dist)) = shadow_cfg { self.world_post @@ -3944,7 +3946,7 @@ impl Renderer { pass.set_vertex_buffer(0, self.debug_line_buffer.slice(..)); pass.draw(0..4, debug_depth..debug_depth + debug_top); } - if pack { + if opaque_depth { drop(pass); self.world_post.capture_opaque_depth(&mut encoder); let attachments = [Some(wgpu::RenderPassColorAttachment { @@ -4042,7 +4044,7 @@ impl Renderer { ); } } - if pack && scaled.is_some() { + if gbuffer && scaled.is_some() { self.world_post.build_gbuffer( &self.queue, &mut encoder, @@ -4617,7 +4619,11 @@ mod tests { ); assert!(files.len() >= 10, "{files:?}"); for path in files { - let text = std::fs::read_to_string(&path).unwrap(); + let mut text = std::fs::read_to_string(&path).unwrap(); + // Api 2's prelude follows api 1's (`shader_pack::ShaderPack::load`). + if path.ends_with("shader_pack_prelude_api2.wgsl") { + text = format!("{}\n{text}", crate::shader_pack::PRELUDE); + } // entity.wgsl comes after the overlay's constants (entity_shader). let module = naga::front::wgsl::parse_str(&text) .or_else(|_| { diff --git a/crates/horizon-client/src/gfx/java_stages.rs b/crates/horizon-client/src/gfx/java_stages.rs index 8091b0703..f86055919 100644 --- a/crates/horizon-client/src/gfx/java_stages.rs +++ b/crates/horizon-client/src/gfx/java_stages.rs @@ -1,16 +1,17 @@ //! A Java (OptiFine/Iris) shader pack on the GPU (docs/shader-packs.md): //! Iris's colour targets (`colortex0..`, each with a main and an alternate -//! side), pre-translucent depth (`depthtex1`/`depthtex2`), directional -//! shadow map (`shadowtex0`/`shadowtex1`) and the pack's `begin`, `prepare`, -//! `deferred`, `composite` and `final` programs as full-screen passes over -//! them, as Iris's `CompositeRenderer` runs them. Horizon's world enters -//! `colortex0` and `depthtex0..2` after `prepare`, where Iris's gbuffers -//! programs would have drawn, and the last picture goes to `world_post`. The +//! side) and the pack's `begin`, `prepare`, `deferred`, `composite` and +//! `final` programs as full-screen passes over them, as Iris's +//! `CompositeRenderer` runs them. Horizon's world enters `colortex0` and +//! `depthtex0` after `prepare`, where Iris's gbuffers programs would have +//! drawn (`depthtex1`/`depthtex2`: its depth before translucent geometry), +//! and the last picture goes to `world_post`. The //! targets keep GL's layout (row 0 at the bottom, which the translated vertex //! programs produce), so the world is flipped going in and the picture coming //! out. -use super::pack_stages::FrameUniform; -use crate::java_pack::{JavaFolder, JavaPasses}; +use super::pack_stages::{FrameUniform, noise, rgba_view}; +use crate::java_pack::{JavaFolder, JavaPasses, NOISE_KEY, texture_key}; +use crate::shader_pack::Rgba; use glam::{Mat3, Mat4, Vec3, Vec4}; use horizon_shaderpack::pipeline::TargetSettings; use horizon_shaderpack::pipeline::{Directives, Program, target_index}; @@ -30,8 +31,6 @@ pub struct JavaFrame { pub moon_angle: f32, } -/// Iris's `noisetex` size (`noiseTextureResolution`'s default). -const NOISE_SIZE: u32 = 256; /// The vertex buffers a pass may read (wgpu's default limit). const MAX_ATTRIBUTES: usize = 8; @@ -173,7 +172,8 @@ enum Source { /// `depthtex1` / `depthtex2`: the opaque world's depth (before translucent water). OpaqueDepth, Noise, - /// `shadowtex*`: directional sun/moon shadow map depth (or far depth for DH/Voxy). + /// `shadowtex*`: no shadow map yet, so a far depth (nothing in shadow); + /// also Distant Horizons' and Voxy's depth, as without those mods. Shadow, /// Anything else (`shadowcolor*`, custom textures): white or black. Blank(bool), @@ -267,11 +267,13 @@ struct Folder { passes: Vec, final_pass: Option, directives: Directives, - shadow_enabled: bool, } pub struct JavaStages { pub id: String, + /// A pass samples `depthtex1`/`depthtex2`: the world's depth is kept + /// before translucent geometry draws. + pub reads_opaque_depth: bool, format: wgpu::TextureFormat, common: Common, folders: Vec, @@ -285,25 +287,12 @@ pub struct JavaStages { uniform_state: UniformState, /// `eyeBrightnessSmooth`, block then sky. eye_smooth: [SmoothFloat; 2], - /// `wetness`, smoothed with `wetnessHalflife` / `drynessHalflife`. + /// `wetness`: `rainStrength` smoothed with `wetnessHalflife` going up + /// and `drynessHalflife` going down. wetness_smooth: SmoothFloat, - /// `centerDepthSmooth`, smoothed with `centerDepthHalflife`. - center_depth_smooth: SmoothFloat, } impl JavaStages { - /// Whether any dimension folder in this pack reads directional shadow maps. - pub fn needs_shadow(&self) -> bool { - self.folders.iter().any(|f| f.shadow_enabled) - } - - /// Shadow map resolution and distance for `dimension`. - pub fn shadow_config(&self, dimension: i8) -> (u32, f32) { - let idx = self.folder_for[(dimension.clamp(-1, 1) + 1) as usize].unwrap_or(0); - let d = &self.folders[idx].directives; - (d.shadow_map_resolution, d.shadow_distance) - } - /// The pipelines of a loaded Java pack, or wgpu's error. pub fn new( device: &wgpu::Device, @@ -342,15 +331,20 @@ impl JavaStages { passes, final_pass, directives: plan.directives, - shadow_enabled: plan.shadow_enabled, }) }) .collect::, _>>()?; if let Some(error) = pollster::block_on(scope.pop()) { return Err(error.to_string()); } + let reads_opaque_depth = folders + .iter() + .flat_map(|f| f.passes.iter().chain(&f.final_pass)) + .flat_map(|p| &p.samplers) + .any(|s| s.source == Source::OpaqueDepth); Ok(Self { id: id.to_owned(), + reads_opaque_depth, format, common, folders, @@ -364,7 +358,6 @@ impl JavaStages { uniform_state: UniformState::default(), eye_smooth: [SmoothFloat::default(); 2], wetness_smooth: SmoothFloat::default(), - center_depth_smooth: SmoothFloat::default(), }) } @@ -405,10 +398,6 @@ impl JavaStages { self.previous, ); inputs.set_world(&world, directives.sun_path_rotation); - inputs.shadow_view = post.shadow_view; - inputs.shadow_projection = post.gl_shadow_projection(); - inputs.ambient_occlusion_level = directives.ambient_occlusion_level; - inputs.shadow_map_resolution = directives.shadow_map_resolution as f32; let half_life = directives.eye_brightness_half_life; for (i, smooth) in self.eye_smooth.iter_mut().enumerate() { inputs.eye_smooth[i] = smooth.update(inputs.eye[i], half_life, half_life, frame_time); @@ -419,12 +408,6 @@ impl JavaStages { directives.dryness_half_life, frame_time, ); - inputs.center_depth_smooth = self.center_depth_smooth.update( - 0.5, - directives.center_depth_half_life, - directives.center_depth_half_life, - frame_time, - ); self.uniforms .update(&mut self.uniform_state, frame_time, &|name| { inputs.builtin(name) @@ -599,7 +582,6 @@ impl JavaStages { &targets, &depth, &opaque_depth, - post, &self.common, &mut blank, ) @@ -780,11 +762,8 @@ fn blit_pipeline( } impl Common { - fn new( - device: &wgpu::Device, - queue: &wgpu::Queue, - custom_map: &BTreeMap)>, - ) -> Self { + /// `custom` holds the pack's `texture.*` images (`JavaPasses::custom_textures`). + fn new(device: &wgpu::Device, queue: &wgpu::Queue, custom: &BTreeMap) -> Self { let sampler = |filter, address, compare| { device.create_sampler(&wgpu::SamplerDescriptor { label: Some("Java shader pack"), @@ -798,68 +777,15 @@ impl Common { }) }; use wgpu::{AddressMode::*, FilterMode::*}; - // Iris's noise: random RGB, opaque. - let mut seed = 0x2545_f491_u32; - let noise_bytes: Vec = (0..NOISE_SIZE * NOISE_SIZE * 4) - .map(|i| { - seed ^= seed << 13; - seed ^= seed >> 17; - seed ^= seed << 5; - if i % 4 == 3 { 255 } else { (seed >> 24) as u8 } - }) + let noise = match custom.get(NOISE_KEY) { + Some(image) => rgba_view(device, queue, "noisetex", image), + None => rgba_view(device, queue, "noisetex", &noise()), + }; + let custom_textures = custom + .iter() + .filter(|(key, _)| *key != NOISE_KEY) + .map(|(key, image)| (key.clone(), rgba_view(device, queue, key, image))) .collect(); - let noise = device.create_texture(&wgpu::TextureDescriptor { - label: Some("noisetex"), - size: wgpu::Extent3d { - width: NOISE_SIZE, - height: NOISE_SIZE, - depth_or_array_layers: 1, - }, - mip_level_count: 1, - sample_count: 1, - dimension: wgpu::TextureDimension::D2, - format: wgpu::TextureFormat::Rgba8Unorm, - usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, - view_formats: &[], - }); - queue.write_texture( - noise.as_image_copy(), - &noise_bytes, - wgpu::TexelCopyBufferLayout { - offset: 0, - bytes_per_row: Some(NOISE_SIZE * 4), - rows_per_image: None, - }, - noise.size(), - ); - let mut custom_textures = BTreeMap::new(); - for (name, (w, h, bytes)) in custom_map { - let tex = device.create_texture(&wgpu::TextureDescriptor { - label: Some(name), - size: wgpu::Extent3d { - width: *w, - height: *h, - depth_or_array_layers: 1, - }, - mip_level_count: 1, - sample_count: 1, - dimension: wgpu::TextureDimension::D2, - format: wgpu::TextureFormat::Rgba8Unorm, - usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, - view_formats: &[], - }); - queue.write_texture( - tex.as_image_copy(), - bytes, - wgpu::TexelCopyBufferLayout { - offset: 0, - bytes_per_row: Some(*w * 4), - rows_per_image: None, - }, - tex.size(), - ); - custom_textures.insert(name.clone(), tex.create_view(&Default::default())); - } // The full-screen triangle (0, 0), (2, 0), (0, 2): the pack's // projection maps 0..1 to the screen. Texture coordinates are the // position; colours white; normals up. @@ -899,7 +825,7 @@ impl Common { nearest: sampler(Nearest, ClampToEdge, None), repeat: sampler(Linear, Repeat, None), compare: sampler(Linear, ClampToEdge, Some(wgpu::CompareFunction::LessEqual)), - noise: noise.create_view(&Default::default()), + noise, custom_textures, vertices, world_layout: device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { @@ -1239,21 +1165,22 @@ impl PassGpu { targets: &BTreeMap, depth: &wgpu::TextureView, opaque_depth: &wgpu::TextureView, - post: &super::world_post::Post, common: &Common, blank: &mut Vec, ) -> wgpu::BindGroup { let mut views = Vec::new(); for s in &self.samplers { - let view = if let Some(custom) = common - .custom_textures - .get(&s.name) - .filter(|_| !s.compare && s.dimension == wgpu::TextureViewDimension::D2) - { + let custom = (!s.compare && s.dimension == wgpu::TextureViewDimension::D2) + .then(|| { + common + .custom_textures + .get(&texture_key(&self.program, &s.name)) + }) + .flatten(); + let view = if let Some(custom) = custom { custom.clone() } else { match (s.compare, s.source) { - (true, Source::Shadow) if post.shadow_active => post.shadow_depth().clone(), (true, _) => blank_view(device, queue, blank, s, BlankKind::FarDepth), (false, Source::Target(i)) if s.dimension == wgpu::TextureViewDimension::D2 => { match targets.get(&i) { @@ -1612,8 +1539,6 @@ struct Inputs { view: Mat4, /// GL's: near at -1, far at 1. projection: Mat4, - shadow_view: Mat4, - shadow_projection: Mat4, camera: Vec3, previous: (Mat4, Mat4, Vec3), size: [f32; 2], @@ -1624,10 +1549,8 @@ struct Inputs { /// `eyeBrightness` and `eyeBrightnessSmooth`: block, sky light × 16. eye: [f32; 2], eye_smooth: [f32; 2], + /// `wetness` (`JavaStages::wetness_smooth`). wetness: f32, - center_depth_smooth: f32, - ambient_occlusion_level: f32, - shadow_map_resolution: f32, /// `CelestialUniforms`, in view space. sun_position: Vec3, moon_position: Vec3, @@ -1676,8 +1599,6 @@ impl Inputs { let mut out = Self { view, projection, - shadow_view: Mat4::IDENTITY, - shadow_projection: Mat4::IDENTITY, camera, previous: previous.unwrap_or((view, projection, camera)), size: size.map(|v| v as f32), @@ -1688,9 +1609,6 @@ impl Inputs { eye: [0.0; 2], eye_smooth: [0.0; 2], wetness: frame.weather[0], - center_depth_smooth: 0.5, - ambient_occlusion_level: 1.0, - shadow_map_resolution: 2048.0, sun_position: Vec3::ZERO, moon_position: Vec3::ZERO, up_position: Vec3::ZERO, @@ -1790,35 +1708,21 @@ impl Inputs { "skyColor" => f.sky_color[..3].to_vec(), "isEyeInWater" => vec![f.camera_state[0]], "nightVision" => vec![f.camera_state[1]], - "darknessFactor" | "darknessLightFactor" => vec![f.camera_state[2]], - "blindness" => vec![f.camera_state[3]], + "darknessFactor" => vec![f.camera_state[2]], "screenBrightness" => vec![1.0], - "centerDepthSmooth" => vec![self.center_depth_smooth], - "ambientOcclusionLevel" => vec![self.ambient_occlusion_level], - "shadowMapResolution" => vec![self.shadow_map_resolution], "eyeBrightness" => self.eye.to_vec(), // An ivec2: the smoothed value truncated. "eyeBrightnessSmooth" => self.eye_smooth.map(f32::trunc).to_vec(), "hasSkylight" => vec![f.dimension[1]], - "heldItemId" | "heldItemId2" | "heldBlockLightValue" | "heldBlockLightValue2" => { - vec![0.0] - } - "biome" | "biome_category" => vec![0.0], - "biome_precipitation" => vec![if f.weather[0] > 0.01 { 1.0 } else { 0.0 }], - "temp" => vec![0.8], - "rainfall" => vec![0.4], - "alphaTestRef" => vec![0.1], - "renderStage" => vec![0.0], - "playerMood" | "currentColorSpace" => vec![0.0], "iris_ModelViewMatrix" | "iris_ModelViewMatrixInverse" => mat(Mat4::IDENTITY), "iris_ProjectionMatrix" | "iris_ModelViewProjectionMatrix" => mat(screen), "iris_ProjectionMatrixInverse" => mat(screen.inverse()), "iris_TextureMatrix" => (0..8).flat_map(|_| mat(Mat4::IDENTITY)).collect(), "iris_NormalMatrix" => Mat3::IDENTITY.to_cols_array().to_vec(), - "shadowModelView" => mat(self.shadow_view), - "shadowModelViewInverse" => mat(self.shadow_view.inverse()), - "shadowProjection" => mat(self.shadow_projection), - "shadowProjectionInverse" => mat(self.shadow_projection.inverse()), + "shadowModelView" + | "shadowModelViewInverse" + | "shadowProjection" + | "shadowProjectionInverse" => mat(Mat4::IDENTITY), _ => return None, }) } diff --git a/crates/horizon-client/src/gfx/pack_stages.rs b/crates/horizon-client/src/gfx/pack_stages.rs index 08a6b9aea..f80a64ce1 100644 --- a/crates/horizon-client/src/gfx/pack_stages.rs +++ b/crates/horizon-client/src/gfx/pack_stages.rs @@ -5,7 +5,7 @@ //! and writes its own target; the last target goes to the screen through //! `world_post` (copy or FXAA) under the hand and HUD. Only exists while a //! pack is selected. -use crate::shader_pack::{ShaderPack, StageKind, VERTEX_ENTRY}; +use crate::shader_pack::{Rgba, ShaderPack, VERTEX_ENTRY}; use horizon_shaderpack::uniforms::SmoothFloat; /// The `Frame` uniform of the prelude (`shader_pack_prelude.wgsl`). @@ -45,7 +45,59 @@ pub struct FrameExtUniform { pub environment: [f32; 4], } -const NOISE_SIZE: u32 = 256; +/// Iris's `noisetex` without a `texture.noise`: 256² random RGB, opaque. +/// Horizon packs get the same one unless `[textures] noise` replaces it. +pub(super) fn noise() -> Rgba { + const SIZE: u32 = 256; + let mut seed = 0x2545_f491_u32; + let pixels = (0..SIZE * SIZE * 4) + .map(|i| { + seed ^= seed << 13; + seed ^= seed >> 17; + seed ^= seed << 5; + if i % 4 == 3 { 255 } else { (seed >> 24) as u8 } + }) + .collect(); + Rgba { + width: SIZE, + height: SIZE, + pixels, + } +} + +/// `image` as a sampled RGBA8 texture. +pub(super) fn rgba_view( + device: &wgpu::Device, + queue: &wgpu::Queue, + label: &str, + image: &Rgba, +) -> wgpu::TextureView { + let texture = device.create_texture(&wgpu::TextureDescriptor { + label: Some(label), + size: wgpu::Extent3d { + width: image.width, + height: image.height, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, + view_formats: &[], + }); + queue.write_texture( + texture.as_image_copy(), + &image.pixels, + wgpu::TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(image.width * 4), + rows_per_image: None, + }, + texture.size(), + ); + texture.create_view(&Default::default()) +} struct Pass { pipeline: wgpu::RenderPipeline, @@ -64,6 +116,10 @@ struct Target { pub struct PackStages { pub id: String, pub needs_shadow: bool, + /// The stages read the G-buffer (`build_gbuffer`) or the depth before + /// translucent geometry (`capture_opaque_depth`). + pub needs_gbuffer: bool, + pub needs_opaque_depth: bool, pub shadow_res: u32, pub shadow_dist: f32, layout: wgpu::BindGroupLayout, @@ -162,7 +218,7 @@ impl PackStages { .iter() .enumerate() .map(|(idx, stage)| { - let is_last = idx + 1 == stage_count || stage.kind == StageKind::Final; + let is_last = idx + 1 == stage_count; let target_format = if is_last { format } else { @@ -240,49 +296,16 @@ impl PackStages { ..Default::default() }) }; - let (nw, nh, noise_bytes) = match &pack.custom_noise { - Some((w, h, bytes)) => (*w, *h, bytes.clone()), - None => { - let mut seed = 0x2545_f491_u32; - let bytes: Vec = (0..NOISE_SIZE * NOISE_SIZE * 4) - .map(|i| { - seed ^= seed << 13; - seed ^= seed >> 17; - seed ^= seed << 5; - if i % 4 == 3 { 255 } else { (seed >> 24) as u8 } - }) - .collect(); - (NOISE_SIZE, NOISE_SIZE, bytes) - } + let noise_view = match &pack.custom_noise { + Some(image) => rgba_view(device, queue, "Shader pack noise", image), + None => rgba_view(device, queue, "Shader pack noise", &noise()), }; - let noise_tex = device.create_texture(&wgpu::TextureDescriptor { - label: Some("Shader pack noise"), - size: wgpu::Extent3d { - width: nw, - height: nh, - depth_or_array_layers: 1, - }, - mip_level_count: 1, - sample_count: 1, - dimension: wgpu::TextureDimension::D2, - format: wgpu::TextureFormat::Rgba8Unorm, - usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, - view_formats: &[], - }); - queue.write_texture( - noise_tex.as_image_copy(), - &noise_bytes, - wgpu::TexelCopyBufferLayout { - offset: 0, - bytes_per_row: Some(nw * 4), - rows_per_image: None, - }, - noise_tex.size(), - ); - let (shadow_res, shadow_dist, _) = pack.shadow_config(0); + let (shadow_res, shadow_dist) = pack.shadow_config(); Ok(Self { id: pack.id.clone(), needs_shadow: pack.needs_shadow(), + needs_gbuffer: pack.needs_gbuffer(), + needs_opaque_depth: pack.needs_opaque_depth(), shadow_res, shadow_dist, layout, @@ -302,7 +325,7 @@ impl PackStages { wgpu::AddressMode::ClampToEdge, Some(wgpu::CompareFunction::GreaterEqual), ), - noise_view: noise_tex.create_view(&Default::default()), + noise_view, passes, targets: Vec::new(), output: None, @@ -462,7 +485,7 @@ impl PackStages { f32::from(eye_light[0]) * 16.0, f32::from(eye_light[1]) * 16.0, wet, - uniform.view_params[2] * 0.5, + 0.0, ], }; uniform.time[0] = self.started.elapsed().as_secs_f32(); diff --git a/crates/horizon-client/src/gfx/world_post.rs b/crates/horizon-client/src/gfx/world_post.rs index 69d95aae6..f592e8a1f 100644 --- a/crates/horizon-client/src/gfx/world_post.rs +++ b/crates/horizon-client/src/gfx/world_post.rs @@ -1,19 +1,19 @@ //! Resolution scale, FXAA, and shader-pack G-buffer/shadow targets (Horizon //! settings): the world renders into its own target at the scaled size, then //! one full-screen pass copies or anti-aliases it onto the screen, under the -//! hand and HUD. When a shader pack is active, `Post` also maintains: -//! - `opaque_depth` (`depthtex1`/`depthtex2`): depth captured before -//! translucent terrain (water, stained glass, ice) renders; -//! - `normal` (`colortex1`/`scene_normal`) and `material` -//! (`colortex2`/`scene_material`): G-buffer surface normals and material -//! properties reconstructed from depth and scene colour; -//! - `shadow_depth` (`shadowtex0`/`shadowtex1`): the directional sun/moon -//! shadow map and its light-space `shadow_view` and `shadow_proj` matrices. +//! hand and HUD. For a shader pack that reads them, `Post` also keeps: +//! - `opaque_depth`: the depth before translucent terrain (water, stained +//! glass, ice) draws, a Java pack's `depthtex1`/`depthtex2`; +//! - `normal` and `material`, an api 2 pack's `scene_normal` and +//! `scene_material`: surface normals and material properties +//! reconstructed from depth and scene colour; +//! - `shadow_depth`, an api 2 pack's: the sun/moon shadow map and its +//! light-space `shadow_view` and `shadow_proj` matrices. //! //! With none of them on, the world renders straight to the screen as before. use super::pack_stages::FrameUniform; -use glam::{Mat4, Vec3, Vec4}; +use glam::{Mat4, Vec3}; const GBUFFER_WGSL: &str = r#" struct GbufferParams { @@ -632,45 +632,34 @@ impl Post { self.target.as_ref().map(|t| t.size) } - /// Pre-translucent depth view (`depthtex1`/`depthtex2` / `opaque_depth`). + /// The depth before translucent geometry (`capture_opaque_depth`). pub fn opaque_depth(&self) -> &wgpu::TextureView { self.target .as_ref() .map_or(&self.fallback_shadow, |t| &t.opaque_depth) } - /// Reconstructed world-space normal G-buffer view (`colortex1` / `scene_normal`). + /// Reconstructed world-space normals (`scene_normal`). pub fn normal(&self) -> &wgpu::TextureView { self.target .as_ref() .map_or(&self.fallback_color, |t| &t.normal) } - /// Reconstructed material/lightmap G-buffer view (`colortex2` / `scene_material`). + /// Reconstructed material and light (`scene_material`). pub fn material(&self) -> &wgpu::TextureView { self.target .as_ref() .map_or(&self.fallback_color, |t| &t.material) } - /// Directional sun/moon shadow map view (`shadowtex0`/`shadowtex1` / `shadow_depth`). + /// The sun/moon shadow map (`shadow_depth` of api 2 packs). pub fn shadow_depth(&self) -> &wgpu::TextureView { self.shadow .as_ref() .map_or(&self.fallback_shadow, |s| &s.depth) } - /// OpenGL-convention (-1..1 Z) shadow projection for Java/Iris shader packs. - pub fn gl_shadow_projection(&self) -> Mat4 { - let to_gl = Mat4::from_cols( - Vec4::X, - Vec4::Y, - Vec4::new(0.0, 0.0, -2.0, 0.0), - Vec4::new(0.0, 0.0, 1.0, 1.0), - ); - to_gl * self.shadow_proj - } - /// Bindings that copy (or anti-alias) `view` onto the screen in `finish_with`. pub fn bind(&self, device: &wgpu::Device, view: &wgpu::TextureView) -> wgpu::BindGroup { device.create_bind_group(&wgpu::BindGroupDescriptor { diff --git a/crates/horizon-client/src/java_pack.rs b/crates/horizon-client/src/java_pack.rs index 5a37aa223..5e592d1b6 100644 --- a/crates/horizon-client/src/java_pack.rs +++ b/crates/horizon-client/src/java_pack.rs @@ -1,9 +1,9 @@ //! Java (OptiFine/Iris) shader packs in `shaderpacks/` (docs/shader-packs.md): //! a folder holding `shaders/`, or a `.zip`. `horizon-shaderpack` translates //! their full-screen programs (`begin`, `prepare`, `deferred`, `composite`, -//! `final`) to WGSL, and `gfx/java_stages.rs` runs them over Horizon's world, -//! G-buffers, pre-translucent depth (`depthtex1`) and directional shadow map -//! (`shadowtex0`/`shadowtex1`) as Iris runs them over its own. +//! `final`) to WGSL, and `gfx/java_stages.rs` runs them over Horizon's world +//! as Iris runs them over its own. Geometry programs (`gbuffers_*`, +//! `shadow`) don't run yet: the world is drawn by Horizon. use horizon_shaderpack::{ JavaPack, pipeline::{Directives, Program, TargetSettings}, @@ -30,10 +30,24 @@ pub struct JavaFolder { pub final_pass: Option, /// The targets whose alternate side holds the frame's last write. pub flipped_at_end: BTreeSet, - /// `sunPathRotation`, `eyeBrightnessHalflife`, shadow and wetness directives. + /// `sunPathRotation`, `eyeBrightnessHalflife`, `wetnessHalflife` and + /// `drynessHalflife`. pub directives: Directives, - /// Whether this dimension's passes read directional shadow maps. - pub shadow_enabled: bool, +} + +/// The key of `texture.noise` (`noisetex`) in [`JavaPasses::custom_textures`]. +pub const NOISE_KEY: &str = "noise"; + +/// The key of `texture..` in [`JavaPasses::custom_textures`] +/// for a pass of `program` (`world0/composite2`): Iris's texture stages, where +/// `final` reads the `composite` ones. +pub fn texture_key(program: &str, sampler: &str) -> String { + let name = program.rsplit('/').next().unwrap_or(program); + let stage = match name.trim_end_matches(|c: char| c.is_ascii_digit()) { + "final" => "composite", + stage => stage, + }; + format!("{stage}.{sampler}") } /// A loaded Java pack. @@ -43,8 +57,9 @@ pub struct JavaPasses { pub uniforms: CustomUniforms, /// What the pack keeps of the vanilla sky (`clouds`, `sun`, `moon`). pub sky: SkyDirectives, - /// Decoded RGBA8 custom textures (`sampler_name` → `(width, height, rgba)`). - pub custom_textures: BTreeMap)>, + /// `texture..` and `texture.noise` images, by + /// `"."` and [`NOISE_KEY`]. + pub custom_textures: BTreeMap, } impl JavaPasses { @@ -135,7 +150,6 @@ pub fn load( final_pass, flipped_at_end: plan.flipped_at_end, directives: plan.directives, - shadow_enabled: plan.shadow_enabled, }); } if folders.is_empty() { @@ -143,15 +157,23 @@ pub fn load( } let mut custom_textures = BTreeMap::new(); for tex in properties.custom_textures() { - if let Some(bytes) = pack.files.read_bytes(&tex.path) { - match crate::shader_pack::decode_png_rgba(&bytes) { - Ok(decoded) => { - custom_textures.insert(tex.sampler, decoded); - } - Err(e) => { - log::warn!("Horizon: shader pack texture {}: {e}", tex.path); - } + let key = match tex.stage { + Some(stage) => format!("{stage}.{}", tex.sampler), + None if tex.sampler == NOISE_KEY => NOISE_KEY.to_owned(), + None => continue, + }; + // Only PNGs for now: resource locations and raw `.dat` textures are + // skipped and the sampler reads what it would without them. + let image = pack + .files + .read_bytes(&tex.path) + .ok_or_else(|| "not in the pack".to_owned()) + .and_then(|bytes| crate::shader_pack::decode_png(&bytes)); + match image { + Ok(image) => { + custom_textures.insert(key, image); } + Err(e) => log::warn!("Horizon: shader pack texture {}: {e}", tex.path), } } let uniforms = properties.custom_uniforms(); @@ -170,6 +192,17 @@ pub fn load( mod tests { use super::*; + #[test] + fn custom_textures_belong_to_iris_s_stages() { + assert_eq!(texture_key("world0/composite2", "gaux1"), "composite.gaux1"); + assert_eq!(texture_key("final", "colortex4"), "composite.colortex4"); + assert_eq!( + texture_key("world-1/deferred10", "noisetex"), + "deferred.noisetex" + ); + assert_eq!(texture_key("prepare", "depthtex2"), "prepare.depthtex2"); + } + #[test] fn loads_the_full_screen_passes_of_a_java_pack() { let dir = Path::new(env!("CARGO_MANIFEST_DIR")) diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 4ae78da40..1bb9953bf 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -10,6 +10,7 @@ use crate::{ keybinds::{self, CATEGORIES, KeyBinds, MAPPINGS}, lang::{self, LanguageInfo}, settings::{SOUND_SOURCES, Settings}, + shader_pack::PackConfig, text::{self, Style, Text}, ui, }; @@ -903,8 +904,6 @@ enum Act { /// Credits & Attribution's Credits button (WinScreen without the poem). Credits, CopyAgentDetails, - /// Pick and import a shader pack `.zip` or folder into `shaderpacks/`. - ImportShaderPack, ShaderPackProfile, ShaderPackSubscreen(String), ShaderPackBackScreen, @@ -968,9 +967,8 @@ pub enum Event { Credits, /// Copy how an agent connects (the AI Agent page). CopyAgentDetails, - /// Pick and import a shader pack `.zip` or folder into `shaderpacks/`. - ImportShaderPack, - /// Reload the active shader pack after its options file changed. + /// The shader pack settings page closed with changes: they are saved, + /// the pack is built again with them. ReloadShaderPack, } /// `SliderableValueSet.applyValueImmediately`: these apply 600 ms after @@ -1030,11 +1028,12 @@ pub struct OptionsUi { /// The AI Agent page's status lines (set by the game while it shows). pub agent_status: Vec, /// Loaded interactive configuration for the currently selected shader pack. - pub shader_pack_config: Option, - /// Classic shader option slider currently being dragged. + pub shader_pack_config: Option, + /// The shader pack option slider being dragged. pub(crate) dragging_shader_option: Option, - /// Horizon shader option slider currently being dragged. - pub(crate) hdragging_shader_option: Option, + /// `shader_pack_config` changed since the settings page opened: leaving + /// it saves the values and reloads the pack. + shader_pack_edited: bool, } impl Default for OptionsUi { fn default() -> Self { @@ -1068,7 +1067,7 @@ impl Default for OptionsUi { agent_status: Vec::new(), shader_pack_config: None, dragging_shader_option: None, - hdragging_shader_option: None, + shader_pack_edited: false, } } } @@ -1225,22 +1224,58 @@ impl OptionsUi { { return; } - let dir = if self.shader_packs.dir.as_os_str().is_empty() { + // A pack whose options can't be read has none, rather than being + // read again every frame. + let config = PackConfig::load(&self.shader_pack_dir(), id).unwrap_or_else(|e| { + log::warn!("Horizon: shader pack {id} options: {e}"); + PackConfig { + id: id.to_owned(), + ..Default::default() + } + }); + self.shader_pack_config = Some(config); + self.shader_pack_edited = false; + } + fn shader_pack_dir(&self) -> std::path::PathBuf { + if self.shader_packs.dir.as_os_str().is_empty() { crate::shader_pack::folder() } else { self.shader_packs.dir.clone() - }; - self.shader_pack_config = crate::shader_pack::PackConfig::load(&dir, id).ok(); + } + } + /// A file or folder dropped on the window: on the Shader Packs page (as + /// Iris's `ShaderPackScreen.onFilesDrop`), a pack copied into + /// `shaderpacks/` and picked. `None` elsewhere; the caller saves the + /// settings and loads the pack on `Some(Ok)`. + pub fn drop_shader_pack( + &mut self, + s: &mut Settings, + path: &std::path::Path, + ) -> Option> { + if self.page() != Page::ShaderPacks { + return None; + } + let dir = self.shader_pack_dir(); + Some(crate::shader_pack::import_pack(path, &dir).map(|id| { + self.shader_packs = Default::default(); + self.shader_packs.poll(dir); + s.horizon.shader_pack = id; + self.sync_shader_pack_config(s); + })) + } + /// Change the shader pack's options, applied when its page closes. + fn edit_shader_pack(&mut self, edit: impl FnOnce(&mut PackConfig)) { + if let Some(cfg) = &mut self.shader_pack_config { + edit(cfg); + self.shader_pack_edited = true; + } } /// Save the active shader pack options to `shaderpacks/.txt`. - pub(crate) fn save_shader_pack_config(&self) { - if let Some(cfg) = &self.shader_pack_config { - let dir = if self.shader_packs.dir.as_os_str().is_empty() { - crate::shader_pack::folder() - } else { - self.shader_packs.dir.clone() - }; - let _ = cfg.save(&dir); + fn save_shader_pack_config(&self) { + if let Some(cfg) = &self.shader_pack_config + && let Err(e) = cfg.save(&self.shader_pack_dir()) + { + log::warn!("Horizon: shader pack {} options: {e}", cfg.id); } } pub(crate) fn shader_pack_failed(&self, id: &str) -> bool { @@ -1658,27 +1693,10 @@ impl OptionsUi { button( 0.0, 0.0, - 150.0, + 310.0, Text::literal("Shader Pack Settings..."), Act::Push(Page::ShaderPackOptions), ), - Some(button( - 0.0, - 0.0, - 150.0, - Text::literal("Import Shader Pack..."), - Act::ImportShaderPack, - )), - )); - } else { - rows.push(Row::Buttons( - button( - 0.0, - 0.0, - 310.0, - Text::literal("Import Shader Pack..."), - Act::ImportShaderPack, - ), None, )); } @@ -2725,14 +2743,12 @@ impl OptionsUi { }) { let v = ui::slider_value(wd.x, wd.w, x); - if let Some(cfg) = &mut self.shader_pack_config - && let Some(opt) = cfg.options.get_mut(idx) - { - opt.set_slider_pos(v); - } - self.save_shader_pack_config(); + self.edit_shader_pack(|cfg| { + if let Some(opt) = cfg.options.get_mut(idx) { + opt.set_slider_pos(v); + } + }); events.push(Event::Changed); - events.push(Event::ReloadShaderPack); } return events; } @@ -2821,14 +2837,9 @@ impl OptionsUi { Act::OpenShaderPackFolder => events.push(Event::OpenShaderPackFolder), Act::Credits => events.push(Event::Credits), Act::CopyAgentDetails => events.push(Event::CopyAgentDetails), - Act::ImportShaderPack => events.push(Event::ImportShaderPack), Act::ShaderPackProfile => { - if let Some(cfg) = &mut self.shader_pack_config { - cfg.cycle_profile(right); - } - self.save_shader_pack_config(); + self.edit_shader_pack(|cfg| cfg.cycle_profile(false)); events.push(Event::Changed); - events.push(Event::ReloadShaderPack); } Act::ShaderPackSubscreen(sub) => { if let Some(cfg) = &mut self.shader_pack_config { @@ -2843,22 +2854,16 @@ impl OptionsUi { self.scroll = 0.0; } Act::ShaderPackOption(i) => { - if let Some(cfg) = &mut self.shader_pack_config - && let Some(opt) = cfg.options.get_mut(i) - { - opt.cycle(right); - } - self.save_shader_pack_config(); + self.edit_shader_pack(|cfg| { + if let Some(opt) = cfg.options.get_mut(i) { + opt.cycle(false); + } + }); events.push(Event::Changed); - events.push(Event::ReloadShaderPack); } Act::ResetShaderPackOptions => { - if let Some(cfg) = &mut self.shader_pack_config { - cfg.reset_all(); - } - self.save_shader_pack_config(); + self.edit_shader_pack(PackConfig::reset_all); events.push(Event::Changed); - events.push(Event::ReloadShaderPack); } Act::None => {} } @@ -2873,14 +2878,12 @@ impl OptionsUi { WKind::ShaderOptionSlider { index, .. } => { self.dragging_shader_option = Some(index); let v = ui::slider_value(wd.x, wd.w, x); - if let Some(cfg) = &mut self.shader_pack_config - && let Some(opt) = cfg.options.get_mut(index) - { - opt.set_slider_pos(v); - } - self.save_shader_pack_config(); + self.edit_shader_pack(|cfg| { + if let Some(opt) = cfg.options.get_mut(index) { + opt.set_slider_pos(v); + } + }); events.push(Event::Changed); - events.push(Event::ReloadShaderPack); } WKind::LanguageRow { code, .. } => { if self.language_choice.as_deref() == Some(code.as_str()) { @@ -2910,9 +2913,7 @@ impl OptionsUi { } // AbstractSliderButton suppresses the press sound and plays once on // release, even if the pointer has left the widget or its value stayed. - let slider = self.dragging.take().is_some() - || self.dragging_shader_option.take().is_some() - || self.hdragging_shader_option.take().is_some(); + let slider = self.dragging.take().is_some() || self.dragging_shader_option.take().is_some(); let graphics_slider = self.graphics.release(); if slider || graphics_slider { vec![Event::ButtonClick] @@ -2992,6 +2993,12 @@ impl OptionsUi { events.push(Event::Language(code)); } } + // Iris's ShaderPackScreen applies its edits on Done, so the + // pack is rebuilt once, not on every click or slider step. + Page::ShaderPackOptions if std::mem::take(&mut self.shader_pack_edited) => { + self.save_shader_pack_config(); + events.push(Event::ReloadShaderPack); + } Page::Packs => { // PackSelectionScreen.onClose: PackSelectionModel.commit. if let Some(p) = self.pack_screen.take() @@ -3416,19 +3423,73 @@ mod tests { false, ); assert_eq!(s.horizon.shader_pack, "", "a second click turns it off"); - let import_btn = find(&mut ui, &s, &|a| *a == Act::ImportShaderPack).unwrap(); + let _ = std::fs::remove_dir_all(&dir); + } + + #[test] + fn a_dropped_pack_is_picked_and_its_settings_apply_on_done() { + let atlas = atlas(); + let mut s = Settings::default(); + let mut ui = OptionsUi::default(); + let size = (480.0, 240.0); + let dir = + std::env::temp_dir().join(format!("horizon-shaderpack-drop-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).unwrap(); + ui.shader_packs.poll(dir.clone()); + let sample = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../examples/shaderpacks/horizon-sample"); assert_eq!( + ui.drop_shader_pack(&mut s, &sample), + None, + "only on its page" + ); + ui.show(Page::ShaderPacks); + assert_eq!(ui.drop_shader_pack(&mut s, &sample), Some(Ok(()))); + assert_eq!(s.horizon.shader_pack, "horizon-sample"); + assert!(dir.join("horizon-sample/pack.toml").is_file()); + let again = ui.drop_shader_pack(&mut s, &sample).unwrap().unwrap_err(); + assert!(again.contains("already"), "{again}"); + + let click = |ui: &mut OptionsUi, s: &mut Settings, act: &dyn Fn(&Act) -> bool| { + let w = ui + .layout(s, size.0, size.1) + .0 + .into_iter() + .find(|w| matches!(&w.kind, WKind::Button { act: a, active: true, .. } if act(a))) + .unwrap(); ui.click( - &mut s, + s, &atlas, - import_btn.x + 1.0, - import_btn.y + 1.0, + w.x + 1.0, + w.y + 1.0, size, [480, 240], false, false, - ), - vec![Event::ButtonClick, Event::ImportShaderPack] + ) + }; + click(&mut ui, &mut s, &|a| { + *a == Act::Push(Page::ShaderPackOptions) + }); + assert_eq!(ui.page(), Page::ShaderPackOptions); + for _ in 0..3 { + let events = click(&mut ui, &mut s, &|a| matches!(a, Act::ShaderPackOption(_))); + assert!(!events.contains(&Event::ReloadShaderPack), "{events:?}"); + } + let txt = dir.join("horizon-sample.txt"); + assert!(!txt.exists(), "nothing is saved before Done"); + let events = click(&mut ui, &mut s, &|a| *a == Act::Done); + assert!(events.contains(&Event::ReloadShaderPack), "{events:?}"); + assert_eq!(ui.page(), Page::ShaderPacks); + assert!(txt.is_file(), "Done saves the values"); + click(&mut ui, &mut s, &|a| { + *a == Act::Push(Page::ShaderPackOptions) + }); + let events = click(&mut ui, &mut s, &|a| *a == Act::Done); + assert!( + !events.contains(&Event::ReloadShaderPack), + "no change: no reload" ); let _ = std::fs::remove_dir_all(&dir); } diff --git a/crates/horizon-client/src/shader_pack.rs b/crates/horizon-client/src/shader_pack.rs index f5a15ca79..d00384748 100644 --- a/crates/horizon-client/src/shader_pack.rs +++ b/crates/horizon-client/src/shader_pack.rs @@ -18,6 +18,13 @@ pub const API: u32 = 2; /// The folder beside `options.txt` that holds the packs. pub const DIR: &str = "shaderpacks"; pub const PRELUDE: &str = include_str!("shader_pack_prelude.wgsl"); +/// What api 2 adds after [`PRELUDE`] (`api = 2` packs only). +pub const PRELUDE_API2: &str = include_str!("shader_pack_prelude_api2.wgsl"); +/// [`PRELUDE_API2`]'s bindings that cost a pass when a stage reads them. +const BINDING_SCENE_NORMAL: u32 = 7; +const BINDING_SCENE_MATERIAL: u32 = 8; +const BINDING_OPAQUE_DEPTH: u32 = 9; +const BINDING_SHADOW_DEPTH: u32 = 10; /// The prelude's vertex entry point, shared by every stage. pub const VERTEX_ENTRY: &str = "horizon_stage_vertex"; const MAX_STAGES: usize = 16; @@ -58,8 +65,6 @@ struct StageEntry { entry: Option, scale: Option, format: Option, - #[serde(default)] - mipmap: bool, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] @@ -74,20 +79,11 @@ struct OptionEntry { values: Option>, } -/// Where a stage runs. Api 1 has `composite` only; Api 2 adds `shadow`, -/// `gbuffer`, `deferred` and `final`. +/// Where a stage runs: `composite` only so far (docs/shader-packs.md, Stages). #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum StageKind { - /// Directional sun/moon shadow map pass. - Shadow, - /// Material / G-buffer evaluation pass over world colour, depth and normals. - Gbuffer, - /// Opaque world lighting pass (runs before translucent water/weather). - Deferred, /// After the world pass, before the hand: reads the scene's colour and depth. Composite, - /// Final tonemapping / anti-aliasing pass before HUD and menus. - Final, } #[derive(Clone, Debug)] pub struct Stage { @@ -99,11 +95,13 @@ pub struct Stage { pub entry: String, /// Target size relative to the world's. pub scale: f32, - /// Optional target format name (`rgba16float`, `rgba8unorm`). + /// The target's format ([`STAGE_FORMATS`]); `None`: the screen's. pub format: Option, - /// Whether the previous stage's output is mipmapped before this stage runs. - pub mipmap: bool, + /// The prelude bindings (group 0) the stage reads. + pub bindings: BTreeSet, } +/// The `format`s a stage's target can have. +pub const STAGE_FORMATS: [&str; 3] = ["rgba8unorm", "rgba16float", "rgb10a2unorm"]; #[derive(Clone, Copy, Debug, PartialEq)] pub enum OptionKind { Bool, @@ -377,22 +375,18 @@ impl PackConfig { fn load_java(path: &Path, id: &str, saved: &BTreeMap) -> Result { let pack = JavaPack::open(path)?; let values = pack.values(saved); + // The menus don't know the GPU: `shaders.properties` is read as on an + // unknown one (the screens and profiles of the packs tested don't + // depend on it). let env = Environment::iris("Unknown", "", 4); let props = pack.properties(&values, &env).unwrap_or_default(); let lang = pack.translations("en_us"); let sliders: BTreeSet<&str> = props.sliders().into_iter().collect(); - let option_label = |name: &str, comment: Option<&str>| -> String { - lang.get(&format!("option.{name}")) - .cloned() - .or_else(|| { - comment - .map(str::trim) - .filter(|c| !c.is_empty() && c.len() <= 40 && !c.contains('.')) - .map(str::to_owned) - }) - .unwrap_or_else(|| humanize_identifier(name)) - }; + // Iris's names: the `.lang` entry, else the name itself; the tooltip + // from `.lang`, else the option's comment. + let named = |key: String, name: &str| lang.get(&key).cloned().unwrap_or(name.to_owned()); + let option_label = |name: &str| named(format!("option.{name}"), name); let option_desc = |name: &str, comment: Option<&str>| -> String { lang.get(&format!("option.{name}.comment")) .cloned() @@ -407,7 +401,7 @@ impl PackConfig { let idx = options.len(); options.push(PackOption { key: name.clone(), - label: option_label(name, b.comment.as_deref()), + label: option_label(name), description: option_desc(name, b.comment.as_deref()), kind: OptionKind::Bool, values: Vec::new(), @@ -428,19 +422,12 @@ impl PackConfig { let choices: Vec<(String, String)> = s .allowed .iter() - .map(|raw| { - let label = lang - .get(&format!("value.{name}.{raw}")) - .or_else(|| lang.get(&format!("option.{name}.value.{raw}"))) - .cloned() - .unwrap_or_else(|| raw.clone()); - (raw.clone(), label) - }) + .map(|raw| (raw.clone(), named(format!("value.{name}.{raw}"), raw))) .collect(); let idx = options.len(); options.push(PackOption { key: name.clone(), - label: option_label(name, s.comment.as_deref()), + label: option_label(name), description: option_desc(name, s.comment.as_deref()), kind: OptionKind::Choice { slider: sliders.contains(name.as_str()), @@ -460,10 +447,7 @@ impl PackConfig { .unwrap_or_default() .into_iter() .map(|p| { - let label = lang - .get(&format!("profile.{}", p.name)) - .cloned() - .unwrap_or_else(|| humanize_identifier(&p.name)); + let label = named(format!("profile.{}", p.name), &p.name); PackProfile { name: p.name, label, @@ -501,10 +485,7 @@ impl PackConfig { } } MenuElement::Screen(sub) => { - let label = lang - .get(&format!("screen.{sub}")) - .cloned() - .unwrap_or_else(|| humanize_identifier(&sub)); + let label = named(format!("screen.{sub}"), &sub); items.push(ScreenItem::Subscreen(sub, label)); } MenuElement::Option(opt) => { @@ -523,10 +504,7 @@ impl PackConfig { } let name_str = screen_name.unwrap_or("").to_owned(); let label = match screen_name { - Some(n) => lang - .get(&format!("screen.{n}")) - .cloned() - .unwrap_or_else(|| humanize_identifier(n)), + Some(n) => named(format!("screen.{n}"), n), None => id.to_owned(), }; PackScreen { @@ -700,7 +678,7 @@ pub struct ShaderPack { pub stages: Vec, pub options: Vec, /// Optional custom noise/LUT texture bytes (RGBA8, width, height) from `[textures]`. - pub custom_noise: Option<(u32, u32, Vec)>, + pub custom_noise: Option, /// A Java (OptiFine/Iris) pack's translated passes, instead of `stages`. pub java: Option, dir: PathBuf, @@ -813,6 +791,9 @@ pub fn import_pack(source: &Path, target_dir: &Path) -> Result { if dest.canonicalize().ok() == source.canonicalize().ok() { return Ok(name); } + if dest.exists() { + return Err(format!("{name} is already in {DIR}/")); + } if source.is_file() { fs::copy(&source, &dest).map_err(|e| format!("failed to copy {name}: {e}"))?; } else { @@ -827,10 +808,13 @@ fn copy_dir_recursive(src: &Path, dst: &Path) -> Result<(), String> { for entry in entries.flatten() { let path = entry.path(); let target = dst.join(entry.file_name()); - if path.is_dir() { - copy_dir_recursive(&path, &target)?; - } else { - fs::copy(&path, &target).map_err(|e| format!("{}: {e}", target.display()))?; + // Links aren't followed: one pointing up the tree would never end. + match entry.file_type() { + Ok(t) if t.is_dir() => copy_dir_recursive(&path, &target)?, + Ok(t) if t.is_file() => { + fs::copy(&path, &target).map_err(|e| format!("{}: {e}", target.display()))?; + } + _ => {} } } Ok(()) @@ -858,17 +842,13 @@ impl Folder { self.dir = dir; self.read = Some(std::time::Instant::now()); } - - pub fn invalidate(&mut self) { - self.read = None; - } } /// A Java pack has no manifest: its name is its file name. fn java_info(name: String) -> Info { Info { name, - description: "Iris/OptiFine pack: G-buffers, shadow map and post passes.".into(), + description: "Iris/OptiFine pack: its full-screen passes run.".into(), authors: Vec::new(), version: String::new(), license: String::new(), @@ -888,7 +868,16 @@ fn manifest(dir: &Path) -> Result { Ok(manifest) } -pub(crate) fn decode_png_rgba(bytes: &[u8]) -> Result<(u32, u32, Vec), String> { +/// An RGBA8 image (`decode_png`). +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Rgba { + pub width: u32, + pub height: u32, + pub pixels: Vec, +} + +/// A PNG of any colour type as [`Rgba`]. +pub(crate) fn decode_png(bytes: &[u8]) -> Result { let mut decoder = png::Decoder::new(std::io::Cursor::new(bytes)); decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16); let mut reader = decoder.read_info().map_err(|e| e.to_string())?; @@ -913,7 +902,11 @@ pub(crate) fn decode_png_rgba(bytes: &[u8]) -> Result<(u32, u32, Vec), Strin png::ColorType::Grayscale => buf.into_iter().flat_map(|g| [g, g, g, 255]).collect(), _ => return Err("unsupported PNG color format".into()), }; - Ok((w, h, rgba)) + Ok(Rgba { + width: w, + height: h, + pixels: rgba, + }) } impl ShaderPack { @@ -936,18 +929,25 @@ impl ShaderPack { .collect::, _>>()?; let mut stages = Vec::new(); for entry in manifest.stage { - let kind = match (pack_api, entry.kind.as_str()) { - (_, "composite") => StageKind::Composite, - (2.., "shadow") => StageKind::Shadow, - (2.., "gbuffer") => StageKind::Gbuffer, - (2.., "deferred") => StageKind::Deferred, - (2.., "final") => StageKind::Final, - (_, other) => { + let kind = match entry.kind.as_str() { + "composite" => StageKind::Composite, + other => { return Err(format!( - "pack.toml: stage kind `{other}` isn't supported (api {pack_api} has `composite`)" + "pack.toml: stage kind `{other}` isn't supported (api {API} has `composite`)" )); } }; + if pack_api == 1 && entry.format.is_some() { + return Err(format!("pack.toml: {}: `format` needs api 2", entry.shader)); + } + if let Some(format) = entry.format.as_deref() + && !STAGE_FORMATS.contains(&format) + { + return Err(format!( + "pack.toml: stage format `{format}` isn't one of {}", + STAGE_FORMATS.join(", ") + )); + } let scale = entry.scale.unwrap_or(1.0); if !(0.25..=2.0).contains(&scale) { return Err(format!( @@ -961,8 +961,17 @@ impl ShaderPack { } let code = fs::read_to_string(&path).map_err(|e| format!("{}: {e}", entry.shader))?; let entry_point = entry.entry.unwrap_or_else(|| "fs_main".into()); - let source = format!("{PRELUDE}\n{code}"); - validate(&source, &entry.shader, &entry_point)?; + let prelude = match pack_api { + 1 => PRELUDE.to_owned(), + _ => format!("{PRELUDE}\n{PRELUDE_API2}"), + }; + let source = format!("{prelude}\n{code}"); + let bindings = validate( + &source, + prelude.lines().count(), + &entry.shader, + &entry_point, + )?; stages.push(Stage { kind, file: entry.shader, @@ -970,20 +979,21 @@ impl ShaderPack { entry: entry_point, scale, format: entry.format, - mipmap: entry.mipmap, + bindings, }); } let mut custom_noise = None; - if let Some(rel) = manifest - .textures - .get("noise") - .or_else(|| manifest.textures.values().next()) - { + for (name, rel) in &manifest.textures { + if name != "noise" { + return Err(format!( + "pack.toml: texture `{name}` isn't supported (api {API} has `noise`)" + )); + } if rel.contains("..") { return Err(format!("pack.toml: texture {rel} is outside the pack")); } let bytes = fs::read(dir.join(rel)).map_err(|e| format!("{rel}: {e}"))?; - custom_noise = Some(decode_png_rgba(&bytes).map_err(|e| format!("{rel}: {e}"))?); + custom_noise = Some(decode_png(&bytes).map_err(|e| format!("{rel}: {e}"))?); } Ok(Self { id: dir @@ -1016,43 +1026,38 @@ impl ShaderPack { .file_name() .map(|n| n.to_string_lossy().into_owned()) .unwrap_or_default(); - let options = PackConfig::load_java(path, &id, values) - .map(|c| c.options) - .unwrap_or_default(); Ok(Self { info: java_info(id.clone()), id, stages: Vec::new(), - options, + options: Vec::new(), custom_noise: None, java: Some(java), dir: path.to_path_buf(), stamp, }) } - /// Whether this pack requests directional shadow map rendering. - pub fn needs_shadow(&self) -> bool { - if let Some(java) = &self.java { - return java.folders.iter().any(|f| f.shadow_enabled); - } - self.stages.iter().any(|s| { - s.kind == StageKind::Shadow - || s.source.contains("sample_shadow") - || s.source.contains("shadow_depth") - }) + /// Whether a stage reads one of the prelude's `bindings`. + fn reads(&self, bindings: &[u32]) -> bool { + self.stages + .iter() + .any(|s| bindings.iter().any(|b| s.bindings.contains(b))) } - /// Shadow map resolution requested by this pack, and shadow distance in blocks. - pub fn shadow_config(&self, dimension: i8) -> (u32, f32, f32) { - if let Some(java) = &self.java - && let Some(idx) = java.folder_for(dimension) - { - let d = &java.folders[idx].directives; - return ( - d.shadow_map_resolution, - d.shadow_distance, - d.sun_path_rotation, - ); - } + /// Whether a stage reads the shadow map (`shadow_depth`, `sample_shadow`). + pub fn needs_shadow(&self) -> bool { + self.reads(&[BINDING_SHADOW_DEPTH]) + } + /// Whether a stage reads the G-buffer (`scene_normal`, `scene_material`). + pub fn needs_gbuffer(&self) -> bool { + self.reads(&[BINDING_SCENE_NORMAL, BINDING_SCENE_MATERIAL]) + } + /// Whether the world's depth before translucent geometry is kept + /// (`opaque_depth`, which the G-buffer is also built from). + pub fn needs_opaque_depth(&self) -> bool { + self.needs_gbuffer() || self.reads(&[BINDING_OPAQUE_DEPTH]) + } + /// The shadow map's resolution and distance in blocks. + pub fn shadow_config(&self) -> (u32, f32) { let res = self .options .iter() @@ -1065,7 +1070,7 @@ impl ShaderPack { .find(|o| o.key == "shadow_distance" || o.key == "shadowDistance") .map(|o| (o.value as f32).clamp(16.0, 512.0)) .unwrap_or(128.0); - (res, dist, 0.0) + (res, dist) } /// The pipeline-overridable constants every stage gets: the option values. pub fn constants(&self) -> Vec<(&str, f64)> { @@ -1139,8 +1144,15 @@ fn option( /// naga parses and validates the stage (prelude included) and checks its /// fragment entry point; errors point into the pack's own file. -fn validate(source: &str, file: &str, entry: &str) -> Result<(), String> { - let prelude_lines = PRELUDE.lines().count() as u32 + 1; +/// Parse and validate a stage: the prelude's bindings (group 0) its entry +/// point uses, or the error at the stage's own line. +fn validate( + source: &str, + prelude_lines: usize, + file: &str, + entry: &str, +) -> Result, String> { + let prelude_lines = prelude_lines as u32 + 1; let at = |location: Option| match location { Some(l) if l.line_number > prelude_lines => { format!( @@ -1153,20 +1165,28 @@ fn validate(source: &str, file: &str, entry: &str) -> Result<(), String> { }; let module = naga::front::wgsl::parse_str(source) .map_err(|e| format!("{}: {}", at(e.location(source)), e.message()))?; - naga::valid::Validator::new( + let info = naga::valid::Validator::new( naga::valid::ValidationFlags::all(), naga::valid::Capabilities::default(), ) .validate(&module) .map_err(|e| format!("{}: {}", at(e.location(source)), e.as_inner()))?; - if !module + let Some(index) = module .entry_points .iter() - .any(|e| e.name == entry && e.stage == naga::ShaderStage::Fragment) - { + .position(|e| e.name == entry && e.stage == naga::ShaderStage::Fragment) + else { return Err(format!("{file}: no fragment entry point `{entry}`")); - } - Ok(()) + }; + let uses = info.get_entry_point(index); + Ok(module + .global_variables + .iter() + .filter(|(handle, _)| !uses[*handle].is_empty()) + .filter_map(|(_, var)| var.binding.as_ref()) + .filter(|binding| binding.group == 0) + .map(|binding| binding.binding) + .collect()) } /// The option values saved for a pack (`shaderpacks/.txt`, `key=value`). @@ -1312,6 +1332,20 @@ override mode: i32 = 1; MANIFEST.replace("\"composite\"", "\"shadow\""), "stage kind `shadow`", ), + ( + MANIFEST.replace( + "kind = \"composite\"", + "kind = \"composite\"\nformat = \"rgba16float\"", + ), + "`format` needs api 2", + ), + ( + MANIFEST.replace("api = 1", "api = 2").replace( + "kind = \"composite\"", + "kind = \"composite\"\nformat = \"rgba32float\"", + ), + "stage format `rgba32float`", + ), ( MANIFEST.replace("grade.wgsl", "../grade.wgsl"), "outside the pack", @@ -1334,12 +1368,27 @@ override mode: i32 = 1; #[test] fn api_2_stages_and_pack_config_work() { - let manifest_v2 = MANIFEST - .replace("api = 1", "api = 2") - .replace("\"composite\"", "\"deferred\""); + let manifest_v2 = MANIFEST.replace("api = 1", "api = 2").replace( + "kind = \"composite\"", + "kind = \"composite\"\nformat = \"rgba16float\"", + ); let dir = pack(&[("pack.toml", &manifest_v2), ("shaders/grade.wgsl", GRADE)]); let loaded = ShaderPack::load(&dir, &BTreeMap::new()).unwrap(); - assert_eq!(loaded.stages[0].kind, StageKind::Deferred); + assert_eq!(loaded.stages[0].format.as_deref(), Some("rgba16float")); + assert!( + !loaded.needs_shadow() && !loaded.needs_gbuffer() && !loaded.needs_opaque_depth(), + "reading none of them costs no pass" + ); + let opaque = GRADE.replace("depth_at(in.uv)", "opaque_depth_at(in.uv)"); + let reads = pack(&[("pack.toml", &manifest_v2), ("shaders/grade.wgsl", &opaque)]); + let reads = ShaderPack::load(&reads, &BTreeMap::new()).unwrap(); + assert!(reads.needs_opaque_depth() && !reads.needs_gbuffer()); + let api_1 = pack(&[("pack.toml", MANIFEST), ("shaders/grade.wgsl", &opaque)]); + let error = ShaderPack::load(&api_1, &BTreeMap::new()).err().unwrap(); + assert!( + error.contains("opaque_depth_at"), + "api 1 stages don't see api 2's names: {error}" + ); let parent = dir.parent().unwrap(); let id = dir.file_name().unwrap().to_str().unwrap(); let mut cfg = PackConfig::load(parent, id).unwrap(); diff --git a/crates/horizon-client/src/shader_pack_prelude.wgsl b/crates/horizon-client/src/shader_pack_prelude.wgsl index ebe3ad4cf..7b16690f9 100644 --- a/crates/horizon-client/src/shader_pack_prelude.wgsl +++ b/crates/horizon-client/src/shader_pack_prelude.wgsl @@ -1,7 +1,6 @@ -// Horizon shader pack prelude, api 2 (docs/shader-packs.md): placed before -// every stage's source. Bindings, the Frame and FrameExt uniforms, the -// full-screen vertex shader, G-buffer/shadow accessors and PBR/post helpers -// that hide the renderer's reversed depth. +// Horizon shader pack prelude, api 1 (docs/shader-packs.md): placed before +// every stage's source. Bindings, the Frame uniform, the full-screen vertex +// shader and helpers that hide the renderer's reversed depth. struct Frame { view: mat4x4, projection: mat4x4, @@ -20,36 +19,12 @@ struct Frame { view_params: vec4, dimension: vec4, } - -struct FrameExt { - previous_view: mat4x4, - previous_projection: mat4x4, - shadow_view: mat4x4, - shadow_projection: mat4x4, - shadow_inverse_view: mat4x4, - shadow_inverse_projection: mat4x4, - // xyz: previous camera world position, w: frame delta time (seconds) - previous_camera: vec4, - // x: shadow map resolution, y: shadow distance (blocks), z: sun_path_rotation (rad), w: shadow strength - shadow_params: vec4, - // x: eye block light (0..240), y: eye sky light (0..240), z: smoothed wetness (0..1), w: center linear depth - environment: vec4, -} - @group(0) @binding(0) var scene_color: texture_2d; @group(0) @binding(1) var scene_depth: texture_depth_2d; @group(0) @binding(2) var previous: texture_2d; @group(0) @binding(3) var linear_sampler: sampler; @group(0) @binding(4) var nearest_sampler: sampler; @group(0) @binding(5) var frame: Frame; -@group(0) @binding(6) var frame_ext: FrameExt; -@group(0) @binding(7) var scene_normal: texture_2d; -@group(0) @binding(8) var scene_material: texture_2d; -@group(0) @binding(9) var opaque_depth: texture_depth_2d; -@group(0) @binding(10) var shadow_depth: texture_depth_2d; -@group(0) @binding(11) var shadow_sampler: sampler_comparison; -@group(0) @binding(12) var noise_texture: texture_2d; -@group(0) @binding(13) var repeat_sampler: sampler; struct StageIn { @builtin(position) position: vec4, @@ -67,10 +42,6 @@ struct StageIn { fn depth_at(uv: vec2) -> f32 { return textureSampleLevel(scene_depth, nearest_sampler, uv, 0); } -// The opaque world's depth at `uv` (before translucent water and stained glass). -fn opaque_depth_at(uv: vec2) -> f32 { - return textureSampleLevel(opaque_depth, nearest_sampler, uv, 0); -} fn is_sky(depth: f32) -> bool { return depth <= 0.0; } @@ -89,70 +60,6 @@ fn view_position(uv: vec2, depth: f32) -> vec3 { fn world_offset(uv: vec2, depth: f32) -> vec3 { return (frame.inverse_view * vec4(view_position(uv, depth), 1.0)).xyz; } -// World-space surface normal at `uv` from the G-buffer (or reconstructed from depth). -fn world_normal_at(uv: vec2) -> vec3 { - let encoded = textureSampleLevel(scene_normal, nearest_sampler, uv, 0.0); - if encoded.w > 0.001 { - return normalize(encoded.xyz * 2.0 - 1.0); - } - let step_uv = frame.resolution.zw; - let d0 = depth_at(uv); - let p0 = world_offset(uv, d0); - let px = world_offset(uv + vec2(step_uv.x, 0.0), depth_at(uv + vec2(step_uv.x, 0.0))) - p0; - let py = world_offset(uv + vec2(0.0, step_uv.y), depth_at(uv + vec2(0.0, step_uv.y))) - p0; - let n = cross(py, px); - let len = length(n); - if len > 1e-6 { - return n / len; - } - return vec3(0.0, 1.0, 0.0); -} -// G-buffer material data at `uv`: r = block light (0..1), g = sky light (0..1), -// b = water/translucent mask (0..1), a = roughness (0..1). -fn material_at(uv: vec2) -> vec4 { - return textureSampleLevel(scene_material, nearest_sampler, uv, 0.0); -} -// Reproject a camera-relative world position into previous-frame UV and clip depth. -fn reproject_uv(world_rel: vec3) -> vec3 { - let camera_delta = frame.camera_position.xyz - frame_ext.previous_camera.xyz; - let prev_rel = world_rel + camera_delta; - let clip = frame_ext.previous_projection * (frame_ext.previous_view * vec4(prev_rel, 1.0)); - if clip.w <= 1e-5 { - return vec3(-1.0); - } - let ndc = clip.xyz / clip.w; - return vec3(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5, ndc.z); -} -// Sample the directional sun/moon shadow map with 5-tap PCF and normal offset bias. -// Returns 1.0 in full light and 0.0 in full shadow. -fn sample_shadow(world_rel: vec3, world_normal: vec3) -> f32 { - if frame_ext.shadow_params.w <= 0.001 { - return 1.0; - } - let dist = length(world_rel); - let max_dist = max(frame_ext.shadow_params.y, 16.0); - if dist >= max_dist { - return 1.0; - } - let light_dir = normalize(select(frame.moon.xyz, frame.sun.xyz, frame.sun.y >= -0.05)); - let ndotl = max(dot(world_normal, light_dir), 0.0); - let bias_pos = world_rel + world_normal * (0.06 + 0.12 * (1.0 - ndotl)); - let light_clip = frame_ext.shadow_projection * (frame_ext.shadow_view * vec4(bias_pos, 1.0)); - let ndc = light_clip.xyz / max(light_clip.w, 1e-5); - let shadow_uv = vec2(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5); - if any(shadow_uv < vec2(0.002)) || any(shadow_uv > vec2(0.998)) || ndc.z <= 0.0 || ndc.z >= 1.0 { - return 1.0; - } - let texel = 1.0 / max(frame_ext.shadow_params.x, 512.0); - let ref_z = clamp(ndc.z + 0.0008, 0.0, 1.0); - var sum = textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv, ref_z); - sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv + vec2(texel, 0.0), ref_z); - sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv - vec2(texel, 0.0), ref_z); - sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv + vec2(0.0, texel), ref_z); - sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv - vec2(0.0, texel), ref_z); - let fade = smoothstep(max_dist, max_dist * 0.82, dist); - return mix(1.0, sum * 0.2, fade * frame_ext.shadow_params.w); -} fn luminance(c: vec3) -> f32 { return dot(c, vec3(0.2126, 0.7152, 0.0722)); } @@ -162,12 +69,3 @@ fn srgb_to_linear(c: vec3) -> vec3 { fn linear_to_srgb(c: vec3) -> vec3 { return select(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, c <= vec3(0.0031308)); } -// ACES fitted filmic tonemapping curve (linear HDR -> linear 0..1). -fn aces_tonemap(x: vec3) -> vec3 { - let a = 2.51; - let b = 0.03; - let c = 2.43; - let d = 0.59; - let e = 0.14; - return clamp((x * (a * x + b)) / (x * (c * x + d) + e), vec3(0.0), vec3(1.0)); -} diff --git a/crates/horizon-client/src/shader_pack_prelude_api2.wgsl b/crates/horizon-client/src/shader_pack_prelude_api2.wgsl new file mode 100644 index 000000000..80e9a205e --- /dev/null +++ b/crates/horizon-client/src/shader_pack_prelude_api2.wgsl @@ -0,0 +1,108 @@ +// Horizon shader pack prelude, api 2 additions (docs/shader-packs.md): placed +// after the api 1 prelude before the stages of an `api = 2` pack, so api 1 +// packs keep every name they may have declared themselves. +struct FrameExt { + previous_view: mat4x4, + previous_projection: mat4x4, + shadow_view: mat4x4, + shadow_projection: mat4x4, + shadow_inverse_view: mat4x4, + shadow_inverse_projection: mat4x4, + // xyz: previous camera world position, w: frame delta time (seconds) + previous_camera: vec4, + // x: shadow map resolution, y: shadow distance (blocks), z: 0, + // w: 1 while the shadow map is drawn this frame, else 0 + shadow_params: vec4, + // x: eye block light (0..240), y: eye sky light (0..240), z: smoothed + // rain (0..1), w: 0 + environment: vec4, +} + +@group(0) @binding(6) var frame_ext: FrameExt; +@group(0) @binding(7) var scene_normal: texture_2d; +@group(0) @binding(8) var scene_material: texture_2d; +@group(0) @binding(9) var opaque_depth: texture_depth_2d; +@group(0) @binding(10) var shadow_depth: texture_depth_2d; +@group(0) @binding(11) var shadow_sampler: sampler_comparison; +@group(0) @binding(12) var noise_texture: texture_2d; +@group(0) @binding(13) var repeat_sampler: sampler; + +// The opaque world's depth at `uv` (before translucent water and stained glass). +fn opaque_depth_at(uv: vec2) -> f32 { + return textureSampleLevel(opaque_depth, nearest_sampler, uv, 0); +} + +// World-space surface normal at `uv` from the G-buffer (or reconstructed from depth). +fn world_normal_at(uv: vec2) -> vec3 { + let encoded = textureSampleLevel(scene_normal, nearest_sampler, uv, 0.0); + if encoded.w > 0.001 { + return normalize(encoded.xyz * 2.0 - 1.0); + } + let step_uv = frame.resolution.zw; + let d0 = depth_at(uv); + let p0 = world_offset(uv, d0); + let px = world_offset(uv + vec2(step_uv.x, 0.0), depth_at(uv + vec2(step_uv.x, 0.0))) - p0; + let py = world_offset(uv + vec2(0.0, step_uv.y), depth_at(uv + vec2(0.0, step_uv.y))) - p0; + let n = cross(py, px); + let len = length(n); + if len > 1e-6 { + return n / len; + } + return vec3(0.0, 1.0, 0.0); +} +// G-buffer material data at `uv`: r = block light (0..1), g = sky light (0..1), +// b = water/translucent mask (0..1), a = roughness (0..1). +fn material_at(uv: vec2) -> vec4 { + return textureSampleLevel(scene_material, nearest_sampler, uv, 0.0); +} +// Reproject a camera-relative world position into previous-frame UV and clip depth. +fn reproject_uv(world_rel: vec3) -> vec3 { + let camera_delta = frame.camera_position.xyz - frame_ext.previous_camera.xyz; + let prev_rel = world_rel + camera_delta; + let clip = frame_ext.previous_projection * (frame_ext.previous_view * vec4(prev_rel, 1.0)); + if clip.w <= 1e-5 { + return vec3(-1.0); + } + let ndc = clip.xyz / clip.w; + return vec3(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5, ndc.z); +} +// Sample the directional sun/moon shadow map with 5-tap PCF and normal offset bias. +// Returns 1.0 in full light and 0.0 in full shadow. +fn sample_shadow(world_rel: vec3, world_normal: vec3) -> f32 { + if frame_ext.shadow_params.w <= 0.001 { + return 1.0; + } + let dist = length(world_rel); + let max_dist = max(frame_ext.shadow_params.y, 16.0); + if dist >= max_dist { + return 1.0; + } + let light_dir = normalize(select(frame.moon.xyz, frame.sun.xyz, frame.sun.y >= -0.05)); + let ndotl = max(dot(world_normal, light_dir), 0.0); + let bias_pos = world_rel + world_normal * (0.06 + 0.12 * (1.0 - ndotl)); + let light_clip = frame_ext.shadow_projection * (frame_ext.shadow_view * vec4(bias_pos, 1.0)); + let ndc = light_clip.xyz / max(light_clip.w, 1e-5); + let shadow_uv = vec2(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5); + if any(shadow_uv < vec2(0.002)) || any(shadow_uv > vec2(0.998)) || ndc.z <= 0.0 || ndc.z >= 1.0 { + return 1.0; + } + let texel = 1.0 / max(frame_ext.shadow_params.x, 512.0); + let ref_z = clamp(ndc.z + 0.0008, 0.0, 1.0); + var sum = textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv, ref_z); + sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv + vec2(texel, 0.0), ref_z); + sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv - vec2(texel, 0.0), ref_z); + sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv + vec2(0.0, texel), ref_z); + sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv - vec2(0.0, texel), ref_z); + let fade = smoothstep(max_dist, max_dist * 0.82, dist); + return mix(1.0, sum * 0.2, fade * frame_ext.shadow_params.w); +} + +// ACES fitted filmic tonemapping curve (linear HDR -> linear 0..1). +fn aces_tonemap(x: vec3) -> vec3 { + let a = 2.51; + let b = 0.03; + let c = 2.43; + let d = 0.59; + let e = 0.14; + return clamp((x * (a * x + b)) / (x * (c * x + d) + e), vec3(0.0), vec3(1.0)); +} diff --git a/crates/horizon-shaderpack/src/options.rs b/crates/horizon-shaderpack/src/options.rs index d25a3d776..3158b12cf 100644 --- a/crates/horizon-shaderpack/src/options.rs +++ b/crates/horizon-shaderpack/src/options.rs @@ -489,11 +489,14 @@ impl OptionValues { out.bools.insert(name.clone(), value); } } + // A saved value the option doesn't list (an old or hand-edited + // file) is dropped, as OptiFine's `ShaderOption.setValue` refuses it. for (name, o) in &options.strings { - if let Some(v) = saved.get(name) { - if *v != o.default { - out.strings.insert(name.clone(), v.clone()); - } + if let Some(v) = saved.get(name) + && *v != o.default + && o.allowed.contains(v) + { + out.strings.insert(name.clone(), v.clone()); } } out @@ -623,6 +626,13 @@ mod tests { !values.bools.contains_key("shadowHardwareFiltering"), "not a boolean: ignored" ); + let stale = [("QUALITY", "abc"), ("sunPathRotation", "")] + .map(|(k, v)| (k.to_owned(), v.to_owned())) + .into(); + assert!( + OptionValues::new(&set, &stale).strings.is_empty(), + "values the options don't list: ignored" + ); let edited: Vec = lines .iter() .enumerate() diff --git a/crates/horizon-shaderpack/src/pipeline.rs b/crates/horizon-shaderpack/src/pipeline.rs index db656e3ae..89898eb07 100644 --- a/crates/horizon-shaderpack/src/pipeline.rs +++ b/crates/horizon-shaderpack/src/pipeline.rs @@ -323,8 +323,6 @@ pub struct Passes { /// next frame starts unflipped. pub flipped_at_end: BTreeSet, pub directives: Directives, - /// Whether the folder uses shadow mapping (`shadow` program or `shadowtex*`). - pub shadow_enabled: bool, } /// The `const` directives of a program folder that aren't about targets @@ -341,24 +339,6 @@ pub struct Directives { pub wetness_half_life: f32, /// `drynessHalflife`, tenths of a second: `wetness` smoothing when dry. pub dryness_half_life: f32, - /// `centerDepthHalflife`, tenths of a second: `centerDepthSmooth`. - pub center_depth_half_life: f32, - /// `shadowMapResolution` (or `SHADOW_RES`), in pixels per side. - pub shadow_map_resolution: u32, - /// `shadowDistance`, in blocks. - pub shadow_distance: f32, - /// `shadowDistanceRenderMul` (-1 when unset). - pub shadow_distance_render_mul: f32, - /// `ambientOcclusionLevel` (0.0..=1.0). - pub ambient_occlusion_level: f32, - /// `noiseTextureResolution`, in pixels per side. - pub noise_texture_resolution: u32, - /// `shadowHardwareFiltering` / `shadowHardwareFiltering0..1`. - pub shadow_hardware_filtering: [bool; 2], - /// `shadowtex0Nearest` / `shadowtex1Nearest`. - pub shadow_nearest: [bool; 2], - /// `generateShadowMipmap` / `shadowtex0Mipmap` / `shadowtex1Mipmap`. - pub shadow_mipmap: [bool; 2], } impl Default for Directives { @@ -368,15 +348,6 @@ impl Default for Directives { eye_brightness_half_life: 10.0, wetness_half_life: 600.0, dryness_half_life: 200.0, - center_depth_half_life: 1.0, - shadow_map_resolution: 2048, - shadow_distance: 128.0, - shadow_distance_render_mul: -1.0, - ambient_occlusion_level: 1.0, - noise_texture_resolution: 256, - shadow_hardware_filtering: [false; 2], - shadow_nearest: [false; 2], - shadow_mipmap: [false; 2], } } } @@ -387,66 +358,13 @@ impl Directives { let mut out = Self::default(); for fragment in fragments { for c in const_directives(fragment) { - let raw = c.value.trim_end_matches(['f', 'F']); - let fval = raw.parse::(); - let ival = raw.parse::(); - let bval = raw.parse::(); - match (c.ty, c.key.as_str()) { - ("float", "sunPathRotation") if fval.is_ok() => { - out.sun_path_rotation = fval.unwrap(); - } - ("float", "eyeBrightnessHalflife") if fval.is_ok() => { - out.eye_brightness_half_life = fval.unwrap(); - } - ("float", "wetnessHalflife") if fval.is_ok() => { - out.wetness_half_life = fval.unwrap(); - } - ("float", "drynessHalflife") if fval.is_ok() => { - out.dryness_half_life = fval.unwrap(); - } - ("float", "centerDepthHalflife") if fval.is_ok() => { - out.center_depth_half_life = fval.unwrap(); - } - ("float", "shadowDistance") if fval.is_ok() => { - out.shadow_distance = fval.unwrap().clamp(8.0, 1024.0); - } - ("float", "shadowDistanceRenderMul") if fval.is_ok() => { - out.shadow_distance_render_mul = fval.unwrap(); - } - ("float", "ambientOcclusionLevel") if fval.is_ok() => { - out.ambient_occlusion_level = fval.unwrap().clamp(0.0, 1.0); - } - ("int", "shadowMapResolution") if ival.is_ok() => { - out.shadow_map_resolution = ival.unwrap().clamp(64, 8192); - } - ("int", "noiseTextureResolution") if ival.is_ok() => { - out.noise_texture_resolution = ival.unwrap().clamp(16, 2048); - } - ("bool", "shadowHardwareFiltering") if bval.is_ok() => { - out.shadow_hardware_filtering = [bval.unwrap(); 2]; - } - ("bool", "shadowHardwareFiltering0") if bval.is_ok() => { - out.shadow_hardware_filtering[0] = bval.unwrap(); - } - ("bool", "shadowHardwareFiltering1") if bval.is_ok() => { - out.shadow_hardware_filtering[1] = bval.unwrap(); - } - ("bool", "shadowtexNearest" | "shadowtex0Nearest" | "shadow0MinMagNearest") - if bval.is_ok() => - { - out.shadow_nearest[0] = bval.unwrap(); - } - ("bool", "shadowtex1Nearest" | "shadow1MinMagNearest") if bval.is_ok() => { - out.shadow_nearest[1] = bval.unwrap(); - } - ("bool", "generateShadowMipmap" | "shadowtexMipmap" | "shadowtex0Mipmap") - if bval.is_ok() => - { - out.shadow_mipmap[0] = bval.unwrap(); - } - ("bool", "shadowtex1Mipmap") if bval.is_ok() => { - out.shadow_mipmap[1] = bval.unwrap(); - } + // Java's `Float.parseFloat` takes a trailing `f`. + let value = c.value.trim_end_matches(['f', 'F']).parse::(); + match (c.ty, c.key.as_str(), value) { + ("float", "sunPathRotation", Ok(v)) => out.sun_path_rotation = v, + ("float", "eyeBrightnessHalflife", Ok(v)) => out.eye_brightness_half_life = v, + ("float", "wetnessHalflife", Ok(v)) => out.wetness_half_life = v, + ("float", "drynessHalflife", Ok(v)) => out.dryness_half_life = v, _ => {} } } @@ -568,19 +486,9 @@ impl JavaPack { for name in &groups[0..2].concat() { fragments.insert(name.clone(), fragment(name)?); } - let shadow_enabled = ["shadow", "shadow_solid", "shadow_cutout"] - .iter() - .any(|s| exists(s)) - || sources.iter().any(|s| { - s.contains("shadowtex0") - || s.contains("shadowtex1") - || s.contains("watershadow") - || s.contains("shadow2D") - }); let mut out = Passes { targets: target_settings(sources.iter().map(String::as_str), properties), directives: Directives::read(sources.iter().map(String::as_str)), - shadow_enabled, ..Passes::default() }; @@ -858,14 +766,14 @@ mod tests { assert_eq!(Directives::read([]), Directives::default()); assert_eq!(Directives::default().eye_brightness_half_life, 10.0); let d = Directives::read([ - "const float sunPathRotation = 30.0;\nconst float eyeBrightnessHalflife = 4.0f;\nconst int shadowMapResolution = 4096;\nconst float shadowDistance = 192.0;", + "const float sunPathRotation = 30.0;\nconst float eyeBrightnessHalflife = 4.0f;\nconst float wetnessHalflife = 300.0;", "const float sunPathRotation = -40.0; // Complementary Unbound", "const int sunPathRotation = 5;", ]); assert_eq!(d.sun_path_rotation, -40.0); assert_eq!(d.eye_brightness_half_life, 4.0); - assert_eq!(d.shadow_map_resolution, 4096); - assert_eq!(d.shadow_distance, 192.0); + assert_eq!(d.wetness_half_life, 300.0); + assert_eq!(d.dryness_half_life, 200.0, "the default"); } #[test] diff --git a/crates/horizon-shaderpack/src/translate.rs b/crates/horizon-shaderpack/src/translate.rs index 623ad760d..27fafe34b 100644 --- a/crates/horizon-shaderpack/src/translate.rs +++ b/crates/horizon-shaderpack/src/translate.rs @@ -806,20 +806,11 @@ impl<'a> Legaliser<'a> { fn unit(&mut self, unit: &mut ast::TranslationUnit) -> Result<(), String> { // Functions, their sampler parameters, and struct definitions first. for ed in &unit.0 { - if let ast::ExternalDeclarationData::Declaration(d) = &ed.content { - match &d.content { - ast::DeclarationData::InitDeclaratorList(list) => { - if let ast::TypeSpecifierNonArrayData::Struct(s) = - &list.head.ty.ty.ty.content - { - self.record_struct(s); - } - } - ast::DeclarationData::TypeOnly(q) => { - let _ = q; - } - _ => {} - } + if let ast::ExternalDeclarationData::Declaration(d) = &ed.content + && let ast::DeclarationData::InitDeclaratorList(list) = &d.content + && let ast::TypeSpecifierNonArrayData::Struct(s) = &list.head.ty.ty.ty.content + { + self.record_struct(s); } let proto = match &ed.content { ast::ExternalDeclarationData::FunctionDefinition(f) => &f.prototype, diff --git a/docs/shader-packs.md b/docs/shader-packs.md index 0ba8981fb..6718be0f7 100644 --- a/docs/shader-packs.md +++ b/docs/shader-packs.md @@ -13,16 +13,18 @@ Both are off by default. With no pack selected the renderer draws exactly what i | Part | State | | --- | --- | | Renderer layout (below) | today's code | -| Horizon shader packs: `composite`, `deferred`, `gbuffer`, `shadow`, `final` stages (API 2), uniforms, custom textures, hot reload | done (`examples/shaderpacks/horizon-ultra` + `horizon-sample`) | -| Shader Packs UI: import (`.zip`/folder dialog + drag-and-drop), profiles, sub-screens, sliders, toggles, reset to defaults | done (Horizon & Classic Video/Graphics settings) | -| Real-time shadow map pass (`"Horizon shadow"`, `shadowtex0/1`, `shadowModelView`, `shadowProjection`) & pre-translucent depth (`depthtex1/2`) | done | -| G-buffer normal & material pass (`"Horizon gbuffer"`, `scene_normal`, `scene_material`, `colortex1..3` initialization) | done | -| Java shader packs: preprocessor (`crates/horizon-shaderpack`: includes, options, Iris's macros, JCPP's `#if` and `#define` rules, `.lang` files) | done: ten packs tested (Compatibility, below) | -| Java shader packs: GLSL → WGSL (`horizon_shaderpack::translate`: syntax-tree legaliser, naga, 2D array & struct varyings, vertex `textureLod`, `mat2(vec4)`, `1 << 31` shifts) | done | -| Java shader packs: `shaders.properties` (`horizon_shaderpack::properties`: screens, sliders, profiles, `program.*.enabled`, image formats, blend modes, custom textures) | done, wired to UI and GPU passes | -| Java shader packs: full-screen pass plan (`horizon_shaderpack::pipeline`: `DRAWBUFFERS`/`RENDERTARGETS`, `colortexN` formats and clearing, buffer flips, blend state) | done | -| Java shader packs: full-screen passes drawn (`java_pack.rs`, `gfx/java_stages.rs`: `begin`, `prepare`, `deferred*`, `composite*`, `final` over Horizon's world) | done: with shadow maps, `depthtex1/2`, custom PNG textures, GL blend modes, `wetness`, `centerDepthSmooth` | -| Java shader packs: custom uniforms (`horizon_shaderpack::uniforms`), `sunPathRotation`, `clouds`/`sun`/`moon`, eye light | done | +| Horizon shader packs: `composite` stage, uniforms, hot reload, Shader Packs page | done (the page: list, pick, open the folder, drop a pack on it) | +| Horizon shader packs, api 2: stage `format`s, `[profiles]`, option descriptions, a `noise` texture, the opaque depth, a G-buffer reconstructed from depth, a sun/moon shadow map (Stages, below) | first slice: `examples/shaderpacks/horizon-ultra` | +| Horizon shader packs: `deferred`, `gbuffer`, `shadow` stages (the pack's own code in the world pass) | planned | +| Shader Pack Settings page: a pack's options, sub-screens, sliders, profiles and Reset, Horizon and Java packs alike; applied once on Done, as Iris does | done | +| Java shader packs: preprocessing + GLSL parse coverage | spike done: 450 of 470 programs reach valid WGSL (below) | +| Java shader packs: preprocessor (`crates/horizon-shaderpack`: includes, options, Iris's macros, JCPP's `#if` and `#define` rules, `.lang` files) | done: every program of the three test packs preprocesses; ten packs tested (Compatibility, below) | +| Java shader packs: GLSL → WGSL (`horizon_shaderpack::translate`: syntax-tree legaliser, naga; struct and nested-array varyings, vertex `texture`, `mat2(vec4)`, `1 << 31`) | done: the 464 programs the three test packs enable by default translate (below) | +| Java shader packs: `shaders.properties` (`horizon_shaderpack::properties`: screens, sliders, profiles, `program.*.enabled`, image formats, blend modes, `texture.*`) | done: read like Iris for the three test packs | +| Java shader packs: full-screen pass plan (`horizon_shaderpack::pipeline`: `DRAWBUFFERS`/`RENDERTARGETS`, `colortexN` formats and clearing, buffer flips, `blend.*`) | done: planned for the three test packs | +| Java shader packs: full-screen passes drawn (`java_pack.rs`, `gfx/java_stages.rs`: `begin`, `prepare`, `deferred*`, `composite*`, `final` over Horizon's world) | first slice: BSL and Complementary run (below); `depthtex1`/`depthtex2` before translucent geometry, `blend.*`, PNG `texture..*` and `texture.noise` | +| Java shader packs: custom uniforms (`horizon_shaderpack::uniforms`), `sunPathRotation`, `clouds`/`sun`/`moon`, eye light, `wetness` | done for the full-screen passes (below) | +| Java shader packs: `gbuffers_*`, `shadow`, `.dat` and resource-location textures, images, compute | planned | ## How the renderer draws a frame today @@ -63,7 +65,14 @@ The lightmap, fog and sky colours are computed on the CPU (`environment.rs`, `fo Horizon Settings... → Shader Packs...**, and the Shader Pack row of the graphics settings lead to it. It shows the folder's full path and an *Open Folder* button (the folder is made if it is missing), then one switch per pack: turning one on picks it, turning it off is the vanilla picture. With no pack, it says so under the path. The list is read again every - second while the page is open, so a pack dropped into the folder shows up. + second while the page is open, so a pack dropped into the folder shows up. A `.zip` or pack folder dropped on the + window while the page shows is copied into the folder and picked (Iris's `ShaderPackScreen.onFilesDrop`); one of + that name already there is left alone. +- With a pack on that has options, **Shader Pack Settings...** opens them: Horizon packs' `[options]` and + `[profiles]`, Java packs' `#define`/`const` options laid out by `shaders.properties` (`screen`, `screen.`, + `sliders`, `profile.*`) and named by `lang/en_us.lang` (`option.*`, `value.*`, `screen.*`, `profile.*`, as Iris; + without one, the option's own name). The values are saved and the pack built again once, when the page closes + (Iris applies on Done), not on every click or slider step. A saved value an option doesn't list is ignored. - The choice is kept in `horizon-graphics.txt` (`shaderPack:`, empty = off). A pack's option values are kept in `shaderpacks/.txt`, as Iris does. - A pack that fails to load or compile leaves the vanilla picture (or the last pack that worked) on and says why on @@ -79,7 +88,7 @@ my-pack/ composite.wgsl bloom.wgsl textures/ - noise.png # planned + noise.png # api 2: [textures] noise LICENSE ``` @@ -112,6 +121,24 @@ step = 0.05 [options.vignette] label = "Vignette" default = true +description = "Darkens the corners." # optional: the button's tooltip +``` + +Api 2 (`api = 2`) adds: + +```toml +[[stage]] +kind = "composite" +shader = "shaders/lighting.wgsl" +format = "rgba16float" # this stage's target: rgba8unorm, rgba16float or rgb10a2unorm; the last stage + # always writes the screen's format, so earlier ones can keep HDR colour + +[profiles.low] # the Profile button cycles these; "Custom" when the values match none +vignette = false +saturation = 1.0 + +[textures] +noise = "textures/noise.png" # replaces the prelude's noise_texture (256x256 random RGB without it) ``` Options become WGSL [pipeline-overridable constants](https://www.w3.org/TR/WGSL/#override-decls): the shader @@ -176,6 +203,29 @@ Prelude helpers: `linear_depth(depth) -> f32` (blocks from the eye), `view_posit The uniform layout only grows: a new field goes at the end and the `api` number goes up; a pack that declares an older `api` still loads. +An `api = 2` pack's stages get a second prelude after the first (`shader_pack_prelude_api2.wgsl`; api 1 packs don't, +so names they declare themselves can't clash): + +| Binding | WGSL | What | +| --- | --- | --- | +| 6 | `frame_ext: FrameExt` (uniform) | last frame's view and projection and camera, the shadow map's matrices, resolution and distance, eye light, smoothed rain | +| 7, 8 | `scene_normal`, `scene_material: texture_2d` | the G-buffer (below) | +| 9 | `opaque_depth: texture_depth_2d` | the world's depth before translucent geometry (water, glass, ice) | +| 10, 11 | `shadow_depth: texture_depth_2d`, `shadow_sampler: sampler_comparison` | the sun's (the moon's at night) shadow map | +| 12, 13 | `noise_texture: texture_2d`, `repeat_sampler: sampler` | `[textures] noise`, linear, repeat | + +Helpers: `opaque_depth_at(uv)`, `world_normal_at(uv)`, `material_at(uv)` (block light, sky light, translucent mask, +roughness), `reproject_uv(world_offset)` (last frame's uv and depth), `sample_shadow(world_offset, normal)` (5-tap +PCF, 1 lit .. 0 shadowed), `aces_tonemap(rgb)`. + +What each costs, only while a stage reads it (naga reports the bindings each entry point uses): the opaque depth, a +depth copy between the opaque and translucent halves of the world pass; the G-buffer, one full-screen pass after +the world; the shadow map, a depth pass of the terrain and entities from the light. Limits of this first slice: the +G-buffer is reconstructed from depth and colour (normals from neighbouring depths, block light estimated from +brightness, sky light the camera's), not written by the world's shaders; the shadow map holds the sections the +camera draws, so casters outside the view throw no shadow, and none of the terrain where Metal draws sections as one +list (`gfx/flat.rs`, more than 4096 of them). The `deferred`, `gbuffer` and `shadow` stages above replace these. + ### How it renders With a pack on, the world pass draws into the world target of `gfx/world_post.rs` (it exists already for resolution diff --git a/examples/shaderpacks/horizon-ultra/pack.toml b/examples/shaderpacks/horizon-ultra/pack.toml index 446115073..9a59eec90 100644 --- a/examples/shaderpacks/horizon-ultra/pack.toml +++ b/examples/shaderpacks/horizon-ultra/pack.toml @@ -1,15 +1,15 @@ # Horizon Ultra: multi-pass API 2 WGSL shader pack with PCF directional shadows, -# G-buffer GTAO, water SSR & absorption, volumetric godrays, HDR bloom and ACES tonemapping. +# screen-space AO, water SSR & absorption, screen-space godrays, HDR bloom and ACES tonemapping. [pack] name = "Horizon Ultra" -description = "PCF sun/moon shadows, GTAO, water reflections, volumetric godrays, bloom and ACES filmic tonemapping." +description = "PCF sun/moon shadows, ambient occlusion, water reflections, godrays, bloom and ACES filmic tonemapping." authors = ["Horizon contributors"] version = "2.0.0" license = "MIT" api = 2 [[stage]] -kind = "deferred" +kind = "composite" shader = "shaders/deferred_lighting.wgsl" format = "rgba16float" @@ -23,10 +23,9 @@ kind = "composite" shader = "shaders/bloom_godrays.wgsl" scale = 0.5 format = "rgba16float" -mipmap = true [[stage]] -kind = "final" +kind = "composite" shader = "shaders/final_tonemap.wgsl" [profiles.low] @@ -82,8 +81,8 @@ max = 1.0 step = 0.05 [options.ao_strength] -label = "Ambient Occlusion (GTAO)" -description = "Screen-space horizon ambient occlusion in corners and crevices." +label = "Ambient Occlusion" +description = "Screen-space ambient occlusion in corners and crevices." default = 0.75 min = 0.0 max = 1.5 @@ -95,7 +94,7 @@ description = "Screen-space sky and terrain reflections on water and translucent default = true [options.godrays] -label = "Volumetric Godrays" +label = "Godrays" description = "Atmospheric light shafts cast through trees and terrain towards the sun." default = true diff --git a/examples/shaderpacks/horizon-ultra/shaders/bloom_godrays.wgsl b/examples/shaderpacks/horizon-ultra/shaders/bloom_godrays.wgsl index 534e9d983..d175eab6c 100644 --- a/examples/shaderpacks/horizon-ultra/shaders/bloom_godrays.wgsl +++ b/examples/shaderpacks/horizon-ultra/shaders/bloom_godrays.wgsl @@ -1,5 +1,5 @@ // Stage 3 (Composite, half-resolution): HDR bloom extraction + 9-tap tent filter -// and radial volumetric light shafts (godrays) towards the sun/moon. +// and radial light shafts (screen-space godrays) towards the sun/moon. override godrays: bool = true; override bloom_strength: f32 = 0.35; @@ -30,7 +30,7 @@ override bloom_strength: f32 = 0.35; } } - // Radial volumetric godrays cast from the sun's screen projection. + // Radial godrays from the sun's screen projection. var shafts = vec3(0.0); if godrays && frame.camera_state.x == 0.0 && frame.dimension.y > 0.5 { let sun_clip = frame.projection * (frame.view * vec4(frame.sun.xyz * 128.0, 1.0)); diff --git a/examples/shaderpacks/horizon-ultra/shaders/deferred_lighting.wgsl b/examples/shaderpacks/horizon-ultra/shaders/deferred_lighting.wgsl index 3930a5c21..e44773f37 100644 --- a/examples/shaderpacks/horizon-ultra/shaders/deferred_lighting.wgsl +++ b/examples/shaderpacks/horizon-ultra/shaders/deferred_lighting.wgsl @@ -1,10 +1,10 @@ -// Stage 1 (Deferred): G-buffer normal reconstruction, multi-tap GTAO ambient +// Stage 1: G-buffer normals, 8-tap screen-space ambient // occlusion, directional sun/moon PCF shadow mapping, and rain puddle wetness. override shadows: bool = true; override shadow_strength: f32 = 0.85; override ao_strength: f32 = 0.75; -fn compute_gtao(uv: vec2, depth: f32, view_pos: vec3) -> f32 { +fn compute_ao(uv: vec2, depth: f32, view_pos: vec3) -> f32 { if ao_strength <= 0.001 { return 1.0; } @@ -60,7 +60,7 @@ fn compute_gtao(uv: vec2, depth: f32, view_pos: vec3) -> f32 { let mat = material_at(in.uv); // Ambient occlusion from depth discontinuity neighborhood. - let ao = compute_gtao(in.uv, depth, view_pos); + let ao = compute_ao(in.uv, depth, view_pos); // Directional sun/moon shadow factor. var shadow = 1.0; From fe7bb3a34b54da4792b6f9b201a6e2eb2bd4c9ca Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 14:02:12 +0200 Subject: [PATCH 54/62] Java packs: the world goes where the pack's terrain program draws MakeUp's gbuffers write colortex1, and its composites read the world from there: with the world in colortex0, it showed nothing but fog. Iris's fallbacks for terrain pick the program (gbuffers_terrain, then textured_lit, textured, basic); its first draw buffer takes the world. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx/java_stages.rs | 29 ++++++++++------ crates/horizon-client/src/java_pack.rs | 6 +++- crates/horizon-shaderpack/src/pipeline.rs | 18 ++++++++++ crates/horizon-shaderpack/tests/pack.rs | 36 ++++++++++++++++++++ 4 files changed, 77 insertions(+), 12 deletions(-) diff --git a/crates/horizon-client/src/gfx/java_stages.rs b/crates/horizon-client/src/gfx/java_stages.rs index f86055919..5079a8f03 100644 --- a/crates/horizon-client/src/gfx/java_stages.rs +++ b/crates/horizon-client/src/gfx/java_stages.rs @@ -2,7 +2,8 @@ //! Iris's colour targets (`colortex0..`, each with a main and an alternate //! side) and the pack's `begin`, `prepare`, `deferred`, `composite` and //! `final` programs as full-screen passes over them, as Iris's -//! `CompositeRenderer` runs them. Horizon's world enters `colortex0` and +//! `CompositeRenderer` runs them. Horizon's world enters the target the +//! pack's terrain program draws to (`colortex0` for most packs) and //! `depthtex0` after `prepare`, where Iris's gbuffers programs would have //! drawn (`depthtex1`/`depthtex2`: its depth before translucent geometry), //! and the last picture goes to `world_post`. The @@ -249,7 +250,8 @@ struct Bound { /// Per pass, then `final`. groups: Vec, world_in: (wgpu::RenderPipeline, wgpu::BindGroup), - /// The world goes to colortex0's alternate side. + /// The world's target, and whether the world goes to its alternate side. + world_target: u32, world_alt: bool, final_target: Option, present: (wgpu::RenderPipeline, wgpu::BindGroup), @@ -262,6 +264,7 @@ struct Bound { struct Folder { targets: Vec, world_at: usize, + world_target: u32, flipped_after_prepare: BTreeSet, flipped_at_end: BTreeSet, passes: Vec, @@ -326,6 +329,7 @@ impl JavaStages { Ok::<_, String>(Folder { targets: plan.targets.clone(), world_at: plan.world_at, + world_target: plan.world_target, flipped_after_prepare: plan.flipped_after_prepare.clone(), flipped_at_end: plan.flipped_at_end.clone(), passes, @@ -486,8 +490,9 @@ impl JavaStages { let folder = &self.folders[folder_index]; let plan = folder; let all = folder.passes.iter().chain(&folder.final_pass); - // Every target a pass reads or writes, and colortex0 (the world). - let mut used: BTreeSet = [0].into(); + // Every target a pass reads or writes, colortex0 (shown without + // `final`) and the world's. + let mut used: BTreeSet = [0, folder.world_target].into(); for pass in all.clone() { used.extend(pass.draw_buffers.iter().copied()); used.extend(pass.samplers.iter().filter_map(|s| match s.source { @@ -588,15 +593,15 @@ impl JavaStages { }) .collect(); - // The world goes into colortex0's side the gbuffers would write. - let colortex0 = &targets[&0]; + // The world goes into its target's side the gbuffers would write. + let world_target = &targets[&folder.world_target]; let world_pipeline = blit_pipeline( device, &self.common, &self.common.world_layout, "world_in", &[ - colortex0.format, + world_target.format, wgpu::TextureFormat::R32Float, wgpu::TextureFormat::R32Float, ], @@ -630,6 +635,7 @@ impl JavaStages { .create_view(&Default::default()) }); // Without `final`, Iris shows colortex0 as the last pass left it. + let colortex0 = &targets[&0]; let shown = final_target.clone().unwrap_or_else(|| { if plan.flipped_at_end.contains(&0) { colortex0.alt_view.clone() @@ -668,7 +674,8 @@ impl JavaStages { opaque_depth, groups, world_in: (world_pipeline, world_group), - world_alt: plan.flipped_after_prepare.contains(&0), + world_target: folder.world_target, + world_alt: plan.flipped_after_prepare.contains(&folder.world_target), final_target, present: (present_pipeline, present_group), output_view, @@ -679,11 +686,11 @@ impl JavaStages { } fn world_in(encoder: &mut wgpu::CommandEncoder, bound: &Bound) { - let colortex0 = &bound.targets[&0]; + let target = &bound.targets[&bound.world_target]; let side = if bound.world_alt { - &colortex0.alt_view + &target.alt_view } else { - &colortex0.main_view + &target.main_view }; let attachments = [ Some(color_attachment(side, None)), diff --git a/crates/horizon-client/src/java_pack.rs b/crates/horizon-client/src/java_pack.rs index 5e592d1b6..ee4d29d61 100644 --- a/crates/horizon-client/src/java_pack.rs +++ b/crates/horizon-client/src/java_pack.rs @@ -23,8 +23,11 @@ pub struct JavaFolder { /// `begin*`, `prepare*`, `deferred*`, `composite*`, in order. pub passes: Vec, /// How many of `passes` run before the world (`begin*`, `prepare*`): the - /// world's colour and depth enter `colortex0` and `depthtex*` after them. + /// world's colour and depth enter `world_target` and `depthtex*` after them. pub world_at: usize, + /// The colour target the world goes into, where the pack's terrain + /// program draws (MakeUp: colortex1). + pub world_target: u32, /// The targets whose alternate side the world is written to. pub flipped_after_prepare: BTreeSet, pub final_pass: Option, @@ -145,6 +148,7 @@ pub fn load( folder: name.to_owned(), targets: plan.targets, world_at: early.count(), + world_target: plan.world_target, passes, flipped_after_prepare: plan.flipped_after_prepare, final_pass, diff --git a/crates/horizon-shaderpack/src/pipeline.rs b/crates/horizon-shaderpack/src/pipeline.rs index 89898eb07..d851fc23a 100644 --- a/crates/horizon-shaderpack/src/pipeline.rs +++ b/crates/horizon-shaderpack/src/pipeline.rs @@ -313,6 +313,10 @@ pub struct Passes { /// The targets gbuffers programs (and Horizon's world) write on their /// alternate side, before and after translucent geometry. pub flipped_after_prepare: BTreeSet, + /// The target Horizon's world goes into: the first one `gbuffers_terrain` + /// (or the program Iris falls back to for terrain) draws to, `colortex0` + /// without one. + pub world_target: u32, pub deferred: Vec, pub flipped_after_translucent: BTreeSet, pub composite: Vec, @@ -532,6 +536,20 @@ impl JavaPack { out.begin = run(&groups[0], "begin_pre", &mut flipped)?; out.prepare = run(&groups[1], "prepare_pre", &mut flipped)?; out.flipped_after_prepare = flipped.clone(); + // Iris's fallbacks for terrain (`ProgramFallbackResolver`). + let terrain = [ + "gbuffers_terrain", + "gbuffers_textured_lit", + "gbuffers_textured", + "gbuffers_basic", + ] + .into_iter() + .find(|name| exists(name)); + if let Some(name) = terrain { + let buffers = + draw_buffers(&fragment(name)?).map_err(|e| format!("{}: {e}", path(name)))?; + out.world_target = buffers.and_then(|b| b.first().copied()).unwrap_or(0); + } out.deferred = run(&groups[2], "deferred_pre", &mut flipped)?; out.flipped_after_translucent = flipped.clone(); out.composite = run(&groups[3], "composite_pre", &mut flipped)?; diff --git a/crates/horizon-shaderpack/tests/pack.rs b/crates/horizon-shaderpack/tests/pack.rs index c957d7fb4..1e2ee8158 100644 --- a/crates/horizon-shaderpack/tests/pack.rs +++ b/crates/horizon-shaderpack/tests/pack.rs @@ -292,6 +292,8 @@ fn plans_the_full_screen_passes() { assert_eq!(passes.composite[0].mipmapped, [3].into()); assert_eq!(passes.composite[1].scale, 0.5); assert_eq!(passes.flipped_after_prepare, [].into()); + // No gbuffers programs: the world goes into colortex0. + assert_eq!(passes.world_target, 0); assert_eq!(passes.flipped_after_translucent, [3].into()); assert_eq!(passes.flipped_at_end, [1, 2, 3].into()); let final_pass = passes.final_pass.unwrap(); @@ -302,6 +304,40 @@ fn plans_the_full_screen_passes() { assert_eq!(final_pass.reads_alt, [1, 2, 3].into()); } +/// The world enters the target terrain draws to first (MakeUp's colortex1), +/// through Iris's fallbacks when `gbuffers_terrain` is missing or disabled. +#[test] +fn the_world_goes_where_terrain_draws() { + let dir = scratch("world-target"); + let shaders = dir.join("shaders"); + std::fs::create_dir_all(&shaders).unwrap(); + let write = |name: &str, text: &str| std::fs::write(shaders.join(name), text).unwrap(); + for program in ["composite", "gbuffers_terrain", "gbuffers_textured"] { + write(&format!("{program}.vsh"), "void main() {}\n"); + } + write("composite.fsh", "void main() {}\n"); + write( + "gbuffers_textured.fsh", + "void main() {\n/* DRAWBUFFERS:12 */\n gl_FragData[0] = vec4(1.0);\n}\n", + ); + write( + "gbuffers_terrain.fsh", + "void main() {\n#ifdef GRASS\n/* DRAWBUFFERS:42 */\n#else\n/* DRAWBUFFERS:3 */\n#endif\n gl_FragData[0] = vec4(1.0);\n}\n", + ); + let target = |properties: &str| { + write("shaders.properties", properties); + let pack = JavaPack::open(&dir).unwrap(); + let values = pack.values(&BTreeMap::new()); + let properties = pack.properties(&values, &env()).unwrap(); + pack.passes("", &values, &env(), &properties) + .unwrap() + .world_target + }; + assert_eq!(target(""), 3); + assert_eq!(target("program.gbuffers_terrain.enabled = false\n"), 1); + std::fs::remove_dir_all(dir).unwrap(); +} + fn scratch(name: &str) -> PathBuf { std::env::temp_dir().join(format!("horizon-shaderpack-{name}-{}", std::process::id())) } From 963d5cedd3671d1c04569b89d98940cd7d9187f9 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 14:02:12 +0200 Subject: [PATCH 55/62] Shader packs: keep the opaque depth and G-buffer only for packs that read them The world target made the opaque depth, normal and material textures for every scaled or anti-aliased frame, packs or not: 12 bytes a pixel nobody read. They now follow what the pack reads, and Post::generation tells the stages to bind again when its targets change (a recreated target of the same size, or a shadow map made after the stages bound). Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx.rs | 12 +- crates/horizon-client/src/gfx/java_stages.rs | 11 +- crates/horizon-client/src/gfx/pack_stages.rs | 10 +- crates/horizon-client/src/gfx/world_post.rs | 199 +++++++++++-------- 4 files changed, 140 insertions(+), 92 deletions(-) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 255f4dd0a..6a154d0de 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -3707,9 +3707,15 @@ impl Renderer { } else { self.world_post.shadow_active = false; } - let scaled = - self.world_post - .prepare(&self.device, [self.config.width, self.config.height], pack); + let scaled = self.world_post.prepare( + &self.device, + [self.config.width, self.config.height], + pack, + world_post::Extras { + opaque_depth, + gbuffer, + }, + ); let (world_view, world_depth) = match &scaled { Some((color, depth)) => (color, depth), None => (&view_target, &self.depth), diff --git a/crates/horizon-client/src/gfx/java_stages.rs b/crates/horizon-client/src/gfx/java_stages.rs index 5079a8f03..14d25745e 100644 --- a/crates/horizon-client/src/gfx/java_stages.rs +++ b/crates/horizon-client/src/gfx/java_stages.rs @@ -244,6 +244,8 @@ struct Common { struct Bound { folder: usize, size: [u32; 2], + /// `world_post`'s targets it binds (`Post::generation`). + post_generation: u64, targets: BTreeMap, depth: wgpu::TextureView, opaque_depth: wgpu::TextureView, @@ -382,11 +384,9 @@ impl JavaStages { ) -> &wgpu::BindGroup { let dimension = (frame.dimension[0] as i32).clamp(-1, 1); let folder = self.folder_for[(dimension + 1) as usize].unwrap_or(0); - if self - .bound - .as_ref() - .is_none_or(|b| b.folder != folder || b.size != size) - { + if self.bound.as_ref().is_none_or(|b| { + b.folder != folder || b.size != size || b.post_generation != post.generation() + }) { self.bound = Some(self.bind(device, queue, folder, color, depth, size, post)); } let now = std::time::Instant::now(); @@ -669,6 +669,7 @@ impl JavaStages { Bound { folder: folder_index, size, + post_generation: post.generation(), targets, depth, opaque_depth, diff --git a/crates/horizon-client/src/gfx/pack_stages.rs b/crates/horizon-client/src/gfx/pack_stages.rs index f80a64ce1..a067812e8 100644 --- a/crates/horizon-client/src/gfx/pack_stages.rs +++ b/crates/horizon-client/src/gfx/pack_stages.rs @@ -129,12 +129,12 @@ pub struct PackStages { shadow_sampler: wgpu::Sampler, noise_view: wgpu::TextureView, passes: Vec, - /// Built for this world target size. + /// Built for this world target size and `world_post` generation. targets: Vec, /// `world_post`'s bindings of the last stage's output. output: Option, world_size: [u32; 2], - shadow_size: u32, + post_generation: u64, started: std::time::Instant, last: Option, frames: u32, @@ -330,7 +330,7 @@ impl PackStages { targets: Vec::new(), output: None, world_size: [0, 0], - shadow_size: 0, + post_generation: u64::MAX, started: std::time::Instant::now(), last: None, frames: 0, @@ -355,11 +355,11 @@ impl PackStages { eye_light: [u8; 2], ) -> &wgpu::BindGroup { if self.world_size != size - || self.shadow_size != post.shadow_resolution + || self.post_generation != post.generation() || self.targets.len() != self.passes.len() { self.world_size = size; - self.shadow_size = post.shadow_resolution; + self.post_generation = post.generation(); self.targets.clear(); for pass in &self.passes { let target_size = size.map(|v| ((v as f32 * pass.scale).round() as u32).max(1)); diff --git a/crates/horizon-client/src/gfx/world_post.rs b/crates/horizon-client/src/gfx/world_post.rs index f592e8a1f..cb3e4b41c 100644 --- a/crates/horizon-client/src/gfx/world_post.rs +++ b/crates/horizon-client/src/gfx/world_post.rs @@ -102,20 +102,33 @@ struct GbufferUniform { env: [f32; 4], } +/// What the frame's shader pack reads beyond the world's colour and depth: +/// `Post` keeps these targets only while one does. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub struct Extras { + pub opaque_depth: bool, + pub gbuffer: bool, +} + struct WorldTarget { size: [u32; 2], + extras: Extras, color: wgpu::TextureView, depth_tex: wgpu::Texture, depth: wgpu::TextureView, - opaque_depth_tex: wgpu::Texture, - opaque_depth: wgpu::TextureView, - normal: wgpu::TextureView, - material: wgpu::TextureView, - gbuffer_group: wgpu::BindGroup, + /// With `extras.opaque_depth` or `extras.gbuffer` (which reads it). + opaque_depth: Option<(wgpu::Texture, wgpu::TextureView)>, + gbuffer: Option, group: wgpu::BindGroup, opaque_captured: bool, } +struct Gbuffer { + normal: wgpu::TextureView, + material: wgpu::TextureView, + group: wgpu::BindGroup, +} + struct ShadowTarget { resolution: u32, depth: wgpu::TextureView, @@ -136,6 +149,8 @@ pub struct Post { pub antialias: bool, target: Option, shadow: Option, + /// Bumped whenever a target is made: bindings of the old ones are stale. + generation: u64, fallback_shadow: wgpu::TextureView, fallback_color: wgpu::TextureView, pub shadow_view: Mat4, @@ -363,6 +378,7 @@ impl Post { antialias: false, target: None, shadow: None, + generation: 0, fallback_shadow, fallback_color, shadow_view: Mat4::IDENTITY, @@ -374,12 +390,14 @@ impl Post { } /// The world's colour and depth targets this frame, or `None` to draw - /// it straight to the screen. `pack`: a shader pack runs this frame. + /// it straight to the screen. `pack`: a shader pack runs this frame, + /// reading `extras`. pub fn prepare( &mut self, device: &wgpu::Device, window: [u32; 2], pack: bool, + extras: Extras, ) -> Option<(wgpu::TextureView, wgpu::TextureView)> { if self.scale == 1.0 && !self.antialias && !pack { self.target = None; @@ -387,7 +405,12 @@ impl Post { return None; } let size = window.map(|v| ((v as f32 * self.scale).round() as u32).clamp(1, 8192)); - if self.target.as_ref().is_none_or(|t| t.size != size) { + if self + .target + .as_ref() + .is_none_or(|t| t.size != size || t.extras != extras) + { + self.generation += 1; let extent = wgpu::Extent3d { width: size[0], height: size[1], @@ -419,63 +442,69 @@ impl Post { | wgpu::TextureUsages::COPY_SRC, ); let depth = depth_tex.create_view(&Default::default()); - let opaque_depth_tex = make_tex( - "Opaque world depth", - wgpu::TextureFormat::Depth32Float, - wgpu::TextureUsages::RENDER_ATTACHMENT - | wgpu::TextureUsages::TEXTURE_BINDING - | wgpu::TextureUsages::COPY_DST, - ); - let opaque_depth = opaque_depth_tex.create_view(&Default::default()); - let normal = make_tex( - "World G-buffer normal", - wgpu::TextureFormat::Rgba8Unorm, - wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, - ) - .create_view(&Default::default()); - let material = make_tex( - "World G-buffer material", - wgpu::TextureFormat::Rgba8Unorm, - wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, - ) - .create_view(&Default::default()); - let gbuffer_group = device.create_bind_group(&wgpu::BindGroupDescriptor { - label: Some("Horizon gbuffer"), - layout: &self.gbuffer_layout, - entries: &[ - wgpu::BindGroupEntry { - binding: 0, - resource: wgpu::BindingResource::TextureView(&color), - }, - wgpu::BindGroupEntry { - binding: 1, - resource: wgpu::BindingResource::TextureView(&depth), - }, - wgpu::BindGroupEntry { - binding: 2, - resource: wgpu::BindingResource::TextureView(&opaque_depth), - }, - wgpu::BindGroupEntry { - binding: 3, - resource: wgpu::BindingResource::Sampler(&self.nearest), - }, - wgpu::BindGroupEntry { - binding: 4, - resource: self.gbuffer_uniform.as_entire_binding(), - }, - ], + let opaque_depth = (extras.opaque_depth || extras.gbuffer).then(|| { + let tex = make_tex( + "Opaque world depth", + wgpu::TextureFormat::Depth32Float, + wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, + ); + let view = tex.create_view(&Default::default()); + (tex, view) }); + let gbuffer = opaque_depth + .as_ref() + .filter(|_| extras.gbuffer) + .map(|(_, opaque)| { + let color_target = |label| { + make_tex( + label, + wgpu::TextureFormat::Rgba8Unorm, + wgpu::TextureUsages::RENDER_ATTACHMENT + | wgpu::TextureUsages::TEXTURE_BINDING, + ) + .create_view(&Default::default()) + }; + let group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("Horizon gbuffer"), + layout: &self.gbuffer_layout, + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: wgpu::BindingResource::TextureView(&color), + }, + wgpu::BindGroupEntry { + binding: 1, + resource: wgpu::BindingResource::TextureView(&depth), + }, + wgpu::BindGroupEntry { + binding: 2, + resource: wgpu::BindingResource::TextureView(opaque), + }, + wgpu::BindGroupEntry { + binding: 3, + resource: wgpu::BindingResource::Sampler(&self.nearest), + }, + wgpu::BindGroupEntry { + binding: 4, + resource: self.gbuffer_uniform.as_entire_binding(), + }, + ], + }); + Gbuffer { + normal: color_target("World G-buffer normal"), + material: color_target("World G-buffer material"), + group, + } + }); let group = self.bind(device, &color); self.target = Some(WorldTarget { size, + extras, color, depth_tex, depth, - opaque_depth_tex, opaque_depth, - normal, - material, - gbuffer_group, + gbuffer, group, opaque_captured: false, }); @@ -523,6 +552,7 @@ impl Post { }) .create_view(&Default::default()); self.shadow = Some(ShadowTarget { resolution, depth }); + self.generation += 1; } let light_dir = if sun_dir.y >= -0.05 { sun_dir.normalize_or_zero() @@ -557,16 +587,19 @@ impl Post { /// right before translucent water and weather draw. pub fn capture_opaque_depth(&mut self, encoder: &mut wgpu::CommandEncoder) { let Some(t) = &mut self.target else { return }; + let Some((opaque, _)) = &t.opaque_depth else { + return; + }; encoder.copy_texture_to_texture( t.depth_tex.as_image_copy(), - t.opaque_depth_tex.as_image_copy(), + opaque.as_image_copy(), t.depth_tex.size(), ); t.opaque_captured = true; } /// Reconstruct the G-buffer `normal` and `material` textures after the - /// world pass finishes. + /// world pass finishes (with `Extras::gbuffer`). pub fn build_gbuffer( &mut self, queue: &wgpu::Queue, @@ -575,15 +608,11 @@ impl Post { eye_light: [u8; 2], wetness: f32, ) { - let Some(t) = &mut self.target else { return }; - if !t.opaque_captured { - encoder.copy_texture_to_texture( - t.depth_tex.as_image_copy(), - t.opaque_depth_tex.as_image_copy(), - t.depth_tex.size(), - ); - t.opaque_captured = true; + if !self.target.as_ref().is_some_and(|t| t.opaque_captured) { + self.capture_opaque_depth(encoder); } + let Some(t) = &self.target else { return }; + let Some(gbuffer) = &t.gbuffer else { return }; let [w, h] = t.size.map(|v| v.max(1) as f32); let uniform = GbufferUniform { inverse_view: frame.inverse_view, @@ -599,7 +628,7 @@ impl Post { queue.write_buffer(&self.gbuffer_uniform, 0, bytemuck::bytes_of(&uniform)); let attachments = [ Some(wgpu::RenderPassColorAttachment { - view: &t.normal, + view: &gbuffer.normal, resolve_target: None, depth_slice: None, ops: wgpu::Operations { @@ -608,7 +637,7 @@ impl Post { }, }), Some(wgpu::RenderPassColorAttachment { - view: &t.material, + view: &gbuffer.material, resolve_target: None, depth_slice: None, ops: wgpu::Operations { @@ -623,7 +652,7 @@ impl Post { ..Default::default() }); pass.set_pipeline(&self.gbuffer_pipeline); - pass.set_bind_group(0, &t.gbuffer_group, &[]); + pass.set_bind_group(0, &gbuffer.group, &[]); pass.draw(0..3, 0..1); } @@ -632,25 +661,37 @@ impl Post { self.target.as_ref().map(|t| t.size) } - /// The depth before translucent geometry (`capture_opaque_depth`). + /// Changes whenever `prepare` or `prepare_shadow` makes new targets: + /// bindings made from the views below must be made again. + pub fn generation(&self) -> u64 { + self.generation + } + + /// The depth before translucent geometry (`capture_opaque_depth`), or + /// the world's depth when nothing reads it. pub fn opaque_depth(&self) -> &wgpu::TextureView { - self.target - .as_ref() - .map_or(&self.fallback_shadow, |t| &t.opaque_depth) + match &self.target { + Some(WorldTarget { + opaque_depth: Some((_, view)), + .. + }) => view, + Some(t) => &t.depth, + None => &self.fallback_shadow, + } } /// Reconstructed world-space normals (`scene_normal`). pub fn normal(&self) -> &wgpu::TextureView { - self.target - .as_ref() - .map_or(&self.fallback_color, |t| &t.normal) + self.gbuffer().map_or(&self.fallback_color, |g| &g.normal) } /// Reconstructed material and light (`scene_material`). pub fn material(&self) -> &wgpu::TextureView { - self.target - .as_ref() - .map_or(&self.fallback_color, |t| &t.material) + self.gbuffer().map_or(&self.fallback_color, |g| &g.material) + } + + fn gbuffer(&self) -> Option<&Gbuffer> { + self.target.as_ref()?.gbuffer.as_ref() } /// The sun/moon shadow map (`shadow_depth` of api 2 packs). From 39ae54379601b12984c302462cf437ada48db790 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 14:02:12 +0200 Subject: [PATCH 56/62] Shader packs: test importing zips and folders, and refusing what isn't a pack Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/shader_pack.rs | 57 ++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/crates/horizon-client/src/shader_pack.rs b/crates/horizon-client/src/shader_pack.rs index d00384748..b1be9d3ea 100644 --- a/crates/horizon-client/src/shader_pack.rs +++ b/crates/horizon-client/src/shader_pack.rs @@ -1428,4 +1428,61 @@ override mode: i32 = 1; assert_eq!(values["invert"], "true"); assert!(load_values(&dir, "other").is_empty()); } + + /// Dropping a pack on the Shader Packs page: zips and folders, Java + /// and Horizon, and the things that aren't packs. + #[test] + fn imports_zips_and_folders_and_refuses_the_rest() { + let shaderpacks = scratch(); + let java = pack(&[("shaders/composite.fsh", "void main() {}\n")]); + let zip_path = scratch().join("Java Pack.zip"); + let mut zip = zip::ZipWriter::new(fs::File::create(&zip_path).unwrap()); + zip.start_file( + "Java Pack/shaders/final.fsh", + zip::write::SimpleFileOptions::default(), + ) + .unwrap(); + std::io::Write::write_all(&mut zip, b"void main() {}\n").unwrap(); + zip.finish().unwrap(); + + assert_eq!( + import_pack(&zip_path, &shaderpacks).unwrap(), + "Java Pack.zip" + ); + assert!(shaderpacks.join("Java Pack.zip").is_file()); + let folder = import_pack(&java, &shaderpacks).unwrap(); + assert!( + shaderpacks + .join(&folder) + .join("shaders/composite.fsh") + .is_file() + ); + // One already there is refused; one dropped from shaderpacks/ itself + // is just picked. + let again = import_pack(&zip_path, &shaderpacks).unwrap_err(); + assert!(again.contains("already"), "{again}"); + assert_eq!( + import_pack(&shaderpacks.join("Java Pack.zip"), &shaderpacks).unwrap(), + "Java Pack.zip" + ); + + let not_a_pack = pack(&[("readme.txt", "hello")]); + assert!( + import_pack(¬_a_pack, &shaderpacks) + .unwrap_err() + .contains("not a shader pack") + ); + let fake_zip = scratch().join("broken.zip"); + fs::write(&fake_zip, "not a zip").unwrap(); + assert!(import_pack(&fake_zip, &shaderpacks).is_err()); + let broken_horizon = pack(&[("pack.toml", "name = ")]); + assert!(import_pack(&broken_horizon, &shaderpacks).is_err()); + assert!(import_pack(&shaderpacks.join("missing"), &shaderpacks).is_err()); + let left: Vec<_> = fs::read_dir(&shaderpacks) + .unwrap() + .flatten() + .map(|e| e.file_name()) + .collect(); + assert_eq!(left.len(), 2, "nothing copied for refused packs: {left:?}"); + } } From fe3a3af5684f7afdb763d1c1f9f66dcc24bc68e0 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 14:16:51 +0200 Subject: [PATCH 57/62] Shader Packs page: the pack's settings button sits beside the folder button As in Iris's ShaderPackScreen: at the end of the list it scrolled out of sight with a few packs. It's greyed out while the picked pack has no options. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/options_ui.rs | 56 +++++++++++++++---------- 1 file changed, 35 insertions(+), 21 deletions(-) diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 1bb9953bf..66ceb93e1 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -1236,6 +1236,14 @@ impl OptionsUi { self.shader_pack_config = Some(config); self.shader_pack_edited = false; } + /// The picked pack has options or profiles to show. + fn shader_pack_has_settings(&self, s: &Settings) -> bool { + self.shader_pack_config.as_ref().is_some_and(|c| { + !s.horizon.shader_pack.is_empty() + && c.id == s.horizon.shader_pack + && (!c.options.is_empty() || !c.profiles.is_empty()) + }) + } fn shader_pack_dir(&self) -> std::path::PathBuf { if self.shader_packs.dir.as_os_str().is_empty() { crate::shader_pack::folder() @@ -1683,23 +1691,6 @@ impl OptionsUi { None, )); } - let has_settings = !s.horizon.shader_pack.is_empty() - && self.shader_pack_config.as_ref().is_some_and(|c| { - c.id == s.horizon.shader_pack - && (!c.options.is_empty() || !c.profiles.is_empty()) - }); - if has_settings { - rows.push(Row::Buttons( - button( - 0.0, - 0.0, - 310.0, - Text::literal("Shader Pack Settings..."), - Act::Push(Page::ShaderPackOptions), - ), - None, - )); - } rows } Page::ShaderPackOptions => { @@ -2185,6 +2176,10 @@ impl OptionsUi { if matches!(page, Page::Video | Page::Controls) { top = 38.0; } + if page == Page::ShaderPacks { + // Two footer rows, as Iris's ShaderPackScreen. + bottom = h - 57.0; + } out.push(Widget { x: 0.0, y: if matches!(page, Page::Video | Page::Controls) { @@ -2273,15 +2268,34 @@ impl OptionsUi { out[list_start..].iter_mut().for_each(|w| w.list = true); let folder = match page { Page::Mods => Some(("Open Mod Folder", Act::OpenModFolder)), - Page::ShaderPacks => { - Some(("Open Shader Pack Folder", Act::OpenShaderPackFolder)) - } Page::ShaderPackOptions => { Some(("Reset to Defaults", Act::ResetShaderPackOptions)) } _ => None, }; - if let Some((label, act)) = folder { + if page == Page::ShaderPacks { + // Iris: the folder and the pack's settings above Done. + out.push(button( + cx - 154.0, + h - 51.0, + 150.0, + Text::literal("Open Shader Pack Folder"), + Act::OpenShaderPackFolder, + )); + let settings = button( + cx + 4.0, + h - 51.0, + 150.0, + Text::literal("Shader Pack Settings..."), + Act::Push(Page::ShaderPackOptions), + ); + out.push(if self.shader_pack_has_settings(s) { + settings + } else { + inactive(settings) + }); + out.push(done(h - 27.0)); + } else if let Some((label, act)) = folder { out.push(button( cx - 154.0, h - 27.0, From d9591047fa44e7fc5c1bb3f2c4863e5bd0bc83e4 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 14:17:13 +0200 Subject: [PATCH 58/62] Shader pack docs: MakeUp, Chocapic13' and Photon on the Java path, and where the world goes Co-Authored-By: Claude Opus 5.5 --- docs/shader-packs.md | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/docs/shader-packs.md b/docs/shader-packs.md index 6718be0f7..3cd6a7191 100644 --- a/docs/shader-packs.md +++ b/docs/shader-packs.md @@ -427,9 +427,11 @@ What makes Horizon look like OpenGL to the pack: Measured on the Mac mini (M4 Pro) with the packs' default options: BSL v10.1.8 and Complementary Reimagined r5.9.3 grade and light Horizon's world as their post-processing would. Sildur's Vibrant v2.02 draws only its sky: its `deferred` reads the albedo `gbuffers_*` write to `colortex4`. Without `gbuffers_*` and `shadow`, no pack has its -shadows, water or sky look yet; Distant Horizons' and Voxy's depth read as far. Not supported yet: images and -compute (`.csh`; a pack that needs them doesn't load), mipmapped targets (`colortexNMipmapEnabled` is read but -ignored), custom textures, the option screen; shadow matrices are identity. +shadows, water or sky look yet; Distant Horizons' and Voxy's depth read as far. Horizon's world goes into the target +the pack's `gbuffers_terrain` (or the program Iris falls back to) draws to first: `colortex0` for most packs, +`colortex1` for MakeUp. Not supported yet: images and compute (`.csh`; a pack that needs them doesn't load), +mipmapped targets (`colortexNMipmapEnabled` is read but ignored), `.dat` and resource-location custom textures (PNG +files in the pack only); shadow matrices are identity. ### Compatibility @@ -438,6 +440,7 @@ the authors' pages (dev-only test inputs, kept outside the repository). "Loads" the overworld, Nether and End is preprocessed, translated and validated, as the game does when the pack is picked (`java_pack::tests::real_packs_load` with `HORIZON_TEST_SHADERPACKS`); "drawn" means it was also picked in the game and screenshotted. Only full-screen passes run (above), so no pack has its own terrain, water, shadows or sky yet. +The MakeUp, Chocapic13' and Photon rows are from 2026-10-23, on Metal and on Vulkan (RTX 4080). | Pack | Version | Result | First thing that stops it | | --- | --- | --- | --- | @@ -446,10 +449,12 @@ and screenshotted. Only full-screen passes run (above), so no pack has its own t | Complementary Unbound | r5.8 | loads: 27 passes | | | Sildur's Vibrant Extreme | 2.02 | drawn: 18 passes, only its sky (above) | | | Steadfast | 0.8.0 | drawn: 3 passes | | +| MakeUp Ultra Fast | 9.6 | drawn: 6 passes, its fog, light shafts and grade over Horizon's world | | +| Chocapic13' | V9 High | drawn: 16 passes; its default TAA upscaling shrinks the world in its `gbuffers_*` vertex programs, which don't run, so the picture is magnified 1/0.7: turn TAA Upscaling off in its settings | | | Bliss | 2.1.2 | fails | `world0/deferred.vsh`: an operation naga forbids in a vertex shader | | Bloop | 1.8.0-Alpha-3 | fails | `world0/prepare1.fsh`: `mat2(vec4)` and other constructors naga's GLSL front end refuses | | Noble | v1.9.9 | fails (Apple and NVIDIA) | `world0/deferred4.vsh`: a `vec3[9][9]` varying (nested arrays between stages) | -| Photon | v1.4 | fails | `world0/prepare.vsh`: a struct varying (`CloudsParameters`) | +| Photon | v1.4 | fails | `world0/deferred1.fsh`: `textureGather` | | Rethinking Voxels | r0.1-beta9 | fails | `world0/prepare.fsh`: `1 << 31` overflows naga's constant folding; it also needs images | What the translator does for these packs, as Iris (JCPP and its GLSL transformer) does: From 7cc47e2b55817b1cba0daaa88b1aa3af495c8e56 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 14:41:40 +0200 Subject: [PATCH 59/62] Delete ten tools/ scripts nothing references command_parse_summary, structure_start_oracle, fetch_client_assets, compare_structure_starts, profile_behaviour_cache, command_tree_diff, compare_loot_fill, compare_structure_blocks, test_lan_lifecycle and PROFILE_SHARED_JSON.md: no workflow, doc, harness, test or other tool names them (review-plan.md, Dead code). History keeps them. Co-Authored-By: Claude Opus 5.5 --- tools/PROFILE_SHARED_JSON.md | 85 ------------ tools/command_parse_summary.py | 36 ----- tools/command_tree_diff.py | 79 ----------- tools/compare_loot_fill.py | 91 ------------ tools/compare_structure_blocks.py | 113 --------------- tools/compare_structure_starts.py | 55 -------- tools/fetch_client_assets.py | 46 ------- tools/profile_behaviour_cache.py | 57 -------- tools/structure_start_oracle.py | 38 ----- tools/test_lan_lifecycle.py | 222 ------------------------------ 10 files changed, 822 deletions(-) delete mode 100644 tools/PROFILE_SHARED_JSON.md delete mode 100644 tools/command_parse_summary.py delete mode 100644 tools/command_tree_diff.py delete mode 100644 tools/compare_loot_fill.py delete mode 100644 tools/compare_structure_blocks.py delete mode 100644 tools/compare_structure_starts.py delete mode 100644 tools/fetch_client_assets.py delete mode 100644 tools/profile_behaviour_cache.py delete mode 100644 tools/structure_start_oracle.py delete mode 100644 tools/test_lan_lifecycle.py diff --git a/tools/PROFILE_SHARED_JSON.md b/tools/PROFILE_SHARED_JSON.md deleted file mode 100644 index 976e43ecb..000000000 --- a/tools/PROFILE_SHARED_JSON.md +++ /dev/null @@ -1,85 +0,0 @@ -# Reproducing PR #607 block-facts startup profiles - -These are loader-only measurements. They include `Assets::load`, `BlockFacts`, and -`Behaviours` and exclude content root preparation, graphics, input setup, first -frame, and the rest of the client startup sequence. No full-client startup gain -has been measured. The prepared `26.3` resource root must match the revision. - -## Historical release builds - -From the PR branch checkout, use an absolute prepared resource-root path and a -single, explicit Cargo release profile for each detached historical worktree: - -```sh -PR_ROOT="$(pwd)" -BENCH_ROOT="$(mktemp -d)" -mkdir -p "$BENCH_ROOT/bin" -CARGO_TARGET_DIR="$BENCH_ROOT/target" -export CARGO_TARGET_DIR - -for entry in baseline:e422bd13 a01:a01d47f2 cf:cf837118 cd:cd61e11b; do - name="${entry%%:*}" - revision="${entry#*:}" - git worktree add --detach "$BENCH_ROOT/$name" "$revision" -done - -# e422bd13 predates the profiler; add the same baseline example source used -# for the benchmark, without changing any production implementation. -cp "$PR_ROOT/tools/baseline_loader_profile.rs" \ - "$BENCH_ROOT/baseline/crates/horizon-client/examples/shared_json_startup_profile.rs" - -for name in baseline a01 cf cd; do - (cd "$BENCH_ROOT/$name" && \ - cargo build --offline --release -p horizon-client --example shared_json_startup_profile) - cp "$CARGO_TARGET_DIR/release/examples/shared_json_startup_profile" \ - "$BENCH_ROOT/bin/$name" -done - -cargo build --offline --release -p horizon-client --example shared_json_startup_profile -cp "$CARGO_TARGET_DIR/release/examples/shared_json_startup_profile" "$BENCH_ROOT/bin/current" - -python3 tools/profile_shared_json.py \ - --resources /absolute/path/to/.local/horizon-client/26.3 \ - --baseline-binary "$BENCH_ROOT/bin/baseline" \ - --a01-binary "$BENCH_ROOT/bin/a01" \ - --cf-binary "$BENCH_ROOT/bin/cf" \ - --cd-binary "$BENCH_ROOT/bin/cd" \ - --binary "$BENCH_ROOT/bin/current" \ - --repeats 10 --output "$BENCH_ROOT/five-way.json" -``` - -The source tree of each historical revision is exact. The baseline profiler is -an added standalone measurement example, and therefore does not alter its -historical loader logic. Comparisons use alternating forward/reverse process -order, separate processes, Linux `wait4` CPU time and peak RSS, and saved raw -samples with 25th/75th percentiles, extrema, build hashes and system load. -Keep concurrent compilation and other CPU-intensive jobs idle if possible. -`ru_maxrss` records process peak residency and cannot establish the real game's -memory usage after rendering begins. If system load rises, preserve rather than -discard outliers and report the uncertainty. - -## Decoding passes and buffer lifetime - -```sh -cargo build --offline --release -p horizon-client --example gameplay_decode_profile -python3 tools/profile_gameplay_decode.py \ - --resources /absolute/path/to/.local/horizon-client/26.3 \ - --repeats 10 --output "$BENCH_ROOT/decode.json" - -python3 tools/profile_shared_json.py \ - --resources /absolute/path/to/.local/horizon-client/26.3 \ - --variant released="$BENCH_ROOT/bin/current"@deferred \ - --variant retained="$BENCH_ROOT/bin/current"@deferred-held \ - --repeats 10 --output "$BENCH_ROOT/lifetime.json" -``` - -The decoder profile measures the `Validate` pass and typed `Gameplay` pass -separately, including the JSON read in `total_ms`. The primary facts loader -continues both passes to preserve JSON validation, error precedence and useful -diagnostics, including overwritten fields and raw geometry. The lifetime -comparison measures current process `VmRSS` after materialisation, plus peak -RSS across the process. An explicit `drop` releases owned Rust values, but the -allocator may retain physical pages, so immediate RSS savings are not implied. - -When finished, `git worktree remove` each temporary historical worktree. Do -not `git clean` or reset the active PR working tree. diff --git a/tools/command_parse_summary.py b/tools/command_parse_summary.py deleted file mode 100644 index 2cd8d1f68..000000000 --- a/tools/command_parse_summary.py +++ /dev/null @@ -1,36 +0,0 @@ -#!/usr/bin/env python3 -"""Group the mismatches of tools/test_command_parse_parity.py by cause. - -usage: command_parse_summary.py MISMATCHES.jsonl [ROOT] -""" -import collections -import json -import sys -from pathlib import Path - - -def describe(side, kind): - if kind == 'parse': - if side.get('ok'): - return 'OK' - return f"ERR {side.get('error')!r}@{'c' if side.get('cursor') else '0'}" - return f"SUGG[{len(side['list'])}]" - - -path = Path(sys.argv[1]) -only = sys.argv[2] if len(sys.argv) > 2 else None -groups = collections.Counter() -examples = {} -for line in path.open(encoding='utf-8'): - m = json.loads(line) - root = m['in'].split(' ')[0] - if only and root != only: - continue - key = (m['kind'], describe(m['vanilla'], m['kind']), describe(m['rust'], m['kind'])) - if m['kind'] == 'parse': - key = key[:1] + (key[1][:90], key[2][:90]) - groups[key] += 1 - examples.setdefault(key, m) -for key, count in sorted(groups.items(), key=lambda kv: -kv[1])[:int(sys.argv[3]) if len(sys.argv) > 3 else 40]: - ex = examples[key] - print(f'{count:6} {key[0]} vanilla={key[1]} rust={key[2]}\n e.g. {ex["in"]!r}') diff --git a/tools/command_tree_diff.py b/tools/command_tree_diff.py deleted file mode 100644 index 8bd049b7a..000000000 --- a/tools/command_tree_diff.py +++ /dev/null @@ -1,79 +0,0 @@ -#!/usr/bin/env python3 -"""Structural diff between vanilla's exported command tree and Horizon's. - -usage: command_tree_diff.py VANILLA_TREE.json RUST_TREE.json [ROOT] - -Reports, for every shared node, the children Horizon lacks or adds, differing -argument parsers and executable/redirect flags. Missing subtrees are reported -once at their root. -""" -import json -import sys - -LOOSE = { - # Horizon's coarse argument kinds that stand in for several vanilla parsers. - 'brigadier:string': {'brigadier:string', 'minecraft:message', 'minecraft:component'}, -} - - -def same_parser(vanilla, rust): - if vanilla == rust: - return True - return False - - -def keyed(children): - """Literals by name; arguments by position (their names are internal).""" - out = {} - index = 0 - for name, child in children.items(): - if child['type'] == 'literal': - out[('l', name)] = (name, child) - else: - out[('a', index)] = (name, child) - index += 1 - return out - - -def diff(path, v, r, out): - vc, rc = keyed(v.get('children', {})), keyed(r.get('children', {})) - for key, (name, node) in vc.items(): - if key not in rc: - out.append(('missing', path + [name], node.get('parser') or 'literal', count(node))) - for key, (name, node) in rc.items(): - if key not in vc: - out.append(('extra', path + [name], node.get('parser') or 'literal', count(node))) - for key, (name, a) in vc.items(): - if key not in rc: - continue - _, b = rc[key] - if a['type'] == 'argument' and not same_parser(a['parser'], b['parser']): - out.append(('parser', path + [name], f"{a['parser']} vs {b['parser']}", 0)) - if bool(a.get('executable')) != bool(b.get('executable')): - out.append(('executable', path + [name], f"vanilla={bool(a.get('executable'))}", 0)) - if bool(a.get('redirect')) != bool(b.get('redirect')): - out.append(('redirect', path + [name], f"vanilla={bool(a.get('redirect'))}", 0)) - diff(path + [name], a, b, out) - - -def count(node): - return 1 + sum(count(c) for c in node.get('children', {}).values()) - - -def main(): - vanilla = json.load(open(sys.argv[1])) - rust = json.load(open(sys.argv[2])) - only = sys.argv[3] if len(sys.argv) > 3 else None - if only: - vanilla = {'children': {only: vanilla['children'][only]}, 'type': 'root'} - rust = {'children': {only: rust['children'].get(only, {'children': {}, 'type': 'literal'})}, 'type': 'root'} - out = [] - diff([], vanilla, rust, out) - for kind, path, detail, size in out: - print(f'{kind:10} {" ".join(path)} [{detail}]' + (f' ({size} nodes)' if size else '')) - missing = sum(size for kind, _, _, size in out if kind == 'missing') - print(f'-- {len(out)} differences, {missing} vanilla nodes missing in Horizon') - - -if __name__ == '__main__': - main() diff --git a/tools/compare_loot_fill.py b/tools/compare_loot_fill.py deleted file mode 100644 index 7ad307420..000000000 --- a/tools/compare_loot_fill.py +++ /dev/null @@ -1,91 +0,0 @@ -#!/usr/bin/env python3 -"""Compare Rust container loot (examples/loot_fill) with vanilla LootTable.fill. - -usage: compare_loot_fill.py RESOURCES TABLES SEED... -TABLES is a comma-separated list or `chests` for every chest table. Builds the -loot_fill example, runs VanillaLootFillOracle and diffs slot contents -(enchantments compared as sets). Tables vanilla cannot fill without a level -(exploration maps) are reported and skipped. -""" -import collections -import os -import subprocess -import sys -from pathlib import Path -try: - from . import lab, test_rust_parity as base -except ImportError: - import lab - import test_rust_parity as base - - -def build_dir(): - return Path(os.environ['HORIZON_ORACLE_BUILD']) if os.environ.get('HORIZON_ORACLE_BUILD') else lab.LOCAL/'loot-fill-oracle' - - -def run_oracle(out, tables, seeds): - lock, jars, libraries = base.verify_artifacts() - source = lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaLootFillOracle.java' - build = build_dir() - classes = build/'classes' - classes.mkdir(parents=True, exist_ok=True) - dependencies = os.pathsep.join(map(str, [jars['server'], *libraries])) - compiled = subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-cp', dependencies, - '-d', str(classes), str(source)], capture_output=True, text=True) - if compiled.returncode: - raise SystemExit('javac failed:\n' + compiled.stderr[-3000:]) - result = subprocess.run(['java', '-Xmx2G', '-cp', str(classes)+os.pathsep+dependencies, - 'dev.horizonlab.parity.VanillaLootFillOracle', str(out), tables, *seeds], - capture_output=True, text=True) - if result.returncode: - lines = [line for line in (result.stdout + result.stderr).splitlines() if 'Exception' in line or 'Caused' in line] - raise SystemExit('oracle failed: ' + ' | '.join(lines[:5])) - - -def parse(lines): - fills, errors = collections.defaultdict(list), set() - for line in lines: - t = line.split() - if not t: - continue - if t[0] == 'table': - fills[(t[1], t[2])] - elif t[0] == 'error': - errors.add((t[1], t[2])) - elif t[0] == 'fill': - fills[(t[1], t[2])].append((int(t[3]), t[4], t[5], t[6], tuple(sorted(t[7:])))) - return fills, errors - - -def main(): - resources, tables, seeds = sys.argv[1], sys.argv[2], sys.argv[3:] - out = build_dir()/'vanilla.txt' - out.parent.mkdir(parents=True, exist_ok=True) - run_oracle(out, tables, seeds) - vanilla, errors = parse(out.read_text().splitlines()) - names = sorted({k[0] for k in vanilla} | {k[0] for k in errors}) - subprocess.run(['cargo', 'build', '--profile', 'fast', '-q', '-p', 'horizon-world', '--example', 'loot_fill'], - check=True, cwd=lab.ROOT) - rust_out = subprocess.run([str(lab.cargo_target()/'fast/examples/loot_fill'), resources, ','.join(names), *seeds], - check=True, capture_output=True, text=True).stdout - rust, _ = parse(rust_out.splitlines()) - matched = differ = 0 - for key in sorted(vanilla): - if key in errors: - continue - if vanilla[key] == rust.get(key): - matched += 1 - continue - differ += 1 - if differ <= 20: - print('DIFF', key, '\n vanilla', vanilla[key], '\n rust ', rust.get(key)) - tables = collections.Counter(k[0] for k in vanilla if k not in errors and vanilla[k] != rust.get(k)) - if tables: - print('differing tables:', dict(tables)) - skipped = sorted({k[0] for k in errors}) - print(f'{matched} of {matched + differ} fills match; skipped (needs a level): {skipped}') - return 1 if differ else 0 - - -if __name__ == '__main__': - sys.exit(main()) diff --git a/tools/compare_structure_blocks.py b/tools/compare_structure_blocks.py deleted file mode 100644 index 51d71f57b..000000000 --- a/tools/compare_structure_blocks.py +++ /dev/null @@ -1,113 +0,0 @@ -#!/usr/bin/env python3 -"""Compare structure placement (terrain + structure pieces, no placed features) -between vanilla and Rust for target chunks. - -usage: compare_structure_blocks.py RESOURCES SEED DIMENSION CX,CZ... -Runs VanillaStructurePlacementOracle and the structure_blocks example and -reports, per chunk, the blocks and block entities that differ. -""" -import json -import os -import subprocess -import sys -from pathlib import Path -try: - from . import lab, test_rust_parity as base -except ImportError: - import lab - import test_rust_parity as base - - -def build_dir(): - return Path(os.environ['HORIZON_ORACLE_BUILD']) if os.environ.get('HORIZON_ORACLE_BUILD') else lab.LOCAL/'structure-placement-oracle' - - -def run_oracle(out, args): - lock, jars, libraries = base.verify_artifacts() - source = lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStructurePlacementOracle.java' - classes = build_dir()/'classes' - classes.mkdir(parents=True, exist_ok=True) - dependencies = os.pathsep.join(map(str, [jars['server'], *libraries])) - compiled = subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-cp', dependencies, - '-d', str(classes), str(source)], capture_output=True, text=True) - if compiled.returncode: - raise SystemExit('javac failed:\n' + compiled.stderr[-3000:]) - result = subprocess.run(['java', '-Xmx4G', '-cp', str(classes)+os.pathsep+dependencies, - 'dev.horizonlab.parity.VanillaStructurePlacementOracle', str(out), *args], - capture_output=True, text=True) - if result.returncode: - lines = [line for line in (result.stdout + result.stderr).splitlines() if 'Exception' in line or 'Error' in line or '\tat ' in line] - raise SystemExit('oracle failed: ' + ' | '.join(lines[:8])) - - -def parse(lines): - chunks, current = {}, None - for line in lines: - t = line.split() - if not t: - continue - if t[0] == 'chunk': - current = (int(t[1]), int(t[2])) - chunks[current] = {'rows': {}, 'be': []} - elif t[0] == 'y' and current: - chunks[current]['rows'][int(t[1])] = t[2:] - elif t[0] == 'be' and current: - # Position, loot table and seed; the block entity type follows - # from the (separately compared) block state. - chunks[current]['be'].append(' '.join(t[1:4] + t[5:])) - return chunks - - -def state_names(resources): - names = {} - report = lab.LOCAL/'datagen/out/reports/blocks.json' - if report.exists(): - for block, info in json.loads(report.read_text()).items(): - for state in info['states']: - props = ','.join(f'{k}={v}' for k, v in sorted(state.get('properties', {}).items())) - names[str(state['id'])] = block + (f'[{props}]' if props else '') - return names - - -def main(): - resources, seed, dimension, targets = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4:] - out = build_dir()/'vanilla.txt' - out.parent.mkdir(parents=True, exist_ok=True) - run_oracle(out, [seed, dimension, *targets]) - vanilla = parse(out.read_text().splitlines()) - subprocess.run(['cargo', 'build', '--profile', 'fast', '-q', '-p', 'horizon-world', '--example', 'structure_blocks'], - check=True, cwd=lab.ROOT) - rust_out = subprocess.run([str(lab.cargo_target()/'fast/examples/structure_blocks'), resources, seed, dimension, *targets], - check=True, capture_output=True, text=True).stdout - (build_dir()/'rust.txt').write_text(rust_out) - rust = parse(rust_out.splitlines()) - names = state_names(resources) - failed = 0 - for key in sorted(vanilla): - v, r = vanilla[key], rust.get(key) - if r is None: - print(key, 'missing from Rust') - failed += 1 - continue - diffs = [] - for y, row in v['rows'].items(): - other = r['rows'].get(y, []) - for i, (a, b) in enumerate(zip(row, other)): - if a != b: - diffs.append((key[0] * 16 + i % 16, y, key[1] * 16 + i // 16, a, b)) - total = sum(len(row) for row in v['rows'].values()) - be_v, be_r = set(v['be']), set(r['be']) - status = 'match' if not diffs and be_v == be_r else 'DIFF' - print(f'chunk {key}: {status}; {total - len(diffs)} of {total} blocks equal; block entities {len(be_v & be_r)} of {len(be_v)} equal') - for x, y, z, a, b in diffs[:12]: - print(f' {x} {y} {z} vanilla {names.get(a, a)} rust {names.get(b, b)}') - for e in sorted(be_v - be_r)[:6]: - print(' only vanilla be', e) - for e in sorted(be_r - be_v)[:6]: - print(' only rust be', e) - failed += status != 'match' - return 1 if failed else 0 - - -if __name__ == '__main__': - sys.exit(main()) diff --git a/tools/compare_structure_starts.py b/tools/compare_structure_starts.py deleted file mode 100644 index 363e7b76f..000000000 --- a/tools/compare_structure_starts.py +++ /dev/null @@ -1,55 +0,0 @@ -#!/usr/bin/env python3 -"""Compare Rust structure starts (chunkgen_bench --starts) with the vanilla oracle. - -usage: compare_structure_starts.py VANILLA RUST [--all] -Pieces are compared by type, bounding box and (for jigsaw pieces) position, -rotation, ground level delta and junction count. Without --all, vanilla -starts of structure types Rust does not generate yet are only counted. -""" -import collections -import sys - - -def load(path): - starts = {} - current = None - for line in open(path): - t = line.split() - if not t: - continue - if t[0] == 'start': - current = (int(t[1]), int(t[2]), t[3]) - starts[current] = [' '.join(t[4:])] - elif t[0] == 'piece' and current: - starts[current].append(' '.join(t[1:14])) - return starts - - -def main(): - vanilla, rust = load(sys.argv[1]), load(sys.argv[2]) - generated = {k[2] for k in rust} - matched = 0 - missing = collections.Counter() - for key in sorted(vanilla): - if key not in rust: - missing[key[2]] += 1 - if key[2] in generated or '--all' in sys.argv: - print('missing', key) - continue - if vanilla[key] == rust[key]: - matched += 1 - continue - v, r = vanilla[key], rust[key] - print('DIFF', key, 'pieces', len(v) - 1, len(r) - 1) - for i, (a, b) in enumerate(zip(v, r)): - if a != b: - print(' first difference at line', i, '\n vanilla', a, '\n rust ', b) - break - for key in sorted(set(rust) - set(vanilla)): - print('extra', key) - print(f'{matched} of {len(vanilla)} vanilla starts match exactly; not generated by Rust:', dict(missing)) - return 0 if matched == len(rust) == sum(1 for k in vanilla if k[2] in generated) else 1 - - -if __name__ == '__main__': - sys.exit(main()) diff --git a/tools/fetch_client_assets.py b/tools/fetch_client_assets.py deleted file mode 100644 index 2027593c5..000000000 --- a/tools/fetch_client_assets.py +++ /dev/null @@ -1,46 +0,0 @@ -#!/usr/bin/env python3 -"""Copy the pinned version's indexed client assets that are not in the game -jar from your own official launcher install: language files and the language -list (pack.mcmeta), the unifont glyph archives and their font definitions, and -the built-in Programmer Art and High Contrast resource packs. Every object's -SHA-1 is verified. Nothing is downloaded; files go to the private client -resource directory (or --target) and are never committed.""" -import argparse -from pathlib import Path -import shutil - -import lab - - -def wanted(name): - return (name == 'pack.mcmeta' - or name.startswith('minecraft/lang/') - or name.startswith('minecraft/font/') - or name.startswith('minecraft/resourcepacks/')) - - -def main(): - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument('--target', type=Path, default=lab.RESOURCES, - help='prepared resource directory (default: .local/horizon-client/)') - parser.add_argument('--minecraft-dir', type=Path, - help="official launcher game directory (default: the launcher's own)") - args = parser.parse_args() - lock, directory = lab.config() - manifest = lab.import_manifest(lock, directory, args.minecraft_dir) - store, index = lab.launcher_assets(manifest, args.minecraft_dir) - target = args.target - target.mkdir(parents=True, exist_ok=True) - shutil.copyfile(index, target / 'asset-index.json') - objects = lab.json.loads(index.read_text())['objects'] - selected = {name: info for name, info in objects.items() if wanted(name)} - total = 0 - for name, info in selected.items(): - source = lab.launcher_object(store, info['hash']) - lab.import_copy(source, target / 'assets' / name, info['hash']) - total += info['size'] - print(f'Client assets ready: {len(selected)} files, {total / 1e6:.1f} MB') - - -if __name__ == '__main__': - main() diff --git a/tools/profile_behaviour_cache.py b/tools/profile_behaviour_cache.py deleted file mode 100644 index 00ba65a6d..000000000 --- a/tools/profile_behaviour_cache.py +++ /dev/null @@ -1,57 +0,0 @@ -#!/usr/bin/env python3 -"""Measure the resource-dependent Behaviours::load portion of client startup. - -Build the behaviour_load_profile example in the checkout to be measured first: - cargo build --release -p horizon-world --example behaviour_load_profile - -Run the profiler from the repository root with the matching example binary. -This measures behaviour loading, not time to first rendered frame. With ---cache-dir, the example reads and refreshes the resolved snapshot there, as the -client does with its .horizon-cache folder: the first load of a run builds it -when it is missing, the next loads restore it. -""" -import argparse -import json -import re -import statistics -import subprocess -from pathlib import Path - - -def main(): - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--binary", type=Path, default=Path("target/release/examples/behaviour_load_profile")) - parser.add_argument("--resources", type=Path, default=Path(".local/horizon-client/26.3")) - parser.add_argument("--cache-dir", type=Path, - help="snapshot folder (default: no snapshot, every load is uncached)") - parser.add_argument("--repeats", type=int, default=5) - parser.add_argument("--output", type=Path) - args = parser.parse_args() - if args.repeats < 1: - parser.error("--repeats must be at least one") - samples = [] - for _ in range(args.repeats): - command = [str(args.binary.resolve()), str(args.resources.resolve())] - if args.cache_dir: - command.append(str(args.cache_dir.resolve())) - run = subprocess.run(command, text=True, capture_output=True, check=True) - values = {key: float(value) for key, value in - re.findall(r"^(registry_ms|behaviours_[0-2]_ms)=([\d.]+)$", run.stderr, re.M)} - if len(values) != 4: - raise RuntimeError(f"incomplete profile output: {run.stderr}") - samples.append(values) - summary = {key: {"median_ms": round(statistics.median(row[key] for row in samples), 3), - "samples_ms": [row[key] for row in samples]} - for key in samples[0]} - result = {"scope": "behaviour loader only; not full client startup", - "binary": str(args.binary), "resources": str(args.resources), "repeats": args.repeats, - "cache_dir": str(args.cache_dir) if args.cache_dir else None, - "metrics": summary} - print(json.dumps(result, indent=2)) - if args.output: - args.output.parent.mkdir(parents=True, exist_ok=True) - args.output.write_text(json.dumps(result, indent=2) + "\n") - - -if __name__ == "__main__": - main() diff --git a/tools/structure_start_oracle.py b/tools/structure_start_oracle.py deleted file mode 100644 index dc622ae19..000000000 --- a/tools/structure_start_oracle.py +++ /dev/null @@ -1,38 +0,0 @@ -#!/usr/bin/env python3 -"""Run the vanilla structure-start oracle for a seed and chunk rectangle. - -usage: structure_start_oracle.py OUT SEED X0 Z0 X1 Z1 -""" -import os -import subprocess -from pathlib import Path -import sys -try: - from . import lab, test_rust_parity as base -except ImportError: - import lab - import test_rust_parity as base - - -def main(): - out, seed, x0, z0, x1, z1 = sys.argv[1:7] - lock, jars, libraries = base.verify_artifacts() - source = lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStructureStartOracle.java' - build = Path(os.environ['HORIZON_ORACLE_BUILD']) if os.environ.get('HORIZON_ORACLE_BUILD') else lab.LOCAL/'structure-start-oracle' - classes = build/'classes' - classes.mkdir(parents=True, exist_ok=True) - dependencies = os.pathsep.join(map(str, [jars['server'], *libraries])) - compiled = subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-cp', dependencies, - '-d', str(classes), str(source)], capture_output=True, text=True) - if compiled.returncode: - raise SystemExit('javac failed:\n' + compiled.stderr[-3000:]) - result = subprocess.run(['java', '-Xmx2G', '-cp', str(classes)+os.pathsep+dependencies, - 'dev.horizonlab.parity.VanillaStructureStartOracle', out, seed, x0, z0, x1, z1], - capture_output=True, text=True) - if result.returncode: - lines = [line for line in (result.stdout + result.stderr).splitlines() if 'Exception' in line or 'Caused' in line] - raise SystemExit('oracle failed: ' + ' | '.join(lines[:5])) - - -if __name__ == '__main__': - main() diff --git a/tools/test_lan_lifecycle.py b/tools/test_lan_lifecycle.py deleted file mode 100644 index 389b8438c..000000000 --- a/tools/test_lan_lifecycle.py +++ /dev/null @@ -1,222 +0,0 @@ -#!/usr/bin/env python3 -"""Check LAN shutdown when leaving a singleplayer world through the pause menu, -and that offline guests joining with their default names are not refused as the -host's profile (#195: everyone was "Player"). - -Requires a built horizon-client, prepared resources and a display on Unix: - xvfb-run -a python3 tools/test_lan_lifecycle.py --client target/fast/horizon-client -Worlds and settings are created in a temporary directory. -""" -import argparse -import json -import os -from pathlib import Path -import socket -import subprocess -import tempfile -import time - -try: - from . import lab -except ImportError: - import lab - -ROOT = Path(__file__).resolve().parents[1] -GROUP = '224.0.2.60' -DISCOVERY_PORT = 4445 - - -def command(endpoint, line): - with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as connection: - connection.settimeout(60) - connection.connect(str(endpoint)) - connection.sendall((line + '\n').encode()) - with connection.makefile('r') as reply: - result = json.loads(reply.readline()) - assert 'error' not in result, (line, result) - return result - - -def wait_for(endpoint, line, predicate, timeout=60): - deadline = time.monotonic() + timeout - while time.monotonic() < deadline: - try: - result = command(endpoint, line) - except (FileNotFoundError, ConnectionRefusedError): - time.sleep(0.1) - continue - if predicate(result): - return result - time.sleep(0.1) - raise AssertionError(f'timed out waiting for {line}') - - -def announcement(scanner, port, timeout): - deadline = time.monotonic() + timeout - marker = f'[AD]{port}[/AD]'.encode() - while time.monotonic() < deadline: - scanner.settimeout(max(0.001, deadline - time.monotonic())) - try: - message, _ = scanner.recvfrom(4096) - except socket.timeout: - return False - if marker in message: - return True - return False - - -def scenario(endpoint, scanner): - wait_for(endpoint, 'screen', lambda value: value['screen'] == 'title') - command(endpoint, 'open LanLifecycle 0 creative') - wait_for(endpoint, 'status', lambda value: value['player'] is not None - and value['pending_chunks'] == 0) - assert command(endpoint, 'lan status') == {'open': False} - port = 0 - for _ in range(2): - port = command(endpoint, f'lan open {port}')['port'] - with socket.create_connection(('127.0.0.1', port), timeout=2): - pass - assert announcement(scanner, port, 5), 'LAN world was not advertised' - command(endpoint, 'key esc tap') - screen = wait_for(endpoint, 'screen', lambda value: any( - button['label'] == 'Save and Quit to Title' for button in value['buttons'])) - assert screen['screen'] == 'paused', screen - command(endpoint, 'click-button Save and Quit to Title') - wait_for(endpoint, 'screen', lambda value: value['screen'] == 'title') - assert command(endpoint, 'lan status') == {'open': False}, 'LAN stayed open after leaving' - try: - connection = socket.create_connection(('127.0.0.1', port), timeout=2) - except ConnectionRefusedError: - pass - else: - connection.close() - raise AssertionError('LAN still accepts connections after leaving') - # Discard datagrams queued before shutdown, then listen for more than - # two announcement intervals (the pinger sends every 1.5 seconds). - scanner.setblocking(False) - try: - while True: - scanner.recvfrom(4096) - except BlockingIOError: - pass - assert not announcement(scanner, port, 3.5), 'LAN kept advertising after leaving' - command(endpoint, 'open LanLifecycle') - wait_for(endpoint, 'status', lambda value: value['player'] is not None - and value['pending_chunks'] == 0) - assert command(endpoint, 'lan status') == {'open': False}, 'LAN reopened with the world' - command(endpoint, 'lan open 0') - command(endpoint, 'quit') - - -def start_client(client, resources, home, endpoint, log, *extra): - return subprocess.Popen([ - str(client), '--resources', str(resources), '--render-distance', '2', - '--test-terrain', '--control-socket', str(endpoint), '--timeout-seconds', '180', *extra, - ], cwd=home, env=dict(os.environ, HORIZON_HOME=str(home), HORIZON_NO_AUDIO='1', - HORIZON_PLAYER_NAME=''), - stdout=log, stderr=subprocess.STDOUT) - - -def guest_names(endpoint, port, guests): - """Two guests with default names join together; a guest named like the host is refused.""" - names = [] - for home, guest in guests: - wait_for(guest, 'screen', lambda value: value['screen'] == 'title') - command(guest, f'connect 127.0.0.1:{port}') - wait_for(guest, 'status', lambda value: (value.get('server') or {}).get('joined')) - kept = (home / 'horizon-player.txt').read_text() - assert kept.startswith('name:Player') and kept.strip() != 'name:Player', kept - names.append(kept.strip().removeprefix('name:')) - assert names[0] != names[1], names - status = wait_for(endpoint, 'lan status', lambda value: len(value['guests']) == 2) - assert sorted(g['name'] for g in status['guests']) == sorted(names), status - # The same home keeps its name: leave and join again as the same profile. - home, guest = guests[0] - command(guest, 'disconnect') - wait_for(endpoint, 'lan status', lambda value: len(value['guests']) == 1) - command(guest, f'connect 127.0.0.1:{port}') - wait_for(guest, 'status', lambda value: (value.get('server') or {}).get('joined')) - assert (home / 'horizon-player.txt').read_text().strip() == f'name:{names[0]}' - # A guest that really is the host's offline profile is refused, the others stay. - command(guest, 'disconnect') - command(guest, f'connect 127.0.0.1:{port} Player') - refused = wait_for(guest, 'screen', lambda value: (value.get('menu') or {}).get('disconnected')) - assert 'another location' in refused['menu']['disconnected'], refused - status = command(endpoint, 'lan status') - assert [g['name'] for g in status['guests']] == [names[1]], status - return names - - -def main(): - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument('--client', type=Path, required=True) - parser.add_argument('--resources', type=Path, default=lab.RESOURCES) - args = parser.parse_args() - client, resources = args.client.resolve(), args.resources.resolve() - with tempfile.TemporaryDirectory(prefix='horizon-lan-') as directory: - work = Path(directory) - endpoint = work / 'control.sock' - with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as scanner: - scanner.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) - scanner.bind(('', DISCOVERY_PORT)) - scanner.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, - socket.inet_aton(GROUP) + socket.inet_aton('0.0.0.0')) - with (work / 'client.log').open('w+') as log: - process = start_client(client, resources, work, endpoint, log) - try: - scenario(endpoint, scanner) - assert process.wait(timeout=20) == 0, 'client exited unsuccessfully' - except Exception: - log.seek(0) - print('\n'.join(log.read().splitlines()[-20:])) - raise - finally: - stop(process) - names = guests_scenario(client, resources, work) - print('LAN lifecycle passed: leaving stops hosting and discovery; reopening stays private') - print(f'LAN guests passed: default names {names[0]} and {names[1]} joined together and kept; ' - '"Player" refused as the host\'s profile') - - -def stop(process): - if process.poll() is None: - process.terminate() - try: - process.wait(timeout=10) - except subprocess.TimeoutExpired: - process.kill() - process.wait(timeout=10) - - -def guests_scenario(client, resources, work): - host_home = work / 'host' - homes = [work / 'guest-a', work / 'guest-b'] - processes, logs = [], [] - try: - for home in [host_home, *homes]: - home.mkdir() - log = (home / 'client.log').open('w+') - logs.append(log) - processes.append(start_client(client, resources, home, home / 'control.sock', log)) - endpoint = host_home / 'control.sock' - wait_for(endpoint, 'screen', lambda value: value['screen'] == 'title') - command(endpoint, 'open LanGuests 0 creative') - wait_for(endpoint, 'status', lambda value: value['player'] is not None - and value['pending_chunks'] == 0) - port = command(endpoint, 'lan open 0')['port'] - return guest_names(endpoint, port, [(home, home / 'control.sock') for home in homes]) - except Exception: - for log in logs: - log.seek(0) - print(f'--- {log.name}') - print('\n'.join(log.read().splitlines()[-20:])) - raise - finally: - for process in processes: - stop(process) - for log in logs: - log.close() - - -if __name__ == '__main__': - main() From eeb4cdb680bb16739a1f4c85e3bea24ad2097052 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 15:06:50 +0200 Subject: [PATCH 60/62] Mod SDK: export_mod! exports only in WebAssembly, so the guests link on macOS A host build of a mod (cargo build or test on the workspace) made a cdylib whose component exports macOS's ld couldn't take: its exported-symbols list cuts `horizon:mods/events@0.1.0#init` at the `#`, so coords-hud and horizon-mods-test-guest failed to link. The exports now exist only for wasm32; on the host the macro still checks the mod and keeps it used. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-mod-sdk/src/lib.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/crates/horizon-mod-sdk/src/lib.rs b/crates/horizon-mod-sdk/src/lib.rs index ccfdb7947..71c36cf80 100644 --- a/crates/horizon-mod-sdk/src/lib.rs +++ b/crates/horizon-mod-sdk/src/lib.rs @@ -135,7 +135,13 @@ macro_rules! export_mod { with(|m| $crate::Mod::chat(m, &text)) } } + // Only WebAssembly has the component's exports: a host build (cargo test or + // clippy on the workspace) checks the mod without them, which macOS + // couldn't link (its exported-symbols list cuts names at the `#`). + #[cfg(target_arch = "wasm32")] $crate::__export_horizon_mod!(Export); + #[cfg(not(target_arch = "wasm32"))] + let _ = ::init; }; }; } From 2eb699228a0064182aa9a8e8da4412c6cd1b6a4e Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 16:18:44 +0200 Subject: [PATCH 61/62] AGENTS.md and docs/architecture.md: a map of the code for agents AGENTS.md (CLAUDE.md links to it): the crates and what each owns, how to build and test fast, where each subsystem of horizon-client lives, how Game is organised, the two single-player paths and how to test both, the vanilla reference, and the rules that bite. docs/architecture.md: feature -> files -> checks for the 40 areas changed most in the last 30 days. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 175 +++++++++++++++++++++++++++++++++++++++++++ CLAUDE.md | 1 + docs/README.md | 1 + docs/architecture.md | 57 ++++++++++++++ 4 files changed, 234 insertions(+) create mode 100644 AGENTS.md create mode 120000 CLAUDE.md create mode 100644 docs/architecture.md diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 000000000..d869aed2a --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,175 @@ +# Horizon: a map for agents + +Minecraft: Java Edition 26.3 rewritten in Rust (wgpu). Vanilla is the specification wherever it has the +feature. Read [CONTRIBUTING.md](CONTRIBUTING.md) once; this page tells you where things are. +Feature → files → harness for the most-changed areas: [docs/architecture.md](docs/architecture.md). + +## Rules that bite + +- **Never commit Mojang's files**: game jars, assets, decompiled source, prepared resources (`.local/`). + `tools/check_public_tree.py` rejects them; `git config core.hooksPath .githooks` runs it on commit. +- **Keep your runs away from real player data.** Any game or launcher you start gets fresh `mktemp -d` + folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and + `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`. Never write to + `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`. +- **Mark what an agent posts.** A PR body starts with + `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.` (issues: "Filed by", reviews: + "Review by"); every comment starts with `🤖 Agent:`. Never write as Ludovic. +- **Attribution.** Commits end with `Co-Authored-By: Claude `; PR bodies end + with `🤖 Generated with [Claude Code](https://claude.com/claude-code)`. +- Everything players run is Rust. Python/Java only for dev tools and harness drivers in `tools/`. +- Horizon-only features follow [docs/design-system.md](docs/design-system.md) and are off by default where + they would change the vanilla look. +- Small PRs (< ~500 lines). Labels: `feature` (players get something new), `skip-release` (they see no + change), none for a fix, `release-now` for crash fixes. Every merge to main ships + ([docs/release-flow.md](docs/release-flow.md)). +- Contributors first: `gh pr list --state open --search ` before you start; never duplicate theirs. + +## Crates + +Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-server` are separate workspaces. + +| Crate | Owns | +|---|---| +| `horizon-client` | The game: a lib (`src/lib.rs`, ~190 flat modules) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) | +| `horizon-world` | Vanilla world data with no gameplay loop: NBT, regions, chunks, `datafix/`, `worldgen/`, `level/` (server-side block behaviour, ticks, redstone), entity physics, items, effects, food, damage | +| `horizon-core` | Simulation primitives: Java `Random`s, `jmath` (HotSpot-exact `Math`), positions, noise, density, paletted storage, `version.rs` (the pinned version) | +| `horizon-protocol` | Network protocol 777: codecs, framing, encryption, `packets/{handshake,status,login,configuration,play}.rs`, `entity_data.rs` | +| `horizon-assets` | Resource decoding: block-state and item models, baking, atlases | +| `horizon-prepare` | Builds `.local/horizon-client/26.3` from the player's own Minecraft install (runs the Java exporters) | +| `horizon-server` | `horizon-server`: `server.toml`, CLI, supervisor of the headless game ([docs/hosting.md](docs/hosting.md)) | +| `horizon-server-files` | `server.properties`, eula, ops/whitelist/bans, usercache | +| `horizon-friends`, `horizon-relay` | Play with Friends: invite codes, encrypted tunnel, the relay ([docs/play-with-friends.md](docs/play-with-friends.md)) | +| `horizon-shaderpack` | OptiFine/Iris packs: preprocessor, GLSL → WGSL ([docs/shader-packs.md](docs/shader-packs.md)) | +| `horizon-mods`, `horizon-mod-sdk`, `cargo-horizon-mod` | Sandboxed WebAssembly mods: runtime, SDK + WIT, `cargo horizon-mod` ([docs/mods.md](docs/mods.md)) | +| `horizon-port-pack` | Porting Java modpacks ([docs/modpacks.md](docs/modpacks.md)) | +| `horizon-theme` | Design tokens and fonts for the launcher, the game's own menus and the website | +| `horizon-telemetry`, `horizon-telemetry-server`, `horizon-bench` | Opt-in data collection, its ingest server, the benchmark report format | +| `horizon-dualsense`, `horizon-threads`, `horizon-release-sign`, `horizon-bots`, `voxel-kernels`, `xtask` | DualSense output, thread priorities, signed release checksums, load-test bots, occupancy kernels, repo tasks | +| `launcher/` | GPUI launcher: `main.rs` (UI), `backend.rs` (installs, updates), `cli.rs`, `mcp.rs`, `*_page.rs` | + +Other top-level folders: `tools/` (harnesses and dev scripts), `tests/` (Python unit tests: `python3 -m +unittest discover -s tests`), `mods/horizon/src/test/java/dev/horizonlab/parity/` (Java oracles), +`website/` (playhorizon.dev; its paths are relative to `website/`), `docs/`, `.github/workflows/`. + +## Build and test fast + +```sh +python3 tools/pr_ready.py # the self-check: fmt, clippy -D warnings, touched crates' tests, harnesses; paste its block in the PR +python3 tools/pr_ready.py --quick # same without harnesses +cargo test -p horizon-client --lib --bins --tests # skips the 104 examples (pr_ready does this); `--doc` separately +cargo build --profile fast -p horizon-client # optimized, quick to link: use it to play or run lan_e2e +python3 tools/parity.py --changed origin/main # the harnesses your branch can affect (CI's parity job) +python3 tools/parity.py --changed-files paths.txt --list # which harnesses cover these files, without running them +python3 tools/parity.py mob_ai sculk # named harnesses +python3 tools/lan_e2e.py --check chest # two real games over LAN (host in-frame); --server-thread for the host on its server thread +python3 tools/agent_control_e2e.py # horizon-ctl / MCP end to end +``` + +- Harnesses and the game need the vanilla data in `.local/` (`minecraft/`, `horizon-client/26.3`, `datagen/`, + `tools/`): see [docs/parity-workflow.md](docs/parity-workflow.md). Without it, pr_ready lists the + harnesses for CI. +- A harness = `tools/test__parity.py` (324 of them) + a Java oracle (`mods/horizon/src/test/java/dev/horizonlab/parity/Vanilla*Oracle.java`) + + a Rust probe: `crates//examples/_{probe,fixture}.rs` (horizon-world 175, horizon-client 104), + or the game binary with a fixture env var (`game/dispense_fixture.rs`, `game/sculk_fixture.rs`, + `game/command_harness.rs`, `game/net_harness.rs`). Copy a nearby harness for a new one. +- Probes build into `.local/parity-target/`; harnesses find binaries via `lab.cargo_target()`, never `target/`. +- What a change reruns (of 329 harnesses, measured 2026-10-23): a file of the game binary (`game.rs`, `game/`) + ~25, a file of the client lib ~103, of `horizon-world` ~103–109, of `horizon-core` ~119. Plan for it. +- Rust integration tests: `crates/horizon-client/tests/` (`lan_bot.rs`, `generation_saves.rs`, `streaming_meshes.rs`). +- **macOS:** `cargo build/test --workspace` may fail to link the two wasm guest cdylibs (undefined + `horizon:mods/events` symbols) until #1446 lands: add `--exclude coords-hud --exclude horizon-mods-test-guest`. + Their real check is `cargo test -p horizon-mods` (builds them for `wasm32-unknown-unknown`). +- Linux needs `libasound2-dev libudev-dev`; `--no-default-features` drops audio and controllers (the server build). +- Run and drive the game (starts the `horizon-client` beside `horizon-ctl`; other arguments go to the game): + `target/fast/horizon-ctl --socket $PWD/ctl.sock launch --world W --creative --offscreen --wait --resources $PWD/.local/horizon-client/26.3`, + then `horizon-ctl --socket … state|keys|turn|command|screenshot|quit` + ([docs/horizon-ctl-commands.md](docs/horizon-ctl-commands.md)). + +## Vanilla reference + +- Decompiled sources: `.local/minecraft/26.3/sources/{client,server}/` (`python3 tools/lab.py decompile`). +- Bytecode queries (callers through lambdas, every overload): + `python3 tools/rea_vanilla.py method net.minecraft.world.level.block.DispenserBlock dispenseFrom` + ([docs/decompilation-status.md](docs/decompilation-status.md)). +- A harness runs the oracle against the real 26.3 jars and the Rust probe on the same inputs, then compares + their JSON. Oracle runs are cached by `tools/parity_shim.py`; `--fresh` reruns them. +- Mirror vanilla's `Math` calls with `horizon_core::jmath`, and vanilla's RNG with `horizon_core::random`: + random draws must happen in vanilla's order. + +## horizon-client: where things live + +`L:` = lib (`crates/horizon-client/src/`), `G:` = bin (`crates/horizon-client/src/game/`). The lib can't see +`Game`; bin code reaches the lib as `horizon_client::`. + +| Subsystem | Files | +|---|---| +| Game loop, tick, frame | `game.rs`: `fn run`, `impl ApplicationHandler for Game` (`window_event`, `about_to_wait`), `fn tick`, `fn tick_world`, `fn render`; L: `clock.rs`, `window.rs`, `spans.rs` | +| Rendering | L: `gfx.rs` (`Renderer::new`, `Renderer::render`), `gfx/` (cull, occlusion, translucency, upload, timing, lod, weather, stars, end_sky), `*.wgsl`, `particles.rs`, `block_entity_render.rs`, `item_render.rs`, `fog.rs`, `clouds.rs`, `camera.rs`, `first_person.rs`; G: `render_tick.rs`, `item_draw.rs` | +| Chunks, streaming, light | L: `streaming.rs` (worker pool: generate, light, mesh), `world.rs`, `chunk.rs`, `chunk_map.rs`, `light.rs`, `mesher.rs` + `mesher/`, `vanillagen.rs` (binds horizon-world's generator), `lod.rs` + `lod/`, `ticket_levels.rs`; G: `world_loading.rs`, `postprocess.rs`; game.rs `fn update_world` | +| World generation | `crates/horizon-world/src/worldgen/` (`generator*.rs`, `feature_graph.rs`, `structure/`, `carver/`) | +| Block behaviour | `crates/horizon-world/src/level/` (`mod.rs`, `tick.rs`, `hooks.rs`, `redstone.rs`, `place.rs`, `interact.rs`); game.rs `fn tick_blocks`, `fn process_level_events` | +| Mobs | L: `mobs.rs` (types), `mobs/` (`ai.rs`, `goals.rs`, `brain.rs`, `*_brain.rs`, `nav.rs`, `path.rs`, `species.rs`, `spawning.rs`, `render.rs`, `anim.rs`); G: `creatures.rs` (ticking, spawning, mob events), one file per mob family (`dragon.rs`, `wither.rs`, `villagers.rs`, `piglins.rs`, `golems.rs`...), `natural_spawning.rs` | +| Other entities | L: `entities.rs`, `projectiles.rs`, `arrows.rs`; G: `boats.rs`, `minecarts.rs`, `mounts.rs`, `armor_stands.rs`, `paintings.rs`, `frames.rs`, `fireworks.rs`, `tnt.rs`, `explosion.rs` | +| Player actions | game.rs (`fn use_hand`, `fn use_item`, `fn attack`, `fn tick_mining`, `fn break_block`); G: `hand.rs`, `combat.rs`, `consume.rs`, `potions.rs`, `shield.rs`, `crossbow.rs`, `trident.rs`, `fishing.rs`; L: `motion.rs` + `motion/` (movement), `collisions.rs`, `items.rs`, `item_data.rs` | +| Inventory and containers | L: `menu.rs` (`AbstractContainerMenu.clicked`), `container_screen.rs`, `containers.rs`, `creative.rs`, `crafting.rs`, `recipe_book*.rs`, `stations.rs`, `merchant.rs`; game.rs `fn menu_ops`, `fn click_inventory`; G: `stations.rs`, `trading.rs`, `recipe_book.rs`, `machines.rs` | +| Commands | parse: L: `command/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`); run: G: `commands.rs` (dispatch) + `commands/*.rs` (`admin`, `execute`, `items`, `players`, `world_cmds`...); L: `scoreboard_cmd.rs`, `data_cmd.rs`, `nbt_path.rs`; G: `functions.rs`, `command_blocks.rs` | +| UI screens | `Screen` enum in game.rs; L: `title.rs` + `title/`, `options_ui.rs`, `multiplayer.rs`, `pack_screen.rs`, `graphics_ui.rs`, `screen_draw.rs`, `ui.rs` (widgets), `hud.rs`, `hud_layout.rs`, `hud_overlays.rs`, `chat.rs`, `tab_list.rs`; G: `startup_menu.rs`, `screens.rs` (pause, death), `options.rs`, `lan_screen.rs`, `chat.rs`, `sign_edit.rs`, `books.rs` | +| Multiplayer client | L: `net.rs` (network thread); G: `remote.rs` (`fn handle_packet`, `fn tick_remote`), `remote_*.rs` (mob data, objects, projectiles, vehicles, stations) | +| LAN host / server side | L: `lan/` (`conn.rs` handshake + login threads, `hub.rs` + `hub/` play state, `chunks.rs`, `entity.rs`, `tracking.rs`, `guest.rs`, `playerdata.rs`); G: `lan.rs` (`LanHost`), `lan_actions.rs` (`fn as_guest`, `fn tick_guests`), `lan_*.rs` per feature, `lan_entities.rs` (tracked entities) | +| Integrated server | G: `integrated.rs` (the server thread), `levels.rs` (one level per dimension, `fn tick_server`), `server_travel.rs` | +| Dedicated server | G: `dedicated.rs`, `dedicated/status.rs`; crates `horizon-server-files`, `horizon-server` | +| Save and load | L: `save.rs` (level.dat, regions, playerdata), `entity_nbt.rs`, `block_entity_nbt.rs`, `options_file.rs`; G: `saving.rs`, `persist.rs` (entities); `crates/horizon-world/src/{region.rs,nbt.rs,datafix/}` | +| Input | game.rs `fn window_event`, `fn key_pressed`, `fn play_mouse`; L: `keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `osk.rs`, `clipboard.rs`; G: `pad.rs`, `pad_menu.rs` | +| Audio | L: `audio.rs` (mixer), `sound_engine.rs`, `sound_events.rs`, `music.rs`, `ambience.rs`; G: `music.rs`, `subtitle_hud.rs` | +| Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`, `lang.rs`; crate `horizon-assets`; G: `packs.rs` | +| Shader packs | L: `shader_pack.rs` (Horizon WGSL packs), `java_pack.rs` + crate `horizon-shaderpack` (Iris/OptiFine), `gfx/pack_stages.rs`, `gfx/java_stages.rs`; G: `shader_packs.rs` | +| Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) | +| Mods | crate `horizon-mods`; G: `mods.rs`; L: `mod_content.rs`, `mod_list.rs` | +| Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs`, `tweaks.rs`, `options.rs` | + +## How `Game` is organised + +- `struct Game` (game.rs, ~290 fields) holds everything. Its methods are spread over ~180 files: game.rs keeps + the core (tick, render, input, inventory, world open/close) and each `game/.rs` adds an + `impl Game<'_>` block for one feature, with its own state types. Fields are private to the bin. +- Find a feature's code: `grep -rn "fn tick_\|fn _" crates/horizon-client/src/game*`; + the file is usually `game/s.rs`. Who calls it: grep the name in game.rs's `fn tick` / `fn tick_world`. +- Fields that say which mode runs: `remote` (this window is a client of a server: multiplayer, LAN guest, or + single player on its server thread), `lan` (`LanHost`: this world is open to the network), `integrated` + (the window's own server thread), `serving` (this `Game` *is* that server thread), `options.dedicated`. + `fn tick` returns `tick_remote()` when `remote` is set; nothing else of the local simulation runs. +- A server's players run through the same gameplay code as the local player: `as_guest` swaps the guest's + state (position, inventory, mode, mining, item use) into `Game` for one call (`game/lan_actions.rs`), and + `levels.rs` swaps whole dimensions in the same way. Changes reach clients through the block log, level + events and the entity tracker (`lan/tracking.rs`, `game/lan_entities.rs`). +- Shared read-only data: `Resources` (`res`: blocks, items, recipes, mob types, biomes) and `PackResources` + (`pack`), both in game.rs. + +## The two single-player paths + +1. **In-frame (default since #1428):** the window's `Game` ticks the world itself, one level that follows + the player (`fn enter_dimension`). This is what Stable players run and what harnesses test. +2. **Server thread (`--server-thread` or `HORIZON_SERVER_THREAD=1`):** `game/integrated.rs` runs a second + `Game` (`serving`) on a "Server thread" with one level per dimension; the window joins it as a client + through memory (`remote`), exactly as a LAN guest or a dedicated server's player does. Not at parity yet: + open `[server-thread]` issues list the gaps. + +LAN guests and dedicated servers always use the server code, so a fix there serves both. Test both paths +when you touch player-facing gameplay: + +```sh +cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T # in-frame +cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T --server-thread # server thread +python3 tools/lan_e2e.py --check # host in-frame, guest is a server client +python3 tools/lan_e2e.py --server-thread --check # host on its server thread (portals, levels, distance, lava need it) +python3 tools/parity.py dedicated_server server_entities server_player_damage +``` + +## Docs worth knowing + +[docs/parity-workflow.md](docs/parity-workflow.md) (runner, gate, shards, scopes) · +[docs/native-client.md](docs/native-client.md) (options, controls, horizon-ctl) · +[docs/server-levels.md](docs/server-levels.md) (levels per dimension) · +[docs/rust-parity.md](docs/rust-parity.md) (what is ported) · [docs/known-issues.md](docs/known-issues.md) · +[docs/release-flow.md](docs/release-flow.md) · [docs/README.md](docs/README.md) (index). diff --git a/CLAUDE.md b/CLAUDE.md new file mode 120000 index 000000000..47dc3e3d8 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1 @@ +AGENTS.md \ No newline at end of file diff --git a/docs/README.md b/docs/README.md index b4398ebfc..2e06b6e89 100644 --- a/docs/README.md +++ b/docs/README.md @@ -4,6 +4,7 @@ To play, use [the launcher](../launcher/README.md); the project site is [playhor ## Build and run +- [AGENTS.md](../AGENTS.md) and [Architecture](architecture.md): where each part of the code lives, how `Game` is organised, which harness checks which area. - [Build from source](../README.md#build-from-source): your own copy of the game, resource preparation, `cargo run`. - [Native client](native-client.md): options, controls, the dedicated server, `horizon-ctl` scripting, packaging, architecture. - [Host a server](hosting.md): install `horizon-server`, prepare the game files, first run, `server.toml`, the commands, the web panel, backups, services and Docker; what works today and what doesn't yet. diff --git a/docs/architecture.md b/docs/architecture.md new file mode 100644 index 000000000..99e9b630e --- /dev/null +++ b/docs/architecture.md @@ -0,0 +1,57 @@ +# Architecture: feature → files → checks + +The 40 areas changed most often in the 30 days to 2026-10-23 (commits on main touching the area; `game.rs` is +counted only for the game loop because nearly every gameplay change touches it). The crate map, how `Game` is +organised and how to build and test are in [AGENTS.md](../AGENTS.md). + +Paths: `L/` = `crates/horizon-client/src/`, `G/` = `crates/horizon-client/src/game/`, `W/` = +`crates/horizon-world/src/`. Checks: a bare name is a harness (`python3 tools/parity.py `, script +`tools/test__parity.py`); `lan_e2e ` is `python3 tools/lan_e2e.py --check `. + +For the full set of harnesses a file can affect, ask the runner: +`printf '%s\n' > /tmp/p.txt && python3 tools/parity.py --changed-files /tmp/p.txt --list`. +Any file of the game binary (`game.rs`, `game/`) selects the ~25 harnesses that run the binary; a client lib +file selects ~103. + +| # | Area (commits) | Files | Checks | +|---|---|---|---| +| 1 | Game loop, tick order, frame pacing (554) | `L/game.rs` (`fn tick`, `fn tick_world`, `fn render`, `about_to_wait`), `L/clock.rs`, `L/window.rs`, `L/spans.rs` | game_loop, frame_limiter, interaction_input, tick | +| 2 | Mobs in the game loop, spawning (166) | `G/creatures.rs`, `G/natural_spawning.rs`, `L/mobs/spawning.rs`, `L/mobs/spawn_rules.rs`, `L/mobs/spawn_selection.rs`, `L/mobs/finalize.rs`, `G/spawner.rs`, `G/trial_spawner.rs` | natural_spawn, spawn_rules, finalize_spawn, spawner, trial_spawner, mob_ai | +| 3 | World save and load (163) | `L/save.rs`, `G/saving.rs`, `G/persist.rs` (entities), `L/entity_nbt.rs`, `L/block_entity_nbt.rs`, `W/region.rs`, `W/nbt.rs` | save_roundtrip, world_reopen, world, datafix | +| 4 | World generation (153) | `W/worldgen.rs`, `W/worldgen/` (`generator*.rs`, `feature_graph.rs`, `structure/`, `placement/`), `L/vanillagen.rs` | chunk_generation, worldgen, server_world_gen, world_spawn, feature_graph, feature_placement, decoration and the other worldgen harnesses | +| 5 | Multiplayer client, packets in (145) | `G/remote.rs` (`fn handle_packet`, `fn tick_remote`), `G/remote_*.rs`, `L/net.rs` | dedicated_server, server_entities, lan_e2e (all) | +| 6 | Agent control, horizon-ctl (145) | `L/control.rs`, `L/bin/horizon-ctl/`, `G/control.rs`, `G/agent.rs`, `G/events.rs`, `G/ui_control.rs` | `python3 tools/agent_control_e2e.py`; `cargo test -p horizon-client --bin horizon-ctl` | +| 7 | CI and release (134) | `.github/workflows/` (`ci.yml`, `parity.yml`, `release.yml`, `launcher.yml`), `tools/ci/`, `tools/parity.py`, `tools/pr_ready.py` | `python3 -m unittest discover -s tests`; actionlint (`.github/actionlint.yaml`) | +| 8 | LAN host: connections, play state, tracking (133) | `L/lan/` (`conn.rs`, `hub.rs` + `hub/`, `chunks.rs`, `entity.rs`, `tracking.rs`, `guest.rs`, `playerdata.rs`), `G/lan.rs` | lan, lan_e2e (all), `cargo test -p horizon-client --test lan_bot` | +| 9 | Renderer core (132) | `L/gfx.rs` (`Renderer::new`, `Renderer::render`), `L/gfx/` (cull, occlusion, translucency, upload, timing, lod) | client_graphics, culling_rays, translucency; `horizon-client --benchmark standard` | +| 10 | Launcher (124) | `launcher/src/` (`main.rs`, `backend.rs`, `cli.rs`, `mcp.rs`, `servers_page.rs`) | `cd launcher && cargo test`; `python3 tools/launcher_mcp_e2e.py` | +| 11 | Mob types and species (117) | `L/mobs.rs`, `L/mobs/species.rs`, `L/mobs/data.rs`, `L/mobs/living.rs`, `L/mobs/drops.rs`, `L/mobs/gear.rs` | mob_attributes, entity_attribute, entity_death_loot, mob_ai | +| 12 | Guests' actions on a server (98) | `G/lan_actions.rs` (`fn as_guest`, `fn tick_guests`), `G/lan_{attributes,pvp,chat,crafting,stations,trading,mount_menu,waypoints}.rs` | server_player_combat, server_player_damage, server_player_targets, lan_e2e (all) | +| 13 | Modpack porting, mod content (97) | `crates/horizon-port-pack/`, `L/mod_content.rs`, `tools/port_*.py`, `packs/` | `cargo test -p horizon-port-pack`; `python3 tools/mod_port_harness.py` | +| 14 | Mob AI (96) | `L/mobs/ai.rs`, `goals.rs`, `brain.rs`, `*_brain.rs`, `nav.rs`, `path.rs`, `control.rs` | mob_ai (probe `examples/mob_ai_probe.rs`; known failure on main: drowned_*, #290) | +| 15 | Items and item use (96) | `L/items.rs`, `L/item_data.rs`, `G/hand.rs`, `G/consume.rs`, `G/potions.rs`, `L/effects.rs`; game.rs `fn use_hand`, `fn use_item` | use_item_on, item_use, item_use_lifecycle, consumable, consume_effect, status_effect | +| 16 | Options and settings screens (93) | `L/options_ui.rs`, `G/options.rs`, `L/settings.rs`, `L/options_file.rs`, `L/graphics_ui.rs`, `L/graphics.rs` | options, toggle_keys | +| 17 | HUD, chat, tab list (93) | `L/hud.rs`, `L/hud_layout.rs`, `L/hud_overlays.rs`, `L/chat.rs`, `G/chat.rs`, `L/tab_list.rs`, `L/locator_bar.rs`, `G/locator_bar.rs` | hud, tab_list, locator_bar, chat_screen, secure_chat | +| 18 | Command execution (88) | `G/commands.rs`, `G/commands/*.rs`, `L/scoreboard_cmd.rs`, `L/data_cmd.rs`, `G/functions.rs` | command_exec (corpus `tools/command_exec_corpus.py`), scoreboard, server_ops_feedback, lan_e2e commands | +| 19 | Chunk streaming, light, tickets (85) | `L/streaming.rs`, `L/world.rs`, `L/chunk.rs`, `L/chunk_map.rs`, `L/light.rs`, `L/ticket_levels.rs`, `L/tick_chunk_membership.rs`, `G/world_loading.rs` | light, chunk_status, random_tick_sections; `cargo test -p horizon-client --test streaming_meshes` | +| 20 | Mob models and animation (78) | `L/mobs/render.rs`, `L/mobs/anim.rs`, `L/mobs/body_anim.rs`, `L/mobs/keyframes.rs`, `L/entity.wgsl` | entity_model | +| 21 | Block behaviour, server side (78) | `W/level/` (`mod.rs`, `tick.rs`, `hooks.rs`, `data.rs`, `redstone.rs`, `place.rs`), `G/block_entity_ticks.rs`, `G/moving_pistons.rs` | block_update, redstone, random_tick, simple_block, piston_movement, block_entity_tickers | +| 22 | Player movement and collision (75) | `L/motion.rs` + `L/motion/`, `L/collisions.rs`, `W/entity_move.rs`, `W/player_travel.rs`, `W/collision.rs` | collision, entity_move, player_travel, living_motion, climbing, swimming; `python3 tools/test_native_scene_motion.py` | +| 23 | Resource packs and models (65) | `L/packs.rs` + `L/packs/`, `L/pack_screen.rs`, `L/atlas_sources.rs`, `L/sprites.rs`, `L/model_library.rs`, `G/packs.rs`, `crates/horizon-assets/` | resource_pack, pack_selection, pack_screen, model_resolution, item_model, mipmap | +| 24 | Container menus and inventory (61) | `L/menu.rs`, `L/container_screen.rs`, `L/containers.rs`, `L/creative.rs`; game.rs `fn menu_ops`, `fn click_inventory` | menu_click, container_screen, creative, lan_e2e containers clicks | +| 25 | Workstations (60) | `L/stations.rs`, `G/stations.rs`, `L/enchant.rs`, `L/brewing.rs` | enchanting, screen_layout, lan_e2e brewing loom stonecutter grindstone anvil smithing | +| 26 | Crafting and the recipe book (59) | `L/crafting.rs`, `L/recipe_book.rs`, `L/recipe_book_screen.rs`, `G/recipe_book.rs`, `G/machines.rs`, `G/machines/crafter.rs` | recipe, recipe_book, recipe_book_view, place_recipe, ghost_recipe, crafter | +| 27 | Vehicles and mounts (54) | `G/boats.rs`, `G/minecarts.rs`, `G/mounts.rs`, `G/mount_menu.rs`, `G/llamas.rs`, `G/passengers.rs` | server_entities, lan_e2e boats minecarts riding mounts | +| 28 | Villagers, trading, raids (50) | `L/mobs/villager*.rs`, `L/merchant.rs`, `G/trading.rs`, `G/villagers.rs`, `L/raid.rs`, `G/raids.rs`, `L/gossip.rs` | trading, raid, mob_ai | +| 29 | Title, worlds, startup (49) | `L/title.rs` + `L/title/`, `G/startup_menu.rs`, `L/title_edition.rs` | world_options; `cargo test -p horizon-client --lib title` | +| 30 | Dedicated server, horizon-server (48) | `G/dedicated.rs`, `G/dedicated/status.rs`, `crates/horizon-server/`, `crates/horizon-server-files/` | dedicated_server, server_files, user_cache, online_mode, server_ops_feedback | +| 31 | Particles and client effects (46) | `L/particles.rs`, `G/render_tick.rs`, `G/level_particles.rs`, `L/animate_tick.rs` | particle_providers, block_particles, entity_particles, emitter_particles, marker_particles | +| 32 | Bosses and the End (45) | `G/dragon.rs`, `G/wither.rs`, `G/end.rs` | server_dragon, end_podium, end_gateway | +| 33 | Protocol and packets (44) | `crates/horizon-protocol/src/` (`packets/play.rs`, `entity_data.rs`, `connection.rs`) | dedicated_server, online_mode, secure_chat; `cargo test -p horizon-protocol` | +| 34 | Multiplayer and LAN screens, friends (44) | `L/multiplayer.rs`, `G/lan_screen.rs`, `G/friends.rs`, `L/friends_screen.rs`, `crates/horizon-friends/`, `crates/horizon-relay/` | lan, world_options; `python3 tools/test_friends.py` | +| 35 | Dispensers (43) | `G/dispenser.rs`, `G/dispense_fixture.rs` (the harness side) | dispenser | +| 36 | Audio and music (38) | `L/audio.rs`, `L/sound_engine.rs`, `L/sound_events.rs`, `L/music.rs`, `G/music.rs`, `L/ambience.rs`, `G/subtitle_hud.rs` | sound_engine, sound_event, music, situational_music, ambient_sound, subtitle | +| 37 | Integrated server and levels (34) | `G/integrated.rs`, `G/levels.rs`, `G/server_travel.rs` | server_dimension_players, `lan_e2e --server-thread` (portals, levels, distance, lava) | +| 38 | Command parsing (34) | `L/command/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`) | command_parse (corpus `tools/command_parse_corpus.py`) | +| 39 | Benchmarks and telemetry (34) | `L/benchmark.rs`, `tools/perf_bench.py`, `L/telemetry.rs`, `crates/horizon-telemetry*/`, `crates/horizon-bench/` | `python3 -m unittest tests.test_perf_bench`; [benchmark.md](benchmark.md) | +| 40 | Explosions and TNT (31) | `G/explosion.rs`, `G/tnt.rs` | lan_e2e blast; no dedicated harness yet | From 1960dc6eb26600d32145eecece3d494ee4f9d019 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 16:30:31 +0200 Subject: [PATCH 62/62] AGENTS.md: agents never add release-now Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/AGENTS.md b/AGENTS.md index d869aed2a..9534fba83 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -21,7 +21,7 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md] - Horizon-only features follow [docs/design-system.md](docs/design-system.md) and are off by default where they would change the vanilla look. - Small PRs (< ~500 lines). Labels: `feature` (players get something new), `skip-release` (they see no - change), none for a fix, `release-now` for crash fixes. Every merge to main ships + change), none for a fix. Agents never add `release-now`: the maintainer decides it. Every merge to main ships ([docs/release-flow.md](docs/release-flow.md)). - Contributors first: `gh pr list --state open --search ` before you start; never duplicate theirs.