Merge pull request #1115 from ludovic111/fix/break-particle-sprite

🤖 Agent: merged. Verify passes. CI parity's only failure is world_spawn seed -2080727421395798566, where vanilla itself gives several heights across runs (also on main; see #1112). Screenshots in the body.
This commit is contained in:
Ludovic Marie
2026-10-22 02:03:42 +02:00
committed by GitHub
13 changed files with 183 additions and 33 deletions
@@ -82,6 +82,19 @@ impl CompiledChoices {
.collect::<Result<_>>()?,
})
}
/// The variant `particleMaterial` comes from: the first entry of a weighted
/// list (`WeightedVariants`) and, for a multipart root, of its first
/// selector whether or not that selector applies (`MultiPartModel`).
pub fn particle_variant(&self, selected: &SelectedModels) -> Option<&Variant> {
let choice = match selected {
SelectedModels::Variant(index) => self.variants.get(*index)?,
SelectedModels::Multipart(_) => self.multipart.first()?,
};
Some(match choice {
Choice::Single(value) => value,
Choice::Weighted { variants, .. } => variants.first()?,
})
}
/// Append selected variants without allocating intermediate part lists. A
/// multipart root consumes nextLong even for an empty selected subset, then
/// resets the same random source to that seed before each selected part.
+56 -19
View File
@@ -1809,14 +1809,10 @@ impl Game<'_> {
}
Some(stack)
}
fn particle_sprite(&self, state: BlockStateId) -> Option<(String, u32)> {
Self::block_particle_sprite(&self.pack, self.res.facts(), state)
}
fn block_particle_sprite(
pack: &PackResources,
facts: &BlockFacts,
state: BlockStateId,
) -> Option<(String, u32)> {
/// The block's first up face (or any face) and its fixed tint, for block
/// models drawn as entities (falling blocks, carried blocks).
fn block_face_sprite(&self, state: BlockStateId) -> Option<(String, u32)> {
let pack = &self.pack;
let models = pack
.render
.model_catalog
@@ -1826,14 +1822,10 @@ impl Game<'_> {
.iter()
.flat_map(|(_, m)| m.faces.iter())
.find(|f| f.quad.facing == horizon_assets::model::Direction::Up)
.or_else(|| models.iter().flat_map(|(_, m)| m.faces.iter()).next());
// Entity-rendered blocks may have a particle texture without any faces.
let layer = face
.map(|face| face.layer)
.or_else(|| models.iter().find_map(|(_, model)| model.particle))?;
let name = pack.layer_names.get(&layer)?.clone();
let tint = if face.is_some_and(|face| face.quad.tint_index >= 0) {
let n = &facts.get(state).name;
.or_else(|| models.iter().flat_map(|(_, m)| m.faces.iter()).next())?;
let name = pack.layer_names.get(&face.layer)?.clone();
let tint = if face.quad.tint_index >= 0 {
let n = &self.res.facts().get(state).name;
if n.contains("leaves") || n.contains("vine") {
0x48B518
} else {
@@ -1844,6 +1836,51 @@ impl Game<'_> {
};
Some((name, tint))
}
/// `TerrainParticle` at `pos`: the model's particle sprite and tint source
/// 0's `colorAsTerrainParticle` (white when the block has none).
fn particle_sprite(&self, state: BlockStateId, pos: [i32; 3]) -> Option<(String, u32)> {
let sprite = Self::block_particle_sprite(&self.pack, state)?;
let chunks = &self.world.chunks;
let (cx, cz) = (pos[0] >> 4, pos[2] >> 4);
let region: [[Option<&horizon_client::chunk::Chunk>; 3]; 3] = std::array::from_fn(|dz| {
std::array::from_fn(|dx| {
chunks
.get(&(cx + dx as i32 - 1, cz + dz as i32 - 1))
.map(|c| &**c)
})
});
let tint = self
.pack
.context
.tables
.terrain_particle_tint(
state,
pos,
&region,
self.res.biomes(),
self.streaming.biome_zoom,
self.streaming.biome_blend,
)
.unwrap_or(0xFFFFFF);
Some((sprite, tint))
}
/// `BlockStateModelSet.getParticleMaterial`: the sprite of the model's
/// `particle` texture, else its first face (entity-rendered blocks may
/// have a particle texture without faces, and faces without one).
fn block_particle_sprite(pack: &PackResources, state: BlockStateId) -> Option<String> {
let catalog = &pack.render.model_catalog;
let layer = catalog.particle(state).or_else(|| {
let models = catalog
.collect(state, horizon_core::position::BlockPos::new(0, 0, 0))
.ok()?;
models
.iter()
.flat_map(|(_, m)| m.faces.iter())
.next()
.map(|f| f.layer)
})?;
pack.layer_names.get(&layer).cloned()
}
fn particle_shape(&self, pos: [i32; 3], state: BlockStateId) -> Vec<[f64; 6]> {
let f = self.res.facts().get(state);
let offset = if f.outline_offset {
@@ -1862,7 +1899,7 @@ impl Game<'_> {
}
/// ClientLevel.addDestroyBlockEffect: a burst per outline box.
fn destroy_particles(&mut self, pos: [i32; 3], state: BlockStateId) {
let Some((sprite, tint)) = self.particle_sprite(state) else {
let Some((sprite, tint)) = self.particle_sprite(state, pos) else {
return;
};
let boxes = self.particle_shape(pos, state);
@@ -1873,7 +1910,7 @@ impl Game<'_> {
}
/// ClientLevel.addBreakingParticles: one crumb on the face being mined.
fn crack_particle(&mut self, pos: [i32; 3], face: [i32; 3], state: BlockStateId) {
let Some((sprite, tint)) = self.particle_sprite(state) else {
let Some((sprite, tint)) = self.particle_sprite(state, pos) else {
return;
};
let boxes = self.particle_shape(pos, state);
@@ -6513,7 +6550,7 @@ impl Game<'_> {
}
// Falling blocks use their baked model, including non-cubic shapes.
for f in &self.falling {
let Some((_, tint)) = self.particle_sprite(f.state) else {
let Some((_, tint)) = self.block_face_sprite(f.state) else {
continue;
};
let p = glam::DVec3::new(
+4 -2
View File
@@ -39,11 +39,13 @@ impl Game<'_> {
m.position.y.floor() as i32,
m.position.z.floor() as i32,
);
let mut at = [x, y, z];
let mut state = self.world.block(x, y, z);
if self.res.facts().is_air(state) {
state = self.world.block(x, (m.position.y - 0.2).floor() as i32, z);
at[1] = (m.position.y - 0.2).floor() as i32;
state = self.world.block(x, at[1], z);
}
let Some((sprite, tint)) = self.particle_sprite(state) else {
let Some((sprite, tint)) = self.particle_sprite(state, at) else {
continue;
};
let at = if jump_trail {
@@ -470,8 +470,12 @@ impl Game<'_> {
match block {
Ok(Arg::Block(b)) => {
let state = self.block_state(&b)?;
let at = self
.position_arg(ctx, "pos")
.unwrap_or_else(|| self.source_position())
.map(|c| c.floor() as i32);
let (sprite, tint) = self
.particle_sprite(state)
.particle_sprite(state, at)
.unwrap_or_else(|| ("block/stone".into(), 0xFFFFFF));
ParticleOptions::block(ty, sprite, tint)
}
+2 -1
View File
@@ -191,7 +191,8 @@ impl Game<'_> {
let Ok(id) = registry.resolve(&state) else {
return;
};
let Some((sprite, tint)) = this.particle_sprite(id) else {
let Some((sprite, tint)) = this.particle_sprite(id, center.map(|c| c.floor() as i32))
else {
return;
};
for _ in 0..count {
+2 -2
View File
@@ -267,7 +267,7 @@ impl Game<'_> {
pos: BlockPos,
fall_distance: f64,
) {
let Some((sprite, tint)) = self.particle_sprite(state) else {
let Some((sprite, tint)) = self.particle_sprite(state, [pos.x, pos.y, pos.z]) else {
return;
};
let count = (50.0 * fall_distance).clamp(0.0, 200.0) as u32;
@@ -288,7 +288,7 @@ impl Game<'_> {
/// pillars of the block at `pos`, a cluster over it and a ring 3.5 out.
pub(super) fn smash_dust(&mut self, pos: BlockPos, count: i32) {
let state = self.world.block(pos.x, pos.y, pos.z);
let Some((sprite, tint)) = self.particle_sprite(state) else {
let Some((sprite, tint)) = self.particle_sprite(state, [pos.x, pos.y, pos.z]) else {
return;
};
let options = ParticleOptions::block(ParticleType::DustPillar, sprite, tint);
+1 -1
View File
@@ -220,7 +220,7 @@ impl Game<'_> {
self.held_item_geometry(mob, camera, alpha, light, true, out);
if mob.species() == Species::Enderman
&& let Some(state) = mob.extra.carried
&& let Some((sprite, tint)) = self.particle_sprite(state)
&& let Some((sprite, tint)) = self.block_face_sprite(state)
{
// CarriedBlockLayer: OverlayTexture.NO_OVERLAY, never the hurt tint.
let base = render::base_transform(mob, alpha as f32, camera);
@@ -184,7 +184,8 @@ impl Game<'_> {
&& f.solid_render
&& f.full_collision
{
block_overlay = self.particle_sprite(state).map(|(name, _)| name);
// ScreenEffectRenderer: the block's particle material.
block_overlay = Self::block_particle_sprite(&self.pack, state);
break;
}
}
@@ -288,11 +289,12 @@ impl Game<'_> {
};
let marker = marker_particle_target(self.mode, self.stack_in(self.selected));
let marker_options = |state| {
let (sprite, tint) = Self::block_particle_sprite(&self.pack, self.res.facts(), state)?;
// BlockMarker: the particle sprite, untinted.
let sprite = Self::block_particle_sprite(&self.pack, state)?;
Some(ParticleOptions::block(
ParticleType::BlockMarker,
sprite,
tint,
0xFFFFFF,
))
};
let world = &self.world;
+1 -1
View File
@@ -1433,7 +1433,7 @@ impl Game<'_> {
at[2].floor() as i32,
);
let state = self.world.block(below.0, below.1, below.2);
let Some((sprite, tint)) = self.particle_sprite(state) else {
let Some((sprite, tint)) = self.particle_sprite(state, [below.0, below.1, below.2]) else {
return;
};
for _ in 0..30 {
+2 -1
View File
@@ -79,7 +79,8 @@ impl Game<'_> {
}
let head = sniffer::head_block(m);
let below = self.world.block(head[0], head[1] - 1, head[2]);
let Some((sprite, tint)) = self.particle_sprite(below) else {
let Some((sprite, tint)) = self.particle_sprite(below, [head[0], head[1] - 1, head[2]])
else {
continue;
};
let dust = [
+29 -2
View File
@@ -232,11 +232,15 @@ fn visibility(pad: &Padded, info: &[Info]) -> u64 {
#[cfg(test)]
mod leaf_culling_tests;
#[cfg(test)]
mod particle_tests;
#[cfg(test)]
mod visibility_tests;
#[derive(Clone, Copy, PartialEq, Eq)]
enum Tint {
None,
Grass,
/// `BlockTintSources.grassBlock`: grass in the world, none on its particles.
GrassBlock,
TallGrassUpper,
Foliage,
DryFoliage,
@@ -353,9 +357,10 @@ impl MeshTables {
([Tint::Grass; 2], 1)
}
}
"fern" | "short_grass" | "potted_fern" | "bush" | "grass_block" | "sugar_cane" => {
"fern" | "short_grass" | "potted_fern" | "bush" | "sugar_cane" => {
([Tint::Grass; 2], 1)
}
"grass_block" => ([Tint::GrassBlock; 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),
@@ -467,6 +472,28 @@ impl MeshTables {
tint_sources: i.tint_count,
})
}
/// `TerrainParticle`'s colour: tint source 0's `colorAsTerrainParticle`,
/// which is the in-world (biome-blended) colour except on grass blocks,
/// whose dirt crumbs stay untinted. `None` when the state has no source.
/// `region[dz][dx]` are the chunks around `pos`'s chunk (centre 1,1).
pub fn terrain_particle_tint(
&self,
state: BlockStateId,
pos: [i32; 3],
region: &[[Option<&Chunk>; 3]; 3],
biomes: &Biomes,
zoom: BiomeZoom,
blend_radius: i32,
) -> Option<u32> {
let info = self.info.get(state.0 as usize)?;
if info.tints[0] == Tint::GrassBlock {
return None;
}
let [x, y, z] = pos;
let origin = [x >> 4, z >> 4, y & !15];
let mut tints = Tints::new(region, biomes, zoom, blend_radius, origin);
Mesher::tint(info, 0, &mut tints, [x & 15, y & 15, z & 15])
}
/// `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)
@@ -791,7 +818,7 @@ impl Mesher<'_> {
}
Some(match state.tints[(index as usize).min(1)] {
Tint::None => return None,
Tint::Grass => tints.get(Resolver::Grass, x, y, z),
Tint::Grass | Tint::GrassBlock => tints.get(Resolver::Grass, x, y, z),
Tint::TallGrassUpper => tints.get(Resolver::Grass, x, y, z),
Tint::Foliage => tints.get(Resolver::Foliage, x, y, z),
Tint::DryFoliage => tints.get(Resolver::Dry, x, y, z),
@@ -0,0 +1,56 @@
use super::*;
/// `TerrainParticle`: the model's particle sprite and tint source 0's
/// `colorAsTerrainParticle` (#1034: grass blocks crumbled as tinted grass tops).
#[test]
fn terrain_particles_use_the_particle_sprite_and_vanilla_tint_sources() {
let root =
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
if !root.join("horizon-resources.json").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let facts = BlockFacts::load(&root, assets.registry).unwrap();
let visibility = crate::models::load_visibility(&root, assets.registry).unwrap();
let tables = MeshTables::new(&assets, &render, &facts, visibility).unwrap();
let biomes = Biomes::load(&root).unwrap();
let state = |name| assets.registry.default_state(name).unwrap();
let sprite = |name| {
let layer = render.model_catalog.particle(state(name)).unwrap();
let (sprite, _) = render
.sprite_layers
.iter()
.find(|(_, l)| **l == layer)
.unwrap();
sprite.clone()
};
assert_eq!(sprite("minecraft:grass_block"), "minecraft:block/dirt");
assert_eq!(
sprite("minecraft:short_grass"),
"minecraft:block/short_grass"
);
assert_eq!(sprite("minecraft:oak_leaves"), "minecraft:block/oak_leaves");
let center = Chunk::empty(0, 0);
let mut region = [[None; 3]; 3];
region[1][1] = Some(&center);
let tint = |name| {
tables.terrain_particle_tint(
state(name),
[5, 70, 9],
&region,
&biomes,
BiomeZoom::new(0),
2,
)
};
// grassBlock() overrides colorAsTerrainParticle to -1: the dirt stays untinted.
assert_eq!(tint("minecraft:grass_block"), None);
assert!(tint("minecraft:short_grass").is_some());
assert!(tint("minecraft:oak_leaves").is_some());
assert_eq!(tint("minecraft:spruce_leaves"), Some(0x61_9961));
// Pink petals' layer 0 is BLANK_LAYER; stone has no tint source.
assert_eq!(tint("minecraft:pink_petals"), None);
assert_eq!(tint("minecraft:stone"), None);
}
@@ -257,6 +257,13 @@ impl StateModels {
// Blocks use their position seed; contained/displayed blocks can supply one.
self.collect_seeded(state, position_seed(position))
}
/// `BlockStateModel.particleMaterial`: the particle sprite layer of the
/// state's first variant (see `CompiledChoices::particle_variant`).
pub fn particle(&self, state: BlockStateId) -> Option<u32> {
let (choice, selected) = self.states.get(&state)?;
let variant = self.choices[*choice].particle_variant(selected)?;
self.baked.get(&key(variant))?.particle
}
pub fn collect_seeded(
&self,
state: BlockStateId,