tawasuyu/llimphi

1//! Demo headless de los dos primitivos GPU nuevos de Llimphi:
2//!
3//! - **Primitivo A** — disco/círculo relleno con AA por SDF en el shader
4//!   (`GpuBatch::add_disc` / `add_ring` en `llimphi-raster`). Esta demo
5//!   pinta por GPU directo una grilla de *rects instanciados* + una grilla
6//!   de *discos AA* sobre la misma pasada `GpuBatch::flush`.
7//! - **Primitivo B** — over-layer: una escena vello que se rasteriza
8//!   DESPUÉS del pase GPU y se compone con alpha encima (un disco vello
9//!   grande + el rótulo "OVER" que deben quedar SOBRE los rects/discos
10//!   GPU). Replica exactamente el orden que el eventloop de `llimphi-ui`
11//!   aplica para `View::paint_over`: `[vello base] → [GPU] → [vello over]`.
12//!
13//! No abre ventana: compone sobre una textura intermedia `Rgba8Unorm`
14//! (misma mecánica que el frame real) y vuelca el resultado a PNG.
15//!
16//! `cargo run -p llimphi-compositor --example gpu_primitivos_demo --release -- [out.png]`
17
18use std::fs::File;
19use std::io::BufWriter;
20
21use llimphi_hal::{wgpu, Hal, OverlayCompositor};
22use llimphi_raster::gpu::{GpuBatch, GpuPipelines};
23use llimphi_raster::peniko::{Color, Fill};
24use llimphi_raster::{vello, Renderer};
25use llimphi_text::{draw_block, TextBlock, Typesetter};
26use vello::kurbo::{Affine, Circle};
27
28const W: u32 = 720;
29const H: u32 = 480;
30const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
31
32fn main() {
33    let out = std::env::args()
34        .nth(1)
35        .unwrap_or_else(|| "gpu_primitivos_demo.png".to_string());
36
37    let hal = pollster::block_on(Hal::new(None)).expect("hal");
38    let mut renderer = Renderer::new(&hal).expect("renderer");
39    let pipelines = GpuPipelines::new(&hal.device, FMT);
40    let overlay = OverlayCompositor::new(&hal.device);
41
42    // ── Textura intermedia (donde se compone todo) ──────────────────────
43    let inter = make_tex(
44        &hal.device,
45        wgpu::TextureUsages::STORAGE_BINDING
46            | wgpu::TextureUsages::TEXTURE_BINDING
47            | wgpu::TextureUsages::RENDER_ATTACHMENT
48            | wgpu::TextureUsages::COPY_SRC,
49    );
50    let inter_view = inter.create_view(&wgpu::TextureViewDescriptor::default());
51
52    // ── (1) vello base: fondo + rótulo "base vello" ─────────────────────
53    // render_to_view limpia con base_color y escribe todos los píxeles.
54    let mut base = vello::Scene::new();
55    let mut ts = Typesetter::new();
56    draw_label(
57        &mut base,
58        &mut ts,
59        16.0,
60        24.0,
61        "base vello (fondo)",
62        18.0,
63        Color::from_rgba8(120, 130, 150, 255),
64    );
65    renderer
66        .render_to_view(
67            &hal,
68            &base,
69            &inter_view,
70            W,
71            H,
72            Color::from_rgba8(16, 20, 30, 255),
73        )
74        .expect("render base");
75
76    // ── (2) pase GPU directo: grilla de rects + grilla de discos AA ─────
77    // Un solo GpuBatch → un flush con LoadOp::Load (preserva el fondo vello).
78    let mut batch = GpuBatch::new(&pipelines);
79    // Grilla de rects instanciados (mitad izquierda).
80    for j in 0..6 {
81        for i in 0..6 {
82            let x = 40.0 + i as f32 * 46.0;
83            let y = 70.0 + j as f32 * 46.0;
84            let c = Color::from_rgba8(
85                60 + (i * 30) as u8,
86                90 + (j * 24) as u8,
87                200,
88                255,
89            );
90            batch.add_rect(x, y, 36.0, 36.0, c);
91        }
92    }
93    // Grilla de discos AA (mitad derecha) — radios variables para ver el
94    // suavizado del borde a distintas escalas.
95    for j in 0..6 {
96        for i in 0..6 {
97            let cx = 400.0 + i as f32 * 46.0;
98            let cy = 88.0 + j as f32 * 46.0;
99            let r = 8.0 + (i + j) as f32 * 1.4;
100            let c = Color::from_rgba8(
101                240,
102                120 + (i * 18) as u8,
103                60 + (j * 24) as u8,
104                255,
105            );
106            batch.add_disc(cx, cy, r, c);
107        }
108    }
109    // Un anillo grande para ejercitar add_ring (borde interno + externo AA).
110    batch.add_ring(180.0, 380.0, 46.0, 10.0, Color::from_rgba8(120, 240, 200, 255));
111
112    let mut enc = hal
113        .device
114        .create_command_encoder(&wgpu::CommandEncoderDescriptor {
115            label: Some("gpu-prim-pass"),
116        });
117    batch.flush(
118        &hal.device,
119        &hal.queue,
120        &mut enc,
121        &inter_view,
122        (W as f32, H as f32),
123        wgpu::LoadOp::Load,
124    );
125    hal.queue.submit(std::iter::once(enc.finish()));
126    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
127
128    // ── (3) over-layer vello: disco grande + rótulo "OVER" ──────────────
129    // Se rasteriza en una scratch transparente y se compone con alpha
130    // sobre la intermedia DESPUÉS del pase GPU → queda ENCIMA de los
131    // rects/discos GPU. Espejo exacto del camino de redraw.rs.
132    let scratch = make_tex(
133        &hal.device,
134        wgpu::TextureUsages::STORAGE_BINDING
135            | wgpu::TextureUsages::TEXTURE_BINDING
136            | wgpu::TextureUsages::RENDER_ATTACHMENT,
137    );
138    let scratch_view = scratch.create_view(&wgpu::TextureViewDescriptor::default());
139
140    let mut over = vello::Scene::new();
141    // Disco vello grande y semitransparente que se monta SOBRE la grilla
142    // GPU (su centro cae sobre rects y discos a la vez).
143    over.fill(
144        Fill::NonZero,
145        Affine::IDENTITY,
146        Color::from_rgba8(255, 60, 120, 200),
147        None,
148        &Circle::new((300.0, 230.0), 70.0),
149    );
150    draw_label(
151        &mut over,
152        &mut ts,
153        232.0,
154        222.0,
155        "OVER",
156        30.0,
157        Color::from_rgba8(255, 255, 255, 255),
158    );
159    renderer
160        .render_to_view(&hal, &over, &scratch_view, W, H, Color::TRANSPARENT)
161        .expect("render over");
162
163    let mut enc2 = hal
164        .device
165        .create_command_encoder(&wgpu::CommandEncoderDescriptor {
166            label: Some("over-composite"),
167        });
168    overlay.composite(&hal.device, &hal.queue, &mut enc2, &inter_view, &scratch_view);
169    hal.queue.submit(std::iter::once(enc2.finish()));
170    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
171
172    // ── (4) readback → PNG ──────────────────────────────────────────────
173    write_png(&hal, &inter, &out);
174    eprintln!("gpu_primitivos_demo: escrito {out} ({W}x{H})");
175}
176
177fn make_tex(device: &wgpu::Device, usage: wgpu::TextureUsages) -> wgpu::Texture {
178    device.create_texture(&wgpu::TextureDescriptor {
179        label: Some("gpu-prim-tex"),
180        size: wgpu::Extent3d {
181            width: W,
182            height: H,
183            depth_or_array_layers: 1,
184        },
185        mip_level_count: 1,
186        sample_count: 1,
187        dimension: wgpu::TextureDimension::D2,
188        format: FMT,
189        usage,
190        view_formats: &[],
191    })
192}
193
194fn draw_label(
195    scene: &mut vello::Scene,
196    ts: &mut Typesetter,
197    x: f32,
198    y: f32,
199    text: &str,
200    size: f32,
201    color: Color,
202) {
203    // Reusa el typesetter: layout de una línea y blit de glyphs a la escena.
204    let block = TextBlock::simple(text, size, color, (x as f64, y as f64));
205    draw_block(scene, ts, &block);
206}
207
208fn write_png(hal: &Hal, target: &wgpu::Texture, path: &str) {
209    let unpadded = (W * 4) as usize;
210    let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
211    let padded = unpadded.div_ceil(align) * align;
212    let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
213        label: Some("readback"),
214        size: (padded * H as usize) as u64,
215        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
216        mapped_at_creation: false,
217    });
218    let mut enc = hal
219        .device
220        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
221    enc.copy_texture_to_buffer(
222        wgpu::TexelCopyTextureInfo {
223            texture: target,
224            mip_level: 0,
225            origin: wgpu::Origin3d::ZERO,
226            aspect: wgpu::TextureAspect::All,
227        },
228        wgpu::TexelCopyBufferInfo {
229            buffer: &buf,
230            layout: wgpu::TexelCopyBufferLayout {
231                offset: 0,
232                bytes_per_row: Some(padded as u32),
233                rows_per_image: Some(H),
234            },
235        },
236        wgpu::Extent3d {
237            width: W,
238            height: H,
239            depth_or_array_layers: 1,
240        },
241    );
242    hal.queue.submit(std::iter::once(enc.finish()));
243    let slice = buf.slice(..);
244    let (tx, rx) = std::sync::mpsc::channel();
245    slice.map_async(wgpu::MapMode::Read, move |r| {
246        let _ = tx.send(r);
247    });
248    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
249    rx.recv().unwrap().unwrap();
250    let data = slice.get_mapped_range();
251    let mut pixels = Vec::with_capacity((W * H * 4) as usize);
252    for row in 0..H as usize {
253        let s = row * padded;
254        pixels.extend_from_slice(&data[s..s + unpadded]);
255    }
256    drop(data);
257    buf.unmap();
258    let file = File::create(path).expect("png");
259    let mut enc = png::Encoder::new(BufWriter::new(file), W, H);
260    enc.set_color(png::ColorType::Rgba);
261    enc.set_depth(png::BitDepth::Eight);
262    let mut w = enc.write_header().unwrap();
263    w.write_image_data(&pixels).unwrap();
264}