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()