tawasuyu/llimphi

1//! Demo headless de M6 — **LOD del horizonte**: más allá de la ventana voxel fina,
2//! una **malla gruesa** del terreno circundante ([`lod_skirt`]) muestra colinas
3//! lejanas en vez de un muro de niebla. Voxel cerca / malla-LOD lejos, compuestos
4//! por el depth compartido de [`Scene3d`].
5//!
6//! Rinde dos PNG para el contraste:
7//! - `/tmp/m6_lod_off.png` — sólo voxels (el terreno se corta en el borde de la
8//!   ventana; la niebla tapa el vacío = "muro").
9//! - `/tmp/m6_lod_on.png`  — voxels + falda LOD (el horizonte sigue con relieve).
10//!
11//! `cargo run -p llimphi-voxel --example terrain_lod --release -- [dim_xz] [seed]`
12
13use std::fs::File;
14use std::io::BufWriter;
15
16use llimphi_3d::glam::Vec3;
17use llimphi_3d::{Atmosphere, Camera3d, Renderer3d, Scene3d, VoxelRenderer};
18use llimphi_hal::{wgpu, Hal};
19use llimphi_raster::peniko::Color;
20use llimphi_raster::{vello, Renderer};
21use llimphi_voxel::{lod_skirt, lod_skirt_pyramid, terrain, LodParams, LodRing};
22
23const W: u32 = 960;
24const H: u32 = 540;
25const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
26
27fn main() {
28    let dim_xz: u32 = std::env::args().nth(1).and_then(|s| s.parse().ok()).unwrap_or(128);
29    let seed: u32 = std::env::args().nth(2).and_then(|s| s.parse().ok()).unwrap_or(1337);
30    let dy: u32 = (dim_xz * 4 / 10).max(48);
31    let dim = [dim_xz, dy, dim_xz];
32
33    let hal = pollster::block_on(Hal::new(None)).expect("hal");
34    let mut renderer = Renderer::new(&hal).expect("renderer");
35
36    // Ventana voxel fina en mundo [0, dim_xz); su centro de mundo es (dim/2, dim/2)
37    // y se renderiza centrada en el origen (rendered = local − dim/2).
38    let grid = terrain(dim, seed);
39    let sun = [0.5, 0.45, 0.32];
40    let atmo = Atmosphere {
41        sky_zenith: [70, 120, 196],
42        sky_horizon: [200, 216, 234],
43        fog_density: 1.1 / dim_xz as f32,
44        god_rays: 0.0,
45    };
46    let mut vr = VoxelRenderer::new(&hal.device, &hal.queue, FMT, &grid);
47    vr.sun_dir = sun;
48    vr.atmosphere = atmo;
49
50    // Falda LOD alrededor: centro = (dim/2, dim/2) en mundo, hueco = la ventana.
51    let center = [dim_xz as i32 / 2, dim_xz as i32 / 2];
52    let p = LodParams {
53        center_xz: center,
54        window_xz: dim_xz,
55        span: dim_xz as i32 * 3, // horizonte a ~3 ventanas de distancia
56        stride: 6,
57        sky_horizon: atmo.sky_horizon,
58        fog_density: atmo.fog_density,
59        sun_dir: sun,
60    };
61    let (verts, indices) = lod_skirt(&p, dim, seed);
62    eprintln!("falda LOD: {} vértices, {} triángulos", verts.len(), indices.len() / 3);
63    let mut skirt = Renderer3d::new(&hal.device, FMT);
64    skirt.set_geometry(&hal.device, &verts, &indices);
65
66    let mut scene = Scene3d::new();
67
68    // Cámara elevada cerca del borde -Z mirando hacia +Z (el horizonte): ve la
69    // ventana fina cerca y, detrás, la falda lejana.
70    let mut hmax = 0u32;
71    for z in (0..dim[2]).step_by(4) {
72        for x in (0..dim[0]).step_by(4) {
73            if let Some(h) = grid.height_at(x, z) {
74                hmax = hmax.max(h);
75            }
76        }
77    }
78    let eye_y = (hmax as f32 - dy as f32 * 0.5) + dy as f32 * 0.30 + 6.0;
79    let camera = Camera3d::fly(Vec3::new(0.0, eye_y, -(dim[2] as f32) * 0.46), 0.0, -0.13);
80
81    // Toma 1: sólo voxels (sin falda) — horizonte = niebla/vacío.
82    let off = render(&hal, &mut renderer, &mut scene, &mut vr, &[], &camera);
83    write_png(&off, "/tmp/m6_lod_off.png");
84    // Toma 2: voxels + falda LOD (un nivel) — horizonte con relieve.
85    let on = render(&hal, &mut renderer, &mut scene, &mut vr, &[&skirt], &camera);
86    write_png(&on, "/tmp/m6_lod_on.png");
87    eprintln!("escritos /tmp/m6_lod_off.png (sin LOD) y /tmp/m6_lod_on.png (con LOD)");
88
89    // --- Un nivel vs PIRÁMIDE multi-nivel, con niebla baja para que se vea hasta
90    // dónde llega cada uno (con la niebla normal el horizonte se taparía igual). El
91    // único nivel se corta a ~3 ventanas; la pirámide llega a ~16.
92    let low_fog = 0.30 / dim_xz as f32;
93    vr.atmosphere = Atmosphere { fog_density: low_fog, ..atmo };
94    // Cámara aérea (alta, mirando hacia abajo) para esta comparación: así el terreno
95    // lejano se despliega en el suelo en vez de apretarse contra la línea del horizonte
96    // — se ve **hasta dónde** llega cada falda.
97    let cam_high = Camera3d::fly(
98        Vec3::new(0.0, eye_y + dy as f32 * 2.2, -(dim[2] as f32) * 0.5),
99        0.0,
100        -0.62,
101    );
102
103    let p_single = LodParams { fog_density: low_fog, ..clone_params(&p) };
104    let (sv, si) = lod_skirt(&p_single, dim, seed);
105    let mut single = Renderer3d::new(&hal.device, FMT);
106    single.set_geometry(&hal.device, &sv, &si);
107    let single_shot = render(&hal, &mut renderer, &mut scene, &mut vr, &[&single], &cam_high);
108    write_png(&single_shot, "/tmp/m6_lod_single.png");
109
110    let rings = [
111        LodRing { stride: 6, span: dim_xz as i32 * 3 },
112        LodRing { stride: 16, span: dim_xz as i32 * 8 },
113        LodRing { stride: 40, span: dim_xz as i32 * 16 },
114    ];
115    let p_pyr = LodParams { fog_density: low_fog, ..clone_params(&p) };
116    let meshes = lod_skirt_pyramid(&p_pyr, dim, seed, &rings);
117    let total_tris: usize = meshes.iter().map(|(_, i)| i.len() / 3).sum();
118    eprintln!("pirámide LOD: {} anillos, {} triángulos a {} voxels de alcance", meshes.len(), total_tris, dim_xz as i32 * 16);
119    let renderers: Vec<Renderer3d> = meshes
120        .iter()
121        .map(|(v, i)| {
122            let mut r = Renderer3d::new(&hal.device, FMT);
123            r.set_geometry(&hal.device, v, i);
124            r
125        })
126        .collect();
127    let refs: Vec<&Renderer3d> = renderers.iter().collect();
128    let pyr_shot = render(&hal, &mut renderer, &mut scene, &mut vr, &refs, &cam_high);
129    write_png(&pyr_shot, "/tmp/m6_lod_pyramid.png");
130    eprintln!("escritos /tmp/m6_lod_single.png (1 nivel) y /tmp/m6_lod_pyramid.png (multi-nivel)");
131}
132
133/// Copia los campos de un [`LodParams`] (no deriva `Clone` a propósito por el
134/// `sun_dir`; aquí lo replicamos para variar sólo la niebla).
135fn clone_params(p: &LodParams) -> LodParams {
136    LodParams {
137        center_xz: p.center_xz,
138        window_xz: p.window_xz,
139        span: p.span,
140        stride: p.stride,
141        sky_horizon: p.sky_horizon,
142        fog_density: p.fog_density,
143        sun_dir: p.sun_dir,
144    }
145}
146
147#[allow(clippy::too_many_arguments)]
148fn render(
149    hal: &Hal,
150    renderer: &mut Renderer,
151    scene: &mut Scene3d,
152    vr: &mut VoxelRenderer,
153    meshes: &[&Renderer3d],
154    camera: &Camera3d,
155) -> Vec<u8> {
156    let inter = hal.device.create_texture(&wgpu::TextureDescriptor {
157        label: Some("inter"),
158        size: wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
159        mip_level_count: 1,
160        sample_count: 1,
161        dimension: wgpu::TextureDimension::D2,
162        format: FMT,
163        usage: wgpu::TextureUsages::STORAGE_BINDING
164            | wgpu::TextureUsages::TEXTURE_BINDING
165            | wgpu::TextureUsages::RENDER_ATTACHMENT
166            | wgpu::TextureUsages::COPY_SRC,
167        view_formats: &[],
168    });
169    let view = inter.create_view(&wgpu::TextureViewDescriptor::default());
170    renderer
171        .render_to_view(hal, &vello::Scene::new(), &view, W, H, Color::from_rgba8(0, 0, 0, 255))
172        .expect("base");
173    let mut enc = hal
174        .device
175        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("lod") });
176    scene.render(&hal.device, &hal.queue, &mut enc, &view, (W, H), camera, Some(vr), meshes);
177    hal.queue.submit(std::iter::once(enc.finish()));
178    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
179    readback(hal, &inter)
180}
181
182fn readback(hal: &Hal, target: &wgpu::Texture) -> Vec<u8> {
183    let unpadded = (W * 4) as usize;
184    let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
185    let padded = unpadded.div_ceil(align) * align;
186    let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
187        label: Some("readback"),
188        size: (padded * H as usize) as u64,
189        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
190        mapped_at_creation: false,
191    });
192    let mut enc = hal
193        .device
194        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
195    enc.copy_texture_to_buffer(
196        wgpu::TexelCopyTextureInfo {
197            texture: target,
198            mip_level: 0,
199            origin: wgpu::Origin3d::ZERO,
200            aspect: wgpu::TextureAspect::All,
201        },
202        wgpu::TexelCopyBufferInfo {
203            buffer: &buf,
204            layout: wgpu::TexelCopyBufferLayout {
205                offset: 0,
206                bytes_per_row: Some(padded as u32),
207                rows_per_image: Some(H),
208            },
209        },
210        wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
211    );
212    hal.queue.submit(std::iter::once(enc.finish()));
213    let slice = buf.slice(..);
214    let (tx, rx) = std::sync::mpsc::channel();
215    slice.map_async(wgpu::MapMode::Read, move |r| {
216        let _ = tx.send(r);
217    });
218    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
219    rx.recv().unwrap().unwrap();
220    let data = slice.get_mapped_range();
221    let mut pixels = Vec::with_capacity((W * H * 4) as usize);
222    for row in 0..H as usize {
223        let s = row * padded;
224        pixels.extend_from_slice(&data[s..s + unpadded]);
225    }
226    drop(data);
227    buf.unmap();
228    pixels
229}
230
231fn write_png(pixels: &[u8], path: &str) {
232    let file = File::create(path).expect("png");
233    let mut enc = png::Encoder::new(BufWriter::new(file), W, H);
234    enc.set_color(png::ColorType::Rgba);
235    enc.set_depth(png::BitDepth::Eight);
236    let mut wtr = enc.write_header().unwrap();
237    wtr.write_image_data(pixels).unwrap();
238}