tawasuyu/llimphi

1//! Demo headless de M6 — **vuelo por dentro del mundo** (cámara libre).
2//!
3//! Complementa a `terrain_demo` (órbita desde afuera): acá la [`Camera3d::fly`]
4//! recorre el paisaje procedural a baja altura, siguiendo el relieve
5//! ([`VoxelGrid::height_at`]) para no meterse dentro de la roca, con la misma
6//! atmósfera (cielo + niebla). Es el plano "showreel" del motor y ejercita el
7//! ray-march DDA **desde adentro** de la grilla (no sólo orbitándola).
8//!
9//! `cargo run -p llimphi-3d --example terrain_flythrough --release -- [dim_xz] [seed] [frames]`
10//! → escribe /tmp/m6_fly_##.png
11
12use std::fs::File;
13use std::io::BufWriter;
14
15use llimphi_3d::glam::Vec3;
16use llimphi_3d::{Atmosphere, Camera3d, VoxelRenderer};
17use llimphi_hal::{wgpu, Hal};
18use llimphi_voxel::terrain;
19use llimphi_raster::peniko::Color;
20use llimphi_raster::{vello, Renderer};
21
22const W: u32 = 960;
23const H: u32 = 540;
24const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
25
26fn main() {
27    let dim_xz: u32 = std::env::args().nth(1).and_then(|s| s.parse().ok()).unwrap_or(192);
28    let seed: u32 = std::env::args().nth(2).and_then(|s| s.parse().ok()).unwrap_or(1337);
29    let frames: u32 = std::env::args().nth(3).and_then(|s| s.parse().ok()).unwrap_or(6);
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    let grid = terrain(dim, seed);
37    let mut vr = VoxelRenderer::new(&hal.device, &hal.queue, FMT, &grid);
38    vr.sun_dir = [0.55, 0.5, 0.32];
39    vr.atmosphere = Atmosphere {
40        sky_zenith: [64, 118, 196],
41        sky_horizon: [202, 218, 236],
42        fog_density: 0.9 / dim_xz as f32, // un poco más densa: estamos adentro
43    };
44
45    let inter = hal.device.create_texture(&wgpu::TextureDescriptor {
46        label: Some("inter"),
47        size: wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
48        mip_level_count: 1,
49        sample_count: 1,
50        dimension: wgpu::TextureDimension::D2,
51        format: FMT,
52        usage: wgpu::TextureUsages::STORAGE_BINDING
53            | wgpu::TextureUsages::TEXTURE_BINDING
54            | wgpu::TextureUsages::RENDER_ATTACHMENT
55            | wgpu::TextureUsages::COPY_SRC,
56        view_formats: &[],
57    });
58    let inter_view = inter.create_view(&wgpu::TextureViewDescriptor::default());
59
60    let (dxf, dyf, dzf) = (dim[0] as f32, dim[1] as f32, dim[2] as f32);
61    let half_z = dzf * 0.5;
62
63    // Altura del terreno (en y de MUNDO) sobre una ventana hacia adelante, para
64    // que el vuelo suba por encima de los picos que vienen.
65    let ground_world_y = |gx: f32, gz: f32| -> f32 {
66        let mut hmax = 0u32;
67        let gxi = gx.clamp(0.0, dxf - 1.0) as u32;
68        for dz in 0..16u32 {
69            let gzi = (gz as i32 + dz as i32).clamp(0, dim[2] as i32 - 1) as u32;
70            if let Some(h) = grid.height_at(gxi, gzi) {
71                hmax = hmax.max(h);
72            }
73        }
74        hmax as f32 - dyf * 0.5 // grid y → mundo y (grilla centrada en origen)
75    };
76
77    for i in 0..frames {
78        let t = if frames > 1 { i as f32 / (frames - 1) as f32 } else { 0.0 };
79        // Avanza en +Z (yaw=0 mira +Z); curva suave en X.
80        let pz = (-0.8 + 1.5 * t) * half_z;
81        let px = (t * std::f32::consts::PI).sin() * dxf * 0.18;
82        let gx = px + dxf * 0.5;
83        let gz = pz + dzf * 0.5;
84        let py = ground_world_y(gx, gz) + dyf * 0.16 + 6.0; // despejado sobre el relieve
85        let yaw = (px / dxf) * -0.6; // mira hacia donde curva
86        let camera = Camera3d::fly(Vec3::new(px, py, pz), yaw, -0.12);
87
88        let base = vello::Scene::new();
89        renderer
90            .render_to_view(&hal, &base, &inter_view, W, H, Color::from_rgba8(0, 0, 0, 255))
91            .expect("render base");
92
93        let mut enc = hal
94            .device
95            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("voxel-pass") });
96        vr.render(&hal.device, &hal.queue, &mut enc, &inter_view, (W, H), &camera);
97        hal.queue.submit(std::iter::once(enc.finish()));
98        let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
99
100        let out = format!("/tmp/m6_fly_{i:02}.png");
101        write_png(&hal, &inter, &out);
102        eprintln!("escrito {out} (eye=[{px:.0},{py:.0},{pz:.0}], yaw={:.2})", yaw);
103    }
104}
105
106fn write_png(hal: &Hal, target: &wgpu::Texture, path: &str) {
107    let unpadded = (W * 4) as usize;
108    let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
109    let padded = unpadded.div_ceil(align) * align;
110    let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
111        label: Some("readback"),
112        size: (padded * H as usize) as u64,
113        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
114        mapped_at_creation: false,
115    });
116    let mut enc = hal
117        .device
118        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
119    enc.copy_texture_to_buffer(
120        wgpu::TexelCopyTextureInfo {
121            texture: target,
122            mip_level: 0,
123            origin: wgpu::Origin3d::ZERO,
124            aspect: wgpu::TextureAspect::All,
125        },
126        wgpu::TexelCopyBufferInfo {
127            buffer: &buf,
128            layout: wgpu::TexelCopyBufferLayout {
129                offset: 0,
130                bytes_per_row: Some(padded as u32),
131                rows_per_image: Some(H),
132            },
133        },
134        wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
135    );
136    hal.queue.submit(std::iter::once(enc.finish()));
137    let slice = buf.slice(..);
138    let (tx, rx) = std::sync::mpsc::channel();
139    slice.map_async(wgpu::MapMode::Read, move |r| {
140        let _ = tx.send(r);
141    });
142    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
143    rx.recv().unwrap().unwrap();
144    let data = slice.get_mapped_range();
145    let mut pixels = Vec::with_capacity((W * H * 4) as usize);
146    for row in 0..H as usize {
147        let s = row * padded;
148        pixels.extend_from_slice(&data[s..s + unpadded]);
149    }
150    drop(data);
151    buf.unmap();
152    let file = File::create(path).expect("png");
153    let mut enc = png::Encoder::new(BufWriter::new(file), W, H);
154    enc.set_color(png::ColorType::Rgba);
155    enc.set_depth(png::BitDepth::Eight);
156    let mut w = enc.write_header().unwrap();
157    w.write_image_data(&pixels).unwrap();
158}