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