From b723ef98282004a2b88bba90c8abc7086e478080 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Wed, 14 Oct 2026 14:34:26 +0200 Subject: [PATCH] Rain and snow: tile the weather texture like WeatherEffectRenderer (#71) Horizon stretched a quarter of rain.png over each whole column, up to 20 blocks tall, so streaks were about five times too long. Vanilla advances v by a quarter per block and lets the sampler repeat, so the texture repeats every 4 blocks. Port createRainColumnInstance, createSnowColumnInstance and prepareInstances exactly (seeded column speed, game-time scroll, snow drift and brightening, camera-block size table, square radius from the Weather Radius option, alpha falloff, precipitation at the camera's y), and split each quad at the texture seams so the atlas sprite repeats. tools/test_weather_render_parity.py compares the columns and quads with the shipped renderer. Co-Authored-By: Claude Opus 5.5 --- .../examples/weather_fixture.rs | 59 ++++ crates/horizon-client/src/game.rs | 120 ++++---- crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/weather.rs | 273 ++++++++++++++++++ .../parity/VanillaWeatherRenderOracle.java | 87 ++++++ tools/test_weather_render_parity.py | 39 +++ 6 files changed, 517 insertions(+), 62 deletions(-) create mode 100644 crates/horizon-client/examples/weather_fixture.rs create mode 100644 crates/horizon-client/src/weather.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaWeatherRenderOracle.java create mode 100644 tools/test_weather_render_parity.py diff --git a/crates/horizon-client/examples/weather_fixture.rs b/crates/horizon-client/examples/weather_fixture.rs new file mode 100644 index 000000000..15aab6bdb --- /dev/null +++ b/crates/horizon-client/examples/weather_fixture.rs @@ -0,0 +1,59 @@ +//! WeatherEffectRenderer column instances and quads, without a GPU. +use horizon_client::weather; +use std::{fmt::Write, fs}; +fn bits(value: f32) -> String { + if value.is_nan() { + "nan".into() + } else { + format!("{:x}", value.to_bits()) + } +} +fn main() -> Result<(), Box> { + let args: Vec<_> = std::env::args().collect(); + let mut output = String::new(); + for (case, line) in fs::read_to_string(&args[1])?.lines().enumerate() { + let p: Vec<&str> = line.split_whitespace().collect(); + let int = |i: usize| p[i].parse::().unwrap(); + let kind = int(0); + let ticks: i64 = p[1].parse()?; + let (x, bottom, top, z, light) = (int(2), int(3), int(4), int(5), int(6)); + let partial: f32 = p[7].parse()?; + let camera = [p[8].parse()?, p[9].parse()?, p[10].parse()?]; + let radius = int(11); + let intensity: f32 = p[12].parse()?; + let mut random = weather::column_random(x, z); + let column = if kind == 0 { + weather::rain_column(&mut random, ticks, x, bottom, top, z, light, partial) + } else { + weather::snow_column(&mut random, ticks, x, bottom, top, z, light, partial) + }; + write!( + output, + "{case} {} {} {} {} {} {} {}", + column.x, + column.z, + column.bottom_y, + column.top_y, + bits(column.u_offset), + bits(column.v_offset), + column.light_coords + )?; + let max_alpha = if kind == 0 { 1.0 } else { 0.8 }; + for v in weather::column_quad(&column, camera, max_alpha, radius, intensity) { + write!( + output, + " |{},{},{},{},{},{:x},{}", + bits(v.pos[0]), + bits(v.pos[1]), + bits(v.pos[2]), + bits(v.uv[0]), + bits(v.uv[1]), + v.color, + v.light_coords + )?; + } + output.push('\n'); + } + fs::write(&args[2], output)?; + Ok(()) +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index c12744a77..1b05c0781 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -6693,10 +6693,11 @@ impl Game<'_> { } } } - /// WeatherEffectRenderer: rain/snow columns within 10 blocks. + /// WeatherEffectRenderer: rain and snow columns within the weather radius. fn weather_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec) { - let (rain, _) = self.world.weather.levels(alpha as f32); - if rain <= 0.0 { + use horizon_client::weather; + let (intensity, _) = self.world.weather.levels(alpha as f32); + if intensity <= 0.0 { return; } let atlas = &self.res.atlas; @@ -6711,76 +6712,71 @@ impl Game<'_> { camera.y.floor() as i32, camera.z.floor() as i32, ); - let radius = 10; - let time = self.ticks as f32 + alpha as f32; - for dz in -radius..=radius { - for dx in -radius..=radius { - let (x, z) = (cx + dx, cz + dz); - let d2 = (dx * dx + dz * dz) as f32; - if d2 > (radius * radius) as f32 { - continue; - } + let radius = self.settings.weather_radius; + let ticks = self.world.game_time; + let partial = alpha as f32; + let eye = [camera.x, camera.y, camera.z]; + // Vanilla draws every rain column before the snow ones. + let mut columns = (Vec::new(), Vec::new()); + for z in cz - radius..=cz + radius { + for x in cx - radius..=cx + radius { let top = self.rain_height(x, z, cy + radius + 10); let y0 = (cy - radius).max(top); let y1 = (cy + radius).max(top); - if y0 >= y1 { + if y1 == y0 { continue; } - let Some(snow) = self.precipitation(x, top, z) else { + let Some(snow) = self.precipitation(x, cy, z) else { continue; }; - let hash = (x - .wrapping_mul(x) - .wrapping_mul(3121) - .wrapping_add(x.wrapping_mul(45_238_971)) - ^ z.wrapping_mul(z) - .wrapping_mul(418_711) - .wrapping_add(z.wrapping_mul(13761))) - & 31; - let r = if snow { snow_tex } else { rain_tex }; - // Columns face the camera horizontally. - let (fx, fz) = (f64::from(x) + 0.5 - camera.x, f64::from(z) + 0.5 - camera.z); - let len = (fx * fx + fz * fz).sqrt().max(1e-3); - let (sx, sz) = ((-fz / len * 0.5) as f32, (fx / len * 0.5) as f32); - let center = glam::Vec3::new(fx as f32, 0.0, fz as f32); - let scroll = if snow { - (time / 512.0 + hash as f32 / 32.0) % 1.0 - } else { - ((time + hash as f32) / 32.0 * (3.0 + (hash % 5) as f32 * 0.25)) % 1.0 - }; - let fade = ((1.0 - d2 / (radius * radius) as f32) * 0.5 + 0.5) * rain; - let a = (fade.clamp(0.0, 1.0) * 255.0) as u32; - let color = a << 24 | 0xFF_FFFF; + let mut random = weather::column_random(x, z); let light = self.world.light(x, top.max(cy), z); - let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8); - let (b, t) = ( - (f64::from(y0) - camera.y) as f32, - (f64::from(y1) - camera.y) as f32, - ); - let vh = r.v1 - r.v0; - let corners = [ - center + glam::Vec3::new(-sx, b, -sz), - center + glam::Vec3::new(sx, b, sz), - center + glam::Vec3::new(sx, t, sz), - center + glam::Vec3::new(-sx, t, -sz), - ]; - // The rain texture is a vertical strip; sample a scrolling window of it. - let s0 = scroll * 0.75; - let uv0 = r.v0 + vh * s0; - let uv1 = r.v0 + vh * (s0 + 0.25); - let uvs = [[r.u0, uv1], [r.u1, uv1], [r.u1, uv0], [r.u0, uv0]]; - for (p, uv) in corners.iter().zip(uvs) { - out.push(Vertex { - normal: [0; 4], - pos: p.to_array(), - uv, - layer: 0, - color, - light: packed, - }); + let coords = i32::from(light & 15) << 4 | i32::from(light >> 4) << 20; + if snow { + columns.1.push(weather::snow_column( + &mut random, + ticks, + x, + y0, + y1, + z, + coords, + partial, + )); + } else { + columns.0.push(weather::rain_column( + &mut random, + ticks, + x, + y0, + y1, + z, + coords, + partial, + )); } } } + let rain = columns.0.iter().map(|c| (c, 1.0, rain_tex)); + let snow = columns.1.iter().map(|c| (c, 0.8, snow_tex)); + for (column, max_alpha, r) in rain.chain(snow) { + let quad = weather::column_quad(column, eye, max_alpha, radius, intensity); + let color = quad[0].color; + let lc = quad[0].light_coords; + let light = ((lc >> 20 & 15) * 16) as u32 | (((lc >> 4 & 15) * 16) as u32) << 8; + weather::tile(&quad, |pos, uvs| { + for (p, [u, v]) in pos.into_iter().zip(uvs) { + out.push(Vertex { + normal: [0; 4], + pos: p, + uv: [r.u0 + (r.u1 - r.u0) * u, r.v0 + (r.v1 - r.v0) * v], + layer: 0, + color, + light, + }); + } + }); + } } /// Player.startSleepInBed: night or thunder, no monsters within 8 blocks; /// the bed becomes the respawn point either way. diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index e5c753c09..044ee3304 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -130,6 +130,7 @@ pub mod title; pub mod ui; pub mod ui_theme; pub mod vanillagen; +pub mod weather; pub mod widgets; pub mod window; pub mod world; diff --git a/crates/horizon-client/src/weather.rs b/crates/horizon-client/src/weather.rs new file mode 100644 index 000000000..71892686c --- /dev/null +++ b/crates/horizon-client/src/weather.rs @@ -0,0 +1,273 @@ +//! Rain and snow columns around the camera (`WeatherEffectRenderer`). +//! +//! Vanilla draws each column as one camera-facing quad whose texture +//! coordinates run past 0..1 (`v` advances a quarter of the texture per block, +//! so `rain.png` repeats every 4 blocks) and relies on a repeating sampler. +//! Horizon samples the sprite from its atlas, so [`tile`] splits a quad at +//! every whole texture repeat into pieces that stay inside the sprite. +use horizon_core::random::{LegacyRandom, RandomSource}; + +/// `WeatherEffectRenderer.ColumnInstance`. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Column { + pub x: i32, + pub z: i32, + pub bottom_y: i32, + pub top_y: i32, + pub u_offset: f32, + pub v_offset: f32, + /// Vanilla packed light (`LightCoordsUtil.pack`: block << 4 | sky << 20). + pub light_coords: i32, +} + +/// One vertex of a column quad, in vanilla's emission order. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct ColumnVertex { + /// Camera-relative position. + pub pos: [f32; 3], + /// Texture coordinates before wrapping (the sampler repeats). + pub uv: [f32; 2], + /// ARGB (`ARGB.white(alpha)`). + pub color: u32, + pub light_coords: i32, +} + +/// The random seed of a column (`extractRenderState`). +pub fn column_seed(x: i32, z: i32) -> i32 { + (x.wrapping_mul(x) + .wrapping_mul(3121) + .wrapping_add(x.wrapping_mul(45_238_971))) + ^ (z.wrapping_mul(z) + .wrapping_mul(418_711) + .wrapping_add(z.wrapping_mul(13761))) +} + +/// The column's random source, seeded as `random.setSeed(seed)`. +pub fn column_random(x: i32, z: i32) -> LegacyRandom { + LegacyRandom::new(i64::from(column_seed(x, z))) +} + +/// `createRainColumnInstance`. +#[allow(clippy::too_many_arguments)] +pub fn rain_column( + random: &mut impl RandomSource, + ticks: i64, + x: i32, + bottom_y: i32, + top_y: i32, + z: i32, + light_coords: i32, + partial: f32, +) -> Column { + let wrapped_ticks = (ticks & 131_071) as i32; + let tick_offset = x + .wrapping_mul(x) + .wrapping_mul(3121) + .wrapping_add(x.wrapping_mul(45_238_971)) + .wrapping_add(z.wrapping_mul(z).wrapping_mul(418_711)) + .wrapping_add(z.wrapping_mul(13761)) + & 0xFF; + let speed = 3.0 + random.next_float(); + let offset = -((wrapped_ticks + tick_offset) as f32 + partial) / 32.0 * speed; + Column { + x, + z, + bottom_y, + top_y, + u_offset: 0.0, + v_offset: offset % 32.0, + light_coords, + } +} + +/// `createSnowColumnInstance`: snow drifts sideways and is brightened. +#[allow(clippy::too_many_arguments)] +pub fn snow_column( + random: &mut impl RandomSource, + ticks: i64, + x: i32, + bottom_y: i32, + top_y: i32, + z: i32, + light_coords: i32, + partial: f32, +) -> Column { + let wrapped_ticks = (ticks & 131_071) as i32; + let time = wrapped_ticks as f32 + partial; + let u = random.next_double(); + let u = (u + f64::from(time * 0.01 * random.next_gaussian() as f32)) as f32; + let v = random.next_double(); + let v = (v + f64::from(time * random.next_gaussian() as f32 * 0.001)) as f32; + let v_offset = -((ticks & 511) as f32 + partial) / 512.0; + let (block, sky) = (light_coords >> 4 & 15, light_coords >> 20 & 15); + Column { + x, + z, + bottom_y, + top_y, + u_offset: u, + v_offset: v_offset + v, + light_coords: ((block * 3 + 15) / 4) << 4 | ((sky * 3 + 15) / 4) << 20, + } +} + +/// The constructor's 32x32 table of horizontal column half-widths, indexed +/// relative to the camera block. The camera's own column divides 0 by 0. +fn column_size(index: usize) -> (f32, f32) { + let delta_x = (index % 32) as f32 - 16.0; + let delta_z = (index / 32) as f32 - 16.0; + let distance = f64::from(delta_x * delta_x + delta_z * delta_z).sqrt() as f32; + (-delta_z / distance, delta_x / distance) +} + +/// `prepareInstances` for one column: rain uses `max_alpha` 1, snow 0.8. +pub fn column_quad( + column: &Column, + camera: [f64; 3], + max_alpha: f32, + radius: i32, + intensity: f32, +) -> [ColumnVertex; 4] { + let radius_sq = (radius * radius) as f32; + let relative_x = (f64::from(column.x) + 0.5 - camera[0]) as f32; + let relative_z = (f64::from(column.z) + 0.5 - camera[2]) as f32; + let distance_sq = relative_x * relative_x + relative_z * relative_z; + let t = (distance_sq / radius_sq).min(1.0); + let alpha = (max_alpha + t * (0.5 - max_alpha)) * intensity; + let color = ((alpha * 255.0).floor() as i32 as u32) << 24 | 0xFF_FFFF; + let index = + (column.z - camera[2].floor() as i32 + 16) * 32 + column.x - camera[0].floor() as i32 + 16; + let (size_x, size_z) = column_size(index as usize); + let (half_x, half_z) = (size_x / 2.0, size_z / 2.0); + let (x0, x1) = (relative_x - half_x, relative_x + half_x); + let y1 = (f64::from(column.top_y) - camera[1]) as f32; + let y0 = (f64::from(column.bottom_y) - camera[1]) as f32; + let (z0, z1) = (relative_z - half_z, relative_z + half_z); + let (u0, u1) = (column.u_offset, column.u_offset + 1.0); + let v0 = column.bottom_y as f32 * 0.25 + column.v_offset; + let v1 = column.top_y as f32 * 0.25 + column.v_offset; + let vertex = |pos, uv| ColumnVertex { + pos, + uv, + color, + light_coords: column.light_coords, + }; + [ + vertex([x0, y1, z0], [u0, v0]), + vertex([x1, y1, z1], [u1, v0]), + vertex([x1, y0, z1], [u1, v1]), + vertex([x0, y0, z0], [u0, v1]), + ] +} + +/// Split a column quad (vertices as [`column_quad`] emits them: top edge +/// `u0..u1` at `v0`, bottom edge at `v1`) at every whole texture repeat. +/// Each piece gets positions on the quad and texture coordinates in `0..=1` +/// of one repeat, ready to map onto an atlas sprite. +pub fn tile(quad: &[ColumnVertex; 4], mut emit: impl FnMut([[f32; 3]; 4], [[f32; 2]; 4])) { + let [u0, v0] = quad[0].uv; + let [u1, v1] = quad[2].uv; + let (top_left, top_right) = (quad[0].pos, quad[1].pos); + let (bottom_right, bottom_left) = (quad[2].pos, quad[3].pos); + let lerp3 = |a: [f32; 3], b: [f32; 3], t: f32| -> [f32; 3] { + std::array::from_fn(|i| a[i] + (b[i] - a[i]) * t) + }; + // Position at fraction s across (u) and t down (v) the quad. + let at = |s: f32, t: f32| { + lerp3( + lerp3(top_left, top_right, s), + lerp3(bottom_left, bottom_right, s), + t, + ) + }; + let cuts = |a: f32, b: f32| { + let mut cuts = vec![a]; + let mut k = a.floor() + 1.0; + while k < b { + cuts.push(k); + k += 1.0; + } + cuts.push(b); + cuts + }; + if !(u1 > u0 && v1 > v0) { + return; + } + let (us, vs) = (cuts(u0, u1), cuts(v0, v1)); + for v in vs.windows(2) { + let repeat_v = v[0].floor(); + let (ta, tb) = ((v[0] - v0) / (v1 - v0), (v[1] - v0) / (v1 - v0)); + let (la, lb) = (v[0] - repeat_v, v[1] - repeat_v); + for u in us.windows(2) { + let repeat_u = u[0].floor(); + let (sa, sb) = ((u[0] - u0) / (u1 - u0), (u[1] - u0) / (u1 - u0)); + let (ka, kb) = (u[0] - repeat_u, u[1] - repeat_u); + emit( + [at(sa, ta), at(sb, ta), at(sb, tb), at(sa, tb)], + [[ka, la], [kb, la], [kb, lb], [ka, lb]], + ); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rain_repeats_every_four_blocks() { + let column = Column { + x: 3, + z: 0, + bottom_y: 60, + top_y: 80, + u_offset: 0.0, + v_offset: 0.0, + light_coords: 15 << 20, + }; + let quad = column_quad(&column, [0.5, 70.0, 0.5], 1.0, 10, 1.0); + // 20 blocks of rain: five repeats of the texture, split at each seam. + let mut pieces = Vec::new(); + tile(&quad, |pos, uv| pieces.push((pos, uv))); + assert_eq!(pieces.len(), 5); + for (pos, uv) in &pieces { + assert!(((pos[0][1] - pos[3][1]) - 4.0).abs() < 1e-4); + assert_eq!(uv[0], [0.0, 0.0]); + assert_eq!(uv[2], [1.0, 1.0]); + } + } + + #[test] + fn snow_drifts_across_one_seam() { + let column = Column { + x: 3, + z: 2, + bottom_y: 64, + top_y: 66, + u_offset: 0.25, + v_offset: 0.0, + light_coords: 0, + }; + let quad = column_quad(&column, [0.5, 70.0, 0.5], 0.8, 10, 1.0); + let mut pieces = Vec::new(); + tile(&quad, |pos, uv| pieces.push((pos, uv))); + assert_eq!(pieces.len(), 2); + assert_eq!(pieces[0].1[0], [0.25, 0.0]); + assert_eq!(pieces[1].1[2], [0.25, 0.5]); + } + + #[test] + fn camera_column_is_degenerate() { + let column = Column { + x: 0, + z: 0, + bottom_y: 60, + top_y: 80, + u_offset: 0.0, + v_offset: 0.0, + light_coords: 0, + }; + let quad = column_quad(&column, [0.5, 70.0, 0.5], 1.0, 10, 1.0); + assert!(quad[0].pos[0].is_nan()); + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaWeatherRenderOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaWeatherRenderOracle.java new file mode 100644 index 000000000..fccd3083e --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaWeatherRenderOracle.java @@ -0,0 +1,87 @@ +package dev.horizonlab.parity; + +import com.mojang.blaze3d.vertex.VertexConsumer; +import java.lang.reflect.Proxy; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import net.minecraft.client.renderer.WeatherEffectRenderer; +import net.minecraft.util.RandomSource; +import net.minecraft.world.phys.Vec3; + +/** Build rain and snow column quads with the shipped renderer, without a GPU or a level. */ +public final class VanillaWeatherRenderOracle { + public static void main(String[] args) throws Exception { + Class unsafeClass = Class.forName("sun.misc.Unsafe"); + var theUnsafe = unsafeClass.getDeclaredField("theUnsafe"); + theUnsafe.setAccessible(true); + Object renderer = unsafeClass.getMethod("allocateInstance", Class.class) + .invoke(theUnsafe.get(null), WeatherEffectRenderer.class); + // The constructor's column table, built the same way before it reaches Minecraft.getInstance(). + float[] sizeX = new float[1024], sizeZ = new float[1024]; + for (int z = 0; z < 32; z++) { + for (int x = 0; x < 32; x++) { + float deltaX = x - 16, deltaZ = z - 16; + float distance = net.minecraft.util.Mth.length(deltaX, deltaZ); + sizeX[z * 32 + x] = -deltaZ / distance; + sizeZ[z * 32 + x] = deltaX / distance; + } + } + for (String name : new String[]{"columnSizeX", "columnSizeZ"}) { + var field = WeatherEffectRenderer.class.getDeclaredField(name); + field.setAccessible(true); + field.set(renderer, name.endsWith("X") ? sizeX : sizeZ); + } + var rain = WeatherEffectRenderer.class.getDeclaredMethod("createRainColumnInstance", + RandomSource.class, long.class, int.class, int.class, int.class, int.class, int.class, float.class); + var snow = WeatherEffectRenderer.class.getDeclaredMethod("createSnowColumnInstance", + RandomSource.class, long.class, int.class, int.class, int.class, int.class, int.class, float.class); + var prepare = WeatherEffectRenderer.class.getDeclaredMethod("prepareInstances", + VertexConsumer.class, List.class, Vec3.class, float.class, int.class, float.class); + rain.setAccessible(true); + snow.setAccessible(true); + prepare.setAccessible(true); + StringBuilder output = new StringBuilder(); + int index = 0; + for (String line : Files.readAllLines(Path.of(args[0]))) { + String[] p = line.split(" "); + int kind = Integer.parseInt(p[0]); + long ticks = Long.parseLong(p[1]); + int x = Integer.parseInt(p[2]), bottom = Integer.parseInt(p[3]), top = Integer.parseInt(p[4]); + int z = Integer.parseInt(p[5]), light = Integer.parseInt(p[6]); + float partial = Float.parseFloat(p[7]); + Vec3 camera = new Vec3(Double.parseDouble(p[8]), Double.parseDouble(p[9]), Double.parseDouble(p[10])); + int radius = Integer.parseInt(p[11]); + float intensity = Float.parseFloat(p[12]); + // extractRenderState: the column random is reseeded per column. + RandomSource random = RandomSource.createThreadLocalInstance(0L); + random.setSeed(x * x * 3121 + x * 45238971 ^ z * z * 418711 + z * 13761); + Object column = (kind == 0 ? rain : snow).invoke(renderer, random, ticks, x, bottom, top, z, light, partial); + var record = (WeatherEffectRenderer.ColumnInstance) column; + output.append(index++).append(' ').append(record.x()).append(' ').append(record.z()).append(' ') + .append(record.bottomY()).append(' ').append(record.topY()).append(' ') + .append(bits(record.uOffset())).append(' ').append(bits(record.vOffset())).append(' ') + .append(record.lightCoords()); + StringBuilder vertices = new StringBuilder(); + VertexConsumer consumer = (VertexConsumer) Proxy.newProxyInstance( + VertexConsumer.class.getClassLoader(), new Class[]{VertexConsumer.class}, (proxy, method, a) -> { + switch (method.getName()) { + case "addVertex" -> vertices.append(" |").append(bits((Float) a[0])).append(',') + .append(bits((Float) a[1])).append(',').append(bits((Float) a[2])); + case "setUv" -> vertices.append(',').append(bits((Float) a[0])).append(',').append(bits((Float) a[1])); + case "setColor" -> vertices.append(',').append(Integer.toHexString((Integer) a[0])); + case "setLight" -> vertices.append(',').append((Integer) a[0]); + default -> throw new IllegalStateException("unexpected " + method); + } + return proxy; + }); + prepare.invoke(renderer, consumer, List.of(column), camera, kind == 0 ? 1.0F : 0.8F, radius, intensity); + output.append(vertices).append('\n'); + } + Files.writeString(Path.of(args[1]), output); + } + + private static String bits(float value) { + return Float.isNaN(value) ? "nan" : Integer.toHexString(Float.floatToRawIntBits(value)); + } +} diff --git a/tools/test_weather_render_parity.py b/tools/test_weather_render_parity.py new file mode 100644 index 000000000..af713ec80 --- /dev/null +++ b/tools/test_weather_render_parity.py @@ -0,0 +1,39 @@ +#!/usr/bin/env python3 +"""Compare rain and snow column instances and quads (positions, texture coordinates, alpha, light) with 26.3.""" +import random + +try: + from . import lab, oracle_harness as harness +except ImportError: + import lab, oracle_harness as harness + + +def make_input(build): + rng = random.Random(71) + cases = [] + for kind in (0, 1): + for ticks in (0, 1, 511, 512, 131071, 131072, 24000 * 37 + 5, 9_000_000_123): + for x, z in ((0, 0), (1, 0), (0, -1), (3, 7), (-10, 10), (10, -10), (-4, -9), (1_000_003, -2_000_011)): + for bottom, top in ((60, 80), (64, 65), (-64, -44), (300, 310)): + light = (rng.randrange(16) << 4) | (rng.randrange(16) << 20) + partial = rng.choice(("0.0", "0.5", "0.999", f"{rng.random():.6f}")) + cam = (x + rng.uniform(-10.5, 10.5), rng.uniform(bottom - 5, top + 5), z + rng.uniform(-10.5, 10.5)) + camera = " ".join(f"{c:.9f}" for c in cam) + radius = rng.choice((3, 5, 10)) + intensity = rng.choice(("1.0", "0.25", f"{rng.random():.6f}")) + cases.append(f"{kind} {ticks} {x} {bottom} {top} {z} {light} {partial} {camera} {radius} {intensity}\n") + # The camera's own column: the size table divides 0 by 0. + cases.append("0 100 5 60 80 5 240 0.0 5.5 70.0 5.5 10 1.0\n") + inputs = build / "inputs.txt" + inputs.write_text("".join(cases)) + return inputs, len(cases) + + +def main(): + harness.differential("weather-render-parity", "VanillaWeatherRenderOracle", "weather_fixture", make_input, + "Rain/snow column instances and quad vertices; not full framebuffer parity.", + sources=[lab.ROOT / "crates/horizon-client/src/weather.rs"]) + + +if __name__ == "__main__": + main()