tawasuyu/llimphi

1//! Demo headless de M6 — **streaming toroidal**: una ventana voxel acotada que
2//! se desliza por un mundo procedural **ilimitado** ([`WorldStream`]) re-subiendo
3//! a la GPU **sólo la franja de bricks que entra** (no la ventana entera, ni
4//! reconstruyendo el renderer): la textura del brick pool es un **ring buffer**
5//! (`world_brick mod cdim`) y el shader envuelve la celda lógica con un offset de
6//! origen ([`VoxelRenderer::scroll_to`]).
7//!
8//! La cámara se queda quieta en el **centro** de la ventana mirando adelante; lo
9//! que avanza es el **foco de mundo** (`focus_z`), que marcha mucho más allá del
10//! tamaño de la ventana. Cada cuadro [`WorldStream::follow`] reubica la ventana y
11//! `scroll_to` sube sólo la franja → cada PNG es **paisaje nuevo y distinto** sin
12//! "muro" ni repetición, y el reporte muestra que se suben **KiB**, no MiB.
13//!
14//! **Prueba de paridad**: en el último cuadro se compara el render scrolleado
15//! contra un renderer **reconstruido de cero** en ese mismo origen — deben dar
16//! la **misma imagen** (el toroidal no degrada el contenido). Falla con assert si
17//! divergen.
18//!
19//! `cargo run -p llimphi-voxel --example terrain_streaming --release -- [dim_xz] [seed] [frames]`
20//! → escribe /tmp/m6_stream_##.png
21
22use std::fs::File;
23use std::io::BufWriter;
24
25use llimphi_3d::glam::Vec3;
26use llimphi_3d::{Atmosphere, Camera3d, VoxelGrid, VoxelRenderer};
27use llimphi_hal::{wgpu, Hal};
28use llimphi_raster::peniko::Color;
29use llimphi_raster::{vello, Renderer};
30use llimphi_voxel::{fill_terrain_window, WorldStream};
31
32const W: u32 = 960;
33const H: u32 = 540;
34const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
35
36fn main() {
37    let dim_xz: u32 = std::env::args().nth(1).and_then(|s| s.parse().ok()).unwrap_or(160);
38    let seed: u32 = std::env::args().nth(2).and_then(|s| s.parse().ok()).unwrap_or(1337);
39    let frames: u32 = std::env::args().nth(3).and_then(|s| s.parse().ok()).unwrap_or(6);
40    let dy: u32 = (dim_xz * 4 / 10).max(48);
41    let dim = [dim_xz, dy, dim_xz];
42
43    let hal = pollster::block_on(Hal::new(None)).expect("hal");
44    let mut renderer = Renderer::new(&hal).expect("renderer");
45
46    // Ventana de mundo (paso = lado de brick). Centro inicial en mundo (0,0).
47    let step = llimphi_3d::VOXEL_BRICK;
48    let mut stream = WorldStream::new(dim, seed, 0, 0, step);
49
50    // El renderer se construye UNA vez, desde un grid en **mundo (0,0)** (donde
51    // `brick_origin = 0` es consistente con el ring buffer: celda física P ⟺
52    // world_brick ≡ P mod cdim). El primer `scroll_to` lo lleva al origen real
53    // del stream; de ahí en más, sólo franjas.
54    let mut zero = VoxelGrid::new(dim);
55    fill_terrain_window(&mut zero, [0, 0], seed);
56    let mut vr = VoxelRenderer::new(&hal.device, &hal.queue, FMT, &zero);
57    vr.sun_dir = [0.55, 0.5, 0.32];
58    vr.atmosphere = Atmosphere {
59        sky_zenith: [64, 118, 196],
60        sky_horizon: [202, 218, 236],
61        fog_density: 0.7 / dim_xz as f32,
62        god_rays: 0.0,
63    };
64    let (_, total_bricks) = vr.brick_usage();
65    let full_pool_kib = vr.memory_bytes().0 / 1024;
66
67    let inter = make_target(&hal);
68    let inter_view = inter.create_view(&wgpu::TextureViewDescriptor::default());
69
70    let mut last_pixels: Vec<u8> = Vec::new();
71
72    for i in 0..frames {
73        // El foco de mundo marcha en +Z; en pocos cuadros recorre varias ventanas
74        // (cada PNG es mundo nuevo) pero cada paso entra sólo ~¼ de ventana, así
75        // se ve que el scroll sube una **franja**, no el mundo entero.
76        let focus_z = i as i32 * (dim_xz as i32 / 4);
77        stream.follow(0, focus_z);
78        // Streaming toroidal: sube sólo la franja de bricks que entró.
79        let uploaded = vr.scroll_to(&hal.device, &hal.queue, stream.origin_voxel(), stream.grid());
80
81        // Cámara: sobre los picos de la ventana, atrás, mirando +Z hacia abajo.
82        let camera = camera_for(stream.grid(), dim);
83
84        last_pixels = render_to_pixels(&hal, &mut renderer, &inter, &inter_view, &mut vr, &camera);
85        let out = format!("/tmp/m6_stream_{i:02}.png");
86        encode_png(&last_pixels, W, H, &out);
87
88        let [ox, oz] = stream.origin();
89        let (used, _) = vr.brick_usage();
90        eprintln!(
91            "{out} — foco_z={focus_z}, origen=({ox},{oz}), subido {} KiB de {} KiB de ventana ({}/{} bricks vivos)",
92            uploaded / 1024,
93            full_pool_kib,
94            used,
95            total_bricks,
96        );
97    }
98
99    // --- Paridad: el render scrolleado del último cuadro debe coincidir con un
100    // renderer RECONSTRUIDO de cero en ese mismo origen (mismo contenido lógico).
101    let camera = camera_for(stream.grid(), dim);
102
103    let mut fresh = VoxelRenderer::new(&hal.device, &hal.queue, FMT, stream.grid());
104    fresh.sun_dir = vr.sun_dir;
105    fresh.atmosphere = vr.atmosphere;
106    let fresh_pixels = render_to_pixels(&hal, &mut renderer, &inter, &inter_view, &mut fresh, &camera);
107
108    let (max_d, mean_d) = diff(&last_pixels, &fresh_pixels);
109    encode_png(&fresh_pixels, W, H, "/tmp/m6_stream_fresh.png");
110    eprintln!(
111        "PARIDAD scroll-vs-rebuild: max |Δ|={max_d}, media |Δ|={mean_d:.3} (0 = idéntico) → /tmp/m6_stream_fresh.png"
112    );
113    assert!(
114        max_d <= 2,
115        "el streaming toroidal divergió del rebuild (max |Δ|={max_d})"
116    );
117    eprintln!("PARIDAD OK — el toroidal rinde idéntico al rebuild, subiendo sólo la franja.");
118
119    // --- Pool-grow: arrancar con un pool minúsculo (grid vacío) y scrollear a una
120    // ventana densa **lejana** (sin solape → todo entra, sin bulk stale) fuerza al
121    // brick pool a crecer. La paridad vs un rebuild prueba que creció sin huecos.
122    let far = [dim_xz as i32 * 2, 0, dim_xz as i32 * 2]; // brick-aligned, lejos del origen
123    let mut far_grid = VoxelGrid::new(dim);
124    fill_terrain_window(&mut far_grid, [far[0], far[2]], seed);
125
126    let mut tiny = VoxelRenderer::new(&hal.device, &hal.queue, FMT, &VoxelGrid::new(dim));
127    tiny.sun_dir = vr.sun_dir;
128    tiny.atmosphere = vr.atmosphere;
129    let cap0 = tiny.pool_capacity();
130    tiny.scroll_to(&hal.device, &hal.queue, far, &far_grid);
131    let cap1 = tiny.pool_capacity();
132
133    let cam = camera_for(&far_grid, dim);
134    let tiny_px = render_to_pixels(&hal, &mut renderer, &inter, &inter_view, &mut tiny, &cam);
135    let mut far_fresh = VoxelRenderer::new(&hal.device, &hal.queue, FMT, &far_grid);
136    far_fresh.sun_dir = vr.sun_dir;
137    far_fresh.atmosphere = vr.atmosphere;
138    let far_fresh_px = render_to_pixels(&hal, &mut renderer, &inter, &inter_view, &mut far_fresh, &cam);
139    let (gmax, _) = diff(&tiny_px, &far_fresh_px);
140    encode_png(&tiny_px, W, H, "/tmp/m6_stream_grow.png");
141    eprintln!("POOL-GROW: pool {cap0} → {cap1} slots, render vs rebuild max|Δ|={gmax}");
142    assert!(cap1 > cap0, "el pool no creció (arrancó con capacidad suficiente)");
143    assert!(gmax <= 2, "el pool creció con huecos (max|Δ|={gmax})");
144    eprintln!("POOL-GROW OK — el pool creció y la ventana densa quedó completa, sin huecos.");
145
146    // --- Persistencia de ediciones: un pilar magenta editado sobre la columna de
147    // mundo (0,0) debe seguir ahí tras alejarse miles de voxels y volver (el
148    // terreno se regenera desde la semilla, el overlay de `edits` lo re-aplica).
149    let mut s = WorldStream::new(dim, seed, 0, 0, llimphi_3d::VOXEL_BRICK);
150    let (lx0, lz0) = s.world_to_local(0, 0).unwrap();
151    let gh = s.grid().height_at(lx0, lz0).unwrap_or(dim[1] / 2) as i32;
152    // Torre magenta gruesa (5×5) y alta sobre la columna de mundo (0,0): el
153    // terreno nunca pone magenta, así el píxel es inequívocamente la edición.
154    let top = (gh + 22).min(dim[1] as i32 - 1);
155    for wy in (gh + 1)..top {
156        for dx in -2..=2 {
157            for dz in -2..=2 {
158                s.edit(dx, wy, dz, Some([240, 40, 220]));
159            }
160        }
161    }
162    // Cámara apuntada a la torre (mundo centrado en el origen → columna (0,0) cae
163    // en el centro; `y` de mundo = `y` de grilla − dim_y/2).
164    let half_y = dim[1] as f32 * 0.5;
165    let tower_mid = (gh + 11) as f32 - half_y;
166    let pcam = Camera3d {
167        eye: Vec3::new(14.0, tower_mid + 10.0, -(dim[2] as f32) * 0.32),
168        target: Vec3::new(0.0, tower_mid, 0.0),
169        ..Camera3d::default()
170    };
171    // Se reconstruye el renderer desde `s.grid()` en cada toma: acá probamos la
172    // PERSISTENCIA (la edición sobrevive el regen), no el upload incremental (ya
173    // verificado arriba). Subir la torre por scroll caería en bricks "bulk" que el
174    // toroidal no re-sube (asume terreno determinista; la edición rompe eso).
175    let mut render_grid = |g: &VoxelGrid| {
176        let mut r = VoxelRenderer::new(&hal.device, &hal.queue, FMT, g);
177        r.sun_dir = vr.sun_dir;
178        r.atmosphere = vr.atmosphere;
179        render_to_pixels(&hal, &mut renderer, &inter, &inter_view, &mut r, &pcam)
180    };
181    let before = render_grid(s.grid());
182    encode_png(&before, W, H, "/tmp/m6_persist_before.png");
183
184    // Alejarse miles de voxels (el terreno se regenera, la torre sale de ventana)
185    // y volver al origen (se regenera de nuevo + overlay re-aplica la torre).
186    s.follow(4000, 4000);
187    s.follow(0, 0);
188    let after = render_grid(s.grid());
189    encode_png(&after, W, H, "/tmp/m6_persist_after.png");
190
191    // Conteo de píxeles magenta (la torre) en ambas tomas: deben ser ~iguales.
192    // Magenta = rojo y azul ambos claramente por encima del verde (robusto a la
193    // luz coloreada/AO, que baja los valores absolutos pero no esa relación).
194    let magenta = |px: &[u8]| -> u32 {
195        px.chunks_exact(4)
196            .filter(|c| {
197                let (r, g, b) = (c[0] as i32, c[1] as i32, c[2] as i32);
198                r > g + 40 && b > g + 40
199            })
200            .count() as u32
201    };
202    let (mb, ma) = (magenta(&before), magenta(&after));
203    eprintln!("PERSISTENCIA: pilar magenta = {mb} px antes / {ma} px tras alejarse+volver ({} ediciones)", s.edit_count());
204    assert!(mb > 200, "el pilar debería verse antes ({mb} px)");
205    assert!(ma * 100 >= mb * 90, "el pilar se perdió al volver ({mb}→{ma} px)");
206    eprintln!("PERSISTENCIA OK — la edición sobrevivió el regen del streaming.");
207
208    // --- CAS a disco: guardar el blob de ediciones en un archivo nombrado por su
209    // BLAKE3 y recargarlo en un mundo FRESCO (simula reiniciar el programa).
210    let blob = s.export_edits();
211    let addr = blake3::hash(&blob).to_hex();
212    let dir = std::path::Path::new("/tmp/m6_cas");
213    std::fs::create_dir_all(dir).ok();
214    let path = dir.join(format!("{addr}.edits"));
215    std::fs::write(&path, &blob).expect("escribir blob");
216
217    let mut loaded = WorldStream::new(dim, seed, 0, 0, llimphi_3d::VOXEL_BRICK);
218    let from_disk = std::fs::read(&path).expect("leer blob");
219    let n = loaded.import_edits(&from_disk).expect("blob válido");
220    let cas = magenta(&render_grid(loaded.grid()));
221    encode_png(&render_grid(loaded.grid()), W, H, "/tmp/m6_persist_cas.png");
222    eprintln!("CAS A DISCO: {n} ediciones desde {} ({} bytes), torre = {cas} px", path.display(), blob.len());
223    assert!(cas * 100 >= mb * 90, "la torre no se restauró desde disco ({mb}→{cas} px)");
224    eprintln!("CAS OK — las ediciones se restauraron desde un archivo direccionado por BLAKE3.");
225}
226
227/// Cámara de la ventana: posada sobre los **picos** del terreno (muestreo de
228/// alturas), atrás del centro y mirando hacia adelante y abajo — encuadra el
229/// relieve sin importar si el centro cae en agua o en una cima.
230fn camera_for(grid: &VoxelGrid, dim: [u32; 3]) -> Camera3d {
231    let (dx, dy, dz) = (dim[0], dim[1], dim[2]);
232    let mut hmax = 0u32;
233    for z in (0..dz).step_by(4) {
234        for x in (0..dx).step_by(4) {
235            if let Some(h) = grid.height_at(x, z) {
236                hmax = hmax.max(h);
237            }
238        }
239    }
240    let (dyf, dzf) = (dy as f32, dz as f32);
241    let eye_y = (hmax as f32 - dyf * 0.5) + dyf * 0.28 + 8.0;
242    Camera3d::fly(Vec3::new(0.0, eye_y, -dzf * 0.42), 0.0, -0.30)
243}
244
245/// Diferencia entre dos buffers RGBA: `(max abs por canal, media abs)`.
246fn diff(a: &[u8], b: &[u8]) -> (u8, f64) {
247    let mut max = 0u8;
248    let mut sum = 0u64;
249    for (x, y) in a.iter().zip(b.iter()) {
250        let d = x.abs_diff(*y);
251        max = max.max(d);
252        sum += d as u64;
253    }
254    (max, sum as f64 / a.len().max(1) as f64)
255}
256
257fn make_target(hal: &Hal) -> wgpu::Texture {
258    hal.device.create_texture(&wgpu::TextureDescriptor {
259        label: Some("inter"),
260        size: wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
261        mip_level_count: 1,
262        sample_count: 1,
263        dimension: wgpu::TextureDimension::D2,
264        format: FMT,
265        usage: wgpu::TextureUsages::STORAGE_BINDING
266            | wgpu::TextureUsages::TEXTURE_BINDING
267            | wgpu::TextureUsages::RENDER_ATTACHMENT
268            | wgpu::TextureUsages::COPY_SRC,
269        view_formats: &[],
270    })
271}
272
273/// Rinde el voxel renderer a `inter` (sobre un fondo negro de vello) y devuelve
274/// los píxeles RGBA planos.
275fn render_to_pixels(
276    hal: &Hal,
277    renderer: &mut Renderer,
278    inter: &wgpu::Texture,
279    inter_view: &wgpu::TextureView,
280    vr: &mut VoxelRenderer,
281    camera: &Camera3d,
282) -> Vec<u8> {
283    let base = vello::Scene::new();
284    renderer
285        .render_to_view(hal, &base, inter_view, W, H, Color::from_rgba8(0, 0, 0, 255))
286        .expect("render base");
287    let mut enc = hal
288        .device
289        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("voxel-pass") });
290    vr.render(&hal.device, &hal.queue, &mut enc, inter_view, (W, H), camera);
291    hal.queue.submit(std::iter::once(enc.finish()));
292    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
293    readback(hal, inter)
294}
295
296fn readback(hal: &Hal, target: &wgpu::Texture) -> Vec<u8> {
297    let unpadded = (W * 4) as usize;
298    let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
299    let padded = unpadded.div_ceil(align) * align;
300    let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
301        label: Some("readback"),
302        size: (padded * H as usize) as u64,
303        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
304        mapped_at_creation: false,
305    });
306    let mut enc = hal
307        .device
308        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
309    enc.copy_texture_to_buffer(
310        wgpu::TexelCopyTextureInfo {
311            texture: target,
312            mip_level: 0,
313            origin: wgpu::Origin3d::ZERO,
314            aspect: wgpu::TextureAspect::All,
315        },
316        wgpu::TexelCopyBufferInfo {
317            buffer: &buf,
318            layout: wgpu::TexelCopyBufferLayout {
319                offset: 0,
320                bytes_per_row: Some(padded as u32),
321                rows_per_image: Some(H),
322            },
323        },
324        wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
325    );
326    hal.queue.submit(std::iter::once(enc.finish()));
327    let slice = buf.slice(..);
328    let (tx, rx) = std::sync::mpsc::channel();
329    slice.map_async(wgpu::MapMode::Read, move |r| {
330        let _ = tx.send(r);
331    });
332    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
333    rx.recv().unwrap().unwrap();
334    let data = slice.get_mapped_range();
335    let mut pixels = Vec::with_capacity((W * H * 4) as usize);
336    for row in 0..H as usize {
337        let s = row * padded;
338        pixels.extend_from_slice(&data[s..s + unpadded]);
339    }
340    drop(data);
341    buf.unmap();
342    pixels
343}
344
345fn encode_png(pixels: &[u8], w: u32, h: u32, path: &str) {
346    let file = File::create(path).expect("png");
347    let mut enc = png::Encoder::new(BufWriter::new(file), w, h);
348    enc.set_color(png::ColorType::Rgba);
349    enc.set_depth(png::BitDepth::Eight);
350    let mut wtr = enc.write_header().unwrap();
351    wtr.write_image_data(pixels).unwrap();
352}