From 43f598fd4e60afe7cca319c0e193cbb9d1910ec8 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 17 Oct 2026 17:19:16 +0200 Subject: [PATCH] LAN: write chunk packets straight into one buffer ChunkEncoder::body_in writes the LevelChunkWithLight body that Clientbound::encode would give, into one buffer sized up front: the cached section bytes and light layers are copied once, uniform light layers are filled in place, and the heightmaps are shared rather than cloned. Before, each chunk sent built a packet (growing its buffer, cloning every 2048-byte layer), then encode copied all of it again. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/lan/chunks.rs | 366 ++++++++++++++++++------ crates/horizon-client/src/lan/hub.rs | 16 +- 2 files changed, 291 insertions(+), 91 deletions(-) diff --git a/crates/horizon-client/src/lan/chunks.rs b/crates/horizon-client/src/lan/chunks.rs index 702f6913c..4c4731d95 100644 --- a/crates/horizon-client/src/lan/chunks.rs +++ b/crates/horizon-client/src/lan/chunks.rs @@ -7,8 +7,10 @@ use crate::{ fast_hash::FxHashMap, }; use horizon_protocol::{ - buf::set_bit, - chunk::{BIOMES, BLOCKS, BlockEntityInfo, ChunkData, LightData, Paletted, Strategy}, + buf::{BitSet, Codec, List, Writer, set_bit}, + chunk::{ + BIOMES, BLOCKS, BlockEntityInfo, ChunkData, Heightmaps, LightData, Paletted, Strategy, + }, packets::play::LevelChunkWithLight, registry::{Builtin, ceil_log2}, }; @@ -105,9 +107,12 @@ pub struct ChunkEncoder { /// A column's client heightmaps, valid while it holds the same sections. struct Heights { sections: Vec>, - maps: Vec<(i32, Vec)>, + maps: ColumnHeightmaps, } +/// Heightmap type ids with their packed long arrays. +type ColumnHeightmaps = Arc)>>; + /// What a resident section gives the wire, kept while the section is /// unchanged. Resident sections are immutable behind `Arc` (edits go through /// `Arc::make_mut`, which moves an edited section to a new address while a @@ -228,7 +233,7 @@ impl ChunkEncoder { /// The client heightmaps (Heightmap.prime over the column), from the /// cache while the column's sections are unchanged. - fn heightmaps(&self, chunk: &Chunk, tables: &crate::save::SaveTables) -> Vec<(i32, Vec)> { + fn heightmaps(&self, chunk: &Chunk, tables: &crate::save::SaveTables) -> ColumnHeightmaps { let same = |h: &Heights| { h.sections.len() == chunk.sections.len() && h.sections @@ -250,7 +255,9 @@ impl ChunkEncoder { } let min_y = MIN_Y + 16 * self.sections.start as i32; let height = 16 * self.sections.len() as i32; - let maps = crate::save::client_heightmaps_in(chunk, tables, min_y, height); + let maps = Arc::new(crate::save::client_heightmaps_in( + chunk, tables, min_y, height, + )); heights.insert( (chunk.x, chunk.z), Heights { @@ -398,7 +405,7 @@ impl ChunkEncoder { /// The non-air sections of a column as bits (LevelChunkSection.hasOnlyAir). fn occupied(&self, chunk: &Chunk) -> u64 { let mut bits = 0u64; - // One lock for the column: encode_in asks for nine columns' sections. + // One lock for the column: body_in asks for nine columns' sections. let mut cache = self.cache.lock().unwrap(); for (i, s) in chunk.sections[self.sections.clone()].iter().enumerate() { if self.entry(&mut cache, s).non_air { @@ -408,9 +415,8 @@ impl ChunkEncoder { bits } - /// The chunk column with its light and block entities. `world` gives the - /// neighbouring columns, whose sections decide which light layers exist. - pub fn encode_in(&self, chunk: &Chunk, world: &crate::world::World) -> LevelChunkWithLight { + /// The non-air sections of the column and its neighbours, as bits. + fn around(&self, chunk: &Chunk, world: &crate::world::World) -> u64 { let mut around = 0u64; for dz in -1..=1 { for dx in -1..=1 { @@ -419,9 +425,55 @@ impl ChunkEncoder { } } } - let mut packet = self.encode_blocks(chunk, &world.block_entities); - packet.light = self.light_data(chunk, around); - packet + around + } + + /// The chunk column with its light and block entities, as the body + /// `Clientbound::encode` gives for its LevelChunkWithLight. `world` gives + /// the neighbouring columns, whose sections decide which light layers + /// exist. It is written once into a buffer of its final size: the cached + /// sections and light layers go straight to it, with no packet built and + /// copied again first. + pub fn body_in(&self, chunk: &Chunk, world: &crate::world::World) -> Vec { + self.body(chunk, &world.block_entities, self.around(chunk, world)) + } + + fn body( + &self, + chunk: &Chunk, + block_entities: &HashMap<(i32, i32, i32), BlockEntity>, + around: u64, + ) -> Vec { + let (wires, entities) = self.blocks(chunk, block_entities); + let heightmaps = self.heightmaps_of(chunk); + let lights = self.light_sections(chunk, around); + let buffer: usize = wires.iter().map(|w| w.len()).sum(); + // Before the light: their tags' size is only known once written. + let mut tags = Writer::new(); + List::::write(&entities, &mut tags); + // The masks, counts and lengths fit the 64 bytes. + let size = 64 + + heightmaps + .iter() + .map(|(_, h)| 10 + 8 * h.len()) + .sum::() + + buffer + + tags.data.len() + + lights.len() * 2 * (2048 + 3); + let mut w = Writer { + data: Vec::with_capacity(size), + }; + w.varint(horizon_protocol::ids::play::clientbound::LEVEL_CHUNK_WITH_LIGHT); + w.i32(chunk.x); + w.i32(chunk.z); + Heightmaps::write(&*heightmaps, &mut w); + w.varint(buffer as i32); + for wire in &wires { + w.bytes(wire); + } + w.bytes(&tags.data); + write_light(&lights, self.sky, &mut w); + w.data } pub fn encode( @@ -440,7 +492,41 @@ impl ChunkEncoder { chunk: &Chunk, block_entities: &HashMap<(i32, i32, i32), BlockEntity>, ) -> LevelChunkWithLight { - let mut buffer = Vec::new(); + let (wires, block_entities) = self.blocks(chunk, block_entities); + LevelChunkWithLight { + x: chunk.x, + z: chunk.z, + chunk: ChunkData { + heightmaps: self.heightmaps_of(chunk).to_vec(), + buffer: wires.concat(), + block_entities, + }, + light: LightData { + sky_mask: Vec::new(), + block_mask: Vec::new(), + empty_sky_mask: Vec::new(), + empty_block_mask: Vec::new(), + sky: Vec::new(), + block: Vec::new(), + }, + } + } + + fn heightmaps_of(&self, chunk: &Chunk) -> ColumnHeightmaps { + self.tables + .as_ref() + .map(|t| self.heightmaps(chunk, t)) + .unwrap_or_default() + } + + /// The level's sections on the wire, and the column's block entities in + /// the packet's order. + fn blocks( + &self, + chunk: &Chunk, + block_entities: &HashMap<(i32, i32, i32), BlockEntity>, + ) -> (Vec>, Vec) { + let mut wires = Vec::with_capacity(self.sections.len()); let mut entity_infos = Vec::new(); for (i, s) in chunk .sections @@ -474,7 +560,7 @@ impl ChunkEncoder { .unwrap_or(Tag::End), }); } - buffer.extend_from_slice(&encoded); + wires.push(encoded); } // A loaded chunk's block entities enter its maps in the save's order // (ChunkAccess.pendingBlockEntities, then LevelChunk.blockEntities): @@ -499,27 +585,7 @@ impl ChunkEncoder { chunk.z * 16 + i32::from(e.packed_xz as u8 & 15), ) }); - LevelChunkWithLight { - x: chunk.x, - z: chunk.z, - chunk: ChunkData { - heightmaps: self - .tables - .as_ref() - .map(|t| self.heightmaps(chunk, t)) - .unwrap_or_default(), - buffer, - block_entities: entity_infos, - }, - light: LightData { - sky_mask: Vec::new(), - block_mask: Vec::new(), - empty_sky_mask: Vec::new(), - empty_block_mask: Vec::new(), - sky: Vec::new(), - block: Vec::new(), - }, - } + (wires, entity_infos) } /// ClientboundLightUpdatePacketData: the light layers of the sections @@ -528,23 +594,20 @@ impl ChunkEncoder { /// the cache while it is unchanged (uniform light is quicker to fill than /// to keep). fn light_data(&self, chunk: &Chunk, around: u64) -> LightData { - let mut data = light_data_with(&chunk.sections[self.sections.clone()], around, |s| { - if matches!(s.light, Light::Uniform(_)) { - return Arc::new(Layers::of(&s.light)); + light_data_of(&self.light_sections(chunk, around), self.sky) + } + + fn light_sections(&self, chunk: &Chunk, around: u64) -> Vec<(usize, SectionLight)> { + light_sections(&chunk.sections[self.sections.clone()], around, |s| { + if let Light::Uniform(v) = s.light { + return SectionLight::Uniform(v); } - self.cached(s, |e| e.light.clone()).unwrap_or_else(|| { + SectionLight::Layers(self.cached(s, |e| e.light.clone()).unwrap_or_else(|| { let layers = Arc::new(Layers::of(&s.light)); self.cached(s, |e| e.light = Some(layers.clone())); layers - }) - }); - if !self.sky { - // No sky light storage at all. - data.sky_mask.clear(); - data.empty_sky_mask.clear(); - data.sky.clear(); - } - data + })) + }) } } @@ -620,51 +683,123 @@ pub fn entity_tag(entity: &BlockEntity) -> Option { /// layer is sent, or marked empty when all dark; the others are left out. #[cfg(test)] fn light_data(sections: &[Arc
], around: u64) -> LightData { - light_data_with(sections, around, |s| Arc::new(Layers::of(&s.light))) + let lights = light_sections(sections, around, |s| { + SectionLight::Layers(Arc::new(Layers::of(&s.light))) + }); + light_data_of(&lights, true) } -/// The light layers, `section` giving a resident section's. -fn light_data_with( +/// A light section's two DataLayers: a resident section's from the cache, +/// or one value everywhere, which is quicker to write than to keep. +enum SectionLight { + Layers(Arc), + /// Sky light in the high nibble, block light in the low one. + Uniform(u8), +} +impl SectionLight { + /// Whether the sky and the block layer hold any light. + fn any(&self) -> (bool, bool) { + match self { + Self::Layers(l) => (l.sky_any, l.block_any), + Self::Uniform(v) => (v >> 4 != 0, v & 15 != 0), + } + } + /// Append the sky or the block layer's 2048 bytes. + fn put(&self, sky: bool, out: &mut Vec) { + match self { + Self::Layers(l) => out.extend_from_slice(if sky { &l.sky } else { &l.block }), + Self::Uniform(v) => { + let n = if sky { v >> 4 } else { v & 15 }; + out.resize(out.len() + 2048, n | n << 4); + } + } + } +} + +/// The existing light sections, by index from below the world, with their +/// layers (`section` giving a section of the world's). +fn light_sections( sections: &[Arc
], around: u64, - section: impl Fn(&Arc
) -> Arc, -) -> LightData { + section: impl Fn(&Arc
) -> SectionLight, +) -> Vec<(usize, SectionLight)> { let n = sections.len(); - let mut data = LightData { - sky_mask: Vec::new(), - block_mask: Vec::new(), - empty_sky_mask: Vec::new(), - empty_block_mask: Vec::new(), - sky: Vec::new(), - block: Vec::new(), - }; // Light section b holds chunk section b - 1. let exists = |b: usize| (b.saturating_sub(2)..=b.min(n - 1)).any(|s| s + 2 >= b && around >> s & 1 != 0); - for b in 0..n + 2 { - if !exists(b) { - continue; + (0..n + 2) + .filter(|&b| exists(b)) + .map(|b| { + let light = match b { + // Below the world nothing is lit; above it the sky is full. + 0 => SectionLight::Uniform(0), + _ if b == n + 1 => SectionLight::Uniform(0xF0), + _ => section(§ions[b - 1]), + }; + (b, light) + }) + .collect() +} + +/// The four masks of ClientboundLightUpdatePacketData (sky, block, empty +/// sky, empty block); a level without sky light has no sky storage at all. +fn light_masks(lights: &[(usize, SectionLight)], sky: bool) -> [Vec; 4] { + let mut masks: [Vec; 4] = Default::default(); + for (b, light) in lights { + let (sky_any, block_any) = light.any(); + if sky { + set_bit(&mut masks[if sky_any { 0 } else { 2 }], *b); } - let layers = match b { - // Below the world nothing is lit; above it the sky is full. - 0 => Arc::new(Layers::of(&Light::Uniform(0))), - _ if b == n + 1 => Arc::new(Layers::of(&Light::Uniform(0xF0))), - _ => section(§ions[b - 1]), - }; - if layers.sky_any { - set_bit(&mut data.sky_mask, b); - data.sky.push(layers.sky.clone()); - } else { - set_bit(&mut data.empty_sky_mask, b); - } - if layers.block_any { - set_bit(&mut data.block_mask, b); - data.block.push(layers.block.clone()); - } else { - set_bit(&mut data.empty_block_mask, b); + set_bit(&mut masks[if block_any { 1 } else { 3 }], *b); + } + masks +} + +/// The layers sent of one kind: those with any light. +fn sent_layers( + lights: &[(usize, SectionLight)], + sky: bool, +) -> impl Iterator + Clone { + lights.iter().map(|(_, l)| l).filter(move |l| { + let (sky_any, block_any) = l.any(); + if sky { sky_any } else { block_any } + }) +} + +fn light_data_of(lights: &[(usize, SectionLight)], sky: bool) -> LightData { + let [sky_mask, block_mask, empty_sky_mask, empty_block_mask] = light_masks(lights, sky); + let layers = |kind: bool| -> Vec> { + sent_layers(lights, kind) + .map(|l| { + let mut layer = Vec::with_capacity(2048); + l.put(kind, &mut layer); + layer + }) + .collect() + }; + LightData { + sky_mask, + block_mask, + empty_sky_mask, + empty_block_mask, + sky: if sky { layers(true) } else { Vec::new() }, + block: layers(false), + } +} + +/// LightData.write, from the layers themselves. +fn write_light(lights: &[(usize, SectionLight)], sky: bool, w: &mut Writer) { + for mask in light_masks(lights, sky) { + BitSet::write(&mask, w); + } + for kind in [true, false] { + let layers = sent_layers(lights, kind).filter(|_| sky || !kind); + w.varint(layers.clone().count() as i32); + for l in layers { + w.varint(2048); + l.put(kind, &mut w.data); } } - data } #[cfg(test)] @@ -844,6 +979,73 @@ mod tests { assert!(horizon_protocol::buf::bit(&data.empty_block_mask, 5)); } + #[test] + fn the_body_is_the_packet_encoded() { + let builtin = Builtin::parse( + r#"{"minecraft:block_entity_type": {"entries": { + "minecraft:chest": {"protocol_id": 1}, + "minecraft:sign": {"protocol_id": 7}}}}"#, + ) + .unwrap(); + let states = [ + "minecraft:air", + "minecraft:stone", + "minecraft:chest", + "minecraft:oak_sign", + ] + .map(|n| (Arc::::from(n), false)); + let mut encoder = ChunkEncoder::new(states, &builtin, &[], &[]); + let mut chunk = Chunk::empty(-7, 12); + // Every kind of light section: uniform dark, uniform lit, sky and + // block light varying, none at all. + let mut light = Box::new([0u8; 4096]); + for (i, v) in light.iter_mut().enumerate() { + *v = (i * 53 % 256) as u8; + } + Arc::make_mut(&mut chunk.sections[4]).light = Light::Full(light); + Arc::make_mut(&mut chunk.sections[5]).light = Light::Uniform(0x07); + Arc::make_mut(&mut chunk.sections[6]).light = Light::Uniform(0); + Arc::make_mut(&mut chunk.sections[7]).light = Light::Full(Box::new([0x30; 4096])); + for (x, y, z, state) in [ + (3, 70, 9, 1), + (5, 70, 5, 2), + (0, -60, 15, 2), + (15, 300, 0, 1), + (8, 64, 1, 3), + ] { + chunk.set(x, y, z, state); + } + // A sign's update tag goes with the column. + let mut entities = HashMap::new(); + entities.insert( + (-7 * 16 + 8, 64, 12 * 16 + 1), + BlockEntity::Sign(crate::signs::SignData::default()), + ); + let packet = |encoder: &ChunkEncoder, around: u64| { + let mut packet = encoder.encode_blocks(&chunk, &entities); + packet.light = encoder.light_data(&chunk, around); + horizon_protocol::packets::play::Clientbound::LevelChunkWithLight(packet).encode() + }; + let sent = encoder + .encode_blocks(&chunk, &entities) + .chunk + .block_entities; + assert_eq!(sent.len(), 3); + assert!(sent.iter().any(|e| e.tag != Tag::End)); + for around in [0, 1, 0b1010_0000, 1 << 23, u64::MAX] { + assert_eq!( + encoder.body(&chunk, &entities, around), + packet(&encoder, around), + "around {around:#b}" + ); + } + encoder.set_dimension(0, 256, false); + assert_eq!( + encoder.body(&chunk, &entities, u64::MAX), + packet(&encoder, u64::MAX) + ); + } + #[test] fn a_nether_column_sends_its_sixteen_sections_without_sky_light() { let chunk = Chunk::empty(0, 0); diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index 598bbc088..5e2d480d6 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -1122,21 +1122,20 @@ impl Hub { if !chunk.lit { continue; } - packets.push(C::LevelChunkWithLight( - self.encoder.encode_in(chunk, ctx.world), - )); + packets.push(self.encoder.body_in(chunk, ctx.world)); taken.push(idx); } if packets.is_empty() { return; } - g.batch_quota -= packets.len() as f32; + let size = packets.len(); + g.batch_quota -= size as f32; g.send(&C::ChunkBatchStart(horizon_protocol::packets::Empty)); - for p in &packets { - g.send(p); + for body in packets { + g.sender.send(body); } g.send(&C::ChunkBatchFinished(play::ChunkBatchFinished { - size: packets.len() as i32, + size: size as i32, })); g.unacknowledged += 1; for idx in taken.into_iter().rev() { @@ -1150,8 +1149,7 @@ impl Hub { let Some(chunk) = world.chunks.get(&(x, z)) else { return; }; - let packet = C::LevelChunkWithLight(self.encoder.encode_in(chunk, world)); - let body = packet.encode(); + let body = self.encoder.body_in(chunk, world); for g in self .guests .iter()