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}