Skip to main content

webizen_render/
scene_contract.rs

1//! Neutral GPU-facing scene contract.
2//!
3//! Re-exports the canonical serde-serializable scene contract from
4//! `etalon_render::webizen_core::scene_contract`.
5
6pub use etalon_render::webizen_core::scene_contract::*;
7
8#[cfg(test)]
9mod tests {
10    use super::*;
11
12    #[test]
13    fn test_scene_point_serialization() {
14        let point = ScenePoint {
15            x: 0.5,
16            y: 0.3,
17            z: 0.0,
18        };
19        let serialized = serde_json::to_string(&point).unwrap();
20        let deserialized: ScenePoint = serde_json::from_str(&serialized).unwrap();
21        assert_eq!(point, deserialized);
22    }
23
24    #[test]
25    fn test_scene_node_serialization() {
26        let node = SceneNode {
27            id: "test-node".to_string(),
28            position: ScenePoint {
29                x: 0.5,
30                y: 0.3,
31                z: 0.0,
32            },
33            color: "#ff0000".to_string(),
34            radius: 5.0,
35            alpha: 1.0,
36            is_inferencing: false,
37            pulse_rate: 0.0,
38            ..SceneNode::default()
39        };
40        let serialized = serde_json::to_string(&node).unwrap();
41        let deserialized: SceneNode = serde_json::from_str(&serialized).unwrap();
42        assert_eq!(node.color, deserialized.color);
43        assert_eq!(node.radius, deserialized.radius);
44        assert_eq!(node.is_inferencing, deserialized.is_inferencing);
45        assert_eq!(node.id, deserialized.id);
46    }
47
48    #[test]
49    fn test_render_scene_serialization() {
50        let scene = RenderScene {
51            nodes: vec![SceneNode {
52                id: "test-node".to_string(),
53                position: ScenePoint {
54                    x: 0.5,
55                    y: 0.3,
56                    z: 0.0,
57                },
58                color: "#ff0000".to_string(),
59                radius: 5.0,
60                alpha: 1.0,
61                is_inferencing: false,
62                pulse_rate: 0.0,
63                ..SceneNode::default()
64            }],
65            edges: vec![],
66            faces: vec![],
67            camera: SceneCamera::default(),
68            background: "#101820".to_string(),
69            ..RenderScene::default()
70        };
71        let serialized = serde_json::to_string(&scene).unwrap();
72        let deserialized: RenderScene = serde_json::from_str(&serialized).unwrap();
73        assert_eq!(scene.nodes.len(), deserialized.nodes.len());
74        assert_eq!(scene.background, deserialized.background);
75    }
76
77    #[test]
78    fn test_render_scene_builder() {
79        let mut scene = RenderScene::new();
80        scene.set_background("#202030");
81        assert_eq!(scene.background, "#202030");
82        assert!(scene.is_empty());
83
84        scene.add_node(SceneNode {
85            id: "test-node".to_string(),
86            position: ScenePoint {
87                x: 0.5,
88                y: 0.5,
89                z: 0.0,
90            },
91            color: "#00ff00".to_string(),
92            radius: 3.0,
93            alpha: 0.8,
94            is_inferencing: false,
95            pulse_rate: 0.0,
96            ..SceneNode::default()
97        });
98        assert!(!scene.is_empty());
99        assert_eq!(scene.element_count(), 1);
100    }
101
102    #[cfg(feature = "qualia")]
103    #[test]
104    fn spectral_color_uses_engine_oracle() {
105        let tensor = Tensor10DProjection {
106            sigma: 0.42,
107            ..Tensor10DProjection::default()
108        };
109        let (r, g, b) = qualia_core_db::render::spectral::sigma_to_display_rgb(0.42);
110        assert_eq!(tensor.spectral_to_color(), format!("rgb({r}, {g}, {b})"));
111    }
112}