1#[cfg(not(feature = "qualia"))]
4use super::pipelines::{AmbientUniforms, ScreenVertex};
5#[cfg(not(feature = "qualia"))]
6use super::vegetation_effects;
7use super::{ScreenPoint, WgpuRenderer};
8
9pub 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 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
41pub 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
54pub 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
71pub 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 renderer.clear_node_positions();
106
107 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 let transition_progress = scene
119 .transition_state
120 .as_ref()
121 .map(|t| t.progress)
122 .unwrap_or(1.0);
123
124 let frame = renderer.begin_frame().ok()?;
126 let frame_view = frame.view();
127
128 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 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 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 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 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 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
391pub 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
404pub 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}