tawasuyu/llimphi

1//! Demo headless de M6 — **vuelo por dentro del mundo** (cámara libre).
2//!
3//! Complementa a `terrain_demo` (órbita desde afuera): aquí 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        god_rays: 0.0,
44    };
45
46    let inter = hal.device.create_texture(&wgpu::TextureDescriptor {
47        label: Some("inter"),
48        size: wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
49        mip_level_count: 1,
50        sample_count: 1,
51        dimension: wgpu::TextureDimension::D2,
52        format: FMT,
53        usage: wgpu::TextureUsages::STORAGE_BINDING
54            | wgpu::TextureUsages::TEXTURE_BINDING
55            | wgpu::TextureUsages::RENDER_ATTACHMENT
56            | wgpu::TextureUsages::COPY_SRC,
57        view_formats: &[],
58    });
59    let inter_view = inter.create_view(&wgpu::TextureViewDescriptor::default());
60
61    let (dxf, dyf, dzf) = (dim[0] as f32, dim[1] as f32, dim[2] as f32);
62    let half_z = dzf * 0.5;
63
64    // Altura del terreno (en y de MUNDO) sobre una ventana hacia adelante, para
65    // que el vuelo suba por encima de los picos que vienen.
66    let ground_world_y = |gx: f32, gz: f32| -> f32 {
67        let mut hmax = 0u32;
68        let gxi = gx.clamp(0.0, dxf - 1.0) as u32;
69        for dz in 0..16u32 {
70            let gzi = (gz as i32 + dz as i32).clamp(0, dim[2] as i32 - 1) as u32;
71            if let Some(h) = grid.height_at(gxi, gzi) {
72                hmax = hmax.max(h);
73            }
74        }
75        hmax as f32 - dyf * 0.5 // grid y → mundo y (grilla centrada en origen)
76    };
77
78    for i in 0..frames {
79        let t = if frames > 1 { i as f32 / (frames - 1) as f32 } else { 0.0 };
80        // Avanza en +Z (yaw=0 mira +Z); curva suave en X.
81        let pz = (-0.8 + 1.5 * t) * half_z;
82        let px = (t * std::f32::consts::PI).sin() * dxf * 0.18;
83        let gx = px + dxf * 0.5;
84        let gz = pz + dzf * 0.5;
85        let py = ground_world_y(gx, gz) + dyf * 0.16 + 6.0; // despejado sobre el relieve
86        let yaw = (px / dxf) * -0.6; // mira hacia donde curva
87        let camera = Camera3d::fly(Vec3::new(px, py, pz), yaw, -0.12);
88
89        let base = vello::Scene::new();
90        renderer
91            .render_to_view(&hal, &base, &inter_view, W, H, Color::from_rgba8(0, 0, 0, 255))
92            .expect("render base");
93
94        let mut enc = hal
95            .device
96            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("voxel-pass") });
97        vr.render(&hal.device, &hal.queue, &mut enc, &inter_view, (W, H), &camera);
98        hal.queue.submit(std::iter::once(enc.finish()));
99        let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
100
101        let out = format!("/tmp/m6_fly_{i:02}.png");
102        write_png(&hal, &inter, &out);
103        eprintln!("escrito {out} (eye=[{px:.0},{py:.0},{pz:.0}], yaw={:.2})", yaw);
104    }
105}
106
107fn write_png(hal: &Hal, target: &wgpu::Texture, path: &str) {
108    let unpadded = (W * 4) as usize;
109    let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
110    let padded = unpadded.div_ceil(align) * align;
111    let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
112        label: Some("readback"),
113        size: (padded * H as usize) as u64,
114        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
115        mapped_at_creation: false,
116    });
117    let mut enc = hal
118        .device
119        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
120    enc.copy_texture_to_buffer(
121        wgpu::TexelCopyTextureInfo {
122            texture: target,
123            mip_level: 0,
124            origin: wgpu::Origin3d::ZERO,
125            aspect: wgpu::TextureAspect::All,
126        },
127        wgpu::TexelCopyBufferInfo {
128            buffer: &buf,
129            layout: wgpu::TexelCopyBufferLayout {
130                offset: 0,
131                bytes_per_row: Some(padded as u32),
132                rows_per_image: Some(H),
133            },
134        },
135        wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
136    );
137    hal.queue.submit(std::iter::once(enc.finish()));
138    let slice = buf.slice(..);
139    let (tx, rx) = std::sync::mpsc::channel();
140    slice.map_async(wgpu::MapMode::Read, move |r| {
141        let _ = tx.send(r);
142    });
143    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
144    rx.recv().unwrap().unwrap();
145    let data = slice.get_mapped_range();
146    let mut pixels = Vec::with_capacity((W * H * 4) as usize);
147    for row in 0..H as usize {
148        let s = row * padded;
149        pixels.extend_from_slice(&data[s..s + unpadded]);
150    }
151    drop(data);
152    buf.unmap();
153    let file = File::create(path).expect("png");
154    let mut enc = png::Encoder::new(BufWriter::new(file), W, H);
155    enc.set_color(png::ColorType::Rgba);
156    enc.set_depth(png::BitDepth::Eight);
157    let mut w = enc.write_header().unwrap();
158    w.write_image_data(&pixels).unwrap();
159}