Skip to main content

webizen_render/wgpu_renderer/
scene_preview.rs

1//! Headless native scene preview rendering (`render_preview_png`, `render_scene_png`, etc.).
2
3#[cfg(not(feature = "qualia"))]
4use super::pipelines::{AmbientUniforms, ScreenVertex};
5#[cfg(not(feature = "qualia"))]
6use super::vegetation_effects;
7use super::{ScreenPoint, WgpuRenderer};
8
9/// Render a placeholder semantic scene headlessly and return raw PNG bytes.
10///
11/// This is **blocking** — it builds a GPU device and drives a synchronous readback
12/// (`device.poll(Wait)`), so it must be called off the UI thread (e.g. a worker
13/// thread or `spawn_blocking`). Intended as the one-call bridge for the native
14/// host until a real `SemanticScene` is wired in. Native-only.
15pub fn render_preview_png(width: u32, height: u32) -> Option<Vec<u8>> {
16    let renderer = pollster::block_on(WgpuRenderer::new_offscreen(width, height)).ok()?;
17    renderer.clear("#101820");
18    // A simple cyan triangle so there is visible, non-trivial content to confirm.
19    let (w, h) = (width as f64, height as f64);
20    renderer.fill_polygon(
21        &[
22            ScreenPoint {
23                x: w * 0.50,
24                y: h * 0.12,
25            },
26            ScreenPoint {
27                x: w * 0.12,
28                y: h * 0.85,
29            },
30            ScreenPoint {
31                x: w * 0.88,
32                y: h * 0.85,
33            },
34        ],
35        "#67e8f9",
36        1.0,
37    );
38    renderer.read_png()
39}
40
41/// Render a RenderScene contract headlessly and return raw PNG bytes.
42///
43/// This is **blocking** — it builds a GPU device and drives a synchronous readback
44/// (`device.poll(Wait)`), so it must be called off the UI thread (e.g. a worker
45/// thread or `spawn_blocking`). Native-only.
46pub fn render_scene_png(
47    scene: &crate::scene_contract::RenderScene,
48    width: u32,
49    height: u32,
50) -> Option<Vec<u8>> {
51    render_scene_png_with_time(scene, width, height, 0.0)
52}
53
54/// Render scene with time parameter for animation effects.
55/// Time is in seconds, used for pulsing/glowing animations.
56pub fn render_scene_png_with_time(
57    scene: &crate::scene_contract::RenderScene,
58    width: u32,
59    height: u32,
60    time_seconds: f64,
61) -> Option<Vec<u8>> {
62    render_scene_png_with_time_and_telemetry(
63        scene,
64        width,
65        height,
66        time_seconds,
67        &crate::scene_contract::SystemTelemetry::default(),
68    )
69}
70
71/// Render scene with time parameter and telemetry for ambient visualization.
72/// Time is in seconds, used for pulsing/glowing animations.
73/// Telemetry drives the ambient particle visualization effects.
74pub fn render_scene_png_with_time_and_telemetry(
75    scene: &crate::scene_contract::RenderScene,
76    width: u32,
77    height: u32,
78    time_seconds: f64,
79    telemetry: &crate::scene_contract::SystemTelemetry,
80) -> Option<Vec<u8>> {
81    #[cfg(feature = "qualia")]
82    {
83        return crate::volumetric::render_scene_png(
84            scene,
85            width,
86            height,
87            time_seconds as f32,
88            telemetry,
89        )
90        .ok();
91    }
92
93    #[cfg(not(feature = "qualia"))]
94    {
95        #[inline]
96        fn lerp(a: f64, b: f64, t: f64) -> f64 {
97            a + (b - a) * t
98        }
99
100        let mut renderer = pollster::block_on(WgpuRenderer::new_offscreen(width, height)).ok()?;
101
102        let (w, h) = (width as f64, height as f64);
103
104        // Clear node positions tracking
105        renderer.clear_node_positions();
106
107        // Build a lookup map for previous positions if transition is active
108        let previous_positions_map: std::collections::HashMap<
109            String,
110            crate::scene_contract::ScenePoint,
111        > = if let Some(ref transition) = scene.transition_state {
112            transition.previous_positions.iter().cloned().collect()
113        } else {
114            std::collections::HashMap::new()
115        };
116
117        // Get transition progress (default to 1.0 if no transition)
118        let transition_progress = scene
119            .transition_state
120            .as_ref()
121            .map(|t| t.progress)
122            .unwrap_or(1.0);
123
124        // Begin single render pass for the entire frame
125        let frame = renderer.begin_frame().ok()?;
126        let frame_view = frame.view();
127
128        // Parse background color
129        let bg_rgba = WgpuRenderer::parse_color(&scene.background, 1.0);
130
131        let mut encoder = renderer
132            .device
133            .create_command_encoder(&etalon::CommandEncoderDescriptor {
134                label: Some("scene-render-encoder"),
135            });
136
137        // Render ambient visualization first (background layer)
138        let ambient_bind_group = if renderer.ambient_config.enabled {
139            if let (
140                Some(ambient_pipeline),
141                Some(particle_buffer),
142                Some(ambient_uniform_buffer),
143                Some(telemetry_buffer),
144            ) = (
145                &renderer.ambient_pipeline,
146                &renderer.particle_buffer,
147                &renderer.ambient_uniform_buffer,
148                &renderer.telemetry_buffer,
149            ) {
150                let uniforms = AmbientUniforms {
151                    time: time_seconds as f32,
152                    view_width: w as f32,
153                    view_height: h as f32,
154                    world_frame: vegetation_effects::WorldFrame::from_time(
155                        time_seconds as f32,
156                        vegetation_effects::DEFAULT_WORLD_SEED,
157                    )
158                    .index,
159                };
160                renderer.queue.write_buffer(
161                    ambient_uniform_buffer,
162                    0,
163                    bytemuck::bytes_of(&uniforms),
164                );
165
166                renderer
167                    .queue
168                    .write_buffer(telemetry_buffer, 0, bytemuck::bytes_of(telemetry));
169
170                Some(
171                    renderer
172                        .device
173                        .create_bind_group(&etalon::BindGroupDescriptor {
174                            label: Some("ambient-bind-group"),
175                            layout: &ambient_pipeline.get_bind_group_layout(0),
176                            entries: &[
177                                etalon::BindGroupEntry {
178                                    binding: 0,
179                                    resource: ambient_uniform_buffer.as_entire_binding(),
180                                },
181                                etalon::BindGroupEntry {
182                                    binding: 1,
183                                    resource: telemetry_buffer.as_entire_binding(),
184                                },
185                                etalon::BindGroupEntry {
186                                    binding: 2,
187                                    resource: particle_buffer.as_entire_binding(),
188                                },
189                            ],
190                        }),
191                )
192            } else {
193                None
194            }
195        } else {
196            None
197        };
198
199        {
200            let mut render_pass = encoder.begin_render_pass(&etalon::RenderPassDescriptor {
201                label: Some("scene-render-pass"),
202                color_attachments: &[Some(etalon::RenderPassColorAttachment {
203                    view: frame_view,
204                    depth_slice: None,
205                    resolve_target: None,
206                    ops: etalon::Operations {
207                        load: etalon::LoadOp::Clear(etalon::Color {
208                            r: bg_rgba[0] as f64,
209                            g: bg_rgba[1] as f64,
210                            b: bg_rgba[2] as f64,
211                            a: bg_rgba[3] as f64,
212                        }),
213                        store: etalon::StoreOp::Store,
214                    },
215                })],
216                depth_stencil_attachment: None,
217                timestamp_writes: None,
218                occlusion_query_set: None,
219                multiview_mask: None,
220            });
221
222            // Render ambient visualization first (background layer)
223            if let Some(ref bind_group) = ambient_bind_group {
224                if let Some(ambient_pipeline) = &renderer.ambient_pipeline {
225                    render_pass.set_pipeline(ambient_pipeline);
226                    render_pass.set_bind_group(0, bind_group, &[]);
227                    render_pass.draw(0..6, 0..renderer.particle_count as u32);
228                }
229            }
230
231            // Render faces (filled polygons) first (background layer)
232            for face in &scene.faces {
233                let vertices: Vec<ScreenPoint> = face
234                    .vertices
235                    .iter()
236                    .map(|v| {
237                        let interpolated = if let Some(ref prev_pos) =
238                            previous_positions_map.get(&format!(
239                                "face_{}",
240                                face.vertices.iter().position(|p| p == v).unwrap_or(0)
241                            )) {
242                            crate::scene_contract::ScenePoint {
243                                x: lerp(prev_pos.x, v.x, transition_progress),
244                                y: lerp(prev_pos.y, v.y, transition_progress),
245                                z: lerp(prev_pos.z, v.z, transition_progress),
246                            }
247                        } else {
248                            *v
249                        };
250                        ScreenPoint {
251                            x: interpolated.x * w,
252                            y: interpolated.y * h,
253                        }
254                    })
255                    .collect();
256
257                let width_px = w as f32;
258                let height_px = h as f32;
259                let clip_vertices: Vec<ScreenVertex> = vertices
260                    .iter()
261                    .map(|p| {
262                        let x = ((p.x as f32 / width_px) * 2.0 - 1.0) * (width_px / height_px);
263                        let y = 1.0 - (p.y as f32 / height_px) * 2.0;
264                        let rgba = WgpuRenderer::parse_color(&face.color, face.alpha);
265                        ScreenVertex {
266                            position: [x, y],
267                            color: rgba,
268                        }
269                    })
270                    .collect();
271
272                if !clip_vertices.is_empty() && clip_vertices.len() <= renderer.max_vertices {
273                    renderer.queue.write_buffer(
274                        &renderer.vertex_buffer,
275                        0,
276                        bytemuck::cast_slice(&clip_vertices),
277                    );
278
279                    if let Some(projector) = &renderer.projector_pipeline {
280                        render_pass.set_pipeline(projector);
281                        render_pass
282                            .set_vertex_buffer(0, renderer.projector_vertex_buffer.slice(..));
283                    } else {
284                        render_pass.set_pipeline(&renderer.render_pipeline);
285                        render_pass.set_vertex_buffer(0, renderer.vertex_buffer.slice(..));
286                    }
287
288                    render_pass.draw(0..clip_vertices.len() as u32, 0..1);
289                }
290            }
291
292            // Render edges (lines)
293            for edge in &scene.edges {
294                let from_interpolated = if let Some(ref prev_pos) =
295                    previous_positions_map.get(&format!("edge_from_{}", edge.from.x))
296                {
297                    crate::scene_contract::ScenePoint {
298                        x: lerp(prev_pos.x, edge.from.x, transition_progress),
299                        y: lerp(prev_pos.y, edge.from.y, transition_progress),
300                        z: lerp(prev_pos.z, edge.from.z, transition_progress),
301                    }
302                } else {
303                    edge.from
304                };
305
306                let to_interpolated = if let Some(ref prev_pos) =
307                    previous_positions_map.get(&format!("edge_to_{}", edge.to.x))
308                {
309                    crate::scene_contract::ScenePoint {
310                        x: lerp(prev_pos.x, edge.to.x, transition_progress),
311                        y: lerp(prev_pos.y, edge.to.y, transition_progress),
312                        z: lerp(prev_pos.z, edge.to.z, transition_progress),
313                    }
314                } else {
315                    edge.to
316                };
317
318                renderer.line(
319                    ScreenPoint {
320                        x: from_interpolated.x * w,
321                        y: from_interpolated.y * h,
322                    },
323                    ScreenPoint {
324                        x: to_interpolated.x * w,
325                        y: to_interpolated.y * h,
326                    },
327                    &edge.color,
328                    edge.width,
329                    edge.alpha,
330                );
331            }
332
333            // Render nodes (vertices) last (foreground layer)
334            for (node_index, node) in scene.nodes.iter().enumerate() {
335                let interpolated_position =
336                    if let Some(ref prev_pos) = previous_positions_map.get(&node.id) {
337                        crate::scene_contract::ScenePoint {
338                            x: lerp(prev_pos.x, node.position.x, transition_progress),
339                            y: lerp(prev_pos.y, node.position.y, transition_progress),
340                            z: lerp(prev_pos.z, node.position.z, transition_progress),
341                        }
342                    } else {
343                        node.position
344                    };
345
346                let is_selected = scene.selected_node_index == Some(node_index);
347                let is_hovered = scene.hovered_node_index == Some(node_index);
348
349                let animated_radius = if node.is_inferencing && node.pulse_rate > 0.0 {
350                    let pulse_phase = 2.0 * std::f64::consts::PI * node.pulse_rate * time_seconds;
351                    let pulse_factor = 1.0 + 0.3 * pulse_phase.sin();
352                    node.radius * pulse_factor.abs()
353                } else {
354                    node.radius
355                };
356
357                let spectral_color = if node.tensor.sigma != 0.0 {
358                    node.tensor.spectral_to_color()
359                } else {
360                    node.color.clone()
361                };
362
363                let (final_radius, final_color) = if is_selected {
364                    (animated_radius * 1.5, "#ffffff".to_string())
365                } else if is_hovered {
366                    (animated_radius * 1.2, "#ffff00".to_string())
367                } else {
368                    (animated_radius, spectral_color)
369                };
370
371                let screen_pos = ScreenPoint {
372                    x: interpolated_position.x * w,
373                    y: interpolated_position.y * h,
374                };
375
376                renderer.point(screen_pos, final_radius, &final_color, node.alpha);
377
378                renderer
379                    .node_positions
380                    .push((node_index, screen_pos, final_radius));
381            }
382        }
383
384        renderer.queue.submit(Some(encoder.finish()));
385        frame.present(&renderer.queue);
386
387        renderer.read_png()
388    }
389}
390
391/// Same as [`render_scene_png`], returned as a `data:image/png;base64,...`
392/// URI for hosts that prefer inline delivery. Blocking; native-only.
393pub fn render_scene_data_uri(
394    scene: &crate::scene_contract::RenderScene,
395    width: u32,
396    height: u32,
397) -> Option<String> {
398    use base64::Engine;
399    let png = render_scene_png(scene, width, height)?;
400    let b64 = base64::engine::general_purpose::STANDARD.encode(png);
401    Some(format!("data:image/png;base64,{b64}"))
402}
403
404/// Same preview as [`render_preview_png`], returned as a `data:image/png;base64,...`
405/// URI for hosts that prefer inline delivery. Blocking; native-only.
406pub fn render_preview_data_uri(width: u32, height: u32) -> Option<String> {
407    use base64::Engine;
408    let png = render_preview_png(width, height)?;
409    let b64 = base64::engine::general_purpose::STANDARD.encode(png);
410    Some(format!("data:image/png;base64,{b64}"))
411}