1use std::{borrow::Cow, error::Error, num::NonZeroU64, path::PathBuf, sync::Arc, time::Instant};
2
3use serde::Serialize;
4use wgpu::util::DeviceExt;
5use winit::{
6 application::ApplicationHandler,
7 event::WindowEvent,
8 event_loop::{ActiveEventLoop, EventLoop},
9 window::{Window, WindowAttributes, WindowId},
10};
11
12use crate::{
13 PreviewFrameLimit, read_preview_control_state_snapshot,
14 render::{
15 FullscreenShaderScene, PreviewDocument, RenderScene, ShaderUniformBinding,
16 ShaderUniformValue, render_scene_from_preview_document,
17 },
18 telemetry::{
19 PreviewTelemetryWriter, ShaderDiagnostic, ShaderDiagnosticPhase, ShaderDiagnosticSeverity,
20 ShaderDiagnosticSource, unix_ms_timestamp,
21 },
22};
23
24#[derive(Debug, Clone, PartialEq, Serialize)]
25#[serde(rename_all = "camelCase")]
26pub struct GeneratedShaderResponse {
27 pub ok: bool,
28 pub node_id: Option<String>,
29 pub language: Option<String>,
30 pub source: Option<String>,
31 pub source_map: Option<GeneratedShaderSourceMap>,
32 pub diagnostics: Vec<ShaderDiagnostic>,
33}
34
35#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
36#[serde(rename_all = "camelCase")]
37pub struct GeneratedShaderSourceMap {
38 pub user_source_start_line: usize,
39 pub generated_line_offset: usize,
40}
41
42#[derive(Debug, Clone, PartialEq, Eq)]
43pub struct GeneratedShaderSource {
44 pub source: String,
45 pub source_map: GeneratedShaderSourceMap,
46}
47
48pub(crate) fn generated_shader_response_from_preview_document(
49 document: &PreviewDocument,
50) -> GeneratedShaderResponse {
51 match render_scene_from_preview_document(document) {
52 Ok(RenderScene::FullscreenShader(scene)) => {
53 let generated = generated_fullscreen_shader_module_source(&scene);
54 GeneratedShaderResponse {
55 ok: true,
56 node_id: Some(scene.source_node_id),
57 language: Some("wgsl".to_owned()),
58 source: Some(generated.source),
59 source_map: Some(generated.source_map),
60 diagnostics: Vec::new(),
61 }
62 }
63 Ok(RenderScene::ClearColor(_)) => GeneratedShaderResponse {
64 ok: false,
65 node_id: None,
66 language: None,
67 source: None,
68 source_map: None,
69 diagnostics: vec![ShaderDiagnostic::new(
70 ShaderDiagnosticSeverity::Info,
71 ShaderDiagnosticPhase::WgslGeneration,
72 "no-generated-shader",
73 "current render scene does not use a fullscreen shader",
74 ShaderDiagnosticSource::Runtime,
75 )],
76 },
77 Err(error) => GeneratedShaderResponse {
78 ok: false,
79 node_id: None,
80 language: None,
81 source: None,
82 source_map: None,
83 diagnostics: error.shader_diagnostics(),
84 },
85 }
86}
87
88pub fn run_render_preview_document_file(
89 document_path: PathBuf,
90 frame_limit: PreviewFrameLimit,
91 telemetry_path: Option<PathBuf>,
92 control_state_path: Option<PathBuf>,
93) -> Result<(), Box<dyn Error>> {
94 let bytes = std::fs::read(document_path)?;
95 let document = serde_json::from_slice(&bytes)?;
96 run_render_preview_window(document, frame_limit, telemetry_path, control_state_path)
97}
98
99pub(crate) fn run_render_preview_window(
100 mut document: PreviewDocument,
101 frame_limit: PreviewFrameLimit,
102 telemetry_path: Option<PathBuf>,
103 control_state_path: Option<PathBuf>,
104) -> Result<(), Box<dyn Error>> {
105 let event_loop = EventLoop::new()?;
106 let initial_control_revision = if let Some(path) = control_state_path.as_deref() {
107 match read_preview_control_state_snapshot(path) {
108 Ok(Some(snapshot)) => {
109 document.control_state = snapshot.control_state();
110 Some(snapshot.control_revision)
111 }
112 Ok(None) | Err(_) => None,
113 }
114 } else {
115 None
116 };
117 let (scene, scene_error) = match render_scene_from_preview_document(&document) {
118 Ok(scene) => (scene, None),
119 Err(error) => (RenderScene::default(), Some(error.to_string())),
120 };
121 let mut app = NativePreviewApp::new(
122 document,
123 scene,
124 scene_error,
125 frame_limit,
126 telemetry_path,
127 control_state_path,
128 initial_control_revision,
129 );
130 event_loop.run_app(&mut app)?;
131 Ok(())
132}
133
134struct NativePreviewApp {
135 document: PreviewDocument,
136 scene: RenderScene,
137 window: Option<Arc<Window>>,
138 renderer: Option<WgpuPreviewRenderer>,
139 telemetry: Option<PreviewTelemetryWriter>,
140 control_state_path: Option<PathBuf>,
141 control_revision: Option<u64>,
142 frame_index: usize,
143 frame_limit: PreviewFrameLimit,
144 started_at: Instant,
145 last_redraw: Instant,
146}
147
148impl NativePreviewApp {
149 fn new(
150 document: PreviewDocument,
151 scene: RenderScene,
152 scene_error: Option<String>,
153 frame_limit: PreviewFrameLimit,
154 telemetry_path: Option<PathBuf>,
155 control_state_path: Option<PathBuf>,
156 control_revision: Option<u64>,
157 ) -> Self {
158 let mut telemetry = telemetry_path.map(|path| {
159 PreviewTelemetryWriter::new(
160 path,
161 document.graph.id.clone(),
162 document.graph.revision.clone(),
163 document.session_revision,
164 scene.renderer_label(),
165 "wgpu",
166 scene.source_node_id(),
167 )
168 });
169 if let (Some(control_revision), Some(telemetry)) = (control_revision, telemetry.as_mut()) {
170 telemetry.record_control_revision(control_revision, unix_ms_timestamp());
171 }
172 if let (Some(error), Some(telemetry)) = (scene_error, telemetry.as_mut()) {
173 telemetry.record_error(error);
174 }
175 Self {
176 document,
177 scene,
178 window: None,
179 renderer: None,
180 telemetry,
181 control_state_path,
182 control_revision,
183 frame_index: 0,
184 frame_limit,
185 started_at: Instant::now(),
186 last_redraw: Instant::now(),
187 }
188 }
189
190 fn title(&self) -> String {
191 let source_node_id = self.scene.source_node_id();
192 let source = source_node_id.as_deref().unwrap_or("default-clear");
193 format!(
194 "Skenion Preview - {} rev {} session {} source {}",
195 self.document.graph.id,
196 self.document.graph.revision,
197 self.document.session_revision,
198 source
199 )
200 }
201
202 fn request_redraw(&self) {
203 if let Some(window) = &self.window {
204 window.request_redraw();
205 }
206 }
207
208 fn should_exit_after_redraw(&self) -> bool {
209 match self.frame_limit {
210 PreviewFrameLimit::Frames(frame_count) => self.frame_index >= frame_count.max(1),
211 PreviewFrameLimit::UntilClose => false,
212 }
213 }
214
215 fn reload_control_state_if_needed(&mut self) {
216 let Some(path) = self.control_state_path.as_deref() else {
217 return;
218 };
219 let snapshot = match read_preview_control_state_snapshot(path) {
220 Ok(Some(snapshot)) => snapshot,
221 Ok(None) => return,
222 Err(error) => {
223 if let Some(telemetry) = &mut self.telemetry {
224 telemetry
225 .record_error(format!("failed to read preview control state: {error}"));
226 }
227 return;
228 }
229 };
230 if self
231 .control_revision
232 .is_some_and(|revision| revision >= snapshot.control_revision)
233 {
234 return;
235 }
236
237 self.document.control_state = snapshot.control_state();
238 match render_scene_from_preview_document(&self.document) {
239 Ok(scene) => {
240 self.scene = scene;
241 self.control_revision = Some(snapshot.control_revision);
242 if let Some(telemetry) = &mut self.telemetry {
243 telemetry
244 .record_control_revision(snapshot.control_revision, snapshot.written_at);
245 }
246 }
247 Err(error) => {
248 if let Some(telemetry) = &mut self.telemetry {
249 telemetry
250 .record_error(format!("failed to apply preview control state: {error}"));
251 }
252 }
253 }
254 }
255}
256
257impl ApplicationHandler for NativePreviewApp {
258 fn resumed(&mut self, event_loop: &ActiveEventLoop) {
259 if self.window.is_some() {
260 return;
261 }
262
263 let attributes = WindowAttributes::default()
264 .with_title(self.title())
265 .with_inner_size(winit::dpi::LogicalSize::new(960.0, 540.0));
266 let window = match event_loop.create_window(attributes) {
267 Ok(window) => Arc::new(window),
268 Err(error) => {
269 eprintln!("failed to create preview window: {error}");
270 if let Some(telemetry) = &mut self.telemetry {
271 telemetry.record_error(format!("failed to create preview window: {error}"));
272 }
273 event_loop.exit();
274 return;
275 }
276 };
277
278 match WgpuPreviewRenderer::new(Arc::clone(&window), &self.scene) {
279 Ok(renderer) => {
280 self.renderer = Some(renderer);
281 self.window = Some(window);
282 self.request_redraw();
283 }
284 Err(error) if matches!(self.scene, RenderScene::FullscreenShader(_)) => {
285 eprintln!("failed to initialize fullscreen shader renderer: {error}");
286 if let Some(telemetry) = &mut self.telemetry {
287 let phase = if error.contains("shader validation failed") {
288 ShaderDiagnosticPhase::WgslCompile
289 } else {
290 ShaderDiagnosticPhase::RenderPipeline
291 };
292 telemetry.record_shader_diagnostic(ShaderDiagnostic::error(
293 phase,
294 "fullscreen-shader-initialization-failed",
295 format!("failed to initialize fullscreen shader renderer: {error}"),
296 ShaderDiagnosticSource::Generated,
297 ));
298 }
299 let fallback_scene = RenderScene::default();
300 match WgpuPreviewRenderer::new(Arc::clone(&window), &fallback_scene) {
301 Ok(renderer) => {
302 self.scene = fallback_scene;
303 self.renderer = Some(renderer);
304 self.window = Some(window);
305 self.request_redraw();
306 }
307 Err(fallback_error) => {
308 eprintln!(
309 "failed to initialize fallback preview renderer: {fallback_error}"
310 );
311 if let Some(telemetry) = &mut self.telemetry {
312 telemetry.record_error(format!(
313 "failed to initialize fallback preview renderer: {fallback_error}"
314 ));
315 }
316 event_loop.exit();
317 }
318 }
319 }
320 Err(error) => {
321 eprintln!("failed to initialize preview renderer: {error}");
322 if let Some(telemetry) = &mut self.telemetry {
323 telemetry
324 .record_error(format!("failed to initialize preview renderer: {error}"));
325 }
326 event_loop.exit();
327 }
328 }
329 }
330
331 fn window_event(
332 &mut self,
333 event_loop: &ActiveEventLoop,
334 window_id: WindowId,
335 event: WindowEvent,
336 ) {
337 let Some(window) = self.window.as_ref().map(Arc::clone) else {
338 return;
339 };
340 if window.id() != window_id {
341 return;
342 }
343
344 match event {
345 WindowEvent::CloseRequested => event_loop.exit(),
346 WindowEvent::Resized(size) => {
347 if let Some(renderer) = &mut self.renderer {
348 renderer.resize(size.width, size.height);
349 }
350 window.request_redraw();
351 }
352 WindowEvent::RedrawRequested => {
353 self.reload_control_state_if_needed();
354 window.set_title(&self.title());
355 let frame_started = Instant::now();
356 if let Some(renderer) = &mut self.renderer
357 && let Err(error) = renderer.render(
358 &self.scene,
359 self.frame_index as u32,
360 self.started_at.elapsed().as_secs_f32(),
361 )
362 {
363 eprintln!("failed to render preview frame: {error}");
364 if let Some(telemetry) = &mut self.telemetry {
365 telemetry.record_error(format!("failed to render preview frame: {error}"));
366 }
367 } else if let Some(telemetry) = &mut self.telemetry {
368 telemetry.record_frame(frame_started.elapsed().as_secs_f64() * 1000.0);
369 }
370 self.frame_index += 1;
371 if self.should_exit_after_redraw() {
372 event_loop.exit();
373 } else {
374 self.last_redraw = Instant::now();
375 window.request_redraw();
376 }
377 }
378 _ => {}
379 }
380 }
381
382 fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
383 if self.last_redraw.elapsed() >= std::time::Duration::from_millis(16) {
384 self.request_redraw();
385 }
386 }
387}
388
389struct WgpuPreviewRenderer {
390 surface: wgpu::Surface<'static>,
391 device: wgpu::Device,
392 queue: wgpu::Queue,
393 config: wgpu::SurfaceConfiguration,
394 mode: WgpuPreviewMode,
395}
396
397enum WgpuPreviewMode {
398 Clear,
399 FullscreenShader {
400 pipeline: wgpu::RenderPipeline,
401 bind_group: wgpu::BindGroup,
402 uniform_buffer: wgpu::Buffer,
403 },
404}
405
406impl WgpuPreviewRenderer {
407 fn new(window: Arc<Window>, scene: &RenderScene) -> Result<Self, String> {
408 let size = window.inner_size();
409 let width = size.width.max(1);
410 let height = size.height.max(1);
411 let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
412 let surface = instance
413 .create_surface(window)
414 .map_err(|error| error.to_string())?;
415 let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
416 power_preference: wgpu::PowerPreference::HighPerformance,
417 compatible_surface: Some(&surface),
418 force_fallback_adapter: false,
419 }))
420 .map_err(|error| error.to_string())?;
421 let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
422 label: Some("skenion-preview-device"),
423 required_features: wgpu::Features::empty(),
424 required_limits: wgpu::Limits::default(),
425 experimental_features: wgpu::ExperimentalFeatures::disabled(),
426 memory_hints: wgpu::MemoryHints::Performance,
427 trace: wgpu::Trace::Off,
428 }))
429 .map_err(|error| error.to_string())?;
430 let config = surface
431 .get_default_config(&adapter, width, height)
432 .ok_or_else(|| "preview surface is not supported by the selected adapter".to_owned())?;
433 surface.configure(&device, &config);
434 let mode = WgpuPreviewMode::new(&device, &config, scene)?;
435
436 Ok(Self {
437 surface,
438 device,
439 queue,
440 config,
441 mode,
442 })
443 }
444
445 fn resize(&mut self, width: u32, height: u32) {
446 let width = width.max(1);
447 let height = height.max(1);
448 if self.config.width == width && self.config.height == height {
449 return;
450 }
451 self.config.width = width;
452 self.config.height = height;
453 self.surface.configure(&self.device, &self.config);
454 }
455
456 fn render(&mut self, scene: &RenderScene, frame_index: u32, time: f32) -> Result<(), String> {
457 let output = match self.surface.get_current_texture() {
458 wgpu::CurrentSurfaceTexture::Success(output)
459 | wgpu::CurrentSurfaceTexture::Suboptimal(output) => output,
460 wgpu::CurrentSurfaceTexture::Outdated | wgpu::CurrentSurfaceTexture::Lost => {
461 self.surface.configure(&self.device, &self.config);
462 match self.surface.get_current_texture() {
463 wgpu::CurrentSurfaceTexture::Success(output)
464 | wgpu::CurrentSurfaceTexture::Suboptimal(output) => output,
465 status => return Err(format!("surface acquisition retry failed: {status:?}")),
466 }
467 }
468 wgpu::CurrentSurfaceTexture::Timeout | wgpu::CurrentSurfaceTexture::Occluded => {
469 return Ok(());
470 }
471 wgpu::CurrentSurfaceTexture::Validation => {
472 return Err("surface acquisition validation error".to_owned());
473 }
474 };
475 let view = output
476 .texture
477 .create_view(&wgpu::TextureViewDescriptor::default());
478 let mut encoder = self
479 .device
480 .create_command_encoder(&wgpu::CommandEncoderDescriptor {
481 label: Some("skenion-preview-render-encoder"),
482 });
483 match &self.mode {
484 WgpuPreviewMode::Clear => {
485 let _render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
486 label: Some("skenion-preview-clear-pass"),
487 color_attachments: &[Some(wgpu::RenderPassColorAttachment {
488 view: &view,
489 depth_slice: None,
490 resolve_target: None,
491 ops: wgpu::Operations {
492 load: wgpu::LoadOp::Clear(wgpu_color(scene.fallback_clear_color())),
493 store: wgpu::StoreOp::Store,
494 },
495 })],
496 depth_stencil_attachment: None,
497 timestamp_writes: None,
498 occlusion_query_set: None,
499 multiview_mask: None,
500 });
501 }
502 WgpuPreviewMode::FullscreenShader {
503 pipeline,
504 bind_group,
505 uniform_buffer,
506 } => {
507 let uniform = SkenionFrameUniform::new(
508 self.config.width,
509 self.config.height,
510 time,
511 frame_index,
512 shader_uniforms(scene),
513 );
514 self.queue.write_buffer(uniform_buffer, 0, &uniform.bytes);
515 let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
516 label: Some("skenion-preview-fullscreen-shader-pass"),
517 color_attachments: &[Some(wgpu::RenderPassColorAttachment {
518 view: &view,
519 depth_slice: None,
520 resolve_target: None,
521 ops: wgpu::Operations {
522 load: wgpu::LoadOp::Clear(wgpu_color(scene.fallback_clear_color())),
523 store: wgpu::StoreOp::Store,
524 },
525 })],
526 depth_stencil_attachment: None,
527 timestamp_writes: None,
528 occlusion_query_set: None,
529 multiview_mask: None,
530 });
531 render_pass.set_pipeline(pipeline);
532 render_pass.set_bind_group(0, bind_group, &[]);
533 render_pass.draw(0..3, 0..1);
534 }
535 }
536 self.queue.submit([encoder.finish()]);
537 output.present();
538 Ok(())
539 }
540}
541
542impl WgpuPreviewMode {
543 fn new(
544 device: &wgpu::Device,
545 config: &wgpu::SurfaceConfiguration,
546 scene: &RenderScene,
547 ) -> Result<Self, String> {
548 match scene {
549 RenderScene::ClearColor(_) => Ok(Self::Clear),
550 RenderScene::FullscreenShader(shader_scene) => {
551 Self::fullscreen_shader(device, config, shader_scene)
552 }
553 }
554 }
555
556 fn fullscreen_shader(
557 device: &wgpu::Device,
558 config: &wgpu::SurfaceConfiguration,
559 shader_scene: &FullscreenShaderScene,
560 ) -> Result<Self, String> {
561 let uniform =
562 SkenionFrameUniform::new(config.width, config.height, 0.0, 0, &shader_scene.uniforms);
563 let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
564 label: Some("skenion-frame-uniform"),
565 contents: &uniform.bytes,
566 usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
567 });
568 let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
569 label: Some("skenion-frame-bind-group-layout"),
570 entries: &[wgpu::BindGroupLayoutEntry {
571 binding: 0,
572 visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
573 ty: wgpu::BindingType::Buffer {
574 ty: wgpu::BufferBindingType::Uniform,
575 has_dynamic_offset: false,
576 min_binding_size: NonZeroU64::new(uniform.bytes.len() as u64),
577 },
578 count: None,
579 }],
580 });
581 let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
582 label: Some("skenion-frame-bind-group"),
583 layout: &bind_group_layout,
584 entries: &[wgpu::BindGroupEntry {
585 binding: 0,
586 resource: uniform_buffer.as_entire_binding(),
587 }],
588 });
589 let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
590 label: Some("skenion-fullscreen-shader-pipeline-layout"),
591 bind_group_layouts: &[Some(&bind_group_layout)],
592 immediate_size: 0,
593 });
594 let shader_error_scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
595 let module_source = fullscreen_shader_module_source(shader_scene);
596 let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
597 label: Some("skenion-fullscreen-shader-module"),
598 source: wgpu::ShaderSource::Wgsl(Cow::Owned(module_source)),
599 });
600 let targets = [Some(wgpu::ColorTargetState {
601 format: config.format,
602 blend: Some(wgpu::BlendState::REPLACE),
603 write_mask: wgpu::ColorWrites::ALL,
604 })];
605 let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
606 label: Some("skenion-fullscreen-shader-pipeline"),
607 layout: Some(&pipeline_layout),
608 vertex: wgpu::VertexState {
609 module: &shader,
610 entry_point: Some("vs_main"),
611 compilation_options: wgpu::PipelineCompilationOptions::default(),
612 buffers: &[],
613 },
614 primitive: wgpu::PrimitiveState {
615 topology: wgpu::PrimitiveTopology::TriangleList,
616 ..Default::default()
617 },
618 depth_stencil: None,
619 multisample: wgpu::MultisampleState::default(),
620 fragment: Some(wgpu::FragmentState {
621 module: &shader,
622 entry_point: Some("fs_main"),
623 compilation_options: wgpu::PipelineCompilationOptions::default(),
624 targets: &targets,
625 }),
626 multiview_mask: None,
627 cache: None,
628 });
629 if let Some(error) = pollster::block_on(shader_error_scope.pop()) {
630 return Err(format!("shader validation failed: {error}"));
631 }
632
633 Ok(Self::FullscreenShader {
634 pipeline,
635 bind_group,
636 uniform_buffer,
637 })
638 }
639}
640
641fn wgpu_color(color: [f64; 4]) -> wgpu::Color {
642 wgpu::Color {
643 r: color[0],
644 g: color[1],
645 b: color[2],
646 a: color[3],
647 }
648}
649
650#[derive(Debug, Clone, PartialEq)]
651struct SkenionFrameUniform {
652 bytes: Vec<u8>,
653}
654
655impl SkenionFrameUniform {
656 fn new(
657 width: u32,
658 height: u32,
659 time: f32,
660 frame: u32,
661 uniforms: &[ShaderUniformBinding],
662 ) -> Self {
663 let mut bytes = Vec::new();
664 write_f32(&mut bytes, 0, width as f32);
665 write_f32(&mut bytes, 4, height as f32);
666 write_f32(&mut bytes, 8, time);
667 write_u32(&mut bytes, 12, frame);
668 let mut offset = 16;
669
670 for uniform in uniforms {
671 let (alignment, size) = uniform_layout(&uniform.value);
672 offset = align_to(offset, alignment);
673 match &uniform.value {
674 ShaderUniformValue::F32(value) => write_f32(&mut bytes, offset, *value),
675 ShaderUniformValue::I32(value) => write_i32(&mut bytes, offset, *value),
676 ShaderUniformValue::U32(value) => write_u32(&mut bytes, offset, *value),
677 ShaderUniformValue::Bool(value) => {
678 write_u32(&mut bytes, offset, u32::from(*value));
679 }
680 ShaderUniformValue::ColorRgba(value) => {
681 for (index, component) in value.iter().enumerate() {
682 write_f32(&mut bytes, offset + index * 4, *component);
683 }
684 }
685 }
686 offset += size;
687 }
688
689 bytes.resize(align_to(offset, 16), 0);
690 Self { bytes }
691 }
692}
693
694fn shader_uniforms(scene: &RenderScene) -> &[ShaderUniformBinding] {
695 match scene {
696 RenderScene::FullscreenShader(shader_scene) => &shader_scene.uniforms,
697 RenderScene::ClearColor(_) => &[],
698 }
699}
700
701fn generated_fullscreen_shader_module_source(
702 shader_scene: &FullscreenShaderScene,
703) -> GeneratedShaderSource {
704 let mut source = String::from(
705 "struct SkenionFrame {\n resolution: vec2<f32>,\n time: f32,\n frame: u32,\n",
706 );
707 for uniform in &shader_scene.uniforms {
708 source.push_str(" ");
709 source.push_str(&uniform.id);
710 source.push_str(": ");
711 source.push_str(wgsl_type(&uniform.value));
712 source.push_str(",\n");
713 }
714 source.push_str("}\n\n@group(0) @binding(0)\nvar<uniform> skenion: SkenionFrame;\n\nfn sk_bool(value: u32) -> bool {\n return value != 0u;\n}\n\nstruct VertexOut {\n @builtin(position) position: vec4<f32>,\n}\n\n@vertex\nfn vs_main(@builtin(vertex_index) vertex_index: u32) -> VertexOut {\n var positions = array<vec2<f32>, 3>(\n vec2<f32>(-1.0, -3.0),\n vec2<f32>(-1.0, 1.0),\n vec2<f32>( 3.0, 1.0)\n );\n\n var out: VertexOut;\n out.position = vec4<f32>(positions[vertex_index], 0.0, 1.0);\n return out;\n}\n\n");
715 let user_source_start_line = source.lines().count() + 1;
716 source.push_str(&shader_scene.source);
717 GeneratedShaderSource {
718 source,
719 source_map: GeneratedShaderSourceMap {
720 user_source_start_line,
721 generated_line_offset: user_source_start_line - 1,
722 },
723 }
724}
725
726fn fullscreen_shader_module_source(shader_scene: &FullscreenShaderScene) -> String {
727 generated_fullscreen_shader_module_source(shader_scene).source
728}
729
730fn wgsl_type(value: &ShaderUniformValue) -> &'static str {
731 match value {
732 ShaderUniformValue::F32(_) => "f32",
733 ShaderUniformValue::I32(_) => "i32",
734 ShaderUniformValue::U32(_) => "u32",
735 ShaderUniformValue::Bool(_) => "u32",
736 ShaderUniformValue::ColorRgba(_) => "vec4<f32>",
737 }
738}
739
740fn uniform_layout(value: &ShaderUniformValue) -> (usize, usize) {
741 match value {
742 ShaderUniformValue::ColorRgba(_) => (16, 16),
743 ShaderUniformValue::F32(_)
744 | ShaderUniformValue::I32(_)
745 | ShaderUniformValue::U32(_)
746 | ShaderUniformValue::Bool(_) => (4, 4),
747 }
748}
749
750fn align_to(value: usize, alignment: usize) -> usize {
751 value.div_ceil(alignment) * alignment
752}
753
754fn write_f32(bytes: &mut Vec<u8>, offset: usize, value: f32) {
755 write_bytes(bytes, offset, &value.to_le_bytes());
756}
757
758fn write_i32(bytes: &mut Vec<u8>, offset: usize, value: i32) {
759 write_bytes(bytes, offset, &value.to_le_bytes());
760}
761
762fn write_u32(bytes: &mut Vec<u8>, offset: usize, value: u32) {
763 write_bytes(bytes, offset, &value.to_le_bytes());
764}
765
766fn write_bytes(bytes: &mut Vec<u8>, offset: usize, value: &[u8]) {
767 let end = offset + value.len();
768 if bytes.len() < end {
769 bytes.resize(end, 0);
770 }
771 bytes[offset..end].copy_from_slice(value);
772}
773
774#[cfg(test)]
775mod tests {
776 use super::*;
777
778 #[test]
779 fn maps_scene_color_to_wgpu_color() {
780 let color = wgpu_color([0.1, 0.2, 0.3, 1.0]);
781
782 assert_eq!(color.r, 0.1);
783 assert_eq!(color.g, 0.2);
784 assert_eq!(color.b, 0.3);
785 assert_eq!(color.a, 1.0);
786 }
787
788 #[test]
789 fn frame_uniform_uses_resolution_time_and_frame() {
790 let uniform = SkenionFrameUniform::new(
791 960,
792 540,
793 1.25,
794 12,
795 &[
796 ShaderUniformBinding {
797 id: "speed".to_owned(),
798 value: ShaderUniformValue::F32(0.75),
799 },
800 ShaderUniformBinding {
801 id: "enabled".to_owned(),
802 value: ShaderUniformValue::Bool(true),
803 },
804 ShaderUniformBinding {
805 id: "iterations".to_owned(),
806 value: ShaderUniformValue::I32(8),
807 },
808 ShaderUniformBinding {
809 id: "tint".to_owned(),
810 value: ShaderUniformValue::ColorRgba([1.0, 0.5, 0.25, 0.8]),
811 },
812 ],
813 );
814
815 assert_eq!(read_f32(&uniform.bytes, 0), 960.0);
816 assert_eq!(read_f32(&uniform.bytes, 4), 540.0);
817 assert_eq!(read_f32(&uniform.bytes, 8), 1.25);
818 assert_eq!(read_u32(&uniform.bytes, 12), 12);
819 assert_eq!(read_f32(&uniform.bytes, 16), 0.75);
820 assert_eq!(read_u32(&uniform.bytes, 20), 1);
821 assert_eq!(read_i32(&uniform.bytes, 24), 8);
822 assert_eq!(read_f32(&uniform.bytes, 32), 1.0);
823 assert_eq!(read_f32(&uniform.bytes, 36), 0.5);
824 assert_eq!(read_f32(&uniform.bytes, 40), 0.25);
825 assert_eq!(read_f32(&uniform.bytes, 44), 0.8);
826 assert_eq!(uniform.bytes.len(), 48);
827 }
828
829 #[test]
830 fn render_scene_reports_renderer_labels() {
831 assert_eq!(RenderScene::default().renderer_label(), "clear-color");
832 assert_eq!(RenderScene::default().source_node_id(), None);
833 }
834
835 #[test]
836 fn generated_shader_module_declares_dynamic_uniforms() {
837 let scene = FullscreenShaderScene {
838 language: crate::render::ShaderLanguage::Wgsl,
839 source: "@fragment\nfn fs_main() -> @location(0) vec4<f32> { return vec4<f32>(1.0); }"
840 .to_owned(),
841 source_node_id: "shader_1".to_owned(),
842 uniforms: vec![
843 ShaderUniformBinding {
844 id: "speed".to_owned(),
845 value: ShaderUniformValue::F32(0.5),
846 },
847 ShaderUniformBinding {
848 id: "enabled".to_owned(),
849 value: ShaderUniformValue::Bool(true),
850 },
851 ],
852 fallback_clear_color: [0.0, 0.0, 0.0, 1.0],
853 };
854
855 let generated = generated_fullscreen_shader_module_source(&scene);
856 let source = generated.source;
857
858 assert!(source.contains("speed: f32"));
859 assert!(source.contains("enabled: u32"));
860 assert!(source.contains("fn sk_bool(value: u32) -> bool"));
861 assert!(source.contains("fn vs_main"));
862 assert!(source.contains("fn fs_main"));
863 assert_eq!(
864 generated.source_map.generated_line_offset + 1,
865 generated.source_map.user_source_start_line
866 );
867 assert!(generated.source_map.user_source_start_line > 1);
868 }
869
870 #[test]
871 fn fullscreen_shader_pipeline_reports_wgsl_validation_errors() {
872 let Some((device, config)) = headless_test_device() else {
873 eprintln!(
874 "skipping WGPU validation diagnostic smoke because no headless adapter is available"
875 );
876 return;
877 };
878 let scene = FullscreenShaderScene {
879 language: crate::render::ShaderLanguage::Wgsl,
880 source: "@fragment\nfn fs_main() -> @location(0) vec4<f32> {\n return vec4<f32>(skenion.missingField, 0.0, 0.0, 1.0);\n}"
881 .to_owned(),
882 source_node_id: "shader_1".to_owned(),
883 uniforms: vec![ShaderUniformBinding {
884 id: "speed".to_owned(),
885 value: ShaderUniformValue::F32(0.5),
886 }],
887 fallback_clear_color: [0.0, 0.0, 0.0, 1.0],
888 };
889
890 let error = match WgpuPreviewMode::fullscreen_shader(&device, &config, &scene) {
891 Ok(_) => panic!("invalid WGSL should fail pipeline validation"),
892 Err(error) => error,
893 };
894
895 assert!(error.contains("shader validation failed"));
896 assert!(error.contains("missingField"));
897 }
898
899 fn headless_test_device() -> Option<(wgpu::Device, wgpu::SurfaceConfiguration)> {
900 let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
901 let adapter =
902 match pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
903 power_preference: wgpu::PowerPreference::LowPower,
904 compatible_surface: None,
905 force_fallback_adapter: false,
906 })) {
907 Ok(adapter) => adapter,
908 Err(error) => {
909 eprintln!("headless wgpu adapter unavailable: {error}");
910 return None;
911 }
912 };
913 let (device, _queue) =
914 match pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
915 label: Some("skenion-preview-test-device"),
916 required_features: wgpu::Features::empty(),
917 required_limits: wgpu::Limits::default(),
918 experimental_features: wgpu::ExperimentalFeatures::disabled(),
919 memory_hints: wgpu::MemoryHints::Performance,
920 trace: wgpu::Trace::Off,
921 })) {
922 Ok(device_and_queue) => device_and_queue,
923 Err(error) => {
924 eprintln!("headless wgpu device unavailable: {error}");
925 return None;
926 }
927 };
928 let rgba_supported = adapter
929 .get_texture_format_features(wgpu::TextureFormat::Rgba8UnormSrgb)
930 .allowed_usages
931 .contains(wgpu::TextureUsages::RENDER_ATTACHMENT);
932 let format = if rgba_supported {
933 wgpu::TextureFormat::Rgba8UnormSrgb
934 } else {
935 wgpu::TextureFormat::Bgra8UnormSrgb
936 };
937
938 Some((
939 device,
940 wgpu::SurfaceConfiguration {
941 usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
942 format,
943 width: 64,
944 height: 64,
945 present_mode: wgpu::PresentMode::AutoVsync,
946 desired_maximum_frame_latency: 2,
947 alpha_mode: wgpu::CompositeAlphaMode::Auto,
948 view_formats: Vec::new(),
949 },
950 ))
951 }
952
953 fn read_f32(bytes: &[u8], offset: usize) -> f32 {
954 f32::from_le_bytes(bytes[offset..offset + 4].try_into().unwrap())
955 }
956
957 fn read_i32(bytes: &[u8], offset: usize) -> i32 {
958 i32::from_le_bytes(bytes[offset..offset + 4].try_into().unwrap())
959 }
960
961 fn read_u32(bytes: &[u8], offset: usize) -> u32 {
962 u32::from_le_bytes(bytes[offset..offset + 4].try_into().unwrap())
963 }
964}