Skip to main content

skenion_runtime/render/
scene.rs

1use serde_json::Value;
2use thiserror::Error;
3
4use crate::render::PreviewDocument;
5use crate::{
6    ControlValue, GraphNode, PortDirection, analyze_shader_interface_v01,
7    convert_control_value_to_data_kind, shader_interface_to_ports_v01,
8    telemetry::{ShaderDiagnostic, ShaderDiagnosticPhase, ShaderDiagnosticSource},
9};
10
11pub const RENDER_CLEAR_COLOR_KIND: &str = "render.clear-color";
12pub const RENDER_FULLSCREEN_SHADER_KIND: &str = "render.fullscreen-shader";
13pub const RENDER_OUTPUT_KIND: &str = "render.output";
14pub const DEFAULT_CLEAR_COLOR: [f64; 4] = [0.02, 0.02, 0.025, 1.0];
15pub const DEFAULT_SHADER_COLOR: [f32; 4] = [1.0, 1.0, 1.0, 1.0];
16
17#[derive(Debug, Clone, PartialEq)]
18pub enum RenderScene {
19    ClearColor(ClearColorScene),
20    FullscreenShader(FullscreenShaderScene),
21}
22
23#[derive(Debug, Clone, PartialEq)]
24pub struct ClearColorScene {
25    pub clear_color: [f64; 4],
26    pub source_node_id: Option<String>,
27}
28
29#[derive(Debug, Clone, PartialEq)]
30pub struct FullscreenShaderScene {
31    pub language: ShaderLanguage,
32    pub source: String,
33    pub source_node_id: String,
34    pub uniforms: Vec<ShaderUniformBinding>,
35    pub fallback_clear_color: [f64; 4],
36}
37
38#[derive(Debug, Clone, PartialEq)]
39pub struct ShaderUniformBinding {
40    pub id: String,
41    pub value: ShaderUniformValue,
42}
43
44#[derive(Debug, Clone, PartialEq)]
45pub enum ShaderUniformValue {
46    F32(f32),
47    I32(i32),
48    U32(u32),
49    Bool(bool),
50    ColorRgba([f32; 4]),
51}
52
53#[derive(Debug, Clone, PartialEq)]
54pub enum ShaderLanguage {
55    Wgsl,
56}
57
58#[derive(Debug, Clone, Error, PartialEq)]
59pub enum RenderSceneBuildError {
60    #[error("fullscreen shader node {node_id} is missing params.language")]
61    MissingShaderLanguage { node_id: String },
62    #[error("fullscreen shader node {node_id} uses unsupported language {language}")]
63    UnsupportedShaderLanguage { node_id: String, language: String },
64    #[error("fullscreen shader node {node_id} is missing non-empty params.source")]
65    MissingShaderSource { node_id: String },
66    #[error("fullscreen shader node {node_id} source is missing {entrypoint} entry point")]
67    MissingShaderEntrypoint {
68        node_id: String,
69        entrypoint: &'static str,
70    },
71    #[error("fullscreen shader node {node_id} source declares reserved {entrypoint} entry point")]
72    ReservedShaderEntrypoint {
73        node_id: String,
74        entrypoint: &'static str,
75    },
76    #[error("fullscreen shader node {node_id} has invalid interface: {message}")]
77    InvalidShaderInterface {
78        node_id: String,
79        message: String,
80        diagnostics: Vec<ShaderDiagnostic>,
81    },
82    #[error("fullscreen shader node {node_id} graph ports do not match shader annotations")]
83    ShaderInterfacePortsOutOfSync { node_id: String },
84    #[error("render output node {node_id} has no incoming edge to port in")]
85    RenderOutputWithoutInput { node_id: String },
86    #[error("render output node {output_node_id} references missing source node {source_node_id}")]
87    MissingRenderOutputSourceNode {
88        output_node_id: String,
89        source_node_id: String,
90    },
91    #[error(
92        "render output node {output_node_id} references missing output port {port_id} on source node {source_node_id}"
93    )]
94    MissingRenderOutputSourcePort {
95        output_node_id: String,
96        source_node_id: String,
97        port_id: String,
98    },
99    #[error(
100        "render output node {output_node_id} is connected to unsupported render source {source_node_id} ({source_kind})"
101    )]
102    UnsupportedRenderOutputSource {
103        output_node_id: String,
104        source_node_id: String,
105        source_kind: String,
106    },
107}
108
109pub(crate) fn render_scene_from_preview_document(
110    document: &PreviewDocument,
111) -> Result<RenderScene, RenderSceneBuildError> {
112    if let Some(scene) = explicit_render_output_scene(document)? {
113        return Ok(scene);
114    }
115
116    legacy_render_scene(document)
117}
118
119impl RenderScene {
120    pub fn renderer_label(&self) -> &'static str {
121        match self {
122            Self::ClearColor(_) => "clear-color",
123            Self::FullscreenShader(_) => "fullscreen-shader",
124        }
125    }
126
127    pub fn source_node_id(&self) -> Option<String> {
128        match self {
129            Self::ClearColor(scene) => scene.source_node_id.clone(),
130            Self::FullscreenShader(scene) => Some(scene.source_node_id.clone()),
131        }
132    }
133
134    pub fn fallback_clear_color(&self) -> [f64; 4] {
135        match self {
136            Self::ClearColor(scene) => scene.clear_color,
137            Self::FullscreenShader(scene) => scene.fallback_clear_color,
138        }
139    }
140}
141
142impl Default for RenderScene {
143    fn default() -> Self {
144        Self::ClearColor(ClearColorScene {
145            clear_color: DEFAULT_CLEAR_COLOR,
146            source_node_id: None,
147        })
148    }
149}
150
151fn explicit_render_output_scene(
152    document: &PreviewDocument,
153) -> Result<Option<RenderScene>, RenderSceneBuildError> {
154    let Some(node) = document
155        .graph
156        .nodes
157        .iter()
158        .find(|node| node.kind == RENDER_OUTPUT_KIND)
159    else {
160        return Ok(None);
161    };
162
163    let Some(edge) = document
164        .graph
165        .edges
166        .iter()
167        .find(|edge| edge.to.node == node.id && edge.to.port == "in")
168    else {
169        return Err(RenderSceneBuildError::RenderOutputWithoutInput {
170            node_id: node.id.clone(),
171        });
172    };
173
174    let Some(source_node) = document
175        .graph
176        .nodes
177        .iter()
178        .find(|candidate| candidate.id == edge.from.node)
179    else {
180        return Err(RenderSceneBuildError::MissingRenderOutputSourceNode {
181            output_node_id: node.id.clone(),
182            source_node_id: edge.from.node.clone(),
183        });
184    };
185
186    if !source_has_output_port(source_node, &edge.from.port) {
187        return Err(RenderSceneBuildError::MissingRenderOutputSourcePort {
188            output_node_id: node.id.clone(),
189            source_node_id: source_node.id.clone(),
190            port_id: edge.from.port.clone(),
191        });
192    }
193
194    match source_node.kind.as_str() {
195        RENDER_CLEAR_COLOR_KIND => Ok(Some(clear_color_scene_from_node(source_node))),
196        RENDER_FULLSCREEN_SHADER_KIND => {
197            fullscreen_shader_scene_from_node(document, source_node).map(Some)
198        }
199        _ => Err(RenderSceneBuildError::UnsupportedRenderOutputSource {
200            output_node_id: node.id.clone(),
201            source_node_id: source_node.id.clone(),
202            source_kind: source_node.kind.clone(),
203        }),
204    }
205}
206
207fn legacy_render_scene(document: &PreviewDocument) -> Result<RenderScene, RenderSceneBuildError> {
208    if let Some(node) = document
209        .graph
210        .nodes
211        .iter()
212        .find(|node| node.kind == RENDER_FULLSCREEN_SHADER_KIND)
213    {
214        return fullscreen_shader_scene_from_node(document, node);
215    }
216
217    Ok(clear_color_scene_from_preview_document(document))
218}
219
220fn clear_color_scene_from_preview_document(document: &PreviewDocument) -> RenderScene {
221    let Some(node) = document
222        .graph
223        .nodes
224        .iter()
225        .find(|node| node.kind == RENDER_CLEAR_COLOR_KIND)
226    else {
227        return RenderScene::default();
228    };
229
230    clear_color_scene_from_node(node)
231}
232
233fn clear_color_scene_from_node(node: &GraphNode) -> RenderScene {
234    let Some(color) = node.params.get("color").and_then(read_color) else {
235        return RenderScene::default();
236    };
237
238    RenderScene::ClearColor(ClearColorScene {
239        clear_color: color.map(|component| component.clamp(0.0, 1.0)),
240        source_node_id: Some(node.id.clone()),
241    })
242}
243
244fn fullscreen_shader_scene_from_node(
245    document: &PreviewDocument,
246    node: &GraphNode,
247) -> Result<RenderScene, RenderSceneBuildError> {
248    let language = match node.params.get("language").and_then(Value::as_str) {
249        Some("wgsl") => ShaderLanguage::Wgsl,
250        Some(language) => {
251            return Err(RenderSceneBuildError::UnsupportedShaderLanguage {
252                node_id: node.id.clone(),
253                language: language.to_owned(),
254            });
255        }
256        None => {
257            return Err(RenderSceneBuildError::MissingShaderLanguage {
258                node_id: node.id.clone(),
259            });
260        }
261    };
262
263    let Some(source) = node.params.get("source").and_then(Value::as_str) else {
264        return Err(RenderSceneBuildError::MissingShaderSource {
265            node_id: node.id.clone(),
266        });
267    };
268    let source = source.trim();
269    if source.is_empty() {
270        return Err(RenderSceneBuildError::MissingShaderSource {
271            node_id: node.id.clone(),
272        });
273    }
274    if source.contains("fn vs_main") {
275        return Err(RenderSceneBuildError::ReservedShaderEntrypoint {
276            node_id: node.id.clone(),
277            entrypoint: "vs_main",
278        });
279    }
280    if !source.contains("fn fs_main") {
281        return Err(RenderSceneBuildError::MissingShaderEntrypoint {
282            node_id: node.id.clone(),
283            entrypoint: "fs_main",
284        });
285    }
286    let analysis = analyze_shader_interface_v01(source);
287    if !analysis.ok {
288        let message = analysis
289            .diagnostics
290            .iter()
291            .map(|diagnostic| diagnostic.message.as_str())
292            .collect::<Vec<_>>()
293            .join("; ");
294        return Err(RenderSceneBuildError::InvalidShaderInterface {
295            node_id: node.id.clone(),
296            message,
297            diagnostics: analysis
298                .diagnostics
299                .iter()
300                .map(shader_analysis_diagnostic)
301                .collect(),
302        });
303    }
304    let expected_ports = shader_interface_to_ports_v01(&analysis.shader_interface);
305    if node.ports != expected_ports {
306        return Err(RenderSceneBuildError::ShaderInterfacePortsOutOfSync {
307            node_id: node.id.clone(),
308        });
309    }
310
311    Ok(RenderScene::FullscreenShader(FullscreenShaderScene {
312        language,
313        source: source.to_owned(),
314        source_node_id: node.id.clone(),
315        uniforms: analysis
316            .shader_interface
317            .uniforms
318            .iter()
319            .map(|uniform| ShaderUniformBinding {
320                id: uniform.id.clone(),
321                value: shader_uniform_value(document, node, uniform),
322            })
323            .collect(),
324        fallback_clear_color: DEFAULT_CLEAR_COLOR,
325    }))
326}
327
328impl RenderSceneBuildError {
329    pub fn shader_diagnostics(&self) -> Vec<ShaderDiagnostic> {
330        match self {
331            Self::InvalidShaderInterface { diagnostics, .. } => diagnostics.clone(),
332            Self::ShaderInterfacePortsOutOfSync { node_id } => vec![ShaderDiagnostic::error(
333                ShaderDiagnosticPhase::SourceSync,
334                "shader-interface-ports-out-of-sync",
335                format!(
336                    "fullscreen shader node {node_id} graph ports do not match shader annotations"
337                ),
338                ShaderDiagnosticSource::Runtime,
339            )],
340            Self::MissingShaderEntrypoint {
341                node_id,
342                entrypoint,
343            } => vec![ShaderDiagnostic::error(
344                ShaderDiagnosticPhase::WgslGeneration,
345                "missing-shader-entrypoint",
346                format!(
347                    "fullscreen shader node {node_id} source is missing {entrypoint} entry point"
348                ),
349                ShaderDiagnosticSource::User,
350            )],
351            Self::ReservedShaderEntrypoint {
352                node_id,
353                entrypoint,
354            } => vec![ShaderDiagnostic::error(
355                ShaderDiagnosticPhase::WgslGeneration,
356                "reserved-shader-entrypoint",
357                format!(
358                    "fullscreen shader node {node_id} source declares reserved {entrypoint} entry point"
359                ),
360                ShaderDiagnosticSource::User,
361            )],
362            Self::MissingShaderLanguage { node_id } => vec![ShaderDiagnostic::error(
363                ShaderDiagnosticPhase::SourceSync,
364                "missing-shader-language",
365                format!("fullscreen shader node {node_id} is missing params.language"),
366                ShaderDiagnosticSource::User,
367            )],
368            Self::UnsupportedShaderLanguage { node_id, language } => vec![ShaderDiagnostic::error(
369                ShaderDiagnosticPhase::SourceSync,
370                "unsupported-shader-language",
371                format!("fullscreen shader node {node_id} uses unsupported language {language}"),
372                ShaderDiagnosticSource::User,
373            )],
374            Self::MissingShaderSource { node_id } => vec![ShaderDiagnostic::error(
375                ShaderDiagnosticPhase::SourceSync,
376                "missing-shader-source",
377                format!("fullscreen shader node {node_id} is missing non-empty params.source"),
378                ShaderDiagnosticSource::User,
379            )],
380            Self::RenderOutputWithoutInput { node_id } => vec![ShaderDiagnostic::error(
381                ShaderDiagnosticPhase::RenderPipeline,
382                "render-output-without-input",
383                format!("render output node {node_id} has no incoming edge to port in"),
384                ShaderDiagnosticSource::Runtime,
385            )],
386            Self::MissingRenderOutputSourceNode {
387                output_node_id,
388                source_node_id,
389            } => vec![ShaderDiagnostic::error(
390                ShaderDiagnosticPhase::RenderPipeline,
391                "missing-render-output-source-node",
392                format!(
393                    "render output node {output_node_id} references missing source node {source_node_id}"
394                ),
395                ShaderDiagnosticSource::Runtime,
396            )],
397            Self::MissingRenderOutputSourcePort {
398                output_node_id,
399                source_node_id,
400                port_id,
401            } => vec![ShaderDiagnostic::error(
402                ShaderDiagnosticPhase::RenderPipeline,
403                "missing-render-output-source-port",
404                format!(
405                    "render output node {output_node_id} references missing output port {port_id} on source node {source_node_id}"
406                ),
407                ShaderDiagnosticSource::Runtime,
408            )],
409            Self::UnsupportedRenderOutputSource {
410                output_node_id,
411                source_node_id,
412                source_kind,
413            } => vec![ShaderDiagnostic::error(
414                ShaderDiagnosticPhase::RenderPipeline,
415                "unsupported-render-output-source",
416                format!(
417                    "render output node {output_node_id} is connected to unsupported render source {source_node_id} ({source_kind})"
418                ),
419                ShaderDiagnosticSource::Runtime,
420            )],
421        }
422    }
423}
424
425fn shader_analysis_diagnostic(diagnostic: &crate::ShaderInterfaceDiagnostic) -> ShaderDiagnostic {
426    ShaderDiagnostic::error(
427        ShaderDiagnosticPhase::InterfaceAnalysis,
428        diagnostic.code.clone(),
429        diagnostic.message.clone(),
430        ShaderDiagnosticSource::User,
431    )
432    .with_line_column(diagnostic.line, None)
433    .with_uniform_id(diagnostic.uniform_id.clone())
434}
435
436fn shader_uniform_value(
437    document: &PreviewDocument,
438    node: &GraphNode,
439    uniform: &crate::ShaderUniform,
440) -> ShaderUniformValue {
441    let connected =
442        resolve_control_value_at_input(document, &node.id, &uniform.id).and_then(|value| {
443            convert_control_value_to_data_kind(
444                &value,
445                &uniform.data_type.data_kind,
446                first_format(&uniform.data_type),
447            )
448        });
449    match uniform.data_type.data_kind.as_str() {
450        "number.float" => connected
451            .as_ref()
452            .and_then(ControlValue::as_f32)
453            .map_or_else(
454                || ShaderUniformValue::F32(default_f32(&uniform.default)),
455                ShaderUniformValue::F32,
456            ),
457        "number.int" => connected
458            .as_ref()
459            .and_then(ControlValue::as_i32)
460            .map_or_else(
461                || ShaderUniformValue::I32(default_i32(&uniform.default)),
462                ShaderUniformValue::I32,
463            ),
464        "number.uint" => connected
465            .as_ref()
466            .and_then(ControlValue::as_u32)
467            .map_or_else(
468                || ShaderUniformValue::U32(default_u32(&uniform.default)),
469                ShaderUniformValue::U32,
470            ),
471        "boolean" => connected
472            .as_ref()
473            .and_then(ControlValue::as_bool)
474            .map_or_else(
475                || ShaderUniformValue::Bool(default_bool(&uniform.default)),
476                ShaderUniformValue::Bool,
477            ),
478        "color" => connected
479            .as_ref()
480            .and_then(ControlValue::as_rgba_f32)
481            .map_or_else(
482                || ShaderUniformValue::ColorRgba(default_color(&uniform.default)),
483                ShaderUniformValue::ColorRgba,
484            ),
485        _ => ShaderUniformValue::F32(0.0),
486    }
487}
488
489fn first_format(data_type: &crate::DataType) -> Option<&str> {
490    data_type
491        .format
492        .as_ref()
493        .and_then(|format| format.values().into_iter().next())
494}
495
496fn default_f32(value: &Option<serde_json::Value>) -> f32 {
497    value
498        .as_ref()
499        .and_then(serde_json::Value::as_f64)
500        .unwrap_or(0.0) as f32
501}
502
503fn default_i32(value: &Option<serde_json::Value>) -> i32 {
504    value
505        .as_ref()
506        .and_then(serde_json::Value::as_i64)
507        .unwrap_or(0) as i32
508}
509
510fn default_u32(value: &Option<serde_json::Value>) -> u32 {
511    value
512        .as_ref()
513        .and_then(serde_json::Value::as_u64)
514        .unwrap_or(0)
515        .min(u32::MAX as u64) as u32
516}
517
518fn default_bool(value: &Option<serde_json::Value>) -> bool {
519    value
520        .as_ref()
521        .and_then(serde_json::Value::as_bool)
522        .unwrap_or(false)
523}
524
525fn default_color(value: &Option<serde_json::Value>) -> [f32; 4] {
526    value
527        .as_ref()
528        .and_then(read_color_f32)
529        .unwrap_or(DEFAULT_SHADER_COLOR)
530}
531
532fn read_color_f32(value: &Value) -> Option<[f32; 4]> {
533    read_color(value).map(|color| color.map(|component| component.clamp(0.0, 1.0) as f32))
534}
535
536pub(crate) fn resolve_control_value_at_input(
537    document: &PreviewDocument,
538    target_node_id: &str,
539    target_port_id: &str,
540) -> Option<ControlValue> {
541    let edge = document
542        .graph
543        .edges
544        .iter()
545        .find(|edge| edge.to.node == target_node_id && edge.to.port == target_port_id)?;
546
547    if edge.from.port != "value" {
548        return None;
549    }
550
551    let source_node = document
552        .graph
553        .nodes
554        .iter()
555        .find(|candidate| candidate.id == edge.from.node)?;
556
557    document
558        .control_state
559        .output_value_for_node(source_node, &edge.from.port)
560}
561
562fn source_has_output_port(node: &GraphNode, port_id: &str) -> bool {
563    node.ports
564        .iter()
565        .any(|port| port.id == port_id && port.direction == PortDirection::Output)
566}
567
568fn read_color(value: &Value) -> Option<[f64; 4]> {
569    let values = value.as_array()?;
570    let [r, g, b, a] = values.as_slice() else {
571        return None;
572    };
573    Some([r.as_f64()?, g.as_f64()?, b.as_f64()?, a.as_f64()?])
574}
575
576#[cfg(test)]
577mod tests {
578    use serde_json::json;
579
580    use super::*;
581    use crate::{
582        Edge, ExecutionPlan, GraphDocument, GraphNode, Port, PortRef,
583        render::{PREVIEW_DOCUMENT_SCHEMA, PREVIEW_DOCUMENT_SCHEMA_VERSION},
584    };
585
586    #[test]
587    fn extracts_valid_clear_color() {
588        let document = document_with_nodes(vec![clear_node(json!([0.05, 0.08, 0.12, 1.0]))]);
589
590        let scene = render_scene_from_preview_document(&document).expect("scene should build");
591
592        assert_eq!(
593            scene,
594            RenderScene::ClearColor(ClearColorScene {
595                clear_color: [0.05, 0.08, 0.12, 1.0],
596                source_node_id: Some("clear_1".to_owned())
597            })
598        );
599    }
600
601    #[test]
602    fn clamps_out_of_range_clear_color() {
603        let document = document_with_nodes(vec![clear_node(json!([-1.0, 0.5, 1.4, 2.0]))]);
604
605        let scene = render_scene_from_preview_document(&document).expect("scene should build");
606
607        assert_eq!(
608            scene,
609            RenderScene::ClearColor(ClearColorScene {
610                clear_color: [0.0, 0.5, 1.0, 1.0],
611                source_node_id: Some("clear_1".to_owned())
612            })
613        );
614    }
615
616    #[test]
617    fn defaults_when_render_node_is_missing() {
618        let document = document_with_nodes(Vec::new());
619
620        let scene = render_scene_from_preview_document(&document).expect("scene should build");
621
622        assert_eq!(scene, RenderScene::default());
623    }
624
625    #[test]
626    fn defaults_when_color_is_invalid() {
627        for value in [
628            json!("red"),
629            json!([0.1, 0.2, 0.3]),
630            json!([0.1, 0.2, 0.3, 1.0, 0.5]),
631            json!([false, 0.2, 0.3, 1.0]),
632            json!([0.1, false, 0.3, 1.0]),
633            json!([0.1, 0.2, false, 1.0]),
634            json!([0.1, 0.2, 0.3, false]),
635        ] {
636            let document = document_with_nodes(vec![clear_node(value)]);
637
638            let scene = render_scene_from_preview_document(&document).expect("scene should build");
639
640            assert_eq!(scene, RenderScene::default());
641        }
642    }
643
644    #[test]
645    fn extracts_fullscreen_shader_source() {
646        let document =
647            document_with_nodes(vec![shader_node(json!("wgsl"), json!(shader_source()))]);
648
649        let scene = render_scene_from_preview_document(&document).expect("scene should build");
650
651        assert_eq!(
652            scene,
653            RenderScene::FullscreenShader(FullscreenShaderScene {
654                language: ShaderLanguage::Wgsl,
655                source: shader_source().to_owned(),
656                source_node_id: "shader_1".to_owned(),
657                uniforms: vec![
658                    ShaderUniformBinding {
659                        id: "speed".to_owned(),
660                        value: ShaderUniformValue::F32(0.0),
661                    },
662                    ShaderUniformBinding {
663                        id: "phase".to_owned(),
664                        value: ShaderUniformValue::F32(0.0),
665                    },
666                    ShaderUniformBinding {
667                        id: "tint".to_owned(),
668                        value: ShaderUniformValue::ColorRgba(DEFAULT_SHADER_COLOR),
669                    },
670                ],
671                fallback_clear_color: DEFAULT_CLEAR_COLOR
672            })
673        );
674        assert_eq!(scene.renderer_label(), "fullscreen-shader");
675        assert_eq!(scene.source_node_id().as_deref(), Some("shader_1"));
676        assert_eq!(scene.fallback_clear_color(), DEFAULT_CLEAR_COLOR);
677        assert_eq!(
678            RenderScene::ClearColor(ClearColorScene {
679                clear_color: [0.1, 0.2, 0.3, 1.0],
680                source_node_id: Some("clear_1".to_owned())
681            })
682            .fallback_clear_color(),
683            [0.1, 0.2, 0.3, 1.0]
684        );
685    }
686
687    #[test]
688    fn rejects_unsupported_shader_language() {
689        let document =
690            document_with_nodes(vec![shader_node(json!("glsl"), json!(shader_source()))]);
691
692        let error = render_scene_from_preview_document(&document).expect_err("scene should fail");
693
694        assert_eq!(
695            error,
696            RenderSceneBuildError::UnsupportedShaderLanguage {
697                node_id: "shader_1".to_owned(),
698                language: "glsl".to_owned()
699            }
700        );
701    }
702
703    #[test]
704    fn rejects_missing_shader_language() {
705        let mut node = shader_node(json!("wgsl"), json!(shader_source()));
706        node.params.remove("language");
707        let document = document_with_nodes(vec![node]);
708
709        let error = render_scene_from_preview_document(&document).expect_err("scene should fail");
710
711        assert_eq!(
712            error,
713            RenderSceneBuildError::MissingShaderLanguage {
714                node_id: "shader_1".to_owned()
715            }
716        );
717    }
718
719    #[test]
720    fn rejects_missing_shader_source() {
721        for source in [json!(null), json!("   ")] {
722            let document = document_with_nodes(vec![shader_node(json!("wgsl"), source)]);
723
724            let error =
725                render_scene_from_preview_document(&document).expect_err("scene should fail");
726
727            assert_eq!(
728                error,
729                RenderSceneBuildError::MissingShaderSource {
730                    node_id: "shader_1".to_owned()
731                }
732            );
733        }
734    }
735
736    #[test]
737    fn rejects_reserved_or_missing_shader_entrypoints() {
738        let document = document_with_nodes(vec![shader_node(
739            json!("wgsl"),
740            json!(
741                "@vertex fn vs_main() -> @builtin(position) vec4<f32> { return vec4<f32>(0.0); }\n@fragment fn fs_main() -> @location(0) vec4<f32> { return vec4<f32>(1.0); }"
742            ),
743        )]);
744
745        let error = render_scene_from_preview_document(&document).expect_err("scene should fail");
746
747        assert_eq!(
748            error,
749            RenderSceneBuildError::ReservedShaderEntrypoint {
750                node_id: "shader_1".to_owned(),
751                entrypoint: "vs_main"
752            }
753        );
754
755        let document = document_with_nodes(vec![shader_node(
756            json!("wgsl"),
757            json!("fn helper() -> f32 { return 1.0; }"),
758        )]);
759
760        let error = render_scene_from_preview_document(&document).expect_err("scene should fail");
761
762        assert_eq!(
763            error,
764            RenderSceneBuildError::MissingShaderEntrypoint {
765                node_id: "shader_1".to_owned(),
766                entrypoint: "fs_main"
767            }
768        );
769    }
770
771    #[test]
772    fn rejects_invalid_or_unsynced_shader_interfaces() {
773        let invalid = document_with_nodes(vec![shader_node(
774            json!("wgsl"),
775            json!(
776                "// @skenion.uniform bad vec3\n@fragment\nfn fs_main() -> @location(0) vec4<f32> { return vec4<f32>(1.0); }"
777            ),
778        )]);
779        let error = render_scene_from_preview_document(&invalid).expect_err("scene should fail");
780        assert!(matches!(
781            error,
782            RenderSceneBuildError::InvalidShaderInterface { node_id, message, diagnostics }
783                if node_id == "shader_1"
784                    && message.contains("unsupported uniform type")
785                    && diagnostics[0].phase == ShaderDiagnosticPhase::InterfaceAnalysis
786                    && diagnostics[0].line == Some(1)
787        ));
788
789        let mut node = shader_node(json!("wgsl"), json!(shader_source()));
790        node.ports = vec![gpu_output_port()];
791        let unsynced = document_with_nodes(vec![node]);
792        let error = render_scene_from_preview_document(&unsynced).expect_err("scene should fail");
793        assert_eq!(
794            error,
795            RenderSceneBuildError::ShaderInterfacePortsOutOfSync {
796                node_id: "shader_1".to_owned()
797            }
798        );
799    }
800
801    #[test]
802    fn prefers_fullscreen_shader_over_clear_color() {
803        let document = document_with_nodes(vec![
804            clear_node(json!([0.05, 0.08, 0.12, 1.0])),
805            shader_node(json!("wgsl"), json!(shader_source())),
806        ]);
807
808        let scene = render_scene_from_preview_document(&document).expect("scene should build");
809
810        assert!(matches!(scene, RenderScene::FullscreenShader(_)));
811    }
812
813    #[test]
814    fn selects_clear_color_connected_to_render_output() {
815        let document = document_with_edges(
816            vec![
817                clear_node(json!([0.05, 0.08, 0.12, 1.0])),
818                shader_node(json!("wgsl"), json!(shader_source())),
819                output_node("output_1"),
820            ],
821            vec![edge("clear_1", "out", "output_1", "in")],
822        );
823
824        let scene = render_scene_from_preview_document(&document).expect("scene should build");
825
826        assert_eq!(
827            scene,
828            RenderScene::ClearColor(ClearColorScene {
829                clear_color: [0.05, 0.08, 0.12, 1.0],
830                source_node_id: Some("clear_1".to_owned())
831            })
832        );
833    }
834
835    #[test]
836    fn selects_fullscreen_shader_connected_to_render_output() {
837        let document = document_with_edges(
838            vec![
839                clear_node(json!([0.05, 0.08, 0.12, 1.0])),
840                shader_node(json!("wgsl"), json!(shader_source())),
841                output_node("output_1"),
842            ],
843            vec![edge("shader_1", "out", "output_1", "in")],
844        );
845
846        let scene = render_scene_from_preview_document(&document).expect("scene should build");
847
848        assert!(matches!(scene, RenderScene::FullscreenShader(_)));
849        assert_eq!(scene.source_node_id().as_deref(), Some("shader_1"));
850    }
851
852    #[test]
853    fn fullscreen_shader_defaults_u_value_to_zero() {
854        let document =
855            document_with_nodes(vec![shader_node(json!("wgsl"), json!(shader_source()))]);
856
857        let scene = render_scene_from_preview_document(&document).expect("scene should build");
858
859        assert_eq!(shader_u_value(&scene), 0.0);
860        assert_eq!(shader_u_value2(&scene), 0.0);
861        assert_eq!(shader_u_color(&scene), DEFAULT_SHADER_COLOR);
862    }
863
864    #[test]
865    fn fullscreen_shader_reads_i32_and_bool_uniform_defaults() {
866        let document = document_with_nodes(vec![shader_node(
867            json!("wgsl"),
868            json!(typed_shader_source()),
869        )]);
870
871        let scene = render_scene_from_preview_document(&document).expect("scene should build");
872
873        assert_eq!(
874            shader_uniform(&scene, "iterations"),
875            &ShaderUniformValue::I32(8)
876        );
877        assert_eq!(
878            shader_uniform(&scene, "enabled"),
879            &ShaderUniformValue::Bool(true)
880        );
881    }
882
883    #[test]
884    fn fullscreen_shader_reads_connected_i32_and_bool_uniforms() {
885        let document = document_with_edges(
886            vec![
887                i32_node_with_value("iterations_1", 12),
888                bool_node_with_value("enabled_1", false),
889                shader_node(json!("wgsl"), json!(typed_shader_source())),
890            ],
891            vec![
892                edge("iterations_1", "value", "shader_1", "iterations"),
893                edge("enabled_1", "value", "shader_1", "enabled"),
894            ],
895        );
896
897        let scene = render_scene_from_preview_document(&document).expect("scene should build");
898
899        assert_eq!(
900            shader_uniform(&scene, "iterations"),
901            &ShaderUniformValue::I32(12)
902        );
903        assert_eq!(
904            shader_uniform(&scene, "enabled"),
905            &ShaderUniformValue::Bool(false)
906        );
907    }
908
909    #[test]
910    fn fullscreen_shader_reads_uint_uniform_defaults_and_connections() {
911        let default_document = document_with_nodes(vec![shader_node(
912            json!("wgsl"),
913            json!(uint_shader_source()),
914        )]);
915        let default_scene =
916            render_scene_from_preview_document(&default_document).expect("scene should build");
917        assert_eq!(
918            shader_uniform(&default_scene, "count"),
919            &ShaderUniformValue::U32(4)
920        );
921
922        let connected_document = document_with_edges(
923            vec![
924                u32_node_with_value("count_1", u64::from(u32::MAX) + 10),
925                shader_node(json!("wgsl"), json!(uint_shader_source())),
926            ],
927            vec![edge("count_1", "value", "shader_1", "count")],
928        );
929        let connected_scene =
930            render_scene_from_preview_document(&connected_document).expect("scene should build");
931
932        assert_eq!(
933            shader_uniform(&connected_scene, "count"),
934            &ShaderUniformValue::U32(u32::MAX)
935        );
936    }
937
938    #[test]
939    fn fullscreen_shader_converts_numeric_uniform_inputs_and_defaults_incompatible_bool() {
940        let document = document_with_edges(
941            vec![
942                value_node_with_id_and_value("wrong_iterations", json!(4.0)),
943                value_node_with_id_and_value("wrong_enabled", json!(1.0)),
944                shader_node(json!("wgsl"), json!(typed_shader_source())),
945            ],
946            vec![
947                edge("wrong_iterations", "value", "shader_1", "iterations"),
948                edge("wrong_enabled", "value", "shader_1", "enabled"),
949            ],
950        );
951
952        let scene = render_scene_from_preview_document(&document).expect("scene should build");
953
954        assert_eq!(
955            shader_uniform(&scene, "iterations"),
956            &ShaderUniformValue::I32(4)
957        );
958        assert_eq!(
959            shader_uniform(&scene, "enabled"),
960            &ShaderUniformValue::Bool(true)
961        );
962    }
963
964    #[test]
965    fn fullscreen_shader_converts_int_and_uint_sources_to_float_uniforms() {
966        let int_document = document_with_edges(
967            vec![
968                i32_node_with_value("int_speed", 12),
969                shader_node(json!("wgsl"), json!(shader_source())),
970            ],
971            vec![edge("int_speed", "value", "shader_1", "speed")],
972        );
973        let int_scene =
974            render_scene_from_preview_document(&int_document).expect("scene should build");
975        assert_eq!(shader_u_value(&int_scene), 12.0);
976
977        let uint_document = document_with_edges(
978            vec![
979                u32_node_with_value("uint_speed", 7),
980                shader_node(json!("wgsl"), json!(shader_source())),
981            ],
982            vec![edge("uint_speed", "value", "shader_1", "speed")],
983        );
984        let uint_scene =
985            render_scene_from_preview_document(&uint_document).expect("scene should build");
986        assert_eq!(shader_u_value(&uint_scene), 7.0);
987    }
988
989    #[test]
990    fn fullscreen_shader_converts_float_source_to_uint_uniform() {
991        let document = document_with_edges(
992            vec![
993                value_node_with_id_and_value("float_count", json!(12.9)),
994                shader_node(json!("wgsl"), json!(uint_shader_source())),
995            ],
996            vec![edge("float_count", "value", "shader_1", "count")],
997        );
998
999        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1000
1001        assert_eq!(
1002            shader_uniform(&scene, "count"),
1003            &ShaderUniformValue::U32(12)
1004        );
1005    }
1006
1007    #[test]
1008    fn shader_uniform_value_defaults_unknown_uniform_data_kind() {
1009        let document =
1010            document_with_nodes(vec![shader_node(json!("wgsl"), json!(shader_source()))]);
1011        let node = document
1012            .graph
1013            .nodes
1014            .iter()
1015            .find(|node| node.id == "shader_1")
1016            .expect("shader node should exist");
1017        let uniform: crate::ShaderUniform = serde_json::from_value(json!({
1018            "id": "unknown",
1019            "label": "Unknown",
1020            "type": { "flow": "value", "dataKind": "unknown.kind" },
1021            "required": false
1022        }))
1023        .expect("uniform should parse");
1024
1025        assert_eq!(
1026            shader_uniform_value(&document, node, &uniform),
1027            ShaderUniformValue::F32(0.0)
1028        );
1029    }
1030
1031    #[test]
1032    fn fullscreen_shader_reads_connected_value_node() {
1033        let document = document_with_edges(
1034            vec![
1035                value_node_with_value(json!(0.42)),
1036                shader_node(json!("wgsl"), json!(shader_source())),
1037            ],
1038            vec![edge("value_1", "value", "shader_1", "speed")],
1039        );
1040
1041        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1042
1043        assert_eq!(shader_u_value(&scene), 0.42);
1044    }
1045
1046    #[test]
1047    fn fullscreen_shader_reads_runtime_control_state_instead_of_graph_params() {
1048        let mut document = document_with_edges(
1049            vec![
1050                value_node_with_value(json!(0.42)),
1051                shader_node(json!("wgsl"), json!(shader_source())),
1052            ],
1053            vec![edge("value_1", "value", "shader_1", "speed")],
1054        );
1055        document
1056            .control_state
1057            .values
1058            .insert("value_1".to_owned(), ControlValue::float(2.5));
1059
1060        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1061
1062        assert_eq!(shader_u_value(&scene), 2.5);
1063    }
1064
1065    #[test]
1066    fn fullscreen_shader_reads_connected_second_value_node() {
1067        let document = document_with_edges(
1068            vec![
1069                value_node_with_id_and_value("value_2", json!(0.73)),
1070                shader_node(json!("wgsl"), json!(shader_source())),
1071            ],
1072            vec![edge("value_2", "value", "shader_1", "phase")],
1073        );
1074
1075        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1076
1077        assert_eq!(shader_u_value2(&scene), 0.73);
1078    }
1079
1080    #[test]
1081    fn fullscreen_shader_reads_connected_color_node() {
1082        let document = document_with_edges(
1083            vec![
1084                color_node_with_value(json!([1.2, 0.5, -0.25, 0.8])),
1085                shader_node(json!("wgsl"), json!(shader_source())),
1086            ],
1087            vec![edge("color_1", "value", "shader_1", "tint")],
1088        );
1089
1090        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1091
1092        assert_eq!(shader_u_color(&scene), [1.0, 0.5, 0.0, 0.8]);
1093    }
1094
1095    #[test]
1096    fn fullscreen_shader_preserves_connected_f32_value_without_global_range_clamp() {
1097        for (value, expected) in [(json!(-0.25), -0.25), (json!(1.25), 1.25)] {
1098            let document = document_with_edges(
1099                vec![
1100                    value_node_with_value(value),
1101                    shader_node(json!("wgsl"), json!(shader_source())),
1102                ],
1103                vec![edge("value_1", "value", "shader_1", "speed")],
1104            );
1105
1106            let scene = render_scene_from_preview_document(&document).expect("scene should build");
1107
1108            assert_eq!(shader_u_value(&scene), expected);
1109        }
1110    }
1111
1112    #[test]
1113    fn fullscreen_shader_ignores_incompatible_u_value_source() {
1114        let document = document_with_edges(
1115            vec![
1116                clear_node(json!([0.1, 0.2, 0.3, 1.0])),
1117                shader_node(json!("wgsl"), json!(shader_source())),
1118            ],
1119            vec![edge("clear_1", "out", "shader_1", "speed")],
1120        );
1121
1122        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1123
1124        assert_eq!(shader_u_value(&scene), 0.0);
1125    }
1126
1127    #[test]
1128    fn fullscreen_shader_ignores_incompatible_u_color_source() {
1129        let document = document_with_edges(
1130            vec![
1131                value_node_with_value(json!(0.42)),
1132                shader_node(json!("wgsl"), json!(shader_source())),
1133            ],
1134            vec![edge("value_1", "value", "shader_1", "tint")],
1135        );
1136
1137        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1138
1139        assert_eq!(shader_u_color(&scene), DEFAULT_SHADER_COLOR);
1140    }
1141
1142    #[test]
1143    fn fullscreen_shader_defaults_u_value_for_missing_source_node() {
1144        let document = document_with_edges(
1145            vec![shader_node(json!("wgsl"), json!(shader_source()))],
1146            vec![edge("missing_value", "value", "shader_1", "speed")],
1147        );
1148
1149        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1150
1151        assert_eq!(shader_u_value(&scene), 0.0);
1152    }
1153
1154    #[test]
1155    fn fullscreen_shader_defaults_u_color_for_missing_source_node() {
1156        let document = document_with_edges(
1157            vec![shader_node(json!("wgsl"), json!(shader_source()))],
1158            vec![edge("missing_color", "value", "shader_1", "tint")],
1159        );
1160
1161        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1162
1163        assert_eq!(shader_u_color(&scene), DEFAULT_SHADER_COLOR);
1164    }
1165
1166    #[test]
1167    fn fullscreen_shader_defaults_u_value_for_non_numeric_value() {
1168        let document = document_with_edges(
1169            vec![
1170                value_node_with_value(json!("not-a-number")),
1171                shader_node(json!("wgsl"), json!(shader_source())),
1172            ],
1173            vec![edge("value_1", "value", "shader_1", "speed")],
1174        );
1175
1176        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1177
1178        assert_eq!(shader_u_value(&scene), 0.0);
1179    }
1180
1181    #[test]
1182    fn fullscreen_shader_defaults_u_color_for_invalid_value() {
1183        for value in [
1184            json!("not-a-color"),
1185            json!([1.0, 0.5, 0.25]),
1186            json!([1.0, false, 0.25, 1.0]),
1187        ] {
1188            let document = document_with_edges(
1189                vec![
1190                    color_node_with_value(value),
1191                    shader_node(json!("wgsl"), json!(shader_source())),
1192                ],
1193                vec![edge("color_1", "value", "shader_1", "tint")],
1194            );
1195
1196            let scene = render_scene_from_preview_document(&document).expect("scene should build");
1197
1198            assert_eq!(shader_u_color(&scene), DEFAULT_SHADER_COLOR);
1199        }
1200    }
1201
1202    #[test]
1203    fn fullscreen_shader_defaults_u_value_for_missing_value_param() {
1204        let document = document_with_edges(
1205            vec![
1206                value_node(),
1207                shader_node(json!("wgsl"), json!(shader_source())),
1208            ],
1209            vec![edge("value_1", "value", "shader_1", "speed")],
1210        );
1211
1212        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1213
1214        assert_eq!(shader_u_value(&scene), 0.0);
1215    }
1216
1217    #[test]
1218    #[should_panic(expected = "expected fullscreen shader scene")]
1219    fn shader_u_value_helper_rejects_non_shader_scene() {
1220        let scene = RenderScene::ClearColor(ClearColorScene {
1221            clear_color: DEFAULT_CLEAR_COLOR,
1222            source_node_id: None,
1223        });
1224
1225        let _ = shader_u_value(&scene);
1226    }
1227
1228    #[test]
1229    #[should_panic(expected = "expected fullscreen shader scene")]
1230    fn shader_u_value2_helper_rejects_non_shader_scene() {
1231        let scene = RenderScene::ClearColor(ClearColorScene {
1232            clear_color: DEFAULT_CLEAR_COLOR,
1233            source_node_id: None,
1234        });
1235
1236        let _ = shader_u_value2(&scene);
1237    }
1238
1239    #[test]
1240    #[should_panic(expected = "expected fullscreen shader scene")]
1241    fn shader_u_color_helper_rejects_non_shader_scene() {
1242        let scene = RenderScene::ClearColor(ClearColorScene {
1243            clear_color: DEFAULT_CLEAR_COLOR,
1244            source_node_id: None,
1245        });
1246
1247        let _ = shader_u_color(&scene);
1248    }
1249
1250    #[test]
1251    #[should_panic(expected = "expected f32 speed uniform")]
1252    fn shader_u_value_helper_rejects_wrong_uniform_type() {
1253        let scene = shader_scene_with_uniform("speed", ShaderUniformValue::Bool(false));
1254
1255        let _ = shader_u_value(&scene);
1256    }
1257
1258    #[test]
1259    #[should_panic(expected = "expected f32 phase uniform")]
1260    fn shader_u_value2_helper_rejects_wrong_uniform_type() {
1261        let scene = shader_scene_with_uniform("phase", ShaderUniformValue::Bool(false));
1262
1263        let _ = shader_u_value2(&scene);
1264    }
1265
1266    #[test]
1267    #[should_panic(expected = "expected color tint uniform")]
1268    fn shader_u_color_helper_rejects_wrong_uniform_type() {
1269        let scene = shader_scene_with_uniform("tint", ShaderUniformValue::Bool(false));
1270
1271        let _ = shader_u_color(&scene);
1272    }
1273
1274    #[test]
1275    #[should_panic(expected = "missing shader uniform missing")]
1276    fn shader_uniform_helper_rejects_missing_uniform() {
1277        let scene = shader_scene_with_uniform("speed", ShaderUniformValue::F32(0.0));
1278
1279        let _ = shader_uniform(&scene, "missing");
1280    }
1281
1282    #[test]
1283    fn rejects_render_output_without_input_edge() {
1284        let document = document_with_nodes(vec![
1285            clear_node(json!([0.05, 0.08, 0.12, 1.0])),
1286            output_node("output_1"),
1287        ]);
1288
1289        let error = render_scene_from_preview_document(&document).expect_err("scene should fail");
1290
1291        assert_eq!(
1292            error,
1293            RenderSceneBuildError::RenderOutputWithoutInput {
1294                node_id: "output_1".to_owned()
1295            }
1296        );
1297    }
1298
1299    #[test]
1300    fn rejects_render_output_source_without_matching_output_port() {
1301        let mut clear = clear_node(json!([0.05, 0.08, 0.12, 1.0]));
1302        clear.ports.clear();
1303        let document = document_with_edges(
1304            vec![clear, output_node("output_1")],
1305            vec![edge("clear_1", "out", "output_1", "in")],
1306        );
1307
1308        let error = render_scene_from_preview_document(&document).expect_err("scene should fail");
1309
1310        assert_eq!(
1311            error,
1312            RenderSceneBuildError::MissingRenderOutputSourcePort {
1313                output_node_id: "output_1".to_owned(),
1314                source_node_id: "clear_1".to_owned(),
1315                port_id: "out".to_owned()
1316            }
1317        );
1318    }
1319
1320    #[test]
1321    fn rejects_render_output_missing_source_node() {
1322        let document = document_with_edges(
1323            vec![output_node("output_1")],
1324            vec![edge("missing", "out", "output_1", "in")],
1325        );
1326
1327        let error = render_scene_from_preview_document(&document).expect_err("scene should fail");
1328
1329        assert_eq!(
1330            error,
1331            RenderSceneBuildError::MissingRenderOutputSourceNode {
1332                output_node_id: "output_1".to_owned(),
1333                source_node_id: "missing".to_owned()
1334            }
1335        );
1336    }
1337
1338    #[test]
1339    fn rejects_unsupported_render_output_source() {
1340        let document = document_with_edges(
1341            vec![value_node(), output_node("output_1")],
1342            vec![edge("value_1", "value", "output_1", "in")],
1343        );
1344
1345        let error = render_scene_from_preview_document(&document).expect_err("scene should fail");
1346
1347        assert_eq!(
1348            error,
1349            RenderSceneBuildError::UnsupportedRenderOutputSource {
1350                output_node_id: "output_1".to_owned(),
1351                source_node_id: "value_1".to_owned(),
1352                source_kind: "core.float".to_owned()
1353            }
1354        );
1355    }
1356
1357    #[test]
1358    fn render_scene_build_errors_emit_shader_diagnostics() {
1359        let cases = vec![
1360            (
1361                RenderSceneBuildError::ShaderInterfacePortsOutOfSync {
1362                    node_id: "shader_1".to_owned(),
1363                },
1364                "shader-interface-ports-out-of-sync",
1365                ShaderDiagnosticPhase::SourceSync,
1366                ShaderDiagnosticSource::Runtime,
1367            ),
1368            (
1369                RenderSceneBuildError::MissingShaderEntrypoint {
1370                    node_id: "shader_1".to_owned(),
1371                    entrypoint: "fs_main",
1372                },
1373                "missing-shader-entrypoint",
1374                ShaderDiagnosticPhase::WgslGeneration,
1375                ShaderDiagnosticSource::User,
1376            ),
1377            (
1378                RenderSceneBuildError::ReservedShaderEntrypoint {
1379                    node_id: "shader_1".to_owned(),
1380                    entrypoint: "vs_main",
1381                },
1382                "reserved-shader-entrypoint",
1383                ShaderDiagnosticPhase::WgslGeneration,
1384                ShaderDiagnosticSource::User,
1385            ),
1386            (
1387                RenderSceneBuildError::MissingShaderLanguage {
1388                    node_id: "shader_1".to_owned(),
1389                },
1390                "missing-shader-language",
1391                ShaderDiagnosticPhase::SourceSync,
1392                ShaderDiagnosticSource::User,
1393            ),
1394            (
1395                RenderSceneBuildError::UnsupportedShaderLanguage {
1396                    node_id: "shader_1".to_owned(),
1397                    language: "glsl".to_owned(),
1398                },
1399                "unsupported-shader-language",
1400                ShaderDiagnosticPhase::SourceSync,
1401                ShaderDiagnosticSource::User,
1402            ),
1403            (
1404                RenderSceneBuildError::MissingShaderSource {
1405                    node_id: "shader_1".to_owned(),
1406                },
1407                "missing-shader-source",
1408                ShaderDiagnosticPhase::SourceSync,
1409                ShaderDiagnosticSource::User,
1410            ),
1411            (
1412                RenderSceneBuildError::RenderOutputWithoutInput {
1413                    node_id: "output_1".to_owned(),
1414                },
1415                "render-output-without-input",
1416                ShaderDiagnosticPhase::RenderPipeline,
1417                ShaderDiagnosticSource::Runtime,
1418            ),
1419            (
1420                RenderSceneBuildError::MissingRenderOutputSourceNode {
1421                    output_node_id: "output_1".to_owned(),
1422                    source_node_id: "missing".to_owned(),
1423                },
1424                "missing-render-output-source-node",
1425                ShaderDiagnosticPhase::RenderPipeline,
1426                ShaderDiagnosticSource::Runtime,
1427            ),
1428            (
1429                RenderSceneBuildError::MissingRenderOutputSourcePort {
1430                    output_node_id: "output_1".to_owned(),
1431                    source_node_id: "shader_1".to_owned(),
1432                    port_id: "out".to_owned(),
1433                },
1434                "missing-render-output-source-port",
1435                ShaderDiagnosticPhase::RenderPipeline,
1436                ShaderDiagnosticSource::Runtime,
1437            ),
1438            (
1439                RenderSceneBuildError::UnsupportedRenderOutputSource {
1440                    output_node_id: "output_1".to_owned(),
1441                    source_node_id: "value_1".to_owned(),
1442                    source_kind: "core.float".to_owned(),
1443                },
1444                "unsupported-render-output-source",
1445                ShaderDiagnosticPhase::RenderPipeline,
1446                ShaderDiagnosticSource::Runtime,
1447            ),
1448        ];
1449
1450        for (error, code, phase, source) in cases {
1451            let diagnostics = error.shader_diagnostics();
1452
1453            assert_eq!(diagnostics.len(), 1);
1454            assert_eq!(diagnostics[0].code, code);
1455            assert_eq!(diagnostics[0].phase, phase);
1456            assert_eq!(diagnostics[0].source, source);
1457            assert!(!diagnostics[0].message.is_empty());
1458        }
1459
1460        let diagnostic = ShaderDiagnostic::error(
1461            ShaderDiagnosticPhase::InterfaceAnalysis,
1462            "invalid-interface",
1463            "bad uniform",
1464            ShaderDiagnosticSource::User,
1465        );
1466        let error = RenderSceneBuildError::InvalidShaderInterface {
1467            node_id: "shader_1".to_owned(),
1468            message: "bad uniform".to_owned(),
1469            diagnostics: vec![diagnostic.clone()],
1470        };
1471
1472        assert_eq!(error.shader_diagnostics(), vec![diagnostic]);
1473    }
1474
1475    #[test]
1476    fn selects_first_render_output_deterministically() {
1477        let document = document_with_edges(
1478            vec![
1479                clear_node(json!([0.1, 0.2, 0.3, 1.0])),
1480                shader_node(json!("wgsl"), json!(shader_source())),
1481                output_node("output_a"),
1482                output_node("output_b"),
1483            ],
1484            vec![
1485                edge("clear_1", "out", "output_a", "in"),
1486                edge("shader_1", "out", "output_b", "in"),
1487            ],
1488        );
1489
1490        let scene = render_scene_from_preview_document(&document).expect("scene should build");
1491
1492        assert_eq!(
1493            scene,
1494            RenderScene::ClearColor(ClearColorScene {
1495                clear_color: [0.1, 0.2, 0.3, 1.0],
1496                source_node_id: Some("clear_1".to_owned())
1497            })
1498        );
1499    }
1500
1501    fn document_with_nodes(nodes: Vec<GraphNode>) -> PreviewDocument {
1502        document_with_edges(nodes, Vec::new())
1503    }
1504
1505    fn document_with_edges(nodes: Vec<GraphNode>, edges: Vec<Edge>) -> PreviewDocument {
1506        let graph = GraphDocument {
1507            schema: "skenion.graph".to_owned(),
1508            schema_version: "0.1.0".to_owned(),
1509            id: "render-graph".to_owned(),
1510            revision: "1".to_owned(),
1511            nodes,
1512            edges,
1513        };
1514        let control_state = crate::ControlState::from_graph(&graph);
1515
1516        PreviewDocument {
1517            schema: PREVIEW_DOCUMENT_SCHEMA.to_owned(),
1518            schema_version: PREVIEW_DOCUMENT_SCHEMA_VERSION.to_owned(),
1519            graph,
1520            plan: ExecutionPlan {
1521                graph_id: "render-graph".to_owned(),
1522                graph_revision: "1".to_owned(),
1523                nodes: Vec::new(),
1524                edges: Vec::new(),
1525                groups: Vec::new(),
1526            },
1527            control_state,
1528            session_revision: 1,
1529        }
1530    }
1531
1532    fn output_node(id: &str) -> GraphNode {
1533        GraphNode {
1534            id: id.to_owned(),
1535            kind: RENDER_OUTPUT_KIND.to_owned(),
1536            kind_version: "0.1.0".to_owned(),
1537            params: serde_json::Map::new(),
1538            ports: vec![gpu_input_port()],
1539        }
1540    }
1541
1542    fn clear_node(color: Value) -> GraphNode {
1543        let mut params = serde_json::Map::new();
1544        params.insert("color".to_owned(), color);
1545        GraphNode {
1546            id: "clear_1".to_owned(),
1547            kind: RENDER_CLEAR_COLOR_KIND.to_owned(),
1548            kind_version: "0.1.0".to_owned(),
1549            params,
1550            ports: vec![gpu_output_port()],
1551        }
1552    }
1553
1554    fn shader_node(language: Value, source: Value) -> GraphNode {
1555        let mut params = serde_json::Map::new();
1556        params.insert("language".to_owned(), language);
1557        params.insert("source".to_owned(), source);
1558        let ports = params
1559            .get("source")
1560            .and_then(Value::as_str)
1561            .map(analyze_shader_interface_v01)
1562            .filter(|analysis| analysis.ok)
1563            .map(|analysis| shader_interface_to_ports_v01(&analysis.shader_interface))
1564            .unwrap_or_else(|| vec![gpu_output_port()]);
1565        GraphNode {
1566            id: "shader_1".to_owned(),
1567            kind: RENDER_FULLSCREEN_SHADER_KIND.to_owned(),
1568            kind_version: "0.1.0".to_owned(),
1569            params,
1570            ports,
1571        }
1572    }
1573
1574    fn value_node() -> GraphNode {
1575        value_node_with_params(serde_json::Map::new())
1576    }
1577
1578    fn value_node_with_value(value: Value) -> GraphNode {
1579        value_node_with_id_and_value("value_1", value)
1580    }
1581
1582    fn value_node_with_id_and_value(id: &str, value: Value) -> GraphNode {
1583        let mut params = serde_json::Map::new();
1584        params.insert("value".to_owned(), value);
1585        value_node_with_id_and_params(id, params)
1586    }
1587
1588    fn value_node_with_params(params: serde_json::Map<String, Value>) -> GraphNode {
1589        value_node_with_id_and_params("value_1", params)
1590    }
1591
1592    fn value_node_with_id_and_params(
1593        id: &str,
1594        params: serde_json::Map<String, Value>,
1595    ) -> GraphNode {
1596        GraphNode {
1597            id: id.to_owned(),
1598            kind: "core.float".to_owned(),
1599            kind_version: "0.1.0".to_owned(),
1600            params,
1601            ports: vec![
1602                serde_json::from_value(json!({
1603                    "id": "in",
1604                    "direction": "input",
1605                    "label": "In",
1606                    "type": {
1607                        "flow": "event",
1608                        "dataKind": "message.any"
1609                    },
1610                    "required": false,
1611                    "activation": "trigger"
1612                }))
1613                .expect("valid value input port"),
1614                serde_json::from_value(json!({
1615                    "id": "cold",
1616                    "direction": "input",
1617                    "label": "Cold",
1618                    "type": {
1619                        "flow": "value",
1620                        "dataKind": "number.float"
1621                    },
1622                    "required": false,
1623                    "activation": "latched"
1624                }))
1625                .expect("valid value cold port"),
1626                serde_json::from_value(json!({
1627                    "id": "value",
1628                    "direction": "output",
1629                    "label": "Value",
1630                    "type": {
1631                        "flow": "value",
1632                        "dataKind": "number.float"
1633                    }
1634                }))
1635                .expect("valid value port"),
1636            ],
1637        }
1638    }
1639
1640    fn i32_node_with_value(id: &str, value: i32) -> GraphNode {
1641        let mut params = serde_json::Map::new();
1642        params.insert("value".to_owned(), json!(value));
1643        GraphNode {
1644            id: id.to_owned(),
1645            kind: "core.int".to_owned(),
1646            kind_version: "0.1.0".to_owned(),
1647            params,
1648            ports: vec![
1649                serde_json::from_value(json!({
1650                    "id": "value",
1651                    "direction": "output",
1652                    "label": "Value",
1653                    "type": {
1654                        "flow": "value",
1655                        "dataKind": "number.int"
1656                    }
1657                }))
1658                .expect("valid i32 value port"),
1659            ],
1660        }
1661    }
1662
1663    fn bool_node_with_value(id: &str, value: bool) -> GraphNode {
1664        let mut params = serde_json::Map::new();
1665        params.insert("value".to_owned(), json!(value));
1666        GraphNode {
1667            id: id.to_owned(),
1668            kind: "core.bool".to_owned(),
1669            kind_version: "0.1.0".to_owned(),
1670            params,
1671            ports: vec![
1672                serde_json::from_value(json!({
1673                    "id": "value",
1674                    "direction": "output",
1675                    "label": "Value",
1676                    "type": {
1677                        "flow": "value",
1678                        "dataKind": "boolean"
1679                    }
1680                }))
1681                .expect("valid bool value port"),
1682            ],
1683        }
1684    }
1685
1686    fn u32_node_with_value(id: &str, value: u64) -> GraphNode {
1687        let mut params = serde_json::Map::new();
1688        params.insert("value".to_owned(), json!(value));
1689        GraphNode {
1690            id: id.to_owned(),
1691            kind: "core.uint".to_owned(),
1692            kind_version: "0.1.0".to_owned(),
1693            params,
1694            ports: vec![
1695                serde_json::from_value(json!({
1696                    "id": "value",
1697                    "direction": "output",
1698                    "label": "Value",
1699                    "type": {
1700                        "flow": "value",
1701                        "dataKind": "number.uint"
1702                    }
1703                }))
1704                .expect("valid u32 value port"),
1705            ],
1706        }
1707    }
1708
1709    fn color_node_with_value(value: Value) -> GraphNode {
1710        let mut params = serde_json::Map::new();
1711        params.insert("value".to_owned(), value);
1712        GraphNode {
1713            id: "color_1".to_owned(),
1714            kind: "core.color".to_owned(),
1715            kind_version: "0.1.0".to_owned(),
1716            params,
1717            ports: vec![
1718                serde_json::from_value(json!({
1719                    "id": "in",
1720                    "direction": "input",
1721                    "label": "In",
1722                    "type": {
1723                        "flow": "event",
1724                        "dataKind": "message.any"
1725                    },
1726                    "required": false,
1727                    "activation": "trigger"
1728                }))
1729                .expect("valid color input port"),
1730                serde_json::from_value(json!({
1731                    "id": "cold",
1732                    "direction": "input",
1733                    "label": "Cold",
1734                    "type": {
1735                        "flow": "value",
1736                        "dataKind": "color"
1737                    },
1738                    "required": false,
1739                    "activation": "latched"
1740                }))
1741                .expect("valid color cold port"),
1742                serde_json::from_value(json!({
1743                    "id": "value",
1744                    "direction": "output",
1745                    "label": "Color",
1746                    "type": {
1747                        "flow": "value",
1748                        "dataKind": "color"
1749                    }
1750                }))
1751                .expect("valid color port"),
1752            ],
1753        }
1754    }
1755
1756    fn shader_u_value(scene: &RenderScene) -> f32 {
1757        match shader_uniform(scene, "speed") {
1758            ShaderUniformValue::F32(value) => *value,
1759            _ => panic!("expected f32 speed uniform"),
1760        }
1761    }
1762
1763    fn shader_u_value2(scene: &RenderScene) -> f32 {
1764        match shader_uniform(scene, "phase") {
1765            ShaderUniformValue::F32(value) => *value,
1766            _ => panic!("expected f32 phase uniform"),
1767        }
1768    }
1769
1770    fn shader_u_color(scene: &RenderScene) -> [f32; 4] {
1771        match shader_uniform(scene, "tint") {
1772            ShaderUniformValue::ColorRgba(value) => *value,
1773            _ => panic!("expected color tint uniform"),
1774        }
1775    }
1776
1777    fn shader_uniform<'a>(scene: &'a RenderScene, id: &str) -> &'a ShaderUniformValue {
1778        match scene {
1779            RenderScene::FullscreenShader(shader) => {
1780                &shader
1781                    .uniforms
1782                    .iter()
1783                    .find(|uniform| uniform.id == id)
1784                    .unwrap_or_else(|| panic!("missing shader uniform {id}"))
1785                    .value
1786            }
1787            _ => panic!("expected fullscreen shader scene"),
1788        }
1789    }
1790
1791    fn shader_scene_with_uniform(id: &str, value: ShaderUniformValue) -> RenderScene {
1792        RenderScene::FullscreenShader(FullscreenShaderScene {
1793            language: ShaderLanguage::Wgsl,
1794            source: "fn fs_main() -> @location(0) vec4<f32> { return vec4<f32>(1.0); }".to_owned(),
1795            source_node_id: "shader_1".to_owned(),
1796            uniforms: vec![ShaderUniformBinding {
1797                id: id.to_owned(),
1798                value,
1799            }],
1800            fallback_clear_color: DEFAULT_CLEAR_COLOR,
1801        })
1802    }
1803
1804    fn edge(from_node: &str, from_port: &str, to_node: &str, to_port: &str) -> Edge {
1805        Edge {
1806            from: PortRef {
1807                node: from_node.to_owned(),
1808                port: from_port.to_owned(),
1809            },
1810            to: PortRef {
1811                node: to_node.to_owned(),
1812                port: to_port.to_owned(),
1813            },
1814        }
1815    }
1816
1817    fn gpu_output_port() -> Port {
1818        serde_json::from_value(json!({
1819            "id": "out",
1820            "direction": "output",
1821            "label": "Out",
1822            "type": gpu_texture_type()
1823        }))
1824        .expect("valid gpu output port")
1825    }
1826
1827    fn gpu_input_port() -> Port {
1828        serde_json::from_value(json!({
1829            "id": "in",
1830            "direction": "input",
1831            "label": "In",
1832            "type": gpu_texture_type(),
1833            "activation": "latched"
1834        }))
1835        .expect("valid gpu input port")
1836    }
1837
1838    fn gpu_texture_type() -> Value {
1839        json!({
1840            "flow": "resource",
1841            "dataKind": "gpu.texture2d",
1842            "format": "rgba8unorm",
1843            "colorSpace": "srgb"
1844        })
1845    }
1846
1847    fn shader_source() -> &'static str {
1848        r#"// @skenion.uniform speed number.float default=0 min=0 max=1 step=0.01
1849// @skenion.uniform phase number.float default=0 min=0 max=1 step=0.01
1850// @skenion.uniform tint color default=[1,1,1,1]
1851@fragment
1852fn fs_main() -> @location(0) vec4<f32> {
1853  let mix_value = clamp(skenion.speed, 0.0, 1.0);
1854  let brightness = 0.25 + 0.75 * clamp(skenion.phase, 0.0, 1.0);
1855  let animated = vec3<f32>(0.2 + mix_value * 0.8, 0.3, 1.0 - mix_value);
1856  return vec4<f32>(mix(animated, skenion.tint.rgb, mix_value) * brightness, skenion.tint.a);
1857}"#
1858    }
1859
1860    fn typed_shader_source() -> &'static str {
1861        r#"// @skenion.uniform iterations number.int default=8
1862// @skenion.uniform enabled boolean default=true
1863@fragment
1864fn fs_main() -> @location(0) vec4<f32> {
1865  let enabled_value = select(0.0, 1.0, skenion.enabled);
1866  return vec4<f32>(f32(skenion.iterations) / 16.0, enabled_value, 0.25, 1.0);
1867}"#
1868    }
1869
1870    fn uint_shader_source() -> &'static str {
1871        r#"// @skenion.uniform count number.uint default=4
1872@fragment
1873fn fs_main() -> @location(0) vec4<f32> {
1874  return vec4<f32>(f32(skenion.count) / 255.0, 0.0, 0.0, 1.0);
1875}"#
1876    }
1877}