tawasuyu/llimphi

1//! Demo headless del **motor 3D general**: voxels + mallas de triángulos en
2//! UNA escena con depth compartido ([`Scene3d`]). Prueba de oclusión mutua: un
3//! cubo-malla y la esfera voxel se **interpenetran** — la esfera asoma por las
4//! caras del cubo. Si el depth NO se compartiera, uno taparía al otro entero;
5//! con `Scene3d` se ve una intersección limpia (cada píxel = lo más cercano,
6//! sea voxel o triángulo).
7//!
8//! `cargo run -p llimphi-3d --example scene_mixed --release -- [out.png] [yaw_deg]`
9
10use std::fs::File;
11use std::io::BufWriter;
12
13use llimphi_3d::glam::{Mat4, Vec3};
14use llimphi_3d::{Camera3d, Renderer3d, Scene3d, VoxelGrid, VoxelRenderer};
15use llimphi_hal::{wgpu, Hal};
16use llimphi_raster::peniko::Color;
17use llimphi_raster::{vello, Renderer};
18
19const W: u32 = 800;
20const H: u32 = 600;
21const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
22const D: u32 = 80;
23
24fn main() {
25    let out = std::env::args().nth(1).unwrap_or_else(|| "/tmp/scene_mixed.png".to_string());
26    let yaw_deg: f32 = std::env::args().nth(2).and_then(|s| s.parse().ok()).unwrap_or(40.0);
27
28    let hal = pollster::block_on(Hal::new(None)).expect("hal");
29    let mut renderer = Renderer::new(&hal).expect("renderer");
30
31    // Voxel: esfera + piso + pilares, centro de la esfera en mundo ≈ (0, 4, 0).
32    let grid = VoxelGrid::demo_scene([D, D, D]);
33    let voxel = VoxelRenderer::new(&hal.device, &hal.queue, FMT, &grid);
34
35    // Malla: cubo coloreado escalado a ~0.45·D, centrado en la esfera → la
36    // esfera (r≈0.3·D) lo atraviesa y asoma por las caras.
37    let mut mesh = Renderer3d::new(&hal.device, FMT);
38    mesh.set_model(Mat4::from_translation(Vec3::new(0.0, 4.0, 0.0)) * Mat4::from_scale(Vec3::splat(0.45 * D as f32)));
39
40    let mut scene = Scene3d::new();
41
42    let inter = hal.device.create_texture(&wgpu::TextureDescriptor {
43        label: Some("inter"),
44        size: wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
45        mip_level_count: 1,
46        sample_count: 1,
47        dimension: wgpu::TextureDimension::D2,
48        format: FMT,
49        usage: wgpu::TextureUsages::STORAGE_BINDING
50            | wgpu::TextureUsages::TEXTURE_BINDING
51            | wgpu::TextureUsages::RENDER_ATTACHMENT
52            | wgpu::TextureUsages::COPY_SRC,
53        view_formats: &[],
54    });
55    let inter_view = inter.create_view(&wgpu::TextureViewDescriptor::default());
56
57    // (1) Fondo vello oscuro.
58    let base = vello::Scene::new();
59    renderer
60        .render_to_view(&hal, &base, &inter_view, W, H, Color::from_rgba8(16, 18, 24, 255))
61        .expect("render base");
62
63    // (2) Escena 3D mixta (voxels + malla, depth compartido).
64    let camera = Camera3d::orbit(
65        Vec3::new(0.0, 4.0, 0.0),
66        yaw_deg.to_radians(),
67        20_f32.to_radians(),
68        D as f32 * 1.7,
69    );
70    let mut enc = hal
71        .device
72        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("scene") });
73    scene.render(&hal.device, &hal.queue, &mut enc, &inter_view, (W, H), &camera, Some(&voxel), &[&mesh]);
74    hal.queue.submit(std::iter::once(enc.finish()));
75    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
76
77    write_png(&hal, &inter, &out);
78    eprintln!("scene_mixed: escrito {out} ({W}x{H}, yaw={yaw_deg}°) — voxel ∩ malla con depth compartido");
79}
80
81fn write_png(hal: &Hal, target: &wgpu::Texture, path: &str) {
82    let unpadded = (W * 4) as usize;
83    let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
84    let padded = unpadded.div_ceil(align) * align;
85    let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
86        label: Some("readback"),
87        size: (padded * H as usize) as u64,
88        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
89        mapped_at_creation: false,
90    });
91    let mut enc = hal
92        .device
93        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
94    enc.copy_texture_to_buffer(
95        wgpu::TexelCopyTextureInfo {
96            texture: target,
97            mip_level: 0,
98            origin: wgpu::Origin3d::ZERO,
99            aspect: wgpu::TextureAspect::All,
100        },
101        wgpu::TexelCopyBufferInfo {
102            buffer: &buf,
103            layout: wgpu::TexelCopyBufferLayout {
104                offset: 0,
105                bytes_per_row: Some(padded as u32),
106                rows_per_image: Some(H),
107            },
108        },
109        wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
110    );
111    hal.queue.submit(std::iter::once(enc.finish()));
112    let slice = buf.slice(..);
113    let (tx, rx) = std::sync::mpsc::channel();
114    slice.map_async(wgpu::MapMode::Read, move |r| {
115        let _ = tx.send(r);
116    });
117    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
118    rx.recv().unwrap().unwrap();
119    let data = slice.get_mapped_range();
120    let mut pixels = Vec::with_capacity((W * H * 4) as usize);
121    for row in 0..H as usize {
122        let s = row * padded;
123        pixels.extend_from_slice(&data[s..s + unpadded]);
124    }
125    drop(data);
126    buf.unmap();
127    let file = File::create(path).expect("png");
128    let mut enc = png::Encoder::new(BufWriter::new(file), W, H);
129    enc.set_color(png::ColorType::Rgba);
130    enc.set_depth(png::BitDepth::Eight);
131    let mut w = enc.write_header().unwrap();
132    w.write_image_data(&pixels).unwrap();
133}