From 2940b5ac902b2690eea0b7ad00e8a96e02309157 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 8 Oct 2026 15:13:16 +0200 Subject: [PATCH 1/5] Add section mesh parity gate against the client's block and fluid renderers Co-Authored-By: Claude Opus 5.5 --- .../examples/section_mesh_fixture.rs | 154 ++++++ .../parity/VanillaSectionMeshOracle.java | 293 ++++++++++++ tools/test_section_mesh_parity.py | 450 ++++++++++++++++++ 3 files changed, 897 insertions(+) create mode 100644 crates/horizon-client/examples/section_mesh_fixture.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSectionMeshOracle.java create mode 100644 tools/test_section_mesh_parity.py diff --git a/crates/horizon-client/examples/section_mesh_fixture.rs b/crates/horizon-client/examples/section_mesh_fixture.rs new file mode 100644 index 000000000..50a8b085e --- /dev/null +++ b/crates/horizon-client/examples/section_mesh_fixture.rs @@ -0,0 +1,154 @@ +//! 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::{Biomes, GrassModifier}, + blocks::BlockFacts, + chunk::{Chunk, Light, MIN_Y, index}, + mesher::{MeshTables, Mesher, Vertex}, + models, +}; +use serde_json::{Value, json}; +use std::{ + collections::BTreeMap, + fs, + io::{BufRead, BufReader, BufWriter, Write}, + path::PathBuf, + sync::Arc, +}; +type Result = std::result::Result>; + +fn int(value: &Value) -> Result { + 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: u32) -> i32 { + ((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 { + 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, + names: &BTreeMap, +) -> Result { + let colors = &row["colors"]; + let color = |k: &str| -> Result { Ok(int(&colors[k])? as u32 & 0xFF_FFFF) }; + 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 = (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, u16::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 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(), + }; + let section_y = int(&row["section_y"])?; + let mesh = mesher.mesh(®ion, (section_y * 16 - MIN_Y) / 16); + let mut quads = Vec::new(); + for (layer, vertices) in [("opaque", &mesh.solid), ("translucent", &mesh.translucent)] { + if vertices.len() % 4 != 0 { + return Err("partial quad".into()); + } + for quad in vertices.chunks_exact(4) { + let sprite = names.get(&quad[0].layer).ok_or("unknown sprite layer")?; + if quad.iter().any(|v: &Vertex| v.layer != quad[0].layer) { + return Err("quad mixes sprite layers".into()); + } + let vertices: Vec = 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 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 = assets + .sprite_layers + .iter() + .map(|(name, layer)| (*layer, name.as_str())) + .collect(); + let mut output = BufWriter::new(fs::File::create(&args[2])?); + 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, &names)?; + serde_json::to_writer(&mut output, &result)?; + output.write_all(b"\n")?; + } + output.flush()?; + Ok(()) +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSectionMeshOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSectionMeshOracle.java new file mode 100644 index 000000000..c35afb92e --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSectionMeshOracle.java @@ -0,0 +1,293 @@ +package dev.horizonlab.parity; + +import com.google.gson.*; +import com.mojang.blaze3d.platform.NativeImage; +import com.mojang.blaze3d.vertex.QuadInstance; +import com.mojang.blaze3d.vertex.VertexConsumer; +import com.mojang.serialization.JsonOps; +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.nio.file.*; +import java.util.*; +import java.util.concurrent.CompletableFuture; +import net.minecraft.client.color.block.BlockColors; +import net.minecraft.client.renderer.BiomeColors; +import net.minecraft.client.renderer.block.*; +import net.minecraft.client.renderer.block.dispatch.*; +import net.minecraft.client.renderer.chunk.ChunkSectionLayer; +import net.minecraft.client.renderer.texture.*; +import net.minecraft.client.resources.metadata.animation.FrameSize; +import net.minecraft.client.resources.model.*; +import net.minecraft.client.resources.model.cuboid.*; +import net.minecraft.client.resources.model.geometry.BakedQuad; +import net.minecraft.client.resources.model.sprite.*; +import net.minecraft.core.*; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.resources.Identifier; +import net.minecraft.util.StrictJsonParser; +import net.minecraft.world.level.CardinalLighting; +import net.minecraft.world.level.ColorResolver; +import net.minecraft.world.level.EmptyBlockGetter; +import net.minecraft.world.level.LightLayer; +import net.minecraft.world.level.block.*; +import net.minecraft.world.level.block.entity.BlockEntity; +import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.level.lighting.LevelLightEngine; +import net.minecraft.world.level.material.FluidState; +import org.joml.Vector3fc; +import static dev.horizonlab.parity.VanillaCuboidModelOracle.map; + +/** Runs the client's own ModelBlockRenderer (smooth lighting on) and FluidRenderer + * over small fixed scenes, the way SectionCompiler visits one section, and + * records every emitted vertex. Block models are baked from the jar's own + * blockstate and model resources; every texture becomes a real sprite alone in + * a unit atlas so UVs stay in sprite-local [0,1] space. Fluid sprites share one + * strip with gaps so their vertex stream still identifies the sprite. */ +public final class VanillaSectionMeshOracle { + private static final Gson JSON = new GsonBuilder().serializeNulls().create(); + private static final String[] FLUID_SPRITES = {"minecraft:block/water_still", "minecraft:block/water_flow", + "minecraft:block/water_overlay", "minecraft:block/lava_still", "minecraft:block/lava_flow"}; + private static final int STRIP = 2 * FLUID_SPRITES.length; + + private static final class Sprite extends TextureAtlasSprite { + Sprite(SpriteContents contents, int slots, int slot) { + super(TextureAtlas.LOCATION_BLOCKS, contents, contents.width() * slots, contents.height(), contents.width() * slot, 0, 0); + } + } + private static final Map SPRITES = new HashMap<>(); + private static SpriteContents contents(Identifier id) throws IOException { + var path = "/assets/" + id.getNamespace() + "/textures/" + id.getPath() + ".png"; + try (var input = VanillaSectionMeshOracle.class.getResourceAsStream(path)) { + NativeImage image = input == null ? new NativeImage(16, 16, true) : NativeImage.read(input); + int size = Math.min(image.getWidth(), image.getHeight()); + return new SpriteContents(id, new FrameSize(image.getWidth(), size), image); + } + } + private static TextureAtlasSprite sprite(Identifier id) { + return SPRITES.computeIfAbsent(id, key -> { + try { + int slot = Arrays.asList(FLUID_SPRITES).indexOf(key.toString()); + return slot < 0 ? new Sprite(contents(key), 1, 0) : new Sprite(contents(key), STRIP, 2 * slot); + } catch (IOException error) { throw new UncheckedIOException(error); } + }); + } + /** Hands out the unit-atlas sprite named by each material. */ + private static final class Materials extends MaterialBaker { + Materials(SpriteLoader.Preparations atlas) { super(atlas, atlas); } + @Override public Material.Baked get(Material material, ModelDebugName name) { + return new Material.Baked(sprite(material.sprite()), material.forceTranslucent()); + } + } + private static final class Baker implements ModelBaker { + final Map resolved; final ResolvedModel missing; final MaterialBaker materials; + final Map, Object> cache = new HashMap<>(); + Baker(Map resolved, ResolvedModel missing, MaterialBaker materials) { + this.resolved = resolved; this.missing = missing; this.materials = materials; + } + public ResolvedModel getModel(Identifier id) { return resolved.getOrDefault(id, missing); } + public BlockStateModelPart missingBlockModelPart() { throw new AssertionError("missing block model part"); } + public MaterialBaker materials() { return materials; } + public ModelBaker.Interner interner() { + return new ModelBaker.Interner() { + public Vector3fc vector(Vector3fc vector) { return vector; } + public BakedQuad.MaterialInfo materialInfo(BakedQuad.MaterialInfo value) { return value; } + }; + } + @SuppressWarnings("unchecked") + public T compute(SharedOperationKey key) { + var value = cache.get(key); + if (value == null) { value = key.compute(this); cache.put(key, value); } + return (T) value; + } + } + private static String resource(String path) throws IOException { + try (var input = VanillaSectionMeshOracle.class.getResourceAsStream(path)) { + return input == null ? null : new String(input.readAllBytes(), StandardCharsets.UTF_8); + } + } + /** Real blockstate definitions and models for the requested blocks. */ + private static final class Models { + final Map roots = new HashMap<>(); + final Map baked = new HashMap<>(); + final Baker baker; + Models(Set blocks, MaterialBaker materials) throws IOException { + var unbaked = new HashMap(); + for (var block : blocks) { + var id = BuiltInRegistries.BLOCK.getKey(block); + var raw = resource("/assets/" + id.getNamespace() + "/blockstates/" + id.getPath() + ".json"); + if (raw == null) continue; + var definition = BlockStateModelDispatcher.CODEC.parse(JsonOps.INSTANCE, StrictJsonParser.parse(raw)).getOrThrow(); + roots.putAll(definition.instantiate(block.getStateDefinition(), id::toString)); + } + var pending = new ArrayList(); + for (var root : new HashSet<>(roots.values())) root.resolveDependencies(pending::add); + for (int i = 0; i < pending.size(); i++) { + var id = pending.get(i); + if (unbaked.containsKey(id)) continue; + var raw = resource("/assets/" + id.getNamespace() + "/models/" + id.getPath() + ".json"); + if (raw == null) continue; + var model = CuboidModel.fromStream(new StringReader(raw)); + unbaked.put(id, model); + if (model.parent() != null) pending.add(model.parent()); + } + var discovery = new ModelDiscovery(unbaked, MissingCuboidModel.missingModel()); + discovery.addRoot(resolver -> { for (var id : unbaked.keySet()) resolver.markDependency(id); }); + var resolved = discovery.resolve(); + baker = new Baker(resolved, discovery.missingModel(), materials); + } + BlockStateModel get(BlockState state) { + return baked.computeIfAbsent(state, s -> Objects.requireNonNull(roots.get(s), () -> "no model for " + s).bake(s, baker)); + } + } + private static long key(int x, int y, int z) { return BlockPos.asLong(x, y, z); } + /** A fixed region: listed blocks over air, listed light over a default. */ + private static final class Scene implements BlockAndTintGetter { + final Map blocks = new HashMap<>(); + final Map light = new HashMap<>(); + int[] defaultLight; boolean nether; int grass, foliage, dry, water; + public CardinalLighting cardinalLighting() { return nether ? CardinalLighting.NETHER : CardinalLighting.DEFAULT; } + public LevelLightEngine getLightEngine() { return LevelLightEngine.EMPTY; } + public int getBrightness(LightLayer layer, BlockPos pos) { + var value = light.getOrDefault(pos.asLong(), defaultLight); + return layer == LightLayer.SKY ? value[0] : value[1]; + } + public int getBlockTint(BlockPos pos, ColorResolver resolver) { + int rgb = resolver == BiomeColors.GRASS_COLOR_RESOLVER ? grass : resolver == BiomeColors.FOLIAGE_COLOR_RESOLVER ? foliage + : resolver == BiomeColors.DRY_FOLIAGE_COLOR_RESOLVER ? dry : resolver == BiomeColors.WATER_COLOR_RESOLVER ? water : -1; + if (rgb == -1) throw new AssertionError("unexpected colour resolver"); + return 0xFF000000 | rgb; + } + public BlockEntity getBlockEntity(BlockPos pos) { return null; } + public BlockState getBlockState(BlockPos pos) { return blocks.getOrDefault(pos.asLong(), Blocks.AIR.defaultBlockState()); } + public FluidState getFluidState(BlockPos pos) { return getBlockState(pos).getFluidState(); } + public int getHeight() { return 384; } + public int getMinY() { return -64; } + } + private static final class Recorder { + final List quads = new ArrayList<>(); + List pending; BlockPos block; String kind, layer, sprite; + void vertex(float x, float y, float z, int color, float u, float v, int light) { + if (pending == null) pending = new ArrayList<>(); + pending.add(new Object[]{x, y, z, u, v, color, light}); + if (pending.size() == 4) { + quads.add(map("block", new int[]{block.getX(), block.getY(), block.getZ()}, "kind", kind, "layer", layer, "sprite", sprite, "vertices", pending)); + pending = null; + } + } + } + private static String layer(ChunkSectionLayer layer) { return layer.name().toLowerCase(Locale.ROOT); } + private static Object scene(JsonObject row, Models models, FluidStateModelSet fluids) { + var scene = new Scene(); + var light = row.getAsJsonArray("light"); + scene.defaultLight = new int[]{light.get(0).getAsInt(), light.get(1).getAsInt()}; + scene.nether = row.get("nether").getAsBoolean(); + var colors = row.getAsJsonObject("colors"); + scene.grass = colors.get("grass").getAsInt(); scene.foliage = colors.get("foliage").getAsInt(); + scene.dry = colors.get("dry_foliage").getAsInt(); scene.water = colors.get("water").getAsInt(); + for (var item : row.getAsJsonArray("blocks")) { + var b = item.getAsJsonArray(); + scene.blocks.put(key(b.get(0).getAsInt(), b.get(1).getAsInt(), b.get(2).getAsInt()), Block.stateById(b.get(3).getAsInt())); + } + for (var item : row.getAsJsonArray("lights")) { + var l = item.getAsJsonArray(); + scene.light.put(key(l.get(0).getAsInt(), l.get(1).getAsInt(), l.get(2).getAsInt()), new int[]{l.get(3).getAsInt(), l.get(4).getAsInt()}); + } + var recorder = new Recorder(); + BlockModelLighter.enableCaching(); + var renderer = new ModelBlockRenderer(true, true, BlockColors.createDefault()); + var fluidRenderer = new FluidRenderer(fluids); + BlockQuadOutput output = (x, y, z, quad, instance) -> { + recorder.kind = "model"; recorder.layer = layer(quad.materialInfo().layer()); + recorder.sprite = quad.materialInfo().sprite().contents().name().toString(); + int emission = quad.materialInfo().lightEmission(); + for (int i = 0; i < 4; i++) { + var p = quad.position(i); long uv = quad.packedUV(i); + recorder.vertex(p.x() + x, p.y() + y, p.z() + z, instance.getColor(i), + Float.intBitsToFloat((int) (uv >>> 32)), Float.intBitsToFloat((int) uv), instance.getLightCoordsWithEmission(i, emission)); + } + }; + int baseY = row.get("section_y").getAsInt() * 16; + for (var pos : BlockPos.betweenClosed(0, baseY, 0, 15, baseY + 15, 15)) { + var state = scene.getBlockState(pos); + if (state.isAir()) continue; + recorder.block = pos.immutable(); + var fluid = state.getFluidState(); + if (!fluid.isEmpty()) { + fluidRenderer.tesselate(scene, pos, sectionLayer -> new VertexConsumer() { + public void addVertex(float x, float y, float z, int color, float u, float v, int overlay, int light, float nx, float ny, float nz) { + int slot = (int) Math.floor(u * STRIP / 2.0f); + recorder.kind = "fluid"; recorder.layer = layer(sectionLayer); recorder.sprite = FLUID_SPRITES[slot]; + recorder.vertex(x, y, z, color, u * STRIP - 2 * slot, v, light); + } + public VertexConsumer addVertex(float x, float y, float z) { throw new AssertionError(); } + public VertexConsumer setColor(int r, int g, int b, int a) { throw new AssertionError(); } + public VertexConsumer setColor(int color) { throw new AssertionError(); } + public VertexConsumer setUv(float u, float v) { throw new AssertionError(); } + public VertexConsumer setUv1(int u, int v) { throw new AssertionError(); } + public VertexConsumer setUv2(int u, int v) { throw new AssertionError(); } + public VertexConsumer setUv3(float u, float v) { throw new AssertionError(); } + public VertexConsumer setNormal(float x, float y, float z) { throw new AssertionError(); } + public VertexConsumer setLineWidth(float width) { throw new AssertionError(); } + }, state, fluid); + } + if (state.getRenderShape() == RenderShape.MODEL) { + renderer.tesselateBlock(ModelBlockRenderer.forceOpaque(true, state) ? (x, y, z, quad, instance) -> { + throw new AssertionError("cutout leaves are enabled"); + } : output, SectionPos.sectionRelative(pos.getX()), SectionPos.sectionRelative(pos.getY()), SectionPos.sectionRelative(pos.getZ()), + scene, pos, state, models.get(state), state.getSeed(pos)); + } + } + BlockModelLighter.clearCache(); + if (recorder.pending != null) throw new AssertionError("partial quad"); + return map("name", row.get("name").getAsString(), "quads", recorder.quads); + } + /** Per-state facts the Rust mesher derives from prepared resources. */ + private static Object facts(BlockState state, int id) { + var level = EmptyBlockGetter.INSTANCE; + var offsets = new ArrayList(); + if (state.hasOffsetFunction()) { + for (var p : new BlockPos[]{new BlockPos(0, 0, 0), new BlockPos(5, 7, -3), new BlockPos(-17, 70, 31), new BlockPos(123, -40, -456), new BlockPos(9, 1, 2)}) { + var o = state.getOffset(p); + offsets.add(new double[]{o.x, o.y, o.z}); + } + } + var block = state.getBlock(); + return map("id", id, "shade", state.getShadeBrightness(level, BlockPos.ZERO), "emissive", state.emissiveRendering(), + "legacy_solid", state.isSolid(), "light_permeable", state.isLightPermeable(), "solid_render", state.isSolidRender(), + "full_collision", state.isCollisionShapeFullBlock(level, BlockPos.ZERO), "emission", state.getLightEmission(), + "half_transparent", block instanceof HalfTransparentBlock, "leaves", block instanceof LeavesBlock, + "tint_sources", BlockColors.createDefault().getTintSources(state).size(), "offsets", offsets); + } + public static void main(String[] args) throws Exception { + net.minecraft.SharedConstants.tryDetectVersion(); + net.minecraft.server.Bootstrap.bootStrap(); + VanillaHeightmapOracle.bindTags(JsonParser.parseString(Files.readString(Path.of(args[2]).resolve("block-tags.json"))).getAsJsonObject()); + LeavesBlock.setCutoutLeaves(true); + if (args[0].equals("facts")) { + try (var output = Files.newBufferedWriter(Path.of(args[1]))) { + int id = 0; + for (var state : Block.BLOCK_STATE_REGISTRY) { + if (Block.getId(state) != id) throw new AssertionError("state registry order"); + output.write(JSON.toJson(facts(state, id++))); output.newLine(); + } + } + return; + } + var rows = new ArrayList(); + try (var input = Files.newBufferedReader(Path.of(args[0]))) { + for (String line; (line = input.readLine()) != null; ) rows.add(JsonParser.parseString(line).getAsJsonObject()); + } + var blocks = new HashSet(); + for (var row : rows) for (var item : row.getAsJsonArray("blocks")) blocks.add(Block.stateById(item.getAsJsonArray().get(3).getAsInt()).getBlock()); + var missingContents = new SpriteContents(Identifier.parse("minecraft:missingno"), new FrameSize(16, 16), new NativeImage(16, 16, true)); + var missing = new Sprite(missingContents, 1, 0); + var atlas = new SpriteLoader.Preparations(16, 16, 0, missing, Map.of(), CompletableFuture.completedFuture(null)); + var materials = new Materials(atlas); + var models = new Models(blocks, materials); + var fluidModels = FluidStateModelSet.bake(materials); + var fluids = new FluidStateModelSet(fluidModels, fluidModels.values().iterator().next()); + try (var output = Files.newBufferedWriter(Path.of(args[1]))) { + for (var row : rows) { output.write(JSON.toJson(scene(row, models, fluids))); output.newLine(); } + } + } +} diff --git a/tools/test_section_mesh_parity.py b/tools/test_section_mesh_parity.py new file mode 100644 index 000000000..6cd7c44ab --- /dev/null +++ b/tools/test_section_mesh_parity.py @@ -0,0 +1,450 @@ +#!/usr/bin/env python3 +"""Compare Horizon's section mesher with the client's own ModelBlockRenderer and FluidRenderer. + +Both sides mesh the same scenes (block states by registry ID, per-cell sky/block +light, constant biome colours, overworld or Nether cardinal lighting). The Java +oracle runs vanilla smooth lighting (AO on, cutout leaves) block by block the way +SectionCompiler visits a section; the Rust fixture runs ``Mesher::mesh`` on real +client chunks. Quads are compared as multisets keyed by sprite, render layer class +and rounded geometry; matched quads then compare UVs, ARGB colours and light +coordinates per vertex. A second gate compares the per-state facts the Rust mesher +derives (shade brightness, emissive rendering, legacy solidity, offsets, ...) +with the client's own state accessors for every registry state. +""" +import argparse +from collections import Counter, defaultdict +import json +import math +import os +from pathlib import Path +import platform +import random +import subprocess +try: + from . import lab, test_rust_parity as base, test_model_baking_parity as baking +except ImportError: + import lab + import test_rust_parity as base + import test_model_baking_parity as baking + +BUILD = lab.ROOT / 'target/section-mesh-parity' +SECTION_Y = 0 +COLORS = {'grass': 0x91BD59, 'foliage': 0x77AB2F, 'dry_foliage': 0xA88B5E, 'water': 0x3F76E4} +POSITION_TOLERANCE = 1e-4 +UV_TOLERANCE = 1e-4 + + +class States: + """Registry state IDs by name and properties, from the prepared registry facts.""" + def __init__(self, resources): + facts = json.loads((resources / 'facts.json').read_text()) + self.defaults = facts['defaults'] + self.properties = [entry[4].get('properties', {}) for entry in facts['states']] + self.names = [entry[0] for entry in facts['states']] + self.by_name = defaultdict(list) + for index, name in enumerate(self.names): + self.by_name[name].append(index) + gameplay = json.loads((resources / 'gameplay-facts.json').read_text())['states'] + self.dampening = [s['dampening'] for s in gameplay] + self.emission = [s['emission'] for s in gameplay] + self.opaque = [s['solid_render'] for s in gameplay] + self.render_shape = [s['render_shape'] for s in gameplay] + + def __call__(self, name, **properties): + name = name if ':' in name else 'minecraft:' + name + wanted = dict(self.properties[self.defaults[name]]) + for key, value in properties.items(): + key = key.rstrip('_') + if key not in wanted: + raise KeyError(f'{name} has no property {key}') + wanted[key] = str(value).lower() + for index in self.by_name[name]: + if self.properties[index] == wanted: + return index + raise KeyError(f'no state {name} {wanted}') + + +class Scene: + def __init__(self, states, name, nether=False): + self.states, self.name, self.nether = states, name, nether + self.blocks = {} + self.light_override = {} + self.noise = None + + def put(self, x, y, z, name, **properties): + self.blocks[(x, y, z)] = name if isinstance(name, int) else self.states(name, **properties) + + def fill(self, x0, y0, z0, x1, y1, z1, name, **properties): + state = self.states(name, **properties) + for x in range(x0, x1 + 1): + for y in range(y0, y1 + 1): + for z in range(z0, z1 + 1): + self.blocks[(x, y, z)] = state + + def floor(self, y=3, name='stone'): + self.fill(-1, y, -1, 16, y, 16, name) + + def lights(self): + """Simple deterministic propagation: straight-down skylight, -1 per step + sideways, dampening per cell; emitters spread block light the same way.""" + lo, hi = -2, 17 + base = SECTION_Y * 16 + cells = [(x, y, z) for x in range(lo, hi + 1) for y in range(base + lo, base + hi + 1) for z in range(lo, hi + 1)] + damp = {c: self.states.dampening[self.blocks.get(c, 0)] for c in cells} + opaque = {c: self.states.opaque[self.blocks.get(c, 0)] and damp[c] > 0 for c in cells} + def spread(seeds, straight_down): + level = {c: 0 for c in cells} + queue = [] + for c, v in seeds: + if v > level[c]: + level[c] = v + queue.append(c) + while queue: + nxt = [] + for c in queue: + v = level[c] + for d in [(1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1)]: + n = (c[0] + d[0], c[1] + d[1], c[2] + d[2]) + if n not in level or opaque[n]: + continue + loss = 0 if straight_down and d == (0, -1, 0) and v == 15 and damp[n] == 0 else 1 + w = v - loss - damp[n] + if w > level[n]: + level[n] = w + nxt.append(n) + queue = nxt + return level + top = base + hi + sky = spread([((x, top, z), 15) for x in range(lo, hi + 1) for z in range(lo, hi + 1) if not opaque[(x, top, z)]], True) + block = spread([(c, self.states.emission[self.blocks.get(c, 0)]) for c in cells], False) + rng = random.Random(self.noise) if self.noise is not None else None + result = [] + for c in cells: + s, b = sky[c], block[c] + if rng is not None: + s, b = rng.randrange(16), rng.randrange(16) + s, b = self.light_override.get(c, (s, b)) + if (s, b) != (15, 0): + result.append([*c, s, b]) + return result + + def row(self): + return {'name': self.name, 'nether': self.nether, 'section_y': SECTION_Y, 'colors': COLORS, 'light': [15, 0], + 'blocks': [[*p, s] for p, s in sorted(self.blocks.items())], 'lights': self.lights()} + + +def corpus(states): + scenes = [] + def scene(name, **kwargs): + s = Scene(states, name, **kwargs) + scenes.append(s) + return s + # Full cubes: open air, corners, cavities, overhangs and steps for AO. + s = scene('cubes_open') + s.put(8, 8, 8, 'stone') + s.put(3, 3, 3, 'grass_block') + s = scene('cubes_corners') + s.floor(3) + s.fill(0, 4, 0, 15, 7, 0, 'stone') + s.fill(0, 4, 0, 0, 7, 15, 'cobblestone') + s.fill(4, 4, 4, 6, 4, 6, 'oak_planks') + s.put(5, 5, 5, 'stone') + s.fill(9, 4, 9, 12, 6, 12, 'stone') + s.put(10, 6, 10, 'air') + s.put(11, 5, 10, 'air') + s.put(10, 5, 10, 'air') + s.fill(2, 8, 2, 6, 8, 6, 'stone') + s.put(13, 4, 2, 'glass') + s.put(13, 4, 3, 'stone') + s.put(14, 4, 2, 'oak_leaves') + s.put(14, 5, 2, 'grass_block') + s.put(12, 4, 14, 'soul_sand') + s.put(13, 4, 14, 'mud') + s.put(14, 4, 14, 'barrier') + s.put(12, 5, 14, 'grass_block') + s.put(13, 5, 14, 'grass_block') + s.put(14, 5, 14, 'snow', layers=8) + s.put(15, 5, 14, 'snow', layers=4) + s = scene('cave') + s.fill(-1, 0, -1, 16, 15, 16, 'stone') + s.fill(2, 3, 2, 13, 9, 13, 'air') + s.fill(5, 3, 5, 9, 3, 9, 'water') + s.put(4, 4, 4, 'torch') + s.put(12, 3, 12, 'glowstone') + s.put(3, 3, 12, 'magma_block') + s.put(12, 3, 3, 'sea_lantern') + s.put(7, 9, 7, 'shroomlight') + s.put(10, 4, 4, 'lantern') + s.put(2, 5, 7, 'wall_torch', facing='east') + s.put(6, 4, 11, 'redstone_wire', power=15) + s.put(7, 4, 11, 'redstone_wire', power=7) + s.put(8, 4, 11, 'redstone_wire', power=0) + s.put(6, 3, 11, 'stone') + s.put(9, 4, 12, 'sculk_sensor', sculk_sensor_phase='active') + s.put(10, 4, 12, 'sculk_sensor') + s.put(11, 4, 12, 'glow_lichen', down=True) + # Shapes on a floor, against walls and in the open. + s = scene('shapes') + s.floor(3) + s.fill(-1, 4, 15, 16, 7, 16, 'stone') + x = 0 + for name, props in [('stone_slab', {'type': 'bottom'}), ('stone_slab', {'type': 'top'}), ('stone_slab', {'type': 'double'}), + ('oak_stairs', {}), ('oak_stairs', {'facing': 'east', 'half': 'top'}), ('oak_stairs', {'shape': 'inner_left'}), + ('oak_stairs', {'facing': 'south', 'shape': 'outer_right'}), ('cobblestone_wall', {'north': 'low', 'up': True}), + ('oak_fence', {'north': True, 'east': True}), ('glass_pane', {'north': True, 'south': True}), + ('iron_bars', {'east': True, 'west': True}), ('torch', {}), ('poppy', {}), ('dandelion', {}), + ('short_grass', {}), ('fern', {})]: + s.put(x, 4, 7, name, **props) + s.put(x, 4, 14, name, **props) + x += 1 + x = 0 + for name, props in [('tall_grass', {'half': 'lower'}), ('large_fern', {'half': 'lower'}), ('sunflower', {'half': 'lower'}), + ('grass_block', {}), ('oak_leaves', {}), ('spruce_leaves', {}), ('birch_leaves', {}), ('snow', {'layers': 1}), + ('snow', {'layers': 7}), ('white_carpet', {}), ('farmland', {}), ('dirt_path', {}), ('cauldron', {}), + ('water_cauldron', {'level': 3}), ('hopper', {}), ('anvil', {})]: + s.put(x, 4, 4, name, **props) + if name in ('tall_grass', 'large_fern', 'sunflower'): + s.put(x, 5, 4, name, half='upper') + x += 1 + x = 0 + for name, props in [('iron_chain', {}), ('iron_chain', {'axis': 'x'}), ('lantern', {}), ('lantern', {'hanging': True}), + ('soul_lantern', {}), ('lily_pad', {}), ('vine', {'north': True}), ('sugar_cane', {}), ('pink_petals', {'flower_amount': 4}), + ('melon_stem', {'age': 5}), ('attached_pumpkin_stem', {}), ('leaf_litter', {'segment_amount': 3}), + ('small_dripleaf', {}), ('pointed_dripstone', {}), ('bamboo', {}), ('brewing_stand', {})]: + s.put(x, 4, 10, name, **props) + x += 1 + s.put(15, 8, 10, 'stone') + s.put(3, 7, 10, 'stone') + s.put(2, 5, 10, 'stone') + s.put(15, 4, 1, 'scaffolding') + # Fluids: sources, flowing levels, falling columns, mixed neighbours, waterlogging. + s = scene('fluids') + s.floor(2) + s.fill(0, 3, 0, 4, 3, 4, 'water') + for i, level in enumerate([1, 2, 3, 4, 5, 6, 7]): + s.put(5 + i, 3, 2, 'water', level=level) + s.put(5 + i, 3, 3, 'water', level=8 - level) + s.put(5 + i, 3, 6, 'lava', level=level) + s.put(2, 4, 2, 'water', level=8) + s.put(2, 5, 2, 'water', level=8) + s.put(13, 3, 3, 'glass') + s.put(12, 4, 3, 'oak_leaves') + s.put(4, 4, 4, 'stone_slab', type='bottom', waterlogged=True) + s.put(4, 4, 3, 'oak_stairs', waterlogged=True) + s.put(3, 4, 4, 'oak_fence', waterlogged=True) + s.put(1, 4, 1, 'ice') + s.fill(0, 3, 8, 3, 3, 11, 'lava') + s.put(1, 4, 9, 'lava', level=8) + s.put(2, 4, 10, 'stone') + s.fill(8, 3, 9, 12, 5, 13, 'water') + s.put(10, 6, 11, 'water', level=3) + s.put(9, 6, 11, 'oak_slab', type='top') + s.put(11, 6, 11, 'glass') + s.put(10, 6, 12, 'stone') + s.put(13, 4, 11, 'kelp') + s.put(14, 3, 11, 'seagrass') + s.put(15, 3, 13, 'water', level=2) + s.put(15, 4, 14, 'water', level=9) + s.put(15, 3, 15, 'stone_slab', type='top') + # Section edges with neighbours in other chunks and sections. + s = scene('edges') + for x in [0, 15]: + for y in [0, 15]: + for z in [0, 15]: + s.put(x, y, z, 'stone') + s.put(x + (-1 if x == 0 else 1), y, z, 'stone') + s.put(x, y + (-1 if y == 0 else 1), z, 'dirt') + s.put(7, 15, 7, 'water') + s.put(7, 16, 7, 'water') + s.put(8, 0, 8, 'water', level=3) + s.put(8, -1, 8, 'stone') + s.put(-1, 7, 7, 'water') + s.put(0, 7, 7, 'water', level=2) + s.put(16, 7, 7, 'oak_leaves') + s.put(15, 7, 7, 'oak_leaves') + # Every block with a model, default state, on a sparse grid. + model_blocks = sorted(name for name, default in states.defaults.items() if states.render_shape[default] == 'MODEL' + and name not in ('minecraft:air', 'minecraft:cave_air', 'minecraft:void_air')) + per_scene = 8 * 8 * 8 + for chunk in range(0, len(model_blocks), per_scene): + s = scene(f'catalog_{chunk // per_scene}') + for i, name in enumerate(model_blocks[chunk:chunk + per_scene]): + s.put(i % 8 * 2, i // 64 * 2, i // 8 % 8 * 2, states.defaults[name]) + # Random dense scenes over a palette, with structured and noisy light. + palette = ['stone', 'glass', 'oak_leaves', 'grass_block', 'water', 'lava', 'oak_slab', 'oak_stairs', 'torch', 'poppy', + 'short_grass', 'glowstone', 'oak_fence', 'snow', 'white_carpet', 'magma_block', 'soul_sand', 'ice', 'farmland', 'dirt_path'] + for seed in range(8): + rng = random.Random(0x4D455348 + seed) + s = scene(f'random_{seed}', nether=seed % 4 == 3) + for _ in range(900): + name = rng.choice(palette) + ids = states.by_name['minecraft:' + name] + s.put(rng.randrange(-1, 17), rng.randrange(-1, 17), rng.randrange(-1, 17), rng.choice(ids)) + if seed % 2: + s.noise = seed + s = scene('cubes_nether', nether=True) + s.floor(3, 'netherrack') + s.fill(4, 4, 4, 6, 6, 6, 'nether_bricks') + s.fill(8, 4, 8, 10, 4, 10, 'lava') + s.put(12, 4, 12, 'glowstone') + return scenes + + +def quad_key(quad): + vertices = quad['vertices'] + rounded = [tuple(round(v[i] * 1000) for i in range(3)) for v in vertices] + rotation = min(range(4), key=lambda r: rounded[r:] + rounded[:r]) + layer = 'translucent' if quad['layer'] == 'translucent' else 'opaque' + return (quad['sprite'], layer, tuple(rounded[rotation:] + rounded[:rotation])), rotation + + +def channels(color): + color &= 0xFFFFFFFF + return [color >> 16 & 255, color >> 8 & 255, color & 255, color >> 24] + + +def light(coords): + return [coords >> 16 & 0xFFFF, coords & 0xFFFF] + + +def compare(scene, client, rust, states, report, limit): + blocks = {tuple(b[:3]): b[3] for b in scene['blocks']} + def describe(quad, rotation): + v = quad['vertices'] + centre = [sum(p[i] for p in v) / 4 for i in range(3)] + block = quad.get('block') or [math.floor(c + 1e-4 if i != 1 else c - 1e-3) for i, c in enumerate(centre)] + state = blocks.get(tuple(block), 0) + return {'block': block, 'state': f"{states.names[state]}{states.properties[state] or ''}", + 'sprite': quad['sprite'], 'kind': quad.get('kind', 'rust'), + 'vertices': [list(x) for x in (v[rotation:] + v[:rotation])]} + groups = defaultdict(lambda: ([], [])) + for side, quads in [(0, client), (1, rust)]: + for quad in quads: + key, rotation = quad_key(quad) + groups[key][side].append((quad, rotation)) + counts = Counter() + def add(category, *examples): + counts[category] += 1 + report['categories'][category] = report['categories'].get(category, 0) + 1 + bucket = report['examples'].setdefault(category, []) + if len(bucket) < limit: + bucket.append({'scene': scene['name'], 'quads': list(examples)}) + for key, (left, right) in groups.items(): + def attributes(entry): + quad, rotation = entry + v = quad['vertices'] + return [(round(x[3], 3), round(x[4], 3), channels(x[5]), light(x[6])) for x in v[rotation:] + v[:rotation]] + left.sort(key=lambda e: str(attributes(e))) + right.sort(key=lambda e: str(attributes(e))) + for a, b in zip(left, right): + report['matched_quads'] += 1 + va = [x for x in attributes(a)] + ca = a[0]['vertices'][a[1]:] + a[0]['vertices'][:a[1]] + cb = b[0]['vertices'][b[1]:] + b[0]['vertices'][:b[1]] + problems = set() + for p, q in zip(ca, cb): + if any(abs(p[i] - q[i]) > POSITION_TOLERANCE for i in range(3)): + problems.add('position') + if any(abs(p[i] - q[i]) > UV_TOLERANCE for i in (3, 4)): + problems.add('uv') + cp, cq = channels(p[5]), channels(q[5]) + if cp != cq: + problems.add('color' if max(abs(x - y) for x, y in zip(cp, cq)) > 1 else 'color_rounding') + if light(p[6]) != light(q[6]): + lp, lq = light(p[6]), light(q[6]) + problems.add('light_sky' if lp[0] != lq[0] else 'light_block') + del va + if not problems: + report['identical_quads'] += 1 + for problem in sorted(problems): + add(f"{problem}:{a[0].get('kind', 'model')}", describe(*a), describe(*b)) + for entry in left[len(right):]: + add(f"missing:{entry[0]['kind']}", describe(*entry)) + for entry in right[len(left):]: + add('extra', describe(*entry)) + report['client_quads'] += len(client) + report['rust_quads'] += len(rust) + return counts + + +def main(): + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + parser.add_argument('--strict', action='store_true', help='fail when any quad or fact differs') + parser.add_argument('--examples', type=int, default=12, help='examples kept per mismatch category') + parser.add_argument('--only', help='only scenes whose name contains this text') + args = parser.parse_args() + lock, jars, _ = base.verify_artifacts() + resources = lab.LOCAL / 'horizon-client' / lock['minecraft']['version'] + BUILD.mkdir(parents=True, exist_ok=True) + report_path = BUILD / 'report.json' + report_path.unlink(missing_ok=True) + oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSectionMeshOracle.java' + helpers = [oracle.with_name(n + '.java') for n in ['VanillaCuboidModelOracle', 'VanillaHeightmapOracle']] + sources = [Path(__file__), lab.ROOT / 'tools/lab.py', lab.ROOT / 'tools/test_rust_parity.py', oracle, *helpers, + lab.ROOT / 'Cargo.toml', lab.ROOT / 'Cargo.lock', lab.ROOT / 'crates/horizon-client/examples/section_mesh_fixture.rs'] + for crate in ['horizon-core', 'horizon-world', 'horizon-assets', 'horizon-client']: + sources += [lab.ROOT / 'crates' / crate / 'Cargo.toml', *sorted((lab.ROOT / 'crates' / crate / 'src').rglob('*.rs'))] + tested = base.source_hashes(sources) + states = States(resources) + scenes = [s for s in corpus(states) if not args.only or args.only in s.name] + rows = [s.row() for s in scenes] + inputs = BUILD / 'inputs.jsonl' + inputs.write_text(''.join(json.dumps(row) + '\n' for row in rows)) + def run(command, name): + with (BUILD / (name + '.log')).open('w') as log: + subprocess.run(list(map(str, command)), cwd=lab.ROOT, check=True, timeout=3600, stdout=log, stderr=subprocess.STDOUT) + classes = BUILD / 'classes' + classes.mkdir(exist_ok=True) + dependencies = os.pathsep.join(map(str, [jars['client'], *baking.client_libraries()])) + run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-cp', dependencies, '-d', classes, oracle, *helpers], 'compile-java') + env_jobs = os.environ.get('CARGO_BUILD_JOBS', '3') + run(['cargo', 'build', '--locked', '--profile', 'fast', '-j', env_jobs, '-p', 'horizon-client', '--example', 'section_mesh_fixture'], 'compile-rust') + metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--locked', '--no-deps', '--format-version', '1'], cwd=lab.ROOT)) + binary = Path(metadata['target_directory']) / 'fast/examples' / ('section_mesh_fixture.exe' if os.name == 'nt' else 'section_mesh_fixture') + java = ['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaSectionMeshOracle'] + run([binary, resources, inputs, BUILD / 'rust.jsonl'], 'rust') + run([*java, inputs, BUILD / 'client.jsonl', resources], 'client') + run([*java, 'facts', BUILD / 'client-facts.jsonl', resources], 'client-facts') + run([binary, resources, 'facts', BUILD / 'rust-facts.jsonl'], 'rust-facts') + report = {'schema': 1, 'minecraft': lock['minecraft']['version'], 'platform': platform.platform(), + 'scenes': len(rows), 'client_quads': 0, 'rust_quads': 0, 'matched_quads': 0, 'identical_quads': 0, + 'categories': {}, 'examples': {}, 'per_scene': {}, 'facts': {}} + client = [json.loads(line) for line in (BUILD / 'client.jsonl').read_text().splitlines()] + rust = [json.loads(line) for line in (BUILD / 'rust.jsonl').read_text().splitlines()] + for row, a, b in zip(rows, client, rust): + assert row['name'] == a['name'] == b['name'] + counts = compare(row, a['quads'], b['quads'], states, report, args.examples) + report['per_scene'][row['name']] = {'client': len(a['quads']), 'rust': len(b['quads']), **counts} + client_facts = [json.loads(line) for line in (BUILD / 'client-facts.jsonl').read_text().splitlines()] + rust_facts = [json.loads(line) for line in (BUILD / 'rust-facts.jsonl').read_text().splitlines()] + fact_mismatches = Counter() + for a, b in zip(client_facts, rust_facts): + for key in a: + if key == 'offsets': + same = len(a[key]) == len(b.get(key, [])) and all(abs(x - y) < 1e-6 for p, q in zip(a[key], b[key]) for x, y in zip(p, q)) + else: + same = a[key] == b.get(key) + if not same: + fact_mismatches[key] += 1 + examples = report['facts'].setdefault(key, []) + if len(examples) < args.examples: + examples.append({'state': f"{states.names[a['id']]}{states.properties[a['id']]}", 'client': a[key], 'rust': b.get(key)}) + report['fact_mismatches'] = dict(fact_mismatches) + report['fact_states'] = len(client_facts) + base.ensure_sources_unchanged(sources, tested) + report['sources_sha256'] = tested + lab.write_json(report_path, report) + total = report['client_quads'] + print(f"Section mesh parity: {len(rows)} scenes, client {total:,} quads, Rust {report['rust_quads']:,} quads, " + f"{report['matched_quads']:,} geometry matches, {report['identical_quads']:,} identical " + f"({100.0 * report['identical_quads'] / max(total, 1):.2f}% of client quads)") + for category, count in sorted(report['categories'].items(), key=lambda kv: -kv[1]): + print(f' {category:<28} {count:,}') + print(f"Mesh facts: {len(client_facts):,} states, mismatches: {dict(fact_mismatches) or 'none'}") + print(f'Report: {report_path}') + if args.strict and (report['categories'] or fact_mismatches): + raise SystemExit(1) + + +if __name__ == '__main__': + main() From 86dac330a5219040b589327587be379de48e0e61 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 8 Oct 2026 15:29:32 +0200 Subject: [PATCH 2/5] Port vanilla block lighting and fluid rendering into the section mesher Smooth lighting and ambient occlusion now follow BlockModelLighter (cubic/partial faces, diagonal samples through light-permeable blocks, light blending with the sky-borrow and zero rules, partial-face weights), with vanilla's integer colour arithmetic, cardinal shading, quad light emission, flat lighting for emitting or non-AO blocks, tint source counts and random block offsets. Fluids follow FluidRenderer: occlusion against neighbour face shapes, legacy-solid corner heights, flow-rotated UVs with Mth.atan2 and the sine table, water overlay beside glass and leaves, back faces and max(self, above) light. Flat model elements skip their degenerate faces like UnbakedCuboidGeometry. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-assets/src/bake.rs | 25 + .../examples/section_mesh_fixture.rs | 26 +- crates/horizon-client/src/assets.rs | 10 + crates/horizon-client/src/blocks.rs | 47 ++ crates/horizon-client/src/mesher.rs | 649 +++++++----------- crates/horizon-client/src/mesher/fluid.rs | 469 +++++++++++++ crates/horizon-client/src/mesher/lighting.rs | 420 ++++++++++++ crates/horizon-client/src/models/catalog.rs | 4 +- crates/horizon-world/src/block_render.rs | 10 + .../parity/VanillaSectionMeshOracle.java | 10 +- tools/test_section_mesh_parity.py | 18 +- 11 files changed, 1286 insertions(+), 402 deletions(-) create mode 100644 crates/horizon-client/src/mesher/fluid.rs create mode 100644 crates/horizon-client/src/mesher/lighting.rs diff --git a/crates/horizon-assets/src/bake.rs b/crates/horizon-assets/src/bake.rs index e2afe55df..1b48ad7dd 100644 --- a/crates/horizon-assets/src/bake.rs +++ b/crates/horizon-assets/src/bake.rs @@ -168,6 +168,22 @@ pub fn bake_model(model: &ResolvedCuboidModel) -> Result> { pub fn bake_model_transformed( model: &ResolvedCuboidModel, transform: BlockModelTransform, +) -> Result> { + bake_elements(model, transform, false) +} +/// Block-model baking as `UnbakedCuboidGeometry.bake` does it: an element with +/// zero extent along an axis draws no faces across that extent (a flat X +/// element keeps only its X faces, and so on). +pub fn bake_block_model( + model: &ResolvedCuboidModel, + transform: BlockModelTransform, +) -> Result> { + bake_elements(model, transform, true) +} +fn bake_elements( + model: &ResolvedCuboidModel, + transform: BlockModelTransform, + skip_flat: bool, ) -> Result> { let mut output = Vec::new(); for element in model.elements() { @@ -175,7 +191,16 @@ pub fn bake_model_transformed( .as_ref() .ok_or_else(|| error("null model element"))?; let matrix = element.rotation.as_ref().map(ElementMatrix::from_rotation); + let flat = |axis: usize| skip_flat && element.from[axis] == element.to[axis]; for (direction, face) in &element.faces { + let drawn = match direction { + Direction::West | Direction::East => !flat(1) && !flat(2), + Direction::Down | Direction::Up => !flat(0) && !flat(2), + Direction::North | Direction::South => !flat(0) && !flat(1), + }; + if !drawn { + continue; + } let face = face.as_ref().ok_or_else(|| error("null model face"))?; let material = model.material(&face.texture)?.cloned().unwrap_or(Material { sprite: "minecraft:missingno".to_owned(), diff --git a/crates/horizon-client/examples/section_mesh_fixture.rs b/crates/horizon-client/examples/section_mesh_fixture.rs index 50a8b085e..ba6c36bd7 100644 --- a/crates/horizon-client/examples/section_mesh_fixture.rs +++ b/crates/horizon-client/examples/section_mesh_fixture.rs @@ -10,6 +10,7 @@ use horizon_client::{ mesher::{MeshTables, Mesher, Vertex}, models, }; +use horizon_world::registry::BlockStateId; use serde_json::{Value, json}; use std::{ collections::BTreeMap, @@ -129,7 +130,9 @@ fn scene( 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 OUTPUT.jsonl".into()); + return Err( + "usage: section_mesh_fixture RESOURCES (INPUT.jsonl | facts) OUTPUT.jsonl".into(), + ); } let root = PathBuf::from(&args[0]); let assets = Assets::load(&root)?; @@ -143,6 +146,27 @@ fn main() -> Result<()> { .map(|(name, layer)| (*layer, name.as_str())) .collect(); 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(()); + } 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, &names)?; diff --git a/crates/horizon-client/src/assets.rs b/crates/horizon-client/src/assets.rs index cafdd7b2d..8e22f7736 100644 --- a/crates/horizon-client/src/assets.rs +++ b/crates/horizon-client/src/assets.rs @@ -63,6 +63,8 @@ pub struct Assets { pub animations: Vec, pub sprite_layers: std::collections::BTreeMap, pub translucent_layers: Vec, + /// Block names in `#minecraft:blocks_fluid_flow` (fluid flow vectors). + pub blocks_fluid_flow: BTreeSet, } fn invalid(message: &str) -> io::Error { io::Error::new(io::ErrorKind::InvalidData, message) @@ -144,6 +146,13 @@ impl Assets { .iter() .map(String::as_str) .collect(); + let blocks_fluid_flow = built + .tags + .get("minecraft:blocks_fluid_flow") + .ok_or_else(|| invalid("missing fluid flow tag"))? + .iter() + .cloned() + .collect(); let properties = Properties(Arc::new( states .iter() @@ -202,6 +211,7 @@ impl Assets { animations: sprites.animations, sprite_layers: sprites.layers, translucent_layers: sprites.translucent, + blocks_fluid_flow, }) } } diff --git a/crates/horizon-client/src/blocks.rs b/crates/horizon-client/src/blocks.rs index b67529ece..fe7547e65 100644 --- a/crates/horizon-client/src/blocks.rs +++ b/crates/horizon-client/src/blocks.rs @@ -52,6 +52,19 @@ pub struct StateFacts { pub fluid_level: u8, pub fluid_falling: bool, pub waterlogged: bool, + /// `hasOffsetFunction`: the model is jittered per column. + pub random_offset: bool, + /// `BlockState.isSolid()` (legacy solidity; fluid surfaces read it). + pub legacy_solid: bool, + /// `isFaceSturdy(.., SupportType.FULL)` by Direction ordinal. + pub sturdy_full: u8, + /// The block's class chain (`TransparentBlock`, `LeavesBlock`, ...), most specific first. + pub classes: Arc<[Arc]>, +} +impl StateFacts { + pub fn has_class(&self, name: &str) -> bool { + self.classes.iter().any(|c| &**c == name) + } } pub struct BlockFacts { pub states: Vec, @@ -67,6 +80,33 @@ impl BlockFacts { if entries.len() != registry.len() { return Err("gameplay facts do not match the block registry".into()); } + // Class chains and per-state behaviour flags exported from the actual block objects. + let behaviours: Value = serde_json::from_reader(BufReader::new(File::open( + root.join("block-behaviours.json"), + )?))?; + let behaviour_states = behaviours["states"] + .as_array() + .filter(|s| s.len() == registry.len()) + .ok_or("block behaviour facts do not match the block registry")?; + let mut class_names: HashMap> = HashMap::new(); + let classes: HashMap<&str, Arc<[Arc]>> = behaviours["blocks"] + .as_array() + .ok_or("missing block behaviour classes")? + .iter() + .filter_map(|b| { + let chain = b["class"] + .as_array()? + .iter() + .filter_map(Value::as_str) + .map(|c| { + class_names + .entry(c.to_owned()) + .or_insert_with(|| Arc::from(c)) + .clone() + }); + Some((b["name"].as_str()?, chain.collect())) + }) + .collect(); let mut names: HashMap> = HashMap::new(); let mut intern = |s: &str| -> Arc { names @@ -143,6 +183,13 @@ impl BlockFacts { fluid_level, fluid_falling, waterlogged: prop("waterlogged") == Some("true"), + random_offset: flag("offset"), + legacy_solid: behaviour_states[index][1].as_u64().unwrap_or(0) & 1 != 0, + sturdy_full: (behaviour_states[index][0].as_u64().unwrap_or(0) & 63) as u8, + classes: classes + .get(state.name.as_str()) + .cloned() + .ok_or("missing block behaviour class chain")?, }); } Ok(Self { diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index 28750057a..b83980a25 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -1,17 +1,23 @@ //! Section meshing on worker threads. Faces follow the baked blockstate models -//! with vanilla's neighbour culling; vertex lighting follows -//! `ModelBlockRenderer`'s smooth-lighting blend (four samples per corner, zero -//! samples replaced by the centre) and ambient-occlusion shade brightness. -//! Fluids follow `FluidRenderer` (corner heights, still/flowing sprites). +//! with vanilla's neighbour culling; vertex light and colour follow +//! `ModelBlockRenderer`/`BlockModelLighter` (smooth light, ambient occlusion, +//! cardinal shading, tint sources, block offsets; see `lighting`). Fluids +//! follow `FluidRenderer` (see `fluid`). +mod fluid; +mod lighting; use crate::{ assets::Assets, biome::Biomes, - blocks::{BlockFacts, Fluid, RenderShape}, + blocks::{BlockFacts, RenderShape}, chunk::{Chunk, MIN_Y}, models::catalog::BakedFace, }; -use horizon_core::{geometry::Direction, position::BlockPos}; -use horizon_world::{block_render::FaceVisibility, registry::BlockStateId}; +use horizon_core::{geometry::Direction, position::BlockPos, random::position_seed}; +use horizon_world::{ + block_render::FaceVisibility, + fluid::{FluidKind, FluidState}, + registry::BlockStateId, +}; use std::sync::Arc; #[repr(C)] @@ -100,22 +106,55 @@ enum Tint { /// Per-state data the mesher needs on every block, flattened for speed. #[derive(Clone, Copy)] struct Info { + /// `isSolidRender`. solid: bool, - /// `isCollisionShapeFullBlock` drives the 0.2 AO shade brightness. + /// `isCollisionShapeFullBlock`: AO faces flush with a full block sample outside it. full: bool, - /// Side blocks that are transparent let the AO corner sample through. - translucent: bool, + /// `isLightPermeable`: diagonal AO samples are taken through such side blocks. + permeable: bool, + /// `getShadeBrightness` (ambient occlusion contribution). + shade: f32, emission: u8, - fluid: Fluid, - level: u8, + /// `emissiveRendering`: drawn and sampled at full brightness. + emissive: bool, + fluid: FluidState, model: bool, tints: [Tint; 2], + tint_count: u8, + /// `OffsetType` as (max horizontal, max vertical): vertical 0 for XZ. + offset: Option<(f32, f32)>, + /// `isSolid()` (legacy), for fluid corner heights. + legacy_solid: bool, + /// `HalfTransparentBlock`/`LeavesBlock`: water sides show the overlay sprite. + overlay: bool, + blocks_flow: bool, + ice: bool, + sturdy: u8, + /// Occlusion face per direction: 0 empty, 1 the full-block singleton, 2 partial. + face: [u8; 6], + /// Height from the bottom over which face `d`, flush with the `d` side, covers + /// the full width (vertical faces: 1 when the whole square is covered). + cover: [f32; 6], +} +/// Derived per-state facts, exposed for the section-mesh parity gate. +#[derive(Clone, Copy, Debug)] +pub struct MeshFacts { + pub shade: f32, + pub emissive: bool, + pub legacy_solid: bool, + pub light_permeable: bool, + pub solid_render: bool, + pub full_collision: bool, + pub emission: u8, + pub overlay: bool, + pub tint_sources: u8, } pub struct MeshTables { info: Vec, pub visibility: FaceVisibility, water_still: u32, water_flow: u32, + water_overlay: u32, lava_still: u32, lava_flow: u32, } @@ -140,75 +179,161 @@ impl MeshTables { .copied() .ok_or_else(|| format!("missing fluid sprite {name}").into()) }; - let info = facts - .states - .iter() - .enumerate() - .map(|(id, s)| { - let props = assets - .registry - .state(BlockStateId(id as u32)) - .map(|s| &s.properties); - let prop = |k: &str| -> u8 { - props - .and_then(|p| p.get(k)) - .and_then(|v| v.parse().ok()) - .unwrap_or(0) - }; - let name = s.name.strip_prefix("minecraft:").unwrap_or(&s.name); - let tints = match name { - "large_fern" | "tall_grass" => { - if props.and_then(|p| p.get("half")).map(String::as_str) == Some("upper") { - [Tint::TallGrassUpper; 2] - } else { - [Tint::Grass; 2] - } + let mut covers = std::collections::HashMap::new(); + let mut info = Vec::with_capacity(facts.states.len()); + for (id, s) in facts.states.iter().enumerate() { + let state = assets + .registry + .state(BlockStateId(id as u32)) + .ok_or("missing registry state")?; + let props = &state.properties; + let prop = |k: &str| -> u8 { props.get(k).and_then(|v| v.parse().ok()).unwrap_or(0) }; + let name = s.name.strip_prefix("minecraft:").unwrap_or(&s.name); + // BlockColors.createDefault: tint sources by block. + let (tints, tint_count) = match name { + "large_fern" | "tall_grass" => { + if props.get("half").map(String::as_str) == Some("upper") { + ([Tint::TallGrassUpper; 2], 1) + } else { + ([Tint::Grass; 2], 1) } - "fern" | "short_grass" | "potted_fern" | "bush" | "grass_block" - | "sugar_cane" => [Tint::Grass; 2], - "pink_petals" | "wildflowers" => [Tint::None, Tint::Grass], - "spruce_leaves" => [Tint::Constant(0x61_9961); 2], - "birch_leaves" => [Tint::Constant(0x80_A755); 2], - "oak_leaves" | "jungle_leaves" | "acacia_leaves" | "dark_oak_leaves" - | "vine" | "mangrove_leaves" => [Tint::Foliage; 2], - "leaf_litter" => [Tint::DryFoliage; 2], - "water_cauldron" | "water" | "bubble_column" => [Tint::Water; 2], - "redstone_wire" => [Tint::Redstone(prop("power")); 2], - "attached_melon_stem" | "attached_pumpkin_stem" => { - [Tint::Constant(0xE0_C71C); 2] - } - "melon_stem" | "pumpkin_stem" => [Tint::Stem(prop("age")); 2], - "lily_pad" => [Tint::Constant(0x20_8030); 2], - _ => [Tint::None; 2], - }; - Info { - solid: s.solid_render, - full: s.full_collision, - translucent: !s.solid_render || s.dampening == 0, - emission: s.emission, - fluid: s.fluid, - level: s.fluid_level, - model: s.render_shape == RenderShape::Model, - tints, } - }) - .collect(); + "fern" | "short_grass" | "potted_fern" | "bush" | "grass_block" | "sugar_cane" => { + ([Tint::Grass; 2], 1) + } + "pink_petals" | "wildflowers" => ([Tint::None, Tint::Grass], 2), + "spruce_leaves" => ([Tint::Constant(0x61_9961); 2], 1), + "birch_leaves" => ([Tint::Constant(0x80_A755); 2], 1), + "oak_leaves" | "jungle_leaves" | "acacia_leaves" | "dark_oak_leaves" | "vine" + | "mangrove_leaves" => ([Tint::Foliage; 2], 1), + "leaf_litter" => ([Tint::DryFoliage; 2], 1), + "water_cauldron" => ([Tint::Water; 2], 1), + // Their in-world colour is the particle-only source's -1. + "water" | "bubble_column" => ([Tint::None; 2], 1), + "redstone_wire" => ([Tint::Redstone(prop("power")); 2], 1), + "attached_melon_stem" | "attached_pumpkin_stem" => { + ([Tint::Constant(0xE0_C71C); 2], 1) + } + "melon_stem" | "pumpkin_stem" => ([Tint::Stem(prop("age")); 2], 1), + "lily_pad" => ([Tint::Constant(0x20_8030); 2], 1), + _ => ([Tint::None; 2], 0), + }; + // getShadeBrightness overrides; the default is 0.2 for full collision shapes. + let overrides = [ + "TransparentBlock", + "BarrierBlock", + "LightBlock", + "StructureVoidBlock", + ]; + let shade = if overrides.iter().any(|c| s.has_class(c)) { + 1.0 + } else if s.has_class("SoulSandBlock") || s.has_class("MudBlock") { + 0.2 + } else if s.has_class("SnowLayerBlock") { + if prop("layers") == 8 { 0.2 } else { 1.0 } + } else if s.full_collision { + 0.2 + } else { + 1.0 + }; + let emissive = name == "magma_block" + || (matches!(name, "sculk_sensor" | "calibrated_sculk_sensor") + && props.get("sculk_sensor_phase").map(String::as_str) == Some("active")); + // OffsetType.XZ/XYZ with getMaxHorizontalOffset/getMaxVerticalOffset. + let offset = s.random_offset.then(|| { + let horizontal = if s.has_class("SpeleothemBlock") { + 0.125 + } else { + 0.25 + }; + let vertical = match name { + "small_dripleaf" => 0.1, + "short_grass" | "fern" | "short_dry_grass" | "tall_dry_grass" => 0.2, + _ => 0.0, + }; + (horizontal, vertical) + }); + let mut face = [0u8; 6]; + let mut cover = [0f32; 6]; + for d in Direction::ALL { + let (face_id, shape) = visibility + .occlusion_face(BlockStateId(id as u32), d) + .ok_or("missing occlusion face")?; + face[d as usize] = face_id.min(2) as u8; + cover[d as usize] = *covers + .entry((face_id, d as u8)) + .or_insert_with(|| fluid::coverage(shape, d)); + } + info.push(Info { + solid: s.solid_render, + full: s.full_collision, + permeable: !s.solid_render || s.dampening == 0, + shade, + emission: s.emission, + emissive, + fluid: FluidState::from_block(state)?, + model: s.render_shape == RenderShape::Model, + tints, + tint_count, + offset, + legacy_solid: s.legacy_solid, + overlay: s.has_class("HalfTransparentBlock") || s.has_class("LeavesBlock"), + blocks_flow: assets.blocks_fluid_flow.contains(&*s.name), + ice: s.has_class("IceBlock"), + sturdy: s.sturdy_full, + face, + cover, + }); + } Ok(Self { info, visibility, water_still: layer("minecraft:block/water_still")?, water_flow: layer("minecraft:block/water_flow")?, + water_overlay: layer("minecraft:block/water_overlay")?, lava_still: layer("minecraft:block/lava_still")?, lava_flow: layer("minecraft:block/lava_flow")?, }) } + pub fn facts(&self, state: BlockStateId) -> Option { + let i = self.info.get(state.0 as usize)?; + Some(MeshFacts { + shade: i.shade, + emissive: i.emissive, + legacy_solid: i.legacy_solid, + light_permeable: i.permeable, + solid_render: i.solid, + full_collision: i.full, + emission: i.emission, + overlay: i.overlay, + tint_sources: i.tint_count, + }) + } + /// `BlockState.getOffset` for blocks with a random model offset. + pub fn offset(&self, state: BlockStateId, x: i32, z: i32) -> Option<[f64; 3]> { + offset(self.info.get(state.0 as usize)?, x, z) + } } -const P: usize = 18; +/// `OffsetType.XZ`/`XYZ`: a per-column jitter from `Mth.getSeed(x, 0, z)`. +fn offset(info: &Info, x: i32, z: i32) -> Option<[f64; 3]> { + let (horizontal, vertical) = info.offset?; + let seed = position_seed(BlockPos::new(x, 0, z)); + let nibble = |shift: u32| ((seed >> shift) & 15) as f32 / 15.0; + let h = f64::from(horizontal); + Some([ + ((f64::from(nibble(0)) - 0.5) * 0.5).clamp(-h, h), + (f64::from(nibble(4)) - 1.0) * f64::from(vertical), + ((f64::from(nibble(8)) - 0.5) * 0.5).clamp(-h, h), + ]) +} +/// Border width: smooth lighting samples up to two blocks out along a face normal. +const B: i32 = 2; +const P: usize = 16 + 2 * B as usize; #[inline] fn pi(x: i32, y: i32, z: i32) -> usize { - ((y + 1) as usize * P + (z + 1) as usize) * P + (x + 1) as usize + ((y + B) as usize * P + (z + B) as usize) * P + (x + B) as usize } -/// Blocks and light of one section plus a one-block border. +/// Blocks and light of one section plus a `B`-block border. struct Padded { blocks: Vec, light: Vec, @@ -218,10 +343,10 @@ impl Padded { let mut blocks = vec![0u16; P * P * P]; let mut light = vec![0u8; P * P * P]; let base_y = MIN_Y + sy * 16; - for y in -1..17 { + for y in -B..16 + B { let wy = base_y + y; - for z in -1..17i32 { - for x in -1..17i32 { + for z in -B..16 + B { + for x in -B..16 + B { let chunk = region[((z + 16) >> 4) as usize][((x + 16) >> 4) as usize]; let i = pi(x, y, z); if let Some(c) = chunk { @@ -288,23 +413,14 @@ fn blend(region: &[[Option<&Chunk>; 3]; 3], biomes: &Biomes, cx: i32, cz: i32, y } colors } -fn shade(direction: horizon_assets::model::Direction) -> f32 { - use horizon_assets::model::Direction as D; - match direction { - D::Down => 0.5, - D::Up => 1.0, - D::North | D::South => 0.8, - D::West | D::East => 0.6, - } -} -fn pack_color(rgb: u32, brightness: f32) -> u32 { - let r = ((rgb >> 16 & 255) as f32 * brightness) as u32; - let g = ((rgb >> 8 & 255) as f32 * brightness) as u32; - let b = ((rgb & 255) as f32 * brightness) as u32; +/// Packs 8-bit RGB into the vertex's RGBA8 (red in the low byte), opaque. +fn pack_rgb([r, g, b]: [u32; 3]) -> u32 { 0xFF00_0000 | b << 16 | g << 8 | r } -fn pack_light(sky: f32, block: f32) -> u32 { - (sky * 16.0).clamp(0.0, 255.0) as u32 | ((block * 16.0).clamp(0.0, 255.0) as u32) << 8 +/// Vanilla light coords (block*16 in the low half, sky*16 in the high half) to +/// the vertex layout (sky*16 in bits 0..8, block*16 in bits 8..16). +fn pack_coords(coords: u32) -> u32 { + (coords >> 16 & 0xFF) | (coords & 0xFF) << 8 } pub struct Mesher<'a> { /// CardinalLighting.NETHER: brighter up/down faces. @@ -335,7 +451,7 @@ impl Mesher<'_> { if id == 0 { continue; } - let state = info[id as usize]; + let state = &info[id as usize]; if state.solid && Direction::ALL.iter().all(|d| { let [dx, dy, dz] = d.normal(); @@ -344,8 +460,10 @@ impl Mesher<'_> { { continue; } - if state.fluid != Fluid::None { - self.fluid(&pad, &colors, &mut out, x, y, z, id); + if state.fluid.kind() != FluidKind::Empty { + let water = colors.water[(z * 16 + x) as usize]; + let nether = self.nether_shading; + fluid::tesselate(self.tables, nether, &pad, water, &mut out, [x, y, z]); } if !state.model { continue; @@ -355,6 +473,20 @@ impl Mesher<'_> { else { continue; }; + // ModelBlockRenderer: the first part decides smooth lighting + // for all; light-emitting blocks are always lit flat. + let Some((_, first)) = models.first() else { + continue; + }; + let ao = state.emission == 0 && first.ambient_occlusion; + let origin = match offset(state, world.x, world.z) { + Some(o) => [ + x as f32 + o[0] as f32, + y as f32 + o[1] as f32, + z as f32 + o[2] as f32, + ], + None => [x as f32, y as f32, z as f32], + }; let mut visible = [false; 6]; for d in Direction::ALL { let [dx, dy, dz] = d.normal(); @@ -369,20 +501,12 @@ impl Mesher<'_> { ) .unwrap_or(true); } - for (_, model) in models { + for (_, model) in &models { for face in &model.faces { if face.quad.cull.is_some_and(|d| !visible[d as usize]) { continue; } - self.face( - &pad, - &colors, - &mut out, - [x, y, z], - face, - model.ambient_occlusion, - state, - ); + self.face(&pad, &colors, &mut out, [x, y, z], origin, face, ao, state); } } } @@ -390,13 +514,14 @@ impl Mesher<'_> { } out } - fn tint(state: Info, index: i32, colors: &Colors, x: i32, z: i32) -> u32 { - if index < 0 { - return 0xFF_FFFF; + /// `BlockColors` tint source `index`, or `None` for an untinted (-1) layer. + fn tint(state: &Info, index: i32, colors: &Colors, x: i32, z: i32) -> Option { + if index < 0 || index >= i32::from(state.tint_count) { + return None; } let column = (z * 16 + x) as usize; - match state.tints[(index as usize).min(1)] { - Tint::None => 0xFF_FFFF, + Some(match state.tints[(index as usize).min(1)] { + Tint::None => return None, Tint::Grass => colors.grass[column], Tint::TallGrassUpper => colors.tall_upper[column], Tint::Foliage => colors.foliage[column], @@ -408,7 +533,7 @@ impl Mesher<'_> { let a = u32::from(age); (a * 32) << 16 | (255 - a * 8) << 8 | a * 4 } - } + }) } #[allow(clippy::too_many_arguments)] fn face( @@ -416,313 +541,51 @@ impl Mesher<'_> { pad: &Padded, colors: &Colors, out: &mut SectionMesh, - [x, y, z]: [i32; 3], + pos: [i32; 3], + origin: [f32; 3], face: &BakedFace, ao: bool, - state: Info, + state: &Info, ) { let q = &face.quad; - let facing = q.facing; - let normal = Direction::ALL[facing as usize].normal(); - let axis = normal.iter().position(|&n| n != 0).unwrap_or(1); - let positive = normal[axis] > 0; - let on_boundary = q.positions.iter().all(|p| { - if positive { - p[axis] >= 1.0 - 1e-4 - } else { - p[axis] <= 1e-4 - } - }); - let base = if on_boundary { - [x + normal[0], y + normal[1], z + normal[2]] + let shade_face = q.shade_direction_override.unwrap_or(q.facing); + let directional = lighting::cardinal(self.nether_shading, shade_face); + // Grey level per vertex before tinting, and vanilla light coords. + let (gray, coords) = if ao { + let info = &self.tables.info; + let (brightness, coords) = + lighting::ambient_occlusion(pad, info, state, pos, &q.positions, q.facing); + let gray = brightness.map(|b| lighting::scale(lighting::gray(b), directional)); + (gray, coords) } else { - [x, y, z] - }; - let tint = Self::tint(state, q.tint_index, colors, x, z); - let mut directional = match q.shade_direction_override { - Some(d) => shade(d), - None => shade(facing), - }; - if self.nether_shading && matches!(q.shade_direction_override.unwrap_or(facing), horizon_assets::model::Direction::Up | horizon_assets::model::Direction::Down) { - directional = 0.9; - } - let info = &self.tables.info; - let light_at = |p: [i32; 3]| -> u32 { - let i = pi(p[0], p[1], p[2]); - let packed = pad.light[i]; - let s = info[pad.blocks[i] as usize]; - let block = (packed & 15).max(s.emission); - u32::from(packed >> 4) << 16 | u32::from(block) - }; - let shade_at = |p: [i32; 3]| -> f32 { - if info[pad.blocks[pi(p[0], p[1], p[2])] as usize].full { - 0.2 - } else { - 1.0 - } - }; - let open_at = |p: [i32; 3]| -> bool { info[pad.blocks[pi(p[0], p[1], p[2])] as usize].translucent }; - // Tangent axes of the face plane. - let (ua, va) = match axis { - 0 => (2, 1), - 1 => (0, 2), - _ => (0, 1), - }; - let center_light = light_at(base); - let center_shade = shade_at(base); - // Corner values for (su, sv) in {0,1}^2 -> (sky, block, ao). - let mut corners = [[0f32; 3]; 4]; - for (ci, corner) in corners.iter_mut().enumerate() { - let su = if ci & 1 == 0 { -1 } else { 1 }; - let sv = if ci & 2 == 0 { -1 } else { 1 }; - let mut p1 = base; - p1[ua] += su; - let mut p2 = base; - p2[va] += sv; - let mut pc = base; - pc[ua] += su; - pc[va] += sv; - let (l1, l2) = (light_at(p1), light_at(p2)); - let (lc, ac) = if open_at(p1) || open_at(p2) { - (light_at(pc), shade_at(pc)) - } else { - (l1, shade_at(p1)) + let coords = match q.cull { + Some(d) => lighting::coords(pad, state, lighting::step(pos, d)), + None => lighting::flat(pad, state, pos, &q.positions, q.facing), }; - // ModelBlockRenderer.blend: zero samples take the centre value. - let fix = |v: u32| if v == 0 { center_light } else { v }; - let sum = fix(l1) + fix(l2) + fix(lc) + center_light; - corner[0] = (sum >> 16) as f32 / 4.0; - corner[1] = (sum & 0xFFFF) as f32 / 4.0; - corner[2] = (shade_at(p1) + shade_at(p2) + ac + center_shade) / 4.0; - } - let flat_sky = (center_light >> 16) as f32; - let flat_block = (center_light & 0xFFFF) as f32; + ([lighting::gray(directional); 4], [coords; 4]) + }; + let tint = Self::tint(state, q.tint_index, colors, pos[0], pos[2]); let target = if face.translucent { &mut out.translucent } else { &mut out.solid }; - for (p, uv) in q.positions.iter().zip(q.uv) { - let (sky, block, occlusion) = if ao { - let u = p[ua].clamp(0.0, 1.0); - let v = p[va].clamp(0.0, 1.0); - let lerp = |k: usize| { - let a = corners[0][k] * (1.0 - u) + corners[1][k] * u; - let b = corners[2][k] * (1.0 - u) + corners[3][k] * u; - a * (1.0 - v) + b * v - }; - (lerp(0), lerp(1), lerp(2)) - } else { - (flat_sky, flat_block, 1.0) + for i in 0..4 { + let g = gray[i] as u32; + let rgb = match tint { + Some(t) => [16, 8, 0].map(|shift| g * (t >> shift & 255) / 255), + None => [g; 3], }; + let p = q.positions[i]; target.push(Vertex { - pos: [p[0] + x as f32, p[1] + y as f32, p[2] + z as f32], - uv, + pos: [p[0] + origin[0], p[1] + origin[1], p[2] + origin[2]], + uv: q.uv[i], layer: face.layer, - color: pack_color(tint, directional * occlusion), - light: pack_light(sky, block), + color: pack_rgb(rgb), + light: pack_coords(lighting::with_emission(coords[i], q.light_emission)), }); } } - #[allow(clippy::too_many_arguments)] - fn fluid(&self, pad: &Padded, colors: &Colors, out: &mut SectionMesh, x: i32, y: i32, z: i32, id: u16) { - let info = &self.tables.info; - let me = info[id as usize]; - let water = me.fluid == Fluid::Water; - let same = |p: [i32; 3]| info[pad.blocks[pi(p[0], p[1], p[2])] as usize].fluid == me.fluid; - let solid = |p: [i32; 3]| { - let s = info[pad.blocks[pi(p[0], p[1], p[2])] as usize]; - s.solid || s.full - }; - let height = |p: [i32; 3]| -> f32 { - let s = info[pad.blocks[pi(p[0], p[1], p[2])] as usize]; - if s.fluid == me.fluid { - if same([p[0], p[1] + 1, p[2]]) { - 1.0 - } else { - f32::from(s.level) / 9.0 - } - } else if !(s.solid || s.full) { - 0.0 - } else { - -1.0 - } - }; - let own = height([x, y, z]); - let corner = |a: f32, b: f32, c: [i32; 3]| -> f32 { - if a >= 1.0 || b >= 1.0 { - return 1.0; - } - let mut sum = [0.0f32; 2]; - let mut add = |h: f32| { - if h >= 0.8 { - sum[0] += h * 10.0; - sum[1] += 10.0; - } else if h >= 0.0 { - sum[0] += h; - sum[1] += 1.0; - } - }; - if a > 0.0 || b > 0.0 { - let hc = height(c); - if hc >= 1.0 { - return 1.0; - } - add(hc); - } - add(own); - add(a); - add(b); - sum[0] / sum[1] - }; - let (nw, sw, se, ne) = if own >= 1.0 { - (1.0, 1.0, 1.0, 1.0) - } else { - let n = height([x, y, z - 1]); - let s = height([x, y, z + 1]); - let e = height([x + 1, y, z]); - let w = height([x - 1, y, z]); - ( - corner(n, w, [x - 1, y, z - 1]), - corner(s, w, [x - 1, y, z + 1]), - corner(s, e, [x + 1, y, z + 1]), - corner(n, e, [x + 1, y, z - 1]), - ) - }; - let tint = if water { - colors.water[(z * 16 + x) as usize] - } else { - 0xFF_FFFF - }; - let (still, flow) = if water { - (self.tables.water_still, self.tables.water_flow) - } else { - (self.tables.lava_still, self.tables.lava_flow) - }; - let light = |p: [i32; 3]| { - let packed = pad.light[pi(p[0], p[1], p[2])]; - let emission = if water { 0 } else { 15 }; - pack_light(f32::from(packed >> 4), f32::from((packed & 15).max(emission))) - }; - let target = if water { - &mut out.translucent - } else { - &mut out.solid - }; - let (fx, fy, fz) = (x as f32, y as f32, z as f32); - let quad = |target: &mut Vec, v: [([f32; 3], [f32; 2]); 4], layer: u32, b: f32, l: u32, back: bool| { - for (p, uv) in v { - target.push(Vertex { - pos: p, - uv, - layer, - color: pack_color(tint, b), - light: l, - }); - } - if back { - for i in [0, 3, 2, 1] { - let (p, uv) = v[i]; - target.push(Vertex { - pos: p, - uv, - layer, - color: pack_color(tint, b), - light: l, - }); - } - } - }; - let above_same = same([x, y + 1, z]); - if !above_same && !solid([x, y + 1, z]) || !above_same && own < 1.0 { - let o = 0.001; - let (h0, h1, h2, h3) = (nw - o, sw - o, se - o, ne - o); - // Flow direction from neighbour height differences. - let mut fxv = 0.0f32; - let mut fzv = 0.0f32; - if own < 1.0 && me.level < 8 || own < 0.88 { - for (dx, dz) in [(1, 0), (-1, 0), (0, 1), (0, -1)] { - let h = height([x + dx, y, z + dz]); - if h >= 0.0 { - let d = own - h.max(0.0); - fxv += dx as f32 * d; - fzv += dz as f32 * d; - } - } - } - let (layer, uvs) = if fxv.abs() < 1e-4 && fzv.abs() < 1e-4 { - (still, [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]]) - } else { - let angle = fzv.atan2(fxv) - std::f32::consts::FRAC_PI_2; - let (s, c) = (angle.sin() * 0.25, angle.cos() * 0.25); - // Flowing sprites are sampled over their top-left quarter-scaled region (getU(0.5+..) of 16 units). - ( - flow, - [ - [0.5 + (-c - s), 0.5 + (-c + s)], - [0.5 + (-c + s), 0.5 + (c + s)], - [0.5 + (c + s), 0.5 + (c - s)], - [0.5 + (c - s), 0.5 + (-c - s)], - ], - ) - }; - quad( - target, - [ - ([fx, fy + h0, fz], uvs[0]), - ([fx, fy + h1, fz + 1.0], uvs[1]), - ([fx + 1.0, fy + h2, fz + 1.0], uvs[2]), - ([fx + 1.0, fy + h3, fz], uvs[3]), - ], - layer, - 1.0, - light([x, y, z]), - water && !solid([x, y + 1, z]), - ); - } - if !same([x, y - 1, z]) && !solid([x, y - 1, z]) { - quad( - target, - [ - ([fx, fy + 0.001, fz], [0.0, 0.0]), - ([fx + 1.0, fy + 0.001, fz], [1.0, 0.0]), - ([fx + 1.0, fy + 0.001, fz + 1.0], [1.0, 1.0]), - ([fx, fy + 0.001, fz + 1.0], [0.0, 1.0]), - ], - still, - 0.5, - light([x, y - 1, z]), - false, - ); - } - let o = 0.001; - for (dx, dz, h0, h1, p0, p1, sh) in [ - (0, -1, nw, ne, [fx, fz + o], [fx + 1.0, fz + o], 0.8), - (0, 1, se, sw, [fx + 1.0, fz + 1.0 - o], [fx, fz + 1.0 - o], 0.8), - (-1, 0, sw, nw, [fx + o, fz + 1.0], [fx + o, fz], 0.6), - (1, 0, ne, se, [fx + 1.0 - o, fz], [fx + 1.0 - o, fz + 1.0], 0.6), - ] { - let n = [x + dx, y, z + dz]; - if same(n) || solid(n) { - continue; - } - let v0 = (1.0 - h0) * 0.5; - let v1 = (1.0 - h1) * 0.5; - quad( - target, - [ - ([p0[0], fy + h0, p0[1]], [0.0, v0]), - ([p1[0], fy + h1, p1[1]], [0.5, v1]), - ([p1[0], fy, p1[1]], [0.5, 0.5]), - ([p0[0], fy, p0[1]], [0.0, 0.5]), - ], - flow, - sh, - light([x, y, z]), - water, - ); - } - } } /// Snapshot of the 3x3 chunk neighbourhood used by a worker job. pub type Region = [[Option>; 3]; 3]; diff --git a/crates/horizon-client/src/mesher/fluid.rs b/crates/horizon-client/src/mesher/fluid.rs new file mode 100644 index 000000000..e555e12ca --- /dev/null +++ b/crates/horizon-client/src/mesher/fluid.rs @@ -0,0 +1,469 @@ +//! Fluid surfaces following `FluidRenderer.tesselate`: corner heights, face +//! occlusion against neighbour shapes, flow-rotated top UVs, the water overlay +//! beside glass and leaves, back faces, cardinal shading and max(self, above) +//! light. +use super::{Info, MeshTables, Padded, SectionMesh, Vertex, lighting, pack_coords, pack_rgb, pi}; +use horizon_core::{ + geometry::{Axis, Direction, VoxelShape, trig}, + position::BlockPos, +}; +use horizon_world::{ + fluid::{FluidKind, FluidState}, + fluid_flow::{FluidFlowWorld, flow_at}, +}; +use std::{convert::Infallible, sync::OnceLock}; + +/// `FluidRenderer.MAX_FLUID_HEIGHT`. +const MAX_HEIGHT: f32 = 0.888_888_9; +const EPSILON: f32 = 0.001; + +/// For the occlusion face toward `direction`: the height from the bottom over +/// which its slice flush with the `direction` side covers the whole width +/// (vertical faces: 1 when the whole square is covered, else 0). This is what +/// `Shapes.blockOccludes` decides for a fluid box of a given height. +pub(super) fn coverage(shape: &VoxelShape, direction: Direction) -> f32 { + let (axis, u, v) = match direction { + Direction::Down | Direction::Up => (Axis::Y, Axis::X, Axis::Z), + Direction::North | Direction::South => (Axis::Z, Axis::X, Axis::Y), + Direction::West | Direction::East => (Axis::X, Axis::Z, Axis::Y), + }; + let positive = matches!( + direction, + Direction::Up | Direction::South | Direction::East + ); + let rects: Vec<[f64; 4]> = shape + .boxes() + .iter() + .filter(|b| { + if positive { + b.max(axis) >= 1.0 - 1e-7 + } else { + b.min(axis) <= 1e-7 + } + }) + .map(|b| [b.min(u), b.max(u), b.min(v), b.max(v)]) + .collect(); + let mut cuts: Vec = rects + .iter() + .flat_map(|r| [r[2], r[3]]) + .filter(|c| (0.0..=1.0).contains(c)) + .chain([0.0, 1.0]) + .collect(); + cuts.sort_by(f64::total_cmp); + cuts.dedup(); + let mut covered = 0.0; + for w in cuts.windows(2) { + let middle = (w[0] + w[1]) / 2.0; + let mut spans: Vec<(f64, f64)> = rects + .iter() + .filter(|r| r[2] <= middle && middle <= r[3]) + .map(|r| (r[0], r[1])) + .collect(); + spans.sort_by(|a, b| a.0.total_cmp(&b.0)); + let mut reach = 0.0f64; + for (lo, hi) in spans { + if lo > reach + 1e-7 { + break; + } + reach = reach.max(hi); + } + if reach < 1.0 - 1e-7 { + break; + } + covered = w[1]; + } + if matches!(direction, Direction::Down | Direction::Up) && covered < 1.0 { + return 0.0; + } + covered as f32 +} +/// `isFaceOccludedByState` for a fluid box `height` tall against `state`'s +/// face opposite `direction`. +fn occluded_by(direction: Direction, height: f32, state: &Info) -> bool { + let opposite = direction.opposite() as usize; + match state.face[opposite] { + 0 => false, + 1 => direction != Direction::Up || height == 1.0, + _ => match direction { + Direction::Up => { + f64::from(height) >= 1.0 - 1e-7 && state.cover[Direction::Down as usize] >= 1.0 + } + Direction::Down => state.cover[Direction::Up as usize] >= 1.0, + _ => f64::from(height) <= f64::from(state.cover[opposite]) + 1e-7, + }, + } +} +/// `isFaceOccludedBySelf`: the cell's own occlusion face toward `direction`. +fn occluded_by_self(state: &Info, direction: Direction) -> bool { + match state.face[direction as usize] { + 0 => false, + 1 => true, + _ => state.cover[direction as usize] >= 1.0, + } +} +/// `Mth.atan2`: the client's table-driven arctangent. +fn atan2(mut y: f64, mut x: f64) -> f64 { + static TABLES: OnceLock<(Vec, Vec)> = OnceLock::new(); + let (asin, cos) = TABLES.get_or_init(|| { + (0..257) + .map(|i| { + let a = (f64::from(i) / 256.0).asin(); + (a, a.cos()) + }) + .unzip() + }); + let frac_bias = f64::from_bits(4_805_340_802_404_319_232); + let d2 = x * x + y * y; + if d2.is_nan() { + return f64::NAN; + } + let negative_y = y < 0.0; + if negative_y { + y = -y; + } + let negative_x = x < 0.0; + if negative_x { + x = -x; + } + let steep = y > x; + if steep { + std::mem::swap(&mut x, &mut y); + } + // Mth.fastInvSqrt + let half = 0.5 * d2; + let mut r = f64::from_bits((6_910_469_410_427_058_090i64 - (d2.to_bits() as i64 >> 1)) as u64); + r *= 1.5 - half * r * r; + x *= r; + y *= r; + let yp = frac_bias + y; + let index = yp.to_bits() as i32 as usize; + let s_phi = yp - frac_bias; + let sd = y * cos[index] - x * s_phi; + let mut theta = asin[index] + (6.0 + sd * sd) * sd * 0.166_666_666_666_666_66; + if steep { + theta = std::f64::consts::FRAC_PI_2 - theta; + } + if negative_x { + theta = std::f64::consts::PI - theta; + } + if negative_y { + theta = -theta; + } + theta +} +/// The padded section as `FlowingFluid.getFlow` sees it (section-relative positions). +struct FlowView<'a> { + pad: &'a Padded, + info: &'a [Info], +} +impl FlowView<'_> { + fn id(&self, p: BlockPos) -> u16 { + self.pad.blocks[pi(p.x, p.y, p.z)] + } +} +impl FluidFlowWorld for FlowView<'_> { + type Error = Infallible; + type Block = u16; + fn fluid(&mut self, p: BlockPos) -> Result { + Ok(self.info[self.id(p) as usize].fluid) + } + fn block(&mut self, p: BlockPos) -> Result { + Ok(self.id(p)) + } + fn blocks_fluid_flow(&self, state: u16) -> bool { + self.info[state as usize].blocks_flow + } + fn is_ice_class(&self, state: u16) -> bool { + self.info[state as usize].ice + } + fn is_face_sturdy( + &mut self, + state: u16, + _: BlockPos, + d: Direction, + ) -> Result { + Ok(self.info[state as usize].sturdy & 1 << d as u8 != 0) + } +} +/// Emits one fluid cell at section-relative `[x, y, z]`. +pub(super) fn tesselate( + tables: &MeshTables, + nether: bool, + pad: &Padded, + water_color: u32, + out: &mut SectionMesh, + [x, y, z]: [i32; 3], +) { + use horizon_assets::model::Direction as D; + let info = &tables.info; + let at = |p: [i32; 3]| &info[pad.blocks[pi(p[0], p[1], p[2])] as usize]; + let me = at([x, y, z]); + let kind = me.fluid.kind(); + let same = |s: &Info| s.fluid.kind().same_family(kind); + let neighbor = |d: Direction| { + let [dx, dy, dz] = d.normal(); + at([x + dx, y + dy, z + dz]) + }; + let (down, up) = (neighbor(Direction::Down), neighbor(Direction::Up)); + let should_render = |d: Direction| !same(neighbor(d)) && !occluded_by_self(me, d); + let render_up = !same(up); + let render_down = + should_render(Direction::Down) && !occluded_by(Direction::Down, MAX_HEIGHT, down); + let sides = [ + Direction::North, + Direction::South, + Direction::West, + Direction::East, + ] + .map(should_render); + if !render_up && !render_down && !sides.iter().any(|&s| s) { + return; + } + let water = matches!(kind, FluidKind::Water | FluidKind::FlowingWater); + let tint = if water { + water_color & 0xFF_FFFF + } else { + 0xFF_FFFF + }; + let color = |by: f32| { + pack_rgb([16, 8, 0].map(|shift| lighting::scale((tint >> shift & 255) as i32, by) as u32)) + }; + let height = |p: [i32; 3]| -> f32 { + let s = at(p); + if same(s) { + if same(at([p[0], p[1] + 1, p[2]])) { + 1.0 + } else { + s.fluid.own_height() + } + } else if !s.legacy_solid { + 0.0 + } else { + -1.0 + } + }; + let own = height([x, y, z]); + let (mut ne, mut nw, mut se, mut sw) = (1.0f32, 1.0f32, 1.0f32, 1.0f32); + if own < 1.0 { + let n = height([x, y, z - 1]); + let s = height([x, y, z + 1]); + let e = height([x + 1, y, z]); + let w = height([x - 1, y, z]); + // calculateAverageHeight(self, height2, height1, corner) + let average = |h2: f32, h1: f32, corner: [i32; 3]| -> f32 { + if h1 >= 1.0 || h2 >= 1.0 { + return 1.0; + } + let mut sum = [0f32; 2]; + let mut add = |h: f32| { + if h >= 0.8 { + sum[0] += h * 10.0; + sum[1] += 10.0; + } else if h >= 0.0 { + sum[0] += h; + sum[1] += 1.0; + } + }; + if h1 > 0.0 || h2 > 0.0 { + let hc = height(corner); + if hc >= 1.0 { + return 1.0; + } + add(hc); + } + add(own); + add(h1); + add(h2); + sum[0] / sum[1] + }; + ne = average(n, e, [x + 1, y, z - 1]); + nw = average(n, w, [x - 1, y, z - 1]); + se = average(s, e, [x + 1, y, z + 1]); + sw = average(s, w, [x - 1, y, z + 1]); + } + let light = |p: [i32; 3]| { + let above = [p[0], p[1] + 1, p[2]]; + pack_coords(lighting::max_coords( + lighting::coords(pad, at(p), p), + lighting::coords(pad, at(above), above), + )) + }; + let (still, flow, overlay) = if water { + ( + tables.water_still, + tables.water_flow, + Some(tables.water_overlay), + ) + } else { + (tables.lava_still, tables.lava_flow, None) + }; + let target = if water { + &mut out.translucent + } else { + &mut out.solid + }; + let mut quad = + |v: [([f32; 3], [f32; 2]); 4], layer: u32, color: u32, light: u32, back: bool| { + let vertex = |(pos, uv): ([f32; 3], [f32; 2])| Vertex { + pos, + uv, + layer, + color, + light, + }; + target.extend(v.map(vertex)); + if back { + target.extend([v[0], v[3], v[2], v[1]].map(vertex)); + } + }; + let (fx, fy, fz) = (x as f32, y as f32, z as f32); + let bottom = if render_down { EPSILON } else { 0.0 }; + if render_up && !occluded_by(Direction::Up, nw.min(sw).min(se.min(ne)), up) { + nw -= EPSILON; + sw -= EPSILON; + se -= EPSILON; + ne -= EPSILON; + let flow_vector = flow_at( + &mut FlowView { pad, info }, + me.fluid, + BlockPos::new(x, y, z), + ) + .unwrap_or_else(|e| match e {}); + let (layer, uv) = if flow_vector.x == 0.0 && flow_vector.z == 0.0 { + (still, [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]]) + } else { + let angle = + atan2(flow_vector.z, flow_vector.x) as f32 - std::f64::consts::FRAC_PI_2 as f32; + let s = trig::sin(f64::from(angle)) * 0.25; + let c = trig::cos(f64::from(angle)) * 0.25; + ( + flow, + [ + [0.5 + (-c - s), 0.5 + (-c + s)], + [0.5 + (-c + s), 0.5 + (c + s)], + [0.5 + (c + s), 0.5 + (c - s)], + [0.5 + (c - s), 0.5 + (-c - s)], + ], + ) + }; + // FluidState.shouldRenderBackwardUpFace over the 3x3 cells above. + let backward = (-1..=1).any(|ox| { + (-1..=1).any(|oz| { + let s = at([x + ox, y + 1, z + oz]); + !same(s) && !s.solid + }) + }); + quad( + [ + ([fx, fy + nw, fz], uv[0]), + ([fx, fy + sw, fz + 1.0], uv[1]), + ([fx + 1.0, fy + se, fz + 1.0], uv[2]), + ([fx + 1.0, fy + ne, fz], uv[3]), + ], + layer, + color(lighting::cardinal(nether, D::Up)), + light([x, y, z]), + backward, + ); + } + if render_down { + let y0 = fy + bottom; + quad( + [ + ([fx, y0, fz], [0.0, 0.0]), + ([fx + 1.0, y0, fz], [1.0, 0.0]), + ([fx + 1.0, y0, fz + 1.0], [1.0, 1.0]), + ([fx, y0, fz + 1.0], [0.0, 1.0]), + ], + still, + color(lighting::cardinal(nether, D::Down)), + light([x, y - 1, z]), + false, + ); + } + let side_light = light([x, y, z]); + let up_shade = lighting::cardinal(nether, D::Up); + for (i, d) in [ + Direction::North, + Direction::South, + Direction::West, + Direction::East, + ] + .into_iter() + .enumerate() + { + let (h0, h1, [x0, z0], [x1, z1]) = match d { + Direction::North => (nw, ne, [fx, fz + EPSILON], [fx + 1.0, fz + EPSILON]), + Direction::South => ( + se, + sw, + [fx + 1.0, fz + 1.0 - EPSILON], + [fx, fz + 1.0 - EPSILON], + ), + Direction::West => (sw, nw, [fx + EPSILON, fz + 1.0], [fx + EPSILON, fz]), + _ => ( + ne, + se, + [fx + 1.0 - EPSILON, fz], + [fx + 1.0 - EPSILON, fz + 1.0], + ), + }; + let face_state = neighbor(d); + if !sides[i] || occluded_by(d, h0.max(h1), face_state) { + continue; + } + let (layer, is_overlay) = match overlay { + Some(layer) if face_state.overlay => (layer, true), + _ => (flow, false), + }; + let side = if matches!(d, Direction::North | Direction::South) { + lighting::cardinal(nether, D::North) + } else { + lighting::cardinal(nether, D::West) + }; + let (v0, v1) = ((1.0 - h0) * 0.5, (1.0 - h1) * 0.5); + quad( + [ + ([x0, fy + h0, z0], [0.0, v0]), + ([x1, fy + h1, z1], [0.5, v1]), + ([x1, fy + bottom, z1], [0.5, 0.5]), + ([x0, fy + bottom, z0], [0.0, 0.5]), + ], + layer, + color(up_shade * side), + side_light, + !is_overlay, + ); + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn atan2_follows_the_table_approximation() { + for (y, x) in [ + (1.0, 0.0), + (0.0, 1.0), + (-0.5, 0.25), + (0.3, -0.9), + (-1.0, -1.0), + (0.1, 0.7), + ] { + let exact = f64::atan2(y, x); + assert!((atan2(y, x) - exact).abs() < 1e-6, "{y} {x}"); + } + assert!(atan2(f64::NAN, 1.0).is_nan()); + } + #[test] + fn coverage_of_full_and_partial_faces() { + assert_eq!(coverage(&VoxelShape::block(), Direction::North), 1.0); + assert_eq!(coverage(&VoxelShape::block(), Direction::Up), 1.0); + assert_eq!(coverage(&VoxelShape::empty(), Direction::East), 0.0); + // A bottom slab covers the lower half of each side and the whole floor. + let slab = VoxelShape::from_cube([1, 2, 1], &[true, false]).unwrap(); + assert_eq!(coverage(&slab, Direction::South), 0.5); + assert_eq!(coverage(&slab, Direction::Down), 1.0); + assert_eq!(coverage(&slab, Direction::Up), 0.0); + } +} diff --git a/crates/horizon-client/src/mesher/lighting.rs b/crates/horizon-client/src/mesher/lighting.rs new file mode 100644 index 000000000..38b79ce54 --- /dev/null +++ b/crates/horizon-client/src/mesher/lighting.rs @@ -0,0 +1,420 @@ +//! Vertex light and colour of model quads, following `BlockModelLighter` +//! (smooth light and ambient occlusion, including the partial-face weights) +//! and `ModelBlockRenderer`'s integer colour arithmetic (`ARGB.gray`, +//! `scaleRGB`, `multiply`). +use super::{Info, Padded, pi}; +use horizon_assets::model::Direction as D; + +/// `LightCoordsUtil.FULL_BRIGHT`. +pub(super) const FULL_BRIGHT: u32 = 0x00F0_00F0; + +/// `CardinalLighting.DEFAULT`/`NETHER` by face. +pub(super) fn cardinal(nether: bool, face: D) -> f32 { + match face { + D::Down if nether => 0.9, + D::Up if nether => 0.9, + D::Down => 0.5, + D::Up => 1.0, + D::North | D::South => 0.8, + D::West | D::East => 0.6, + } +} +fn normal(face: D) -> [i32; 3] { + match face { + D::Down => [0, -1, 0], + D::Up => [0, 1, 0], + D::North => [0, 0, -1], + D::South => [0, 0, 1], + D::West => [-1, 0, 0], + D::East => [1, 0, 0], + } +} +pub(super) fn step(p: [i32; 3], face: D) -> [i32; 3] { + let n = normal(face); + [p[0] + n[0], p[1] + n[1], p[2] + n[2]] +} +fn state<'a>(pad: &Padded, info: &'a [Info], p: [i32; 3]) -> &'a Info { + &info[pad.blocks[pi(p[0], p[1], p[2])] as usize] +} +/// `LightCoordsUtil.getLightCoords`: light at `p` as seen through `state` +/// (block level << 4 | sky level << 20). +pub(super) fn coords(pad: &Padded, state: &Info, p: [i32; 3]) -> u32 { + if state.emissive { + return FULL_BRIGHT; + } + let packed = pad.light[pi(p[0], p[1], p[2])]; + let block = u32::from((packed & 15).max(state.emission)); + block << 4 | u32::from(packed >> 4) << 20 +} +/// `LightCoordsUtil.max`. +pub(super) fn max_coords(a: u32, b: u32) -> u32 { + (a >> 4 & 15).max(b >> 4 & 15) << 4 | (a >> 20 & 15).max(b >> 20 & 15) << 20 +} +/// `LightCoordsUtil.lightCoordsWithEmission` (a quad's element light emission). +pub(super) fn with_emission(coords: u32, emission: u8) -> u32 { + if emission == 0 { + return coords; + } + let e = u32::from(emission); + (coords >> 4 & 15).max(e) << 4 | (coords >> 20 & 15).max(e) << 20 +} +/// `LightCoordsUtil.smoothBlend`: zero samples take the centre; samples without +/// sky light borrow the centre's sky. +pub(super) fn smooth_blend(mut a: u32, mut b: u32, mut c: u32, center: u32) -> u32 { + if center >> 20 & 15 > 2 || center >> 4 & 15 > 2 { + for n in [&mut a, &mut b, &mut c] { + if *n == 0 { + *n = center; + } else if *n >> 20 & 15 == 0 { + *n |= center & 0x00FF_0000; + } + } + } + (a + b + c + center) >> 2 & 0x00FF_00FF +} +/// `LightCoordsUtil.smoothWeightedBlend` (Java float sums and int narrowing). +fn weighted_blend(c: [u32; 4], w: [f32; 4]) -> u32 { + let channel = |shift: u32| { + let v = |i: usize| (c[i] >> shift & 0xFF) as f32 * w[i]; + (v(0) + v(1) + v(2) + v(3)) as i32 as u32 & 0xFF + }; + channel(0) | channel(16) << 16 +} +/// `ARGB.gray` channel: `Mth.floor(brightness * 255)`. +pub(super) fn gray(brightness: f32) -> i32 { + (brightness * 255.0).floor() as i32 +} +/// One channel of `ARGB.scaleRGB(color, float)`. +pub(super) fn scale(channel: i32, by: f32) -> i32 { + ((channel as f32 * by) as i32).clamp(0, 255) +} +// SizeInfo indices into the face shape. +const DOWN: u8 = 0; +const UP: u8 = 1; +const NORTH: u8 = 2; +const SOUTH: u8 = 3; +const WEST: u8 = 4; +const EAST: u8 = 5; +const FLIP_DOWN: u8 = 6; +const FLIP_UP: u8 = 7; +const FLIP_NORTH: u8 = 8; +const FLIP_SOUTH: u8 = 9; +const FLIP_WEST: u8 = 10; +const FLIP_EAST: u8 = 11; +struct Adjacency { + corners: [D; 4], + /// Face-shape factor pairs for each vertex's four corner weights. + weights: [[u8; 8]; 4], + /// Output vertex for each of the four computed corners. + remap: [usize; 4], +} +const fn adjacency(face: D) -> Adjacency { + use D::*; + match face { + Down => Adjacency { + corners: [West, East, North, South], + weights: [ + [ + FLIP_WEST, SOUTH, FLIP_WEST, FLIP_SOUTH, WEST, FLIP_SOUTH, WEST, SOUTH, + ], + [ + FLIP_WEST, NORTH, FLIP_WEST, FLIP_NORTH, WEST, FLIP_NORTH, WEST, NORTH, + ], + [ + FLIP_EAST, NORTH, FLIP_EAST, FLIP_NORTH, EAST, FLIP_NORTH, EAST, NORTH, + ], + [ + FLIP_EAST, SOUTH, FLIP_EAST, FLIP_SOUTH, EAST, FLIP_SOUTH, EAST, SOUTH, + ], + ], + remap: [0, 1, 2, 3], + }, + Up => Adjacency { + corners: [East, West, North, South], + weights: [ + [ + EAST, SOUTH, EAST, FLIP_SOUTH, FLIP_EAST, FLIP_SOUTH, FLIP_EAST, SOUTH, + ], + [ + EAST, NORTH, EAST, FLIP_NORTH, FLIP_EAST, FLIP_NORTH, FLIP_EAST, NORTH, + ], + [ + WEST, NORTH, WEST, FLIP_NORTH, FLIP_WEST, FLIP_NORTH, FLIP_WEST, NORTH, + ], + [ + WEST, SOUTH, WEST, FLIP_SOUTH, FLIP_WEST, FLIP_SOUTH, FLIP_WEST, SOUTH, + ], + ], + remap: [2, 3, 0, 1], + }, + North => Adjacency { + corners: [Up, Down, East, West], + weights: [ + [UP, FLIP_WEST, UP, WEST, FLIP_UP, WEST, FLIP_UP, FLIP_WEST], + [UP, FLIP_EAST, UP, EAST, FLIP_UP, EAST, FLIP_UP, FLIP_EAST], + [ + DOWN, FLIP_EAST, DOWN, EAST, FLIP_DOWN, EAST, FLIP_DOWN, FLIP_EAST, + ], + [ + DOWN, FLIP_WEST, DOWN, WEST, FLIP_DOWN, WEST, FLIP_DOWN, FLIP_WEST, + ], + ], + remap: [3, 0, 1, 2], + }, + South => Adjacency { + corners: [West, East, Down, Up], + weights: [ + [UP, FLIP_WEST, FLIP_UP, FLIP_WEST, FLIP_UP, WEST, UP, WEST], + [ + DOWN, FLIP_WEST, FLIP_DOWN, FLIP_WEST, FLIP_DOWN, WEST, DOWN, WEST, + ], + [ + DOWN, FLIP_EAST, FLIP_DOWN, FLIP_EAST, FLIP_DOWN, EAST, DOWN, EAST, + ], + [UP, FLIP_EAST, FLIP_UP, FLIP_EAST, FLIP_UP, EAST, UP, EAST], + ], + remap: [0, 1, 2, 3], + }, + West => Adjacency { + corners: [Up, Down, North, South], + weights: [ + [ + UP, SOUTH, UP, FLIP_SOUTH, FLIP_UP, FLIP_SOUTH, FLIP_UP, SOUTH, + ], + [ + UP, NORTH, UP, FLIP_NORTH, FLIP_UP, FLIP_NORTH, FLIP_UP, NORTH, + ], + [ + DOWN, NORTH, DOWN, FLIP_NORTH, FLIP_DOWN, FLIP_NORTH, FLIP_DOWN, NORTH, + ], + [ + DOWN, SOUTH, DOWN, FLIP_SOUTH, FLIP_DOWN, FLIP_SOUTH, FLIP_DOWN, SOUTH, + ], + ], + remap: [3, 0, 1, 2], + }, + East => Adjacency { + corners: [Down, Up, North, South], + weights: [ + [ + FLIP_DOWN, SOUTH, FLIP_DOWN, FLIP_SOUTH, DOWN, FLIP_SOUTH, DOWN, SOUTH, + ], + [ + FLIP_DOWN, NORTH, FLIP_DOWN, FLIP_NORTH, DOWN, FLIP_NORTH, DOWN, NORTH, + ], + [ + FLIP_UP, NORTH, FLIP_UP, FLIP_NORTH, UP, FLIP_NORTH, UP, NORTH, + ], + [ + FLIP_UP, SOUTH, FLIP_UP, FLIP_SOUTH, UP, FLIP_SOUTH, UP, SOUTH, + ], + ], + remap: [1, 2, 3, 0], + }, + } +} +const ADJACENCY: [Adjacency; 6] = [ + adjacency(D::Down), + adjacency(D::Up), + adjacency(D::North), + adjacency(D::South), + adjacency(D::West), + adjacency(D::East), +]; +/// `prepareQuadShape`: the quad's bounds, whether it is partial (smaller than +/// the block face) and whether it is cubic (flush with the block boundary, or +/// flat on a full collision shape). +struct Shape { + bounds: [f32; 12], + partial: bool, + cubic: bool, +} +fn shape(positions: &[[f32; 3]; 4], face: D, full: bool) -> Shape { + let (mut min, mut max) = ([32f32; 3], [-32f32; 3]); + for p in positions { + for i in 0..3 { + min[i] = min[i].min(p[i]); + max[i] = max[i].max(p[i]); + } + } + let mut bounds = [0f32; 12]; + for (index, value) in [ + (WEST, min[0]), + (EAST, max[0]), + (DOWN, min[1]), + (UP, max[1]), + (NORTH, min[2]), + (SOUTH, max[2]), + ] { + bounds[index as usize] = value; + bounds[index as usize + 6] = 1.0 - value; + } + let (lo, hi) = (1.0e-4f32, 0.9999f32); + let partial = |a: usize, b: usize| min[a] >= lo || min[b] >= lo || max[a] <= hi || max[b] <= hi; + let (partial, cubic) = match face { + D::Down => (partial(0, 2), min[1] == max[1] && (min[1] < lo || full)), + D::Up => (partial(0, 2), min[1] == max[1] && (max[1] > hi || full)), + D::North => (partial(0, 1), min[2] == max[2] && (min[2] < lo || full)), + D::South => (partial(0, 1), min[2] == max[2] && (max[2] > hi || full)), + D::West => (partial(1, 2), min[0] == max[0] && (min[0] < lo || full)), + D::East => (partial(1, 2), min[0] == max[0] && (max[0] > hi || full)), + }; + Shape { + bounds, + partial, + cubic, + } +} +/// `prepareQuadFlat` for a quad without a cull face: light from the +/// neighbour when the quad is flush with the face, else from the block itself. +pub(super) fn flat( + pad: &Padded, + own: &Info, + pos: [i32; 3], + positions: &[[f32; 3]; 4], + face: D, +) -> u32 { + let cubic = shape(positions, face, own.full).cubic; + coords(pad, own, if cubic { step(pos, face) } else { pos }) +} +/// `prepareQuadAmbientOcclusion`: per-vertex AO brightness (before `ARGB.gray`) +/// and smooth light coords, by vertex index. +pub(super) fn ambient_occlusion( + pad: &Padded, + info: &[Info], + own: &Info, + pos: [i32; 3], + positions: &[[f32; 3]; 4], + face: D, +) -> ([f32; 4], [u32; 4]) { + let shape = shape(positions, face, own.full); + let base = if shape.cubic { step(pos, face) } else { pos }; + let adjacency = &ADJACENCY[face as usize]; + let corner = |i: usize| step(base, adjacency.corners[i]); + let sample = |p: [i32; 3]| { + let s = state(pad, info, p); + (coords(pad, s, p), s.shade) + }; + let (light0, shade0) = sample(corner(0)); + let (light1, shade1) = sample(corner(1)); + let (light2, shade2) = sample(corner(2)); + let (light3, shade3) = sample(corner(3)); + let permeable = |i: usize| state(pad, info, step(corner(i), face)).permeable; + let (p0, p1, p2, p3) = (permeable(0), permeable(1), permeable(2), permeable(3)); + let diagonal = |a: usize, b: usize, open: bool| { + if open { + sample(step(corner(a), adjacency.corners[b])) + } else { + (light0, shade0) + } + }; + let (light02, shade02) = diagonal(0, 2, p2 || p0); + let (light03, shade03) = diagonal(0, 3, p3 || p0); + let (light12, shade12) = diagonal(1, 2, p2 || p1); + let (light13, shade13) = diagonal(1, 3, p3 || p1); + let next = step(pos, face); + let next_state = state(pad, info, next); + let light_center = if shape.cubic || !next_state.solid { + coords(pad, next_state, next) + } else { + coords(pad, own, pos) + }; + let shade_center = if shape.cubic { + state(pad, info, base).shade + } else { + own.shade + }; + let ao = [ + (shade3 + shade0 + shade03 + shade_center) * 0.25, + (shade2 + shade0 + shade02 + shade_center) * 0.25, + (shade2 + shade1 + shade12 + shade_center) * 0.25, + (shade3 + shade1 + shade13 + shade_center) * 0.25, + ]; + let blended = [ + smooth_blend(light3, light0, light03, light_center), + smooth_blend(light2, light0, light02, light_center), + smooth_blend(light2, light1, light12, light_center), + smooth_blend(light3, light1, light13, light_center), + ]; + let mut brightness = [0f32; 4]; + let mut light = [0u32; 4]; + for (k, &vertex) in adjacency.remap.iter().enumerate() { + if shape.partial { + let f = |i: usize| shape.bounds[adjacency.weights[k][i] as usize]; + let w = [f(0) * f(1), f(2) * f(3), f(4) * f(5), f(6) * f(7)]; + brightness[vertex] = + (ao[0] * w[0] + ao[1] * w[1] + ao[2] * w[2] + ao[3] * w[3]).clamp(0.0, 1.0); + light[vertex] = weighted_blend(blended, w); + } else { + brightness[vertex] = ao[k]; + light[vertex] = blended[k]; + } + } + (brightness, light) +} + +#[cfg(test)] +mod tests { + use super::*; + const fn packed(block: u32, sky: u32) -> u32 { + block << 4 | sky << 20 + } + #[test] + fn smooth_blend_replaces_dark_samples_with_the_centre() { + let center = packed(2, 15); + // A zero sample takes the centre; a sky-less sample borrows its sky. + let blended = smooth_blend(0, packed(8, 0), packed(4, 15), center); + assert_eq!(blended & 0xFF, (32 + 128 + 64 + 32) / 4); + assert_eq!(blended >> 16 & 0xFF, 240); + // A dark centre leaves samples untouched. + assert_eq!( + smooth_blend(0, 0, packed(15, 15), packed(1, 1)) & 0xFF, + (240 + 16) / 4 + ); + } + #[test] + fn weighted_blend_narrows_like_java_int_casts() { + let c = [packed(15, 15); 4]; + assert_eq!(weighted_blend(c, [0.25; 4]), packed(15, 15)); + // Negative weights (geometry past the block) wrap through the 0xFF mask. + assert_eq!( + weighted_blend([packed(1, 0); 4], [-0.25; 4]) & 0xFF, + (-16i32 as u32) & 0xFF + ); + } + #[test] + fn colour_arithmetic_matches_argb_helpers() { + assert_eq!(gray(1.0), 255); + assert_eq!(gray(0.8), 204); + assert_eq!(scale(255, 0.5), 127); + assert_eq!(scale(gray(0.6), 0.8), 122); + assert_eq!(cardinal(true, D::Down), 0.9); + assert_eq!(cardinal(false, D::Down), 0.5); + } + #[test] + fn emission_raises_both_channels_and_drops_fractions() { + assert_eq!(with_emission(0x0087_0013, 0), 0x0087_0013); + assert_eq!(with_emission(0x0087_0013, 3), packed(3, 8)); + assert_eq!(max_coords(packed(3, 9), packed(7, 2)), packed(7, 9)); + } + #[test] + fn quad_shape_classifies_partial_and_cubic_faces() { + let full_top = [ + [0.0, 1.0, 0.0], + [0.0, 1.0, 1.0], + [1.0, 1.0, 1.0], + [1.0, 1.0, 0.0], + ]; + let s = shape(&full_top, D::Up, false); + assert!(s.cubic && !s.partial); + let slab_top = full_top.map(|[x, _, z]| [x, 0.5, z]); + let s = shape(&slab_top, D::Up, false); + assert!(!s.cubic && !s.partial); + assert!(shape(&slab_top, D::Up, true).cubic); + let small = slab_top.map(|[x, y, z]| [x * 0.5, y, z]); + let s = shape(&small, D::Up, false); + assert!(s.partial); + assert_eq!(s.bounds[EAST as usize], 0.5); + assert_eq!(s.bounds[FLIP_EAST as usize], 0.5); + } +} diff --git a/crates/horizon-client/src/models/catalog.rs b/crates/horizon-client/src/models/catalog.rs index fa223905b..61db847a0 100644 --- a/crates/horizon-client/src/models/catalog.rs +++ b/crates/horizon-client/src/models/catalog.rs @@ -3,7 +3,7 @@ //! resource-pack reloads remain separate work. use crate::{Result, sprites::Sprites}; use horizon_assets::{ - bake::{BlockModelTransform, ModelQuad, bake_model_transformed}, + bake::{BlockModelTransform, ModelQuad, bake_block_model}, blockstate::{ BlockStateDefinition, Variant, VariantSet, bind::{Properties, PropertySchema, PropertyValues, SelectedModels}, @@ -176,7 +176,7 @@ impl StateModels { for (name, turns, lock) in variants { let model = library.resolve(&name)?; let faces: Vec = - bake_model_transformed(&model, BlockModelTransform::new(turns, lock))? + bake_block_model(&model, BlockModelTransform::new(turns, lock))? .into_iter() .map(|quad| { let layer = sprites.insert(root, &quad.material.sprite)?; diff --git a/crates/horizon-world/src/block_render.rs b/crates/horizon-world/src/block_render.rs index 2d3932c81..1ed9c51af 100644 --- a/crates/horizon-world/src/block_render.rs +++ b/crates/horizon-world/src/block_render.rs @@ -163,6 +163,16 @@ impl FaceVisibility { .get(state.0 as usize) .is_some_and(|s| s.faces[direction as usize] == 1) } + /// The state's occlusion face toward `direction` (`getFaceOcclusionShape`) and + /// its shared ID: 0 is the empty singleton, 1 the full-block singleton. + pub fn occlusion_face( + &self, + state: BlockStateId, + direction: Direction, + ) -> Option<(u32, &VoxelShape)> { + let id = self.states.get(state.0 as usize)?.faces[direction as usize]; + Some((id, &self.faces[id as usize])) + } /// Whether the state's occlusion face toward `direction` is empty. pub fn empty_face(&self, state: BlockStateId, direction: Direction) -> bool { self.states diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSectionMeshOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSectionMeshOracle.java index c35afb92e..548275cbe 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSectionMeshOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSectionMeshOracle.java @@ -200,10 +200,12 @@ public final class VanillaSectionMeshOracle { recorder.kind = "model"; recorder.layer = layer(quad.materialInfo().layer()); recorder.sprite = quad.materialInfo().sprite().contents().name().toString(); int emission = quad.materialInfo().lightEmission(); + int slot = Arrays.asList(FLUID_SPRITES).indexOf(recorder.sprite); for (int i = 0; i < 4; i++) { var p = quad.position(i); long uv = quad.packedUV(i); + float u = Float.intBitsToFloat((int) (uv >>> 32)); recorder.vertex(p.x() + x, p.y() + y, p.z() + z, instance.getColor(i), - Float.intBitsToFloat((int) (uv >>> 32)), Float.intBitsToFloat((int) uv), instance.getLightCoordsWithEmission(i, emission)); + slot < 0 ? u : u * STRIP - 2 * slot, Float.intBitsToFloat((int) uv), instance.getLightCoordsWithEmission(i, emission)); } }; int baseY = row.get("section_y").getAsInt() * 16; @@ -241,6 +243,7 @@ public final class VanillaSectionMeshOracle { if (recorder.pending != null) throw new AssertionError("partial quad"); return map("name", row.get("name").getAsString(), "quads", recorder.quads); } + private static BlockColors COLORS; /** Per-state facts the Rust mesher derives from prepared resources. */ private static Object facts(BlockState state, int id) { var level = EmptyBlockGetter.INSTANCE; @@ -255,14 +258,15 @@ public final class VanillaSectionMeshOracle { return map("id", id, "shade", state.getShadeBrightness(level, BlockPos.ZERO), "emissive", state.emissiveRendering(), "legacy_solid", state.isSolid(), "light_permeable", state.isLightPermeable(), "solid_render", state.isSolidRender(), "full_collision", state.isCollisionShapeFullBlock(level, BlockPos.ZERO), "emission", state.getLightEmission(), - "half_transparent", block instanceof HalfTransparentBlock, "leaves", block instanceof LeavesBlock, - "tint_sources", BlockColors.createDefault().getTintSources(state).size(), "offsets", offsets); + "overlay", block instanceof HalfTransparentBlock || block instanceof LeavesBlock, + "tint_sources", COLORS.getTintSources(state).size(), "offsets", offsets); } public static void main(String[] args) throws Exception { net.minecraft.SharedConstants.tryDetectVersion(); net.minecraft.server.Bootstrap.bootStrap(); VanillaHeightmapOracle.bindTags(JsonParser.parseString(Files.readString(Path.of(args[2]).resolve("block-tags.json"))).getAsJsonObject()); LeavesBlock.setCutoutLeaves(true); + COLORS = BlockColors.createDefault(); if (args[0].equals("facts")) { try (var output = Files.newBufferedWriter(Path.of(args[1]))) { int id = 0; diff --git a/tools/test_section_mesh_parity.py b/tools/test_section_mesh_parity.py index 6cd7c44ab..118f561a8 100644 --- a/tools/test_section_mesh_parity.py +++ b/tools/test_section_mesh_parity.py @@ -19,6 +19,7 @@ import os from pathlib import Path import platform import random +import struct import subprocess try: from . import lab, test_rust_parity as base, test_model_baking_parity as baking @@ -290,9 +291,14 @@ def corpus(states): return scenes +def f32(value): + """Both sides emit binary32 values; Java prints them shortest-form, so parse back to the same float.""" + return struct.unpack(' Date: Thu, 8 Oct 2026 15:39:01 +0200 Subject: [PATCH 3/5] Cover every model state and dense mixed scenes in the section mesh gate Adds the all-states catalogue and dense random scenes with fluids, a --quick mode, fixture meshing time in the report, and clippy fixes. Co-Authored-By: Claude Opus 5.5 --- .../examples/section_mesh_fixture.rs | 18 ++++++-- crates/horizon-client/src/mesher.rs | 4 +- tools/test_section_mesh_parity.py | 46 +++++++++++++++---- 3 files changed, 53 insertions(+), 15 deletions(-) diff --git a/crates/horizon-client/examples/section_mesh_fixture.rs b/crates/horizon-client/examples/section_mesh_fixture.rs index ba6c36bd7..1ac0e094d 100644 --- a/crates/horizon-client/examples/section_mesh_fixture.rs +++ b/crates/horizon-client/examples/section_mesh_fixture.rs @@ -18,6 +18,7 @@ use std::{ io::{BufRead, BufReader, BufWriter, Write}, path::PathBuf, sync::Arc, + time::{Duration, Instant}, }; type Result = std::result::Result>; @@ -48,6 +49,7 @@ fn scene( tables: &MeshTables, biomes: &mut Biomes, names: &BTreeMap, + elapsed: &mut Duration, ) -> Result { let colors = &row["colors"]; let color = |k: &str| -> Result { Ok(int(&colors[k])? as u32 & 0xFF_FFFF) }; @@ -97,13 +99,16 @@ fn scene( visibility: tables.visibility.clone(), }; let section_y = int(&row["section_y"])?; + let started = Instant::now(); let mesh = mesher.mesh(®ion, (section_y * 16 - MIN_Y) / 16); + *elapsed += started.elapsed(); let mut quads = Vec::new(); for (layer, vertices) in [("opaque", &mesh.solid), ("translucent", &mesh.translucent)] { - if vertices.len() % 4 != 0 { + let (vertices, rest) = vertices.as_chunks::<4>(); + if !rest.is_empty() { return Err("partial quad".into()); } - for quad in vertices.chunks_exact(4) { + for quad in vertices { let sprite = names.get(&quad[0].layer).ok_or("unknown sprite layer")?; if quad.iter().any(|v: &Vertex| v.layer != quad[0].layer) { return Err("quad mixes sprite layers".into()); @@ -167,12 +172,19 @@ fn main() -> Result<()> { 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, &names)?; + let result = scene(&row, &assets, &tables, &mut biomes, &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(()) } diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index b83980a25..807f69bbb 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -394,7 +394,7 @@ fn blend(region: &[[Option<&Chunk>; 3]; 3], biomes: &Biomes, cx: i32, cz: i32, y } } let n = ((2 * R + 1) * (2 * R + 1)) as u32; - (r / n) << 16 | (g / n) << 8 | b / n + (r / n) << 16 | (g / n) << 8 | (b / n) }; for z in 0..16 { for x in 0..16 { @@ -531,7 +531,7 @@ impl Mesher<'_> { Tint::Redstone(p) => redstone_color(p), Tint::Stem(age) => { let a = u32::from(age); - (a * 32) << 16 | (255 - a * 8) << 8 | a * 4 + (a * 32) << 16 | (255 - a * 8) << 8 | (a * 4) } }) } diff --git a/tools/test_section_mesh_parity.py b/tools/test_section_mesh_parity.py index 118f561a8..629696cd5 100644 --- a/tools/test_section_mesh_parity.py +++ b/tools/test_section_mesh_parity.py @@ -134,7 +134,7 @@ class Scene: 'blocks': [[*p, s] for p, s in sorted(self.blocks.items())], 'lights': self.lights()} -def corpus(states): +def corpus(states, full=True): scenes = [] def scene(name, **kwargs): s = Scene(states, name, **kwargs) @@ -271,6 +271,29 @@ def corpus(states): s = scene(f'catalog_{chunk // per_scene}') for i, name in enumerate(model_blocks[chunk:chunk + per_scene]): s.put(i % 8 * 2, i // 64 * 2, i // 8 % 8 * 2, states.defaults[name]) + # Every model state (rotations, multipart, UV lock, waterlogging) on a sparse grid. + air = {'minecraft:air', 'minecraft:cave_air', 'minecraft:void_air'} + model_states = [i for i, name in enumerate(states.names) if states.render_shape[i] == 'MODEL' and name not in air] + if full: + for chunk in range(0, len(model_states), per_scene): + s = scene(f'states_{chunk // per_scene}') + for i, state in enumerate(model_states[chunk:chunk + per_scene]): + s.put(i % 8 * 2, i // 64 * 2, i // 8 % 8 * 2, state) + # Dense random states from the whole registry packed against each other and fluids. + fluids = [states('water'), states('lava'), states('water', level=3), states('water', level=9), states('lava', level=4)] + for seed in range(6 if full else 2): + rng = random.Random(0x44454E53 + seed) + s = scene(f'dense_{seed}', nether=seed == 5) + for x in range(-1, 17): + for y in range(-1, 17): + for z in range(-1, 17): + roll = rng.random() + if roll < 0.45: + s.put(x, y, z, rng.choice(model_states)) + elif roll < 0.6: + s.put(x, y, z, rng.choice(fluids)) + if seed % 2: + s.noise = seed # Random dense scenes over a palette, with structured and noisy light. palette = ['stone', 'glass', 'oak_leaves', 'grass_block', 'water', 'lava', 'oak_slab', 'oak_stairs', 'torch', 'poppy', 'short_grass', 'glowstone', 'oak_fence', 'snow', 'white_carpet', 'magma_block', 'soul_sand', 'ice', 'farmland', 'dirt_path'] @@ -335,16 +358,16 @@ def compare(scene, client, rust, states, report, limit): bucket = report['examples'].setdefault(category, []) if len(bucket) < limit: bucket.append({'scene': scene['name'], 'quads': list(examples)}) + def attributes(entry): + quad, rotation = entry + v = quad['vertices'] + return str([(round(x[3], 3), round(x[4], 3), channels(x[5]), light(x[6])) for x in v[rotation:] + v[:rotation]]) for key, (left, right) in groups.items(): - def attributes(entry): - quad, rotation = entry - v = quad['vertices'] - return [(round(x[3], 3), round(x[4], 3), channels(x[5]), light(x[6])) for x in v[rotation:] + v[:rotation]] - left.sort(key=lambda e: str(attributes(e))) - right.sort(key=lambda e: str(attributes(e))) + # Coincident quads (back faces, overlapping elements) pair up by their attributes. + left.sort(key=attributes) + right.sort(key=attributes) for a, b in zip(left, right): report['matched_quads'] += 1 - va = [x for x in attributes(a)] ca = a[0]['vertices'][a[1]:] + a[0]['vertices'][:a[1]] cb = b[0]['vertices'][b[1]:] + b[0]['vertices'][:b[1]] problems = set() @@ -359,7 +382,6 @@ def compare(scene, client, rust, states, report, limit): if light(p[6]) != light(q[6]): lp, lq = light(p[6]), light(q[6]) problems.add('light_sky' if lp[0] != lq[0] else 'light_block') - del va if not problems: report['identical_quads'] += 1 for problem in sorted(problems): @@ -378,6 +400,7 @@ def main(): parser.add_argument('--strict', action='store_true', help='fail when any quad or fact differs') parser.add_argument('--examples', type=int, default=12, help='examples kept per mismatch category') parser.add_argument('--only', help='only scenes whose name contains this text') + parser.add_argument('--quick', action='store_true', help='skip the all-states catalogue and most dense scenes') args = parser.parse_args() lock, jars, _ = base.verify_artifacts() resources = lab.LOCAL / 'horizon-client' / lock['minecraft']['version'] @@ -392,7 +415,7 @@ def main(): sources += [lab.ROOT / 'crates' / crate / 'Cargo.toml', *sorted((lab.ROOT / 'crates' / crate / 'src').rglob('*.rs'))] tested = base.source_hashes(sources) states = States(resources) - scenes = [s for s in corpus(states) if not args.only or args.only in s.name] + scenes = [s for s in corpus(states, not args.quick) if not args.only or args.only in s.name] rows = [s.row() for s in scenes] inputs = BUILD / 'inputs.jsonl' inputs.write_text(''.join(json.dumps(row) + '\n' for row in rows)) @@ -441,6 +464,8 @@ def main(): examples = report['facts'].setdefault(key, []) if len(examples) < args.examples: examples.append({'state': f"{states.names[a['id']]}{states.properties[a['id']]}", 'client': a[key], 'rust': b.get(key)}) + timing = [line for line in (BUILD / 'rust.log').read_text().splitlines() if line.startswith('meshed ')] + report['rust_mesh_timing'] = timing[-1] if timing else None report['fact_mismatches'] = dict(fact_mismatches) report['fact_states'] = len(client_facts) base.ensure_sources_unchanged(sources, tested) @@ -453,6 +478,7 @@ def main(): for category, count in sorted(report['categories'].items(), key=lambda kv: -kv[1]): print(f' {category:<28} {count:,}') print(f"Mesh facts: {len(client_facts):,} states, mismatches: {dict(fact_mismatches) or 'none'}") + print(f"Rust fixture (fast profile): {report['rust_mesh_timing']}") print(f'Report: {report_path}') if args.strict and (report['categories'] or fact_mismatches): raise SystemExit(1) From ece28615a79f40f48394f571f6ca229fcd5f8a6f Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 8 Oct 2026 15:40:42 +0200 Subject: [PATCH 4/5] Document the section meshing parity gate Co-Authored-By: Claude Opus 5.5 --- docs/parity/meshing.md | 126 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 126 insertions(+) create mode 100644 docs/parity/meshing.md diff --git a/docs/parity/meshing.md b/docs/parity/meshing.md new file mode 100644 index 000000000..43c6731d2 --- /dev/null +++ b/docs/parity/meshing.md @@ -0,0 +1,126 @@ +# Section meshing parity + +`tools/test_section_mesh_parity.py` compares the vertices Horizon's section +mesher (`crates/horizon-client/src/mesher.rs`, with `mesher/lighting.rs` and +`mesher/fluid.rs`) emits with the vertices the pinned client's own renderers +emit for the same scenes. + +## What is compared + +- **Vanilla side**: `VanillaSectionMeshOracle` bootstraps the game, binds the + prepared block tags, parses the jar's blockstate definitions and block + models, and bakes `BlockStateModel`s through the real `ModelDiscovery`, + `UnbakedRoot.bake` and `FaceBakery` path. Every texture becomes a real sprite + (its PNG from the jar) alone in a unit atlas, so UVs stay in sprite-local + [0,1] space; the five fluid sprites share one strip with gaps so the fluid + vertex stream still identifies them. A fixed `BlockAndTintGetter` serves the + scene's block states, per-cell sky/block light, constant biome colours per + `ColorResolver` and the overworld or Nether `CardinalLighting`. Blocks of one + section are visited like `SectionCompiler.compile`: fluids through + `FluidRenderer.tesselate`, then `RenderShape.MODEL` blocks through + `ModelBlockRenderer.tesselateBlock` with smooth lighting on, culling on, + cutout leaves, `BlockColors.createDefault()` and `state.getSeed(pos)`. +- **Horizon side**: `crates/horizon-client/examples/section_mesh_fixture.rs` + loads the prepared resources (`Assets`, `BlockFacts`, `Biomes`, + `load_visibility`, `MeshTables`), builds the same blocks and light in real + client `Chunk`s (a 3x3 chunk region), sets every biome's colours to the + scene constants and runs `Mesher::mesh`. +- **Comparison**: quads are matched as multisets per scene, keyed by sprite, + render-layer class (translucent vs. solid/cutout) and geometry rounded to + 1/1000 after binary32 normalisation, with a winding-preserving rotation. + Matched quads compare per vertex: positions and UVs within 1e-4, ARGB colour + and light coordinates (sky and block, 1/16 steps) exactly. +- **Per-state facts**: a second gate compares, for all 35,723 states, the facts + the Rust tables derive from prepared resources with the client's accessors: + `getShadeBrightness`, `emissiveRendering`, `isSolid`, `isLightPermeable`, + `isSolidRender`, `isCollisionShapeFullBlock`, light emission, the water + overlay classes (`HalfTransparentBlock`/`LeavesBlock`), tint source counts + and `getOffset` at five columns. + +The corpus (94 sections, ~842k quads, ~206k of them fluid quads) has full +cubes in open air, corners, cavities and overhangs; slabs, stairs, walls, +fences, panes, bars, torches, flowers and grasses with XZ/XYZ offsets, tall +plants, tinted blocks (grass, leaves, stems, redstone, lily pad, petals, leaf +litter, cauldrons), snow layers, carpets, farmland, paths, hoppers, anvils, +chains, lanterns, dripleaf, dripstone; water and lava sources, flowing levels, +falling columns, waterlogged blocks, water against glass/leaves/slabs/ice; +section edges with neighbours in other chunks and sections; a cave with +emissive and light-emitting blocks (magma, glowstone, sea lantern, active +sculk sensor, glow lichen); Nether shading; every block's default state; every +`RenderShape.MODEL` state of the registry on a sparse grid; and dense random +scenes mixing all model states with fluids under propagated or random light. + +## Running + +```sh +python3 tools/test_section_mesh_parity.py # full corpus +python3 tools/test_section_mesh_parity.py --quick # skip the all-states catalogue +python3 tools/test_section_mesh_parity.py --strict # exit 1 on any difference +python3 tools/test_section_mesh_parity.py --only fluids +``` + +It needs the pinned jars (`tools/lab.py prepare`) and prepared client resources +(`tools/prepare_native_client.py --prepare`). Outputs, logs and +`report.json` go to `target/section-mesh-parity/`; nothing is written under +`.local/`. The fixture is built with `--profile fast` and reports its +meshing time. + +## Results + +Before the port (commit `2940b5a`, first 18 scenes): 25,391 of 55,017 vanilla +quads identical (46%); 7,685 fluid quads missing, 9,231 extra quads, and +light/colour differences on most of the rest. + +After: all 841,775 quads of the 94 scenes match and are identical, and all +per-state facts match. + +What was ported to get there: + +- `BlockModelLighter`: quad shape (`faceCubic`/`facePartial`), the corner, + diagonal and centre samples (diagonals only through light-permeable blocks, + the centre from the neighbour unless it is solid-render), shade brightness + overrides, emissive full-bright samples, `smoothBlend` (zero samples take the + centre, sky-less samples borrow its sky, only when the centre is above 2), + the partial-face weights with `smoothWeightedBlend`'s int narrowing, and the + vertex remap. The padded section border grew to two blocks because cubic + faces sample two blocks out along their normal. +- `ModelBlockRenderer`: flat lighting for light-emitting blocks or when the + first model part disables AO (culled quads read light from the cull + neighbour, others from the neighbour only when flush), `ARGB.gray`/ + `scaleRGB`/`multiply` integer arithmetic, cardinal shading including + `NETHER`, shade-direction overrides, per-element light emission, tint source + counts (layer indices past the list are untinted; water and bubble columns + are untinted in the world) and `getOffset` for XZ/XYZ blocks. +- `FluidRenderer`: face culling against the neighbour's occlusion face shape + for the fluid box height, self occlusion, `isSolid` corner heights, the + weighted corner averages in vanilla order, the 0.001 insets (also feeding the + side faces), `FlowingFluid.getFlow` with `Mth.atan2` and the sine table, the + water overlay beside half-transparent and leaf blocks, back faces, + `max(self, above)` light, bottom light from below, and cardinal shading. +- `UnbakedCuboidGeometry.bake`: elements flat along an axis draw no faces + across it (`bake_block_model` in horizon-assets; the raw + `bake_model_transformed` used by the model-baking gate is unchanged). + +Exported facts used: `block-behaviours.json` (class chains, `isSolid`, full +face sturdiness), `gameplay-facts.json` (`offset` flag, emission, shapes), +the `#minecraft:blocks_fluid_flow` tag and the occlusion faces already loaded +for face visibility. Offset types and maximum offsets, shade-brightness and +emissive overrides are keyed by class or block name and checked by the facts +gate. + +## What remains different or untested + +- Biome tint blending: vanilla blends `BiomeManager`'s zoomed biome at each + block's own height; Horizon blends its quart biome cells at the section's + mid-height. The gate uses one constant colour per resolver, so this is not + compared. +- Model variant seeds: `DoublePlantBlock`, `DoorBlock` and `AbstractBedBlock` + override `getSeed`; Horizon seeds every block from its own position. No + vanilla block among those has weighted variants, so output is unaffected. +- Settings: only smooth lighting on and cutout ("fancy") leaves are covered; + Horizon has no flat-lighting or opaque-leaves modes. +- Layers: vanilla's solid and cutout layers are compared as one class because + Horizon draws both in its opaque pass. +- Not compared: block entities and their renderers, animated sprite frames, + translucent sorting, chunk-border light outside loaded chunks and GPU + pixels. From 26858f039d52b14abef066a821faef14be367bb2 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 8 Oct 2026 15:43:25 +0200 Subject: [PATCH 5/5] Note meshing cost in the section meshing parity doc Co-Authored-By: Claude Opus 5.5 --- docs/parity/meshing.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/parity/meshing.md b/docs/parity/meshing.md index 43c6731d2..841ca30a3 100644 --- a/docs/parity/meshing.md +++ b/docs/parity/meshing.md @@ -72,7 +72,9 @@ quads identical (46%); 7,685 fluid quads missing, 9,231 extra quads, and light/colour differences on most of the rest. After: all 841,775 quads of the 94 scenes match and are identical, and all -per-state facts match. +per-state facts match. Meshing cost is unchanged within noise: the fixture +meshes the 94 (dense) corpus sections in about 3 ms each with both the old and +the ported mesher (`--profile fast`, loaded 24-thread desktop). What was ported to get there: