Files
horizon-airdef/crates/horizon-client/examples/section_mesh_fixture.rs
T
Ludovic Marie f48a54da09 Block state ids past 16 bits
Chunk sections keep block states as u32 and size the global palette
to the registry: 16 bits for vanilla's 35,723 states, wider when
content mods take the registry past 65,536. The content-mod limit
goes from 2^16 to 2^20 states.

The LAN host writes chunks at the registry's width, so with vanilla
(or mods within 16 bits) the wire is unchanged. Remote chunks are read
at the server's width, 16 from a vanilla server, and widened to ours.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 09:12:41 +02:00

243 lines
9.3 KiB
Rust

//! Headless transport for the section-mesh parity gate: builds the requested
//! scenes in real client chunks and writes the vertices `Mesher::mesh` emits in
//! the oracle's canonical form (vanilla ARGB colours and packed light coords).
#![forbid(unsafe_code)]
use horizon_client::{
assets::Assets,
biome::{BiomeInfo, Biomes, GrassModifier},
blocks::BlockFacts,
chunk::{Chunk, Light, MIN_Y, index},
mesher::{MeshTables, Mesher, OPAQUE_LAYER, TerrainVertex},
models,
};
use horizon_core::biome::BiomeZoom;
use horizon_world::registry::BlockStateId;
use serde_json::{Value, json};
use std::{
collections::BTreeMap,
fs,
io::{BufRead, BufReader, BufWriter, Write},
path::PathBuf,
sync::Arc,
time::{Duration, Instant},
};
type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
fn int(value: &Value) -> Result<i32> {
Ok(i32::try_from(value.as_i64().ok_or("expected integer")?)?)
}
/// Horizon packs RGBA little endian (red in the low byte); vanilla uses ARGB.
fn argb(color: u32) -> i32 {
let [r, g, b, a] = color.to_le_bytes();
i32::from_be_bytes([a, r, g, b])
}
/// Horizon keeps sky*16 in the low byte and block*16 above it; vanilla's light
/// coords keep block in the low half-word and sky in the high one.
fn light_coords(light: u16) -> i32 {
let light = u32::from(light);
((light & 0xFF) << 16 | (light >> 8 & 0xFF)) as i32
}
/// Scenes cover the 3x3 chunk region around chunk (0, 0).
fn chunk_index(x: i32, z: i32) -> Result<usize> {
let (cx, cz) = (x.div_euclid(16), z.div_euclid(16));
if !(-1..=1).contains(&cx) || !(-1..=1).contains(&cz) {
return Err("scene block outside the 3x3 chunk region".into());
}
Ok(((cz + 1) * 3 + cx + 1) as usize)
}
fn scene(
row: &Value,
assets: &Assets,
tables: &MeshTables,
biomes: &mut Biomes,
pristine: &[BiomeInfo],
names: &BTreeMap<u32, &str>,
elapsed: &mut Duration,
) -> Result<Value> {
let colors = &row["colors"];
let color = |k: &str| -> Result<u32> { Ok(int(&colors[k])? as u32 & 0xFF_FFFF) };
// Scenes without a biome field give every biome the same constant colours;
// the others use the real biome definitions.
biomes.list = pristine.to_vec();
if row.get("biomes").is_none() {
for biome in &mut biomes.list {
biome.grass = color("grass")?;
biome.modifier = GrassModifier::None;
biome.foliage = color("foliage")?;
biome.dry_foliage = color("dry_foliage")?;
biome.water = color("water")?;
}
}
let default = row["light"].as_array().ok_or("missing default light")?;
let packed = |sky: i32, block: i32| (sky << 4 | block) as u8;
let default = packed(int(&default[0])?, int(&default[1])?);
let mut chunks: Vec<Chunk> = (0..9)
.map(|i| {
let mut chunk = Chunk::empty(i % 3 - 1, i / 3 - 1);
for section in &mut chunk.sections {
Arc::make_mut(section).light = Light::Uniform(default);
}
chunk
})
.collect();
for block in row["blocks"].as_array().ok_or("missing blocks")? {
let (x, y, z) = (int(&block[0])?, int(&block[1])?, int(&block[2])?);
let i = chunk_index(x, z)?;
chunks[i].set(x & 15, y, z & 15, u32::try_from(int(&block[3])?)?);
}
for cell in row["lights"].as_array().ok_or("missing lights")? {
let (x, y, z) = (int(&cell[0])?, int(&cell[1])?, int(&cell[2])?);
let i = chunk_index(x, z)?;
let s = ((y - MIN_Y) >> 4) as usize;
let section = Arc::make_mut(&mut chunks[i].sections[s]);
if let Light::Uniform(v) = section.light {
section.light = Light::Full(Box::new([v; 4096]));
}
if let Light::Full(values) = &mut section.light {
values[index(x, y, z)] = packed(int(&cell[3])?, int(&cell[4])?);
}
}
let (mut zoom, mut blend_radius) = (BiomeZoom::new(0), 2);
let smooth_lighting = row["smooth"].as_bool().unwrap_or(true);
let cutout_leaves = row["cutout_leaves"].as_bool().unwrap_or(true);
if let Some(field) = row.get("biomes") {
zoom = BiomeZoom::new(field["seed"].as_i64().ok_or("missing biome seed")?);
blend_radius = int(&field["radius"])?;
let default = biomes.id(field["default"].as_str().ok_or("missing default biome")?);
for chunk in &mut chunks {
for qy in 0..96 {
for cell in 0..16 {
chunk.set_biome_cell(cell & 3, qy, cell >> 2, default);
}
}
}
for cell in field["cells"].as_array().ok_or("missing biome cells")? {
let (qx, qy, qz) = (int(&cell[0])?, int(&cell[1])?, int(&cell[2])?);
let i = chunk_index(qx * 4, qz * 4)?;
chunks[i].set_biome_cell(
qx,
qy - MIN_Y / 4,
qz,
biomes.id(cell[3].as_str().ok_or("biome name")?),
);
}
}
let region: [[Option<&Chunk>; 3]; 3] =
std::array::from_fn(|z| std::array::from_fn(|x| Some(&chunks[z * 3 + x])));
let mut mesher = Mesher {
nether_shading: row["nether"].as_bool().unwrap_or(false),
assets,
tables,
biomes: &*biomes,
visibility: tables.visibility.clone(),
zoom,
blend_radius,
smooth_lighting,
cutout_leaves,
cull_leaves: false,
};
let section_y = int(&row["section_y"])?;
let started = Instant::now();
let mesh = mesher.mesh(&region, (section_y * 16 - MIN_Y) / 16);
*elapsed += started.elapsed();
let mut quads = Vec::new();
for (layer, vertices) in [("opaque", &mesh.solid), ("translucent", &mesh.translucent)] {
let (vertices, rest) = vertices.as_chunks::<4>();
if !rest.is_empty() {
return Err("partial quad".into());
}
for quad in vertices {
let sprite = names
.get(&u32::from(quad[0].layer & !OPAQUE_LAYER))
.ok_or("unknown sprite layer")?;
if quad
.iter()
.any(|v: &TerrainVertex| v.layer != quad[0].layer)
{
return Err("quad mixes sprite layers".into());
}
let vertices: Vec<Value> = quad
.iter()
.map(|v| {
json!([
v.pos[0],
v.pos[1],
v.pos[2],
v.uv[0],
v.uv[1],
argb(v.color),
light_coords(v.light)
])
})
.collect();
quads.push(json!({"layer": layer, "sprite": sprite, "vertices": vertices}));
}
}
Ok(json!({"name": row["name"], "quads": quads}))
}
fn main() -> Result<()> {
let args: Vec<_> = std::env::args().skip(1).collect();
if args.len() != 3 {
return Err(
"usage: section_mesh_fixture RESOURCES (INPUT.jsonl | facts) OUTPUT.jsonl".into(),
);
}
let root = PathBuf::from(&args[0]);
let assets = Assets::load(&root)?;
let facts = BlockFacts::load(&root, assets.registry)?;
let mut biomes = Biomes::load(&root)?;
let visibility = models::load_visibility(&root, assets.registry)?;
let tables = MeshTables::new(&assets, &facts, visibility)?;
let names: BTreeMap<u32, &str> = assets
.sprite_layers
.iter()
.map(|(name, layer)| (*layer, name.as_str()))
.collect();
let pristine = biomes.list.clone();
let mut output = BufWriter::new(fs::File::create(&args[2])?);
if args[1] == "facts" {
// The per-state facts the mesher derives, in the oracle's order and positions.
let positions = [(0, 0), (5, -3), (-17, 31), (123, -456), (9, 2)];
for id in 0..assets.registry.len() as u32 {
let state = BlockStateId(id);
let f = tables.facts(state).ok_or("missing mesh facts")?;
let offsets: Vec<_> = positions
.iter()
.filter_map(|&(x, z)| tables.offset(state, x, z))
.collect();
let row = json!({"id": id, "shade": f.shade, "emissive": f.emissive,
"legacy_solid": f.legacy_solid, "light_permeable": f.light_permeable,
"solid_render": f.solid_render, "full_collision": f.full_collision,
"emission": f.emission, "overlay": f.overlay, "tint_sources": f.tint_sources,
"offsets": offsets});
serde_json::to_writer(&mut output, &row)?;
output.write_all(b"\n")?;
}
output.flush()?;
return Ok(());
}
let (mut elapsed, mut sections) = (Duration::ZERO, 0u32);
for line in BufReader::new(fs::File::open(&args[1])?).lines() {
let row: Value = serde_json::from_str(&line?)?;
let result = scene(
&row,
&assets,
&tables,
&mut biomes,
&pristine,
&names,
&mut elapsed,
)?;
serde_json::to_writer(&mut output, &result)?;
output.write_all(b"\n")?;
sections += 1;
}
output.flush()?;
eprintln!(
"meshed {sections} sections in {:.1} ms ({:.0} us per section)",
elapsed.as_secs_f64() * 1e3,
elapsed.as_secs_f64() * 1e6 / f64::from(sections.max(1))
);
Ok(())
}