tawasuyu/llimphi

1//! Demo "hero" de M6 — **el mundo completo**: un vuelo por un mundo procedural
2//! **ilimitado** que combina las dos mitades del frente de streaming:
3//!
4//! - **Streaming toroidal** ([`WorldStream`] + `VoxelRenderer::scroll_to`): la
5//!   ventana voxel fina se desliza siguiendo a la cámara, re-subiendo sólo la
6//!   franja que entra (mundo sin fin, sin muro ni repetición).
7//! - **LOD del horizonte** ([`lod_skirt`]): una malla gruesa del terreno
8//!   circundante, regenerada al recentrar, hace que más allá de la ventana fina
9//!   se vean colinas lejanas (compuesta con los voxels por el depth de
10//!   [`Scene3d`]).
11//!
12//! La cámara queda en el centro de la ventana mirando hacia el relieve que viene;
13//! lo que avanza es el foco de mundo. Cada PNG es terreno nuevo, siempre con
14//! horizonte.
15//!
16//! `cargo run -p llimphi-voxel --example terrain_world --release -- [dim_xz] [seed] [frames]`
17//! → /tmp/m6_world_##.png
18
19use std::fs::File;
20use std::io::BufWriter;
21
22use llimphi_3d::glam::Vec3;
23use llimphi_3d::{Atmosphere, Camera3d, Renderer3d, Scene3d, VoxelGrid, VoxelRenderer};
24use llimphi_hal::{wgpu, Hal};
25use llimphi_raster::peniko::Color;
26use llimphi_raster::{vello, Renderer};
27use llimphi_voxel::{fill_terrain_window, lod_skirt, LodParams, WorldStream};
28
29const W: u32 = 960;
30const H: u32 = 540;
31const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
32
33fn main() {
34    let dim_xz: u32 = std::env::args().nth(1).and_then(|s| s.parse().ok()).unwrap_or(160);
35    let seed: u32 = std::env::args().nth(2).and_then(|s| s.parse().ok()).unwrap_or(1337);
36    let frames: u32 = std::env::args().nth(3).and_then(|s| s.parse().ok()).unwrap_or(6);
37    let dy: u32 = (dim_xz * 4 / 10).max(48);
38    let dim = [dim_xz, dy, dim_xz];
39
40    let hal = pollster::block_on(Hal::new(None)).expect("hal");
41    let mut renderer = Renderer::new(&hal).expect("renderer");
42
43    let step = llimphi_3d::VOXEL_BRICK;
44    let mut stream = WorldStream::new(dim, seed, 0, 0, step);
45
46    let sun = [0.55, 0.5, 0.32];
47    let atmo = Atmosphere {
48        sky_zenith: [66, 120, 198],
49        sky_horizon: [202, 218, 236],
50        fog_density: 1.0 / dim_xz as f32,
51        god_rays: 0.0,
52    };
53
54    // Renderer voxel construido UNA vez desde mundo (0,0) (invariante del ring
55    // buffer); el 1er scroll lo lleva al origen del stream.
56    let mut zero = VoxelGrid::new(dim);
57    fill_terrain_window(&mut zero, [0, 0], seed);
58    let mut vr = VoxelRenderer::new(&hal.device, &hal.queue, FMT, &zero);
59    vr.sun_dir = sun;
60    vr.atmosphere = atmo;
61
62    let mut skirt = Renderer3d::new(&hal.device, FMT);
63    let mut scene = Scene3d::new();
64
65    let inter = make_target(&hal);
66    let view = inter.create_view(&wgpu::TextureViewDescriptor::default());
67
68    for i in 0..frames {
69        // El foco marcha en +Z; cada cuadro entra a mundo nuevo.
70        let focus_z = i as i32 * (dim_xz as i32 / 2);
71        stream.follow(0, focus_z);
72        vr.scroll_to(&hal.device, &hal.queue, stream.origin_voxel(), stream.grid());
73
74        // Falda LOD recentrada en la ventana actual (su hueco = la ventana fina).
75        let [ox, oz] = stream.origin();
76        let center = [ox + dim_xz as i32 / 2, oz + dim_xz as i32 / 2];
77        let p = LodParams {
78            center_xz: center,
79            window_xz: dim_xz,
80            span: dim_xz as i32 * 3,
81            stride: 6,
82            sky_horizon: atmo.sky_horizon,
83            fog_density: atmo.fog_density,
84            sun_dir: sun,
85        };
86        let (verts, indices) = lod_skirt(&p, dim, seed);
87        skirt.set_geometry(&hal.device, &verts, &indices);
88
89        // Cámara: en el centro de la ventana, atrás, mirando +Z hacia el horizonte.
90        let mut hmax = 0u32;
91        for z in (0..dim[2]).step_by(4) {
92            for x in (0..dim[0]).step_by(4) {
93                if let Some(h) = stream.grid().height_at(x, z) {
94                    hmax = hmax.max(h);
95                }
96            }
97        }
98        let eye_y = (hmax as f32 - dy as f32 * 0.5) + dy as f32 * 0.22 + 7.0;
99        let camera = Camera3d::fly(Vec3::new(0.0, eye_y, -(dim[2] as f32) * 0.42), 0.0, -0.12);
100
101        // Render base (vello) + escena 3D (voxel fino + falda LOD, depth compartido).
102        renderer
103            .render_to_view(&hal, &vello::Scene::new(), &view, W, H, Color::from_rgba8(0, 0, 0, 255))
104            .expect("base");
105        let mut enc = hal
106            .device
107            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("world") });
108        scene.render(&hal.device, &hal.queue, &mut enc, &view, (W, H), &camera, Some(&vr), &[&skirt]);
109        hal.queue.submit(std::iter::once(enc.finish()));
110        let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
111
112        let out = format!("/tmp/m6_world_{i:02}.png");
113        write_png(&readback(&hal, &inter), &out);
114        eprintln!("{out} — foco_z={focus_z}, origen=({ox},{oz}), {} tris de horizonte", indices.len() / 3);
115    }
116}
117
118fn make_target(hal: &Hal) -> wgpu::Texture {
119    hal.device.create_texture(&wgpu::TextureDescriptor {
120        label: Some("inter"),
121        size: wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
122        mip_level_count: 1,
123        sample_count: 1,
124        dimension: wgpu::TextureDimension::D2,
125        format: FMT,
126        usage: wgpu::TextureUsages::STORAGE_BINDING
127            | wgpu::TextureUsages::TEXTURE_BINDING
128            | wgpu::TextureUsages::RENDER_ATTACHMENT
129            | wgpu::TextureUsages::COPY_SRC,
130        view_formats: &[],
131    })
132}
133
134fn readback(hal: &Hal, target: &wgpu::Texture) -> Vec<u8> {
135    let unpadded = (W * 4) as usize;
136    let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
137    let padded = unpadded.div_ceil(align) * align;
138    let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
139        label: Some("readback"),
140        size: (padded * H as usize) as u64,
141        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
142        mapped_at_creation: false,
143    });
144    let mut enc = hal
145        .device
146        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
147    enc.copy_texture_to_buffer(
148        wgpu::TexelCopyTextureInfo {
149            texture: target,
150            mip_level: 0,
151            origin: wgpu::Origin3d::ZERO,
152            aspect: wgpu::TextureAspect::All,
153        },
154        wgpu::TexelCopyBufferInfo {
155            buffer: &buf,
156            layout: wgpu::TexelCopyBufferLayout {
157                offset: 0,
158                bytes_per_row: Some(padded as u32),
159                rows_per_image: Some(H),
160            },
161        },
162        wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
163    );
164    hal.queue.submit(std::iter::once(enc.finish()));
165    let slice = buf.slice(..);
166    let (tx, rx) = std::sync::mpsc::channel();
167    slice.map_async(wgpu::MapMode::Read, move |r| {
168        let _ = tx.send(r);
169    });
170    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
171    rx.recv().unwrap().unwrap();
172    let data = slice.get_mapped_range();
173    let mut pixels = Vec::with_capacity((W * H * 4) as usize);
174    for row in 0..H as usize {
175        let s = row * padded;
176        pixels.extend_from_slice(&data[s..s + unpadded]);
177    }
178    drop(data);
179    buf.unmap();
180    pixels
181}
182
183fn write_png(pixels: &[u8], path: &str) {
184    let file = File::create(path).expect("png");
185    let mut enc = png::Encoder::new(BufWriter::new(file), W, H);
186    enc.set_color(png::ColorType::Rgba);
187    enc.set_depth(png::BitDepth::Eight);
188    let mut wtr = enc.write_header().unwrap();
189    wtr.write_image_data(pixels).unwrap();
190}