tawasuyu/llimphi

1//! Demo **interactivo** del motor 3D: el mundo voxel (M1-M4) dentro de un
2//! `View` vivo de Llimphi, manejado con el mouse.
3//!
4//! - **Arrastrar** (botón izquierdo): orbita la cámara (yaw/pitch).
5//! - **Rueda**: zoom (acerca/aleja).
6//! - Las 4 entidades de colores orbitan solas (animación por `spawn_periodic`).
7//!
8//! Es el cableado real a una app: el `VoxelRenderer` se compone dentro del
9//! árbol `View<Msg>` por `View::gpu_paint_with` (corre DESPUÉS de la pasada
10//! vello, con `LoadOp::Load`). El renderer se crea perezosamente en la primera
11//! llamada GPU (ahí recién hay `Device`/`Queue`) y se cachea en el Model tras
12//! un `Arc<Mutex<…>>`.
13//!
14//! `cargo run -p llimphi-3d --example voxel_interactivo --release -- [dim]`
15
16use std::sync::{Arc, Mutex};
17use std::time::Duration;
18
19use llimphi_3d::glam::Vec3;
20use llimphi_3d::{Camera3d, Entity3d, VoxelGrid, VoxelRenderer};
21use llimphi_ui::llimphi_hal::{wgpu, Hal};
22use llimphi_ui::llimphi_layout::taffy::prelude::{percent, Size, Style};
23use llimphi_ui::llimphi_layout::LayoutTree;
24use llimphi_ui::llimphi_raster::peniko::Color;
25use llimphi_ui::llimphi_raster::{vello, Renderer};
26use llimphi_ui::{mount, paint_gpu, App, DragPhase, Handle, Modifiers, View, WheelDelta};
27
28const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
29
30#[derive(Clone)]
31enum Msg {
32    Orbit(f32, f32),
33    Zoom(f32),
34    Tick,
35}
36
37struct Model {
38    yaw: f32,
39    pitch: f32,
40    dist: f32,
41    phase: f32,
42    dim: u32,
43    grid: Arc<VoxelGrid>,
44    /// Renderer voxel, creado en la 1ª pintada GPU (necesita el Device).
45    engine: Arc<Mutex<Option<VoxelRenderer>>>,
46}
47
48fn entities_at(phase: f32, dim: u32) -> Vec<Entity3d> {
49    let d = dim as f32;
50    let colors = [[235u8, 70, 70], [70, 220, 110], [90, 130, 250], [240, 200, 60]];
51    (0..4)
52        .map(|k| {
53            let a = phase + k as f32 * std::f32::consts::FRAC_PI_2;
54            let radius = d * 0.42;
55            Entity3d {
56                pos: [
57                    d * 0.5 + a.cos() * radius,
58                    d * (0.45 + 0.12 * (a * 1.3).sin()),
59                    d * 0.5 + a.sin() * radius,
60                ],
61                half: [d * 0.05, d * 0.05, d * 0.05],
62                color: colors[k],
63            }
64        })
65        .collect()
66}
67
68struct VoxelApp;
69
70impl App for VoxelApp {
71    type Model = Model;
72    type Msg = Msg;
73
74    fn title() -> &'static str {
75        "llimphi-3d · motor voxel interactivo"
76    }
77
78    fn initial_size() -> (u32, u32) {
79        (1000, 720)
80    }
81
82    fn init(handle: &Handle<Msg>) -> Model {
83        let dim: u32 = std::env::args().nth(1).and_then(|s| s.parse().ok()).unwrap_or(64);
84        // Anima las entidades a ~30 fps.
85        handle.spawn_periodic(Duration::from_millis(33), || Msg::Tick);
86        Model {
87            yaw: 35_f32.to_radians(),
88            pitch: 30_f32.to_radians(),
89            dist: dim as f32 * 1.7,
90            phase: 0.0,
91            dim,
92            grid: Arc::new(VoxelGrid::demo_scene([dim, dim, dim])),
93            engine: Arc::new(Mutex::new(None)),
94        }
95    }
96
97    fn update(mut model: Model, msg: Msg, _handle: &Handle<Msg>) -> Model {
98        match msg {
99            Msg::Orbit(dx, dy) => {
100                model.yaw -= dx * 0.008;
101                model.pitch += dy * 0.008;
102            }
103            Msg::Zoom(dy) => {
104                // Rueda hacia adelante = acercar (reduce la distancia). El signo
105                // va invertido respecto del delta crudo para que sea natural.
106                let f = (1.0 + dy * 0.1).clamp(0.5, 1.5);
107                let d = model.dim as f32;
108                model.dist = (model.dist * f).clamp(d * 0.5, d * 4.0);
109            }
110            Msg::Tick => {
111                model.phase += 0.035;
112            }
113        }
114        model
115    }
116
117    fn on_wheel(
118        _model: &Model,
119        delta: WheelDelta,
120        _cursor: (f32, f32),
121        _mods: Modifiers,
122    ) -> Option<Msg> {
123        Some(Msg::Zoom(delta.y))
124    }
125
126    fn view(model: &Model) -> View<Msg> {
127        let camera = Camera3d::orbit(Vec3::ZERO, model.yaw, model.pitch, model.dist);
128        let entities = entities_at(model.phase, model.dim);
129        let engine = model.engine.clone();
130        let grid = model.grid.clone();
131
132        let canvas = View::new(Style {
133            size: Size {
134                width: percent(1.0),
135                height: percent(1.0),
136            },
137            ..Default::default()
138        })
139        .gpu_paint_with(move |device, queue, encoder, target, _rect, vp| {
140            let mut guard = engine.lock().unwrap();
141            let er = guard.get_or_insert_with(|| VoxelRenderer::new(device, queue, FMT, &grid));
142            er.entities = entities.clone();
143            er.render(device, queue, encoder, target, vp, &camera);
144        })
145        .draggable(|phase, dx, dy| match phase {
146            DragPhase::Move => Some(Msg::Orbit(dx, dy)),
147            DragPhase::End => None,
148        });
149
150        View::new(Style {
151            size: Size {
152                width: percent(1.0),
153                height: percent(1.0),
154            },
155            ..Default::default()
156        })
157        .children(vec![canvas])
158    }
159}
160
161fn main() {
162    let args: Vec<String> = std::env::args().collect();
163    // Modo verificación headless: monta el MISMO View por el compositor real
164    // (mount → compute → paint_gpu) y vuelca un PNG, sin abrir ventana.
165    if let Some(i) = args.iter().position(|a| a == "--shot") {
166        let out = args
167            .get(i + 1)
168            .cloned()
169            .unwrap_or_else(|| "/tmp/voxel_interactivo.png".to_string());
170        shot(&out);
171        return;
172    }
173    llimphi_ui::run::<VoxelApp>();
174}
175
176/// Render headless del árbol `View` de la app a través del compositor real.
177fn shot(out: &str) {
178    const W: u32 = 1000;
179    const H: u32 = 720;
180    let dim = 64u32;
181    let model = Model {
182        yaw: 35_f32.to_radians(),
183        pitch: 30_f32.to_radians(),
184        dist: dim as f32 * 1.7,
185        phase: 0.6,
186        dim,
187        grid: Arc::new(VoxelGrid::demo_scene([dim, dim, dim])),
188        engine: Arc::new(Mutex::new(None)),
189    };
190
191    // Árbol real de la app → mount + layout (igual que el runtime por frame).
192    let view = VoxelApp::view(&model);
193    let mut layout = LayoutTree::new();
194    let mounted = mount(&mut layout, view);
195    let computed = layout
196        .compute(mounted.root, (W as f32, H as f32))
197        .expect("layout");
198
199    let hal = pollster::block_on(Hal::new(None)).expect("hal");
200    let mut renderer = Renderer::new(&hal).expect("renderer");
201    let inter = hal.device.create_texture(&wgpu::TextureDescriptor {
202        label: Some("inter"),
203        size: wgpu::Extent3d {
204            width: W,
205            height: H,
206            depth_or_array_layers: 1,
207        },
208        mip_level_count: 1,
209        sample_count: 1,
210        dimension: wgpu::TextureDimension::D2,
211        format: FMT,
212        usage: wgpu::TextureUsages::STORAGE_BINDING
213            | wgpu::TextureUsages::TEXTURE_BINDING
214            | wgpu::TextureUsages::RENDER_ATTACHMENT
215            | wgpu::TextureUsages::COPY_SRC,
216        view_formats: &[],
217    });
218    let inter_view = inter.create_view(&wgpu::TextureViewDescriptor::default());
219
220    // Pasada vello base (fondo) — igual que el frame real.
221    renderer
222        .render_to_view(&hal, &vello::Scene::new(), &inter_view, W, H, Color::from_rgba8(18, 22, 32, 255))
223        .expect("base");
224
225    // Pasada GPU directo: dispara los gpu_painter del árbol (nuestro voxel).
226    let mut enc = hal
227        .device
228        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("gpu") });
229    let any = paint_gpu(&mounted, &computed, &hal.device, &hal.queue, &mut enc, &inter_view, (W, H));
230    hal.queue.submit(std::iter::once(enc.finish()));
231    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
232    assert!(any, "ningún gpu_painter corrió — el cableado no llegó al compositor");
233
234    write_png(&hal, &inter, W, H, out);
235    eprintln!("voxel_interactivo --shot: {out} ({W}x{H}) — gpu_painter del View ejecutado por el compositor");
236}
237
238fn write_png(hal: &Hal, target: &wgpu::Texture, w: u32, h: u32, path: &str) {
239    use std::fs::File;
240    use std::io::BufWriter;
241    let unpadded = (w * 4) as usize;
242    let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
243    let padded = unpadded.div_ceil(align) * align;
244    let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
245        label: Some("readback"),
246        size: (padded * h as usize) as u64,
247        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
248        mapped_at_creation: false,
249    });
250    let mut enc = hal
251        .device
252        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
253    enc.copy_texture_to_buffer(
254        wgpu::TexelCopyTextureInfo {
255            texture: target,
256            mip_level: 0,
257            origin: wgpu::Origin3d::ZERO,
258            aspect: wgpu::TextureAspect::All,
259        },
260        wgpu::TexelCopyBufferInfo {
261            buffer: &buf,
262            layout: wgpu::TexelCopyBufferLayout {
263                offset: 0,
264                bytes_per_row: Some(padded as u32),
265                rows_per_image: Some(h),
266            },
267        },
268        wgpu::Extent3d {
269            width: w,
270            height: h,
271            depth_or_array_layers: 1,
272        },
273    );
274    hal.queue.submit(std::iter::once(enc.finish()));
275    let slice = buf.slice(..);
276    let (tx, rx) = std::sync::mpsc::channel();
277    slice.map_async(wgpu::MapMode::Read, move |r| {
278        let _ = tx.send(r);
279    });
280    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
281    rx.recv().unwrap().unwrap();
282    let data = slice.get_mapped_range();
283    let mut pixels = Vec::with_capacity((w * h * 4) as usize);
284    for row in 0..h as usize {
285        let s = row * padded;
286        pixels.extend_from_slice(&data[s..s + unpadded]);
287    }
288    drop(data);
289    buf.unmap();
290    let file = File::create(path).expect("png");
291    let mut penc = png::Encoder::new(BufWriter::new(file), w, h);
292    penc.set_color(png::ColorType::Rgba);
293    penc.set_depth(png::BitDepth::Eight);
294    let mut wr = penc.write_header().unwrap();
295    wr.write_image_data(&pixels).unwrap();
296}