From 56dc4352d2d935b8b199ea40baa8256bb41a6301 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 17:18:03 +0200 Subject: [PATCH] Run single player on an integrated server thread (opt-in) With --server-thread or HORIZON_SERVER_THREAD=1, opening a single-player world starts a game of its own on a "Server thread" over the shared resources, as vanilla's IntegratedServer does, and the window joins it as a player over a local connection. The world tick then never runs inside a frame. - The server listens on 127.0.0.1 only, lets in the window's profile alone, without compression, and makes it an operator when the world allows commands. - The window's player is the world's own player: it loads from and saves to players/data/.dat, so the world opens the same way in either mode. - A pause screen pauses the server (IntegratedServer.tickServer), and leaving the world or quitting waits for the server to save. - The integrated server does not mesh sections it never draws. - Worlds whose player is outside the Overworld open the usual way for now. - The bench summary reports the 0.1% low. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/control.rs | 20 +- crates/horizon-client/src/game.rs | 30 +- crates/horizon-client/src/game/dedicated.rs | 4 +- crates/horizon-client/src/game/integrated.rs | 288 +++++++++++++++++++ crates/horizon-client/src/game/lan.rs | 52 +++- crates/horizon-client/src/game/remote.rs | 13 + crates/horizon-client/src/lan/playerdata.rs | 55 ++-- crates/horizon-client/src/streaming.rs | 8 + 8 files changed, 434 insertions(+), 36 deletions(-) create mode 100644 crates/horizon-client/src/game/integrated.rs diff --git a/crates/horizon-client/src/control.rs b/crates/horizon-client/src/control.rs index 3019d8dfa..9749cc9bd 100644 --- a/crates/horizon-client/src/control.rs +++ b/crates/horizon-client/src/control.rs @@ -467,13 +467,16 @@ impl FrameStats { } let total: f64 = sorted.iter().map(|&m| f64::from(m)).sum(); let percentile = |p: f64| sorted[((n as f64 * p).ceil() as usize).clamp(1, n) - 1]; - // Average frame time of the slowest 1% of frames, as frames per second. - let slowest = n.div_ceil(100); - let slow: f64 = sorted[n - slowest..] - .iter() - .map(|&m| f64::from(m)) - .sum::() - / slowest as f64; + // Average frame time of the slowest 1% (0.1%) of frames, as frames per second. + let low = |per: usize| { + let slowest = n.div_ceil(per); + let slow: f64 = sorted[n - slowest..] + .iter() + .map(|&m| f64::from(m)) + .sum::() + / slowest as f64; + 1000.0 / slow + }; // Where the slowest 1% of frames by CPU time go. let slow_phases = { let mut cpu = self.cpu.clone(); @@ -487,7 +490,8 @@ impl FrameStats { "frames": n, "seconds": total / 1000.0, "avg_fps": n as f64 * 1000.0 / total, - "low_1pct_fps": 1000.0 / slow, + "low_1pct_fps": low(100), + "low_01pct_fps": low(1000), "p50_ms": percentile(0.5), "p95_ms": percentile(0.95), "p99_ms": percentile(0.99), diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 34af3318d..6b9cfb700 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -56,6 +56,7 @@ mod golems; mod growth; mod hand; mod initial_spawn; +mod integrated; mod item_draw; mod item_particles; mod jukebox; @@ -243,6 +244,11 @@ struct Options { benchmark: Option, /// `--dev-mod PATH` (repeatable): mods always on and reloaded when rebuilt. dev_mods: Vec, + /// `--server-thread` or `HORIZON_SERVER_THREAD=1`: single player runs on + /// an integrated server thread (game/integrated.rs). + server_thread: bool, + /// Set on the integrated server's own options: it draws nothing, so it skips meshing. + integrated: bool, } impl Options { /// The name to join servers with: the one given, else the offline name kept @@ -294,6 +300,8 @@ impl Options { dedicated: None, benchmark: None, dev_mods: Vec::new(), + server_thread: std::env::var("HORIZON_SERVER_THREAD").is_ok_and(|v| v == "1"), + integrated: false, }; let mut session_file = std::env::var("HORIZON_SESSION_FILE").ok(); let mut args = std::env::args().skip(1); @@ -314,6 +322,7 @@ impl Options { "--no-pause" => o.no_pause = true, "--offscreen" => o.offscreen = true, "--control" => o.control = Some(horizon_client::control::default_path()), + "--server-thread" => o.server_thread = true, _ => { let value = args .next() @@ -1074,6 +1083,8 @@ struct Game<'a> { remote: Option, /// This world is open to the network (game/lan.rs). lan: Option, + /// Single player's server thread, which `remote` is connected to. + integrated: Option, /// The open world is shared behind an invite code (game/friends.rs). friends: Option, world_options: Option, @@ -3632,7 +3643,7 @@ impl Game<'_> { } /// `Minecraft.pause`: a single-player game with a pausing screen open. fn pauses_game(&self) -> bool { - self.remote.is_none() + (self.remote.is_none() || self.integrated.is_some()) && self.lan.is_none() && self.title.is_none() && (matches!( @@ -6129,8 +6140,11 @@ impl Game<'_> { creative: bool, create: Option<&horizon_client::title::WorldOptions>, ) -> Result<()> { - self.perf.world_opening(); let save_root = std::env::current_dir()?.join("saves").join(folder); + if integrated::wanted(&self.options, &save_root) { + return self.open_integrated(folder, name, seed, creative, create); + } + self.perf.world_opening(); horizon_client::save::upgrade_older_world(&save_root)?; horizon_client::save::migrate_legacy(&save_root)?; self.session_lock = None; @@ -6392,6 +6406,8 @@ impl Game<'_> { streaming.biome_zoom = BiomeZoom::new(obfuscate_seed(seed)); streaming.sky_light = dim != Dim::Nether; streaming.nether_shading = dim == Dim::Nether; + // The integrated server draws nothing (the dedicated server keeps its behaviour). + streaming.mesh = !self.options.integrated; Ok((streaming, save)) } /// Change dimension through a portal (Entity.changeDimension with @@ -6587,6 +6603,11 @@ impl Game<'_> { return Ok(()); } self.saved_for_exit = true; + if let Some(server) = self.integrated.take() { + // The server thread saves the world. + server.stop(); + return Ok(()); + } self.close_container(); if self.remote.is_none() { self.stats.custom("leave_game", 1); @@ -8340,6 +8361,7 @@ impl Game<'_> { self.save_schedule(); self.save_warden_tracker(); self.sync_level(); + self.store_owner(); self.level.write(&self.world_root)?; self.save_world_state(); self.message = Some(("Saved the game".into(), Instant::now())); @@ -9652,6 +9674,9 @@ impl ApplicationHandler for Game<'_> { } self.limit_frame(); self.pause = self.pauses_game(); + if let Some(server) = &self.integrated { + server.set_paused(self.pause); + } self.clock.end_frame(self.pause); let finished = self .renderer @@ -10047,6 +10072,7 @@ impl<'a> Game<'a> { persist: Default::default(), remote: None, lan: None, + integrated: None, world_options: None, options_to_world_options: false, command_block_screen: None, diff --git a/crates/horizon-client/src/game/dedicated.rs b/crates/horizon-client/src/game/dedicated.rs index cd7744d87..e0b283f69 100644 --- a/crates/horizon-client/src/game/dedicated.rs +++ b/crates/horizon-client/src/game/dedicated.rs @@ -525,7 +525,7 @@ impl Game<'_> { /// Load the spawn area and find the world spawn as single player does, /// without keeping a player there. - fn settle_spawn(&mut self) -> Result<()> { + pub(super) fn settle_spawn(&mut self) -> Result<()> { let deadline = Instant::now() + Duration::from_secs(600); while self.player.is_none() { self.update_world(); @@ -541,7 +541,7 @@ impl Game<'_> { /// The chunks to keep loaded: the players' (lan_update_streaming), or /// the spawn chunk while nobody is online. - fn update_dedicated_streaming(&mut self) { + pub(super) fn update_dedicated_streaming(&mut self) { let center = self .lan .as_ref() diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs new file mode 100644 index 000000000..1b20b077d --- /dev/null +++ b/crates/horizon-client/src/game/integrated.rs @@ -0,0 +1,288 @@ +//! The integrated server (`IntegratedServer`): single player's world runs on +//! its own "Server thread", as vanilla's does, and the window joins it as a +//! player over a local connection, so a world tick never holds up a frame. +//! +//! Opt-in for now (`--server-thread` or `HORIZON_SERVER_THREAD=1`): the +//! player joins as a network player, and the server side of a network player +//! does not do everything single player does yet. Worlds whose player is +//! outside the Overworld open the usual way, since network players stay in +//! the Overworld so far. +use super::{ + Dim, Game, Options, PackResources, Resources, + lan::{LanSettings, Owner}, +}; +use horizon_client::{ + Result, + audio::Audio, + hud::HudAtlas, + lan::{MAX_PLAYERS, NetConfig, hub::HubConfig}, + save::Level, + settings::Settings, + title::WorldOptions, +}; +use horizon_protocol::{crypto::offline_uuid, text::translatable}; +use std::{ + net::{IpAddr, Ipv4Addr}, + path::Path, + sync::{ + Arc, + atomic::{AtomicBool, Ordering}, + mpsc::{Sender, channel}, + }, + thread::JoinHandle, + time::{Duration, Instant}, +}; + +/// What the window tells its server thread. +#[derive(Default)] +struct Flags { + /// `Minecraft.pause`: a single-player pause screen is open. + paused: AtomicBool, + stop: AtomicBool, +} + +/// The window's handle on its server thread. +pub(super) struct Integrated { + flags: Arc, + thread: Option>, +} +impl Integrated { + /// `IntegratedServer.tickServer` skips the world while the game is paused. + pub fn set_paused(&self, paused: bool) { + self.flags.paused.store(paused, Ordering::Relaxed); + } + /// `IntegratedServer.halt(true)`: returns once the world is saved and let go. + pub fn stop(mut self) { + self.halt(); + } + fn halt(&mut self) { + self.flags.stop.store(true, Ordering::Relaxed); + if let Some(thread) = self.thread.take() { + let _ = thread.join(); + } + } +} +impl Drop for Integrated { + fn drop(&mut self) { + self.halt(); + } +} + +/// The world to open and the player who owns it. +struct Launch { + folder: String, + name: Option, + seed: Option, + creative: bool, + create: Option, + /// The window's profile: the only one let in, and the world's player. + owner: u128, +} + +/// Whether this world opens on a server thread: asked for, and its player +/// (if any yet) in the Overworld. +pub(super) fn wanted(options: &Options, world: &Path) -> bool { + options.server_thread + && options.dedicated.is_none() + && Level::read(world).is_none_or(|l| Dim::from_id(&l.dimension) == Dim::Overworld) +} + +impl Game<'_> { + /// `Minecraft.doWorldLoad`: start the server thread on the world, wait + /// until it listens, then join it. + pub(super) fn open_integrated( + &mut self, + folder: &str, + name: Option<&str>, + seed: Option, + creative: bool, + create: Option<&WorldOptions>, + ) -> Result<()> { + let auth = horizon_client::auth::current(); + let player = auth + .as_ref() + .map_or_else(|| self.options.player_name(), |a| a.name.clone()); + let launch = Launch { + folder: folder.to_owned(), + name: name.map(str::to_owned), + seed, + creative, + create: create.cloned(), + // An offline-mode server names its players by their offline profile. + owner: offline_uuid(&player), + }; + let mut options = self.options.clone(); + // A server without a console: no local player, no window, no control socket. + options.dedicated = Some(Vec::new()); + options.server_thread = false; + options.integrated = true; + options.control = None; + options.benchmark = None; + options.frames = None; + options.world_frames = None; + options.report = None; + options.server = None; + options.world = None; + options.dev_mods.clear(); + let (res, pack, settings) = (self.res.clone(), self.pack.clone(), self.settings.clone()); + let flags = Arc::new(Flags::default()); + let (ready_tx, ready) = channel(); + let server_flags = flags.clone(); + let thread = std::thread::Builder::new() + .name("Server thread".into()) + .spawn(move || { + let result = serve( + &res, + pack, + options, + settings, + launch, + &server_flags, + &ready_tx, + ); + if let Err(e) = result { + log::error!("Horizon: integrated server: {e}"); + let _ = ready_tx.send(Err(e.to_string())); + } + })?; + let handle = Integrated { + flags, + thread: Some(thread), + }; + let port = match ready.recv() { + Ok(Ok(port)) => port, + Ok(Err(e)) => return Err(e.into()), + Err(_) => return Err("the integrated server stopped".into()), + }; + self.connect_server(&format!("127.0.0.1:{port}"), &player)?; + self.integrated = Some(handle); + Ok(()) + } + + /// The server thread's loop (`MinecraftServer.runServer`): 20 ticks a + /// second, the world held while the window is paused. + fn run_integrated( + &mut self, + launch: Launch, + flags: &Flags, + ready: &Sender>, + ) -> Result<()> { + self.open_world( + &launch.folder, + launch.name.as_deref(), + launch.seed, + launch.creative, + launch.create.as_ref(), + )?; + let saved = Box::new(self.level.clone()); + let view_distance = self.settings.render_distance.clamp(2, 32); + let config = HubConfig { + default_game_mode: self.level.mode(), + guest_commands: true, + force_game_mode: false, + hardcore: self.level.hardcore, + view_distance, + simulation_distance: self.settings.simulation_distance.clamp(2, 32), + dimension: self.dim.id().to_owned(), + seed: self.level.seed, + max_players: MAX_PLAYERS, + // No player of its own: the hub runs without a host. + dedicated: true, + }; + let owner = launch.owner; + let net = NetConfig { + bind: Some(IpAddr::V4(Ipv4Addr::LOCALHOST)), + // A local connection is not compressed (`Connection.isMemoryConnection`). + compression_threshold: -1, + enable_status: false, + announce: false, + gate: Some(Arc::new(move |_, uuid, _| { + (uuid != owner).then(|| translatable("multiplayer.disconnect.not_whitelisted", &[])) + })), + ..NetConfig::lan(0, self.level.name.clone(), MAX_PLAYERS) + }; + let settings = LanSettings { + port: 0, + guest_commands: true, + force_game_mode: false, + }; + self.lan_host(settings, net, config, None)?; + let commands = self.allow_commands(); + let port = { + let host = self + .lan + .as_mut() + .ok_or("the integrated server did not start")?; + // The owner is an operator when the world allows commands + // (`IntegratedPlayerList`, `MinecraftServer.getProfilePermissions`). + host.hub.ops.insert(owner, if commands { 4 } else { 0 }); + host.owner = Some(Owner { + uuid: owner, + saved: Some(saved), + }); + host.settings.port + }; + let _ = ready.send(Ok(port)); + self.settle_spawn()?; + let mut next = Instant::now(); + while !flags.stop.load(Ordering::Relaxed) { + self.update_dedicated_streaming(); + self.update_world(); + if flags.paused.load(Ordering::Relaxed) { + // Only the connections run. + self.tick_lan(); + } else { + self.tick()?; + } + let rate = self.clock.rate().max(1.0); + next += Duration::from_secs_f64(1.0 / f64::from(rate)); + let now = Instant::now(); + if next > now { + std::thread::sleep(next - now); + } else if now - next > Duration::from_secs(2) { + next = now; + } + } + self.stop_integrated() + } + + /// `MinecraftServer.stopServer`: the players are saved and sent away, + /// then the world is saved. + fn stop_integrated(&mut self) -> Result<()> { + if let Some(mut host) = self.lan.take() { + for g in &host.hub.guests { + self.save_guest(&host, g); + } + let conns: Vec = host.hub.guests.iter().map(|g| g.conn).collect(); + for conn in conns { + host.hub.kick( + conn, + translatable("multiplayer.disconnect.server_shutdown", &[]), + ); + } + self.lan = Some(host); + } + std::thread::sleep(Duration::from_millis(100)); + self.save_game()?; + self.lan_close(false); + self.save.flush(); + self.session_lock = None; + Ok(()) + } +} + +/// The server thread: a game of its own over the shared resources. +fn serve( + res: &Arc, + pack: PackResources, + options: Options, + settings: Settings, + launch: Launch, + flags: &Flags, + ready: &Sender>, +) -> Result<()> { + let atlas = HudAtlas::build(&options.resources)?; + let audio = Audio::silent(&options.resources); + let mut server = Game::new(res, pack, atlas, options, settings, audio)?; + server.run_integrated(launch, flags, ready) +} diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 024f671b2..c416c202f 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -55,6 +55,17 @@ pub(super) struct LanHost { mob_state: HashMap, /// The guest each mob sees as its player, when not the host (game/lan_mobs.rs). pub mob_players: HashMap, + /// An integrated server's owner (game/integrated.rs). + pub owner: Option, +} + +/// The player who owns an integrated server's world: a guest whose state is +/// the world's own player (`players/data/.dat`), as in +/// single player. +pub(super) struct Owner { + pub uuid: u128, + /// The world's player as loaded, until the owner joins. + pub saved: Option>, } /// A stable UUID for an entity that has none. @@ -465,6 +476,7 @@ impl Game<'_> { broken: Vec::new(), mob_state: HashMap::new(), mob_players: HashMap::new(), + owner: None, }); self.audio.capture = Some(Vec::new()); Ok(()) @@ -477,7 +489,7 @@ impl Game<'_> { return; }; for g in &host.hub.guests { - playerdata::save(g, &self.world_root); + self.save_guest(&host, g); } host.hub.disconnect_all(); // Give the writer threads a moment to flush the disconnect packets. @@ -494,6 +506,30 @@ impl Game<'_> { } } + /// Save a guest when they leave or the world closes: an integrated + /// server's owner with the world (`save_game`), anyone else in their file. + pub(super) fn save_guest(&mut self, host: &LanHost, guest: &horizon_client::lan::guest::Guest) { + if host.owner.as_ref().is_some_and(|o| o.uuid == guest.uuid) { + if guest.placed { + playerdata::store(guest, &mut self.level); + } + } else { + playerdata::save(guest, &self.world_root); + } + } + /// The integrated server's owner into the world's player, for `Level::write`. + pub(super) fn store_owner(&mut self) { + let Some(host) = &self.lan else { + return; + }; + let Some(uuid) = host.owner.as_ref().map(|o| o.uuid) else { + return; + }; + if let Some(g) = host.hub.guests.iter().find(|g| g.uuid == uuid && g.placed) { + playerdata::store(g, &mut self.level); + } + } + /// The world's default game mode (`defaultgamemode`). pub(super) fn set_default_game_mode(&mut self, mode: i32) { self.level.game_mode = mode; @@ -664,7 +700,7 @@ impl Game<'_> { self.container_openers_changed(pos, false); } self.lan_crafting_left(&mut host, &mut guest); - playerdata::save(&guest, &self.world_root); + self.save_guest(&host, &guest); host.models.remove(&guest.conn); if self.options.dedicated.is_some() && guest.placed { super::dedicated::log( @@ -707,10 +743,20 @@ impl Game<'_> { let default_mode = host.hub.config.default_game_mode; let force = host.hub.config.force_game_mode; let root = self.world_root.clone(); + let owner = host.owner.as_mut(); let Some(g) = host.hub.guest_mut(conn) else { return; }; - let known = playerdata::load(g, &root); + let saved = owner + .filter(|o| o.uuid == g.uuid) + .and_then(|o| o.saved.take()); + let known = match saved { + Some(level) => { + playerdata::apply(g, &level); + level.position.is_some() + } + None => playerdata::load(g, &root), + }; if !known || force { g.game_mode = default_mode; } diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 7bc41d703..0d6df8663 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -274,6 +274,14 @@ impl Game<'_> { if let Some(mut r) = self.remote.take() { r.session.disconnect(); } + // Single player's server thread saves the world before the title shows. + let single_player = match self.integrated.take() { + Some(server) => { + server.stop(); + true + } + None => false, + }; horizon_client::crash::clear_detail("Server"); self.debug_charts.reset(); self.tab_list.reset(); @@ -296,6 +304,11 @@ impl Game<'_> { } let saves = std::env::current_dir()?.join("saves"); let mut title = horizon_client::title::Title::new(saves.clone(), &self.options.resources); + if single_player && reason.is_none() { + self.title = Some(title); + self.capture(false); + return Ok(()); + } title.mode = horizon_client::title::Mode::Multiplayer(match reason { Some(reason) => horizon_client::multiplayer::Screen::Disconnected { reason, diff --git a/crates/horizon-client/src/lan/playerdata.rs b/crates/horizon-client/src/lan/playerdata.rs index c0ccc41b0..3554463ea 100644 --- a/crates/horizon-client/src/lan/playerdata.rs +++ b/crates/horizon-client/src/lan/playerdata.rs @@ -45,6 +45,13 @@ pub fn load(guest: &mut Guest, world: &Path) -> bool { ..Level::default() }; level.read_player(&tag); + level.player_extra = Some(tag); + apply(guest, &level); + true +} + +/// Give a guest the player state read into `level`. +pub fn apply(guest: &mut Guest, level: &Level) { if let Some(p) = level.position { guest.position = p; guest.previous_position = p; @@ -61,7 +68,7 @@ pub fn load(guest: &mut Guest, world: &Path) -> bool { guest.xp_total = level.xp_total; guest.game_mode = level.mode(); guest.selected = (level.selected_slot.max(0) as usize).min(8); - guest.saved = Some(tag); + guest.saved = level.player_extra.clone(); if level.ender_items.len() == 27 { guest.ender_items = level.ender_items.clone(); } @@ -85,30 +92,41 @@ pub fn load(guest: &mut Guest, world: &Path) -> bool { _ => {} } } - true } /// Save a guest (PlayerDataStorage.save). pub fn save(guest: &Guest, world: &Path) { let mut level = Level { player_uuid: Some(uuid_ints(guest.uuid)), - position: Some(guest.position), - rotation: [guest.yaw, guest.pitch], - health: guest.health, - food: guest.food, - saturation: guest.saturation, - xp_level: guest.xp_level, - xp_progress: guest.xp_progress, - xp_total: guest.xp_total, - game_mode: guest.game_mode, - creative: guest.game_mode == 1, - selected_slot: guest.selected as i32, - on_ground: guest.on_ground, dimension: "minecraft:overworld".into(), - player_extra: guest.saved.clone(), - ender_items: guest.ender_items.clone(), ..Level::default() }; + store(guest, &mut level); + let file = path(world, guest.uuid); + if let Some(dir) = file.parent() { + let _ = std::fs::create_dir_all(dir); + } + let _ = write_dat(&file, level.player_tag()); +} + +/// Put a guest's state in `level`'s player fields. +pub fn store(guest: &Guest, level: &mut Level) { + level.position = Some(guest.position); + level.rotation = [guest.yaw, guest.pitch]; + level.health = guest.health; + level.food = guest.food; + level.saturation = guest.saturation; + level.xp_level = guest.xp_level; + level.xp_progress = guest.xp_progress; + level.xp_total = guest.xp_total; + level.game_mode = guest.game_mode; + level.creative = guest.game_mode == 1; + level.selected_slot = guest.selected as i32; + level.on_ground = guest.on_ground; + level.player_extra = guest.saved.clone(); + level.ender_items = guest.ender_items.clone(); + level.inventory.clear(); + level.inventory_components.clear(); let mut put = |slot: u8, stack: &Option| { if let Some(s) = stack { level @@ -127,9 +145,4 @@ pub fn save(guest: &Guest, world: &Path) { put(101, &guest.armor[2]); put(100, &guest.armor[3]); put(150, &guest.offhand); - let file = path(world, guest.uuid); - if let Some(dir) = file.parent() { - let _ = std::fs::create_dir_all(dir); - } - let _ = write_dat(&file, level.player_tag()); } diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs index e341caa3d..df1001640 100644 --- a/crates/horizon-client/src/streaming.rs +++ b/crates/horizon-client/src/streaming.rs @@ -200,6 +200,8 @@ pub struct Streaming { /// More areas to keep loaded (centre chunk, radius), e.g. around guests /// of a world open to the network. They are generated and kept but not meshed. pub extra: Vec<((i32, i32), i32)>, + /// Mesh the sections for drawing (false on a server thread). + pub mesh: bool, } /// Snapshot only after a scan found no missing candidates. Public range fields /// and `World::chunks` can change without going through Streaming, so compare @@ -466,6 +468,7 @@ impl Streaming { meshed_total: 0, remote: false, extra: Vec::new(), + mesh: true, } } /// Resource packs reloaded (`LevelRenderer.allChanged`): mesh with the new @@ -959,6 +962,11 @@ impl Streaming { Job::Light(x, z, region, self.sequence, self.sky_light), ); } + // A server draws nothing: its sections are never meshed. + if !self.mesh { + world.dirty_sections.clear(); + return (uploads, removed); + } // Meshing once the column and its neighbours are lit, and the column // is within the render distance. Sections set aside past it come back // when the player moves: a column that loads with its light gets no