Skip to main content

skenion_runtime/render/
native.rs

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}