Skip to main content

webizen_render/
poet_preview.rs

1//! Native `webizen-render` provider for the POET loopback service boundary.
2
3use std::{collections::BTreeMap, sync::Arc};
4
5use qualia_core_db::{
6    poet_host::{invoke::ids, PoetSnapshot},
7    services::poet_render_api::{
8        register_poet_render_provider as register_provider, PoetRenderProvider, PoetRenderRequest,
9        PoetRenderResponse,
10    },
11};
12use vibe::Value;
13
14use crate::scene_contract::{
15    RenderScene, SceneCamera, SceneEdge, SceneFace, SceneNode, ScenePoint, Tensor10DProjection,
16};
17
18pub struct WebizenPoetRenderProvider;
19
20/// Register the real native renderer before the loopback server starts.
21pub fn register_poet_render_provider() -> Result<(), &'static str> {
22    register_provider(Arc::new(WebizenPoetRenderProvider))
23}
24
25impl PoetRenderProvider for WebizenPoetRenderProvider {
26    fn render_preview(&self, request: &PoetRenderRequest) -> PoetRenderResponse {
27        let width = request.width.unwrap_or(960);
28        let height = request.height.unwrap_or(480);
29        let mut snapshot = PoetSnapshot::from_daemon();
30        let mut args = BTreeMap::new();
31        args.insert("kind".into(), Value::String(request.kind.clone()));
32        let value = match snapshot.invoke_id(ids::RENDER_SCENE, Value::Record(args)) {
33            Ok(value) => value,
34            Err(error) => {
35                return response(
36                    request,
37                    width,
38                    height,
39                    false,
40                    0,
41                    0,
42                    0,
43                    None,
44                    Some(error.to_string()),
45                );
46            }
47        };
48
49        let scene = scene_from_value(&value);
50        let data_uri = crate::render_scene_data_uri(&scene, width, height);
51        response(
52            request,
53            width,
54            height,
55            data_uri.is_some(),
56            scene.nodes.len(),
57            scene.edges.len(),
58            scene.faces.len(),
59            data_uri,
60            None,
61        )
62    }
63}
64
65#[allow(clippy::too_many_arguments)]
66fn response(
67    request: &PoetRenderRequest,
68    width: u32,
69    height: u32,
70    ok: bool,
71    node_count: usize,
72    edge_count: usize,
73    face_count: usize,
74    data_uri: Option<String>,
75    diagnostic: Option<String>,
76) -> PoetRenderResponse {
77    PoetRenderResponse {
78        ok,
79        kind: request.kind.clone(),
80        honesty: if ok { "live" } else { "unavailable" }.into(),
81        width,
82        height,
83        node_count,
84        edge_count,
85        face_count,
86        data_uri,
87        diagnostic: diagnostic.or_else(|| {
88            (!ok).then(|| {
89                "webizen-render returned no frame; no compatible GPU adapter may be available"
90                    .into()
91            })
92        }),
93        contract: "webizen_render::scene_contract::RenderScene".into(),
94    }
95}
96
97/// `scene-from` value.
98pub fn scene_from_value(value: &Value) -> RenderScene {
99    let mut scene = RenderScene::new();
100    scene.set_background(rec_str(value, "background").unwrap_or_else(|| "#07090e".into()));
101    if let Some(Value::Record(camera)) = rec(value, "camera") {
102        scene.set_camera(SceneCamera {
103            position: [
104                num(camera, "x").unwrap_or(0.0),
105                num(camera, "y").unwrap_or(0.0),
106                num(camera, "z").unwrap_or(2.4),
107            ],
108            target: [0.5, 0.5, 0.0],
109            fov: num(camera, "fov").unwrap_or(58.0),
110        });
111    }
112    if let Some(Value::List(nodes)) = rec(value, "nodes") {
113        for node in nodes.iter().filter_map(node_from) {
114            scene.add_node(node);
115        }
116    }
117    if let Some(Value::List(edges)) = rec(value, "edges") {
118        for edge in edges.iter().filter_map(edge_from) {
119            scene.add_edge(edge);
120        }
121    }
122    if let Some(Value::List(faces)) = rec(value, "faces") {
123        for face in faces.iter().filter_map(face_from) {
124            scene.add_face(face);
125        }
126    }
127    scene
128}
129
130fn node_from(value: &Value) -> Option<SceneNode> {
131    let Value::Record(record) = value else {
132        return None;
133    };
134    let sigma = num(record, "sigma").unwrap_or(0.4);
135    Some(SceneNode {
136        id: string(record, "id").unwrap_or_else(|| "node".into()),
137        position: ScenePoint {
138            x: num(record, "x")?,
139            y: num(record, "y")?,
140            z: num(record, "z").unwrap_or(0.0),
141        },
142        color: string(record, "color").unwrap_or_else(|| "#00d2ff".into()),
143        radius: num(record, "radius").unwrap_or(6.0),
144        alpha: num(record, "alpha").unwrap_or(0.92),
145        pulse_rate: 0.4,
146        tensor: Tensor10DProjection {
147            sigma,
148            x: num(record, "x").unwrap_or(0.5),
149            y: num(record, "y").unwrap_or(0.5),
150            z: num(record, "z").unwrap_or(0.0),
151            alpha: num(record, "alpha").unwrap_or(0.92),
152            ..Tensor10DProjection::default()
153        },
154        ..SceneNode::default()
155    })
156}
157
158fn edge_from(value: &Value) -> Option<SceneEdge> {
159    let Value::Record(record) = value else {
160        return None;
161    };
162    Some(SceneEdge {
163        from: point(record.get("from")?)?,
164        to: point(record.get("to")?)?,
165        color: string(record, "color").unwrap_or_else(|| "#334155".into()),
166        width: num(record, "width").unwrap_or(1.2),
167        alpha: num(record, "alpha").unwrap_or(0.8),
168    })
169}
170
171fn face_from(value: &Value) -> Option<SceneFace> {
172    let Value::Record(record) = value else {
173        return None;
174    };
175    let Value::List(values) = record.get("vertices")? else {
176        return None;
177    };
178    let vertices: Vec<ScenePoint> = values.iter().filter_map(point).collect();
179    (vertices.len() >= 3).then(|| SceneFace {
180        vertices,
181        color: string(record, "color").unwrap_or_else(|| "#14532d".into()),
182        alpha: num(record, "alpha").unwrap_or(0.28),
183    })
184}
185
186fn point(value: &Value) -> Option<ScenePoint> {
187    match value {
188        Value::List(values) if values.len() >= 2 => Some(ScenePoint {
189            x: as_f64(&values[0])?,
190            y: as_f64(&values[1])?,
191            z: values.get(2).and_then(as_f64).unwrap_or(0.0),
192        }),
193        Value::Record(record) => Some(ScenePoint {
194            x: num(record, "x")?,
195            y: num(record, "y")?,
196            z: num(record, "z").unwrap_or(0.0),
197        }),
198        _ => None,
199    }
200}
201
202fn rec<'a>(value: &'a Value, key: &str) -> Option<&'a Value> {
203    match value {
204        Value::Record(record) => record.get(key),
205        _ => None,
206    }
207}
208
209fn rec_str(value: &Value, key: &str) -> Option<String> {
210    match rec(value, key) {
211        Some(Value::String(value)) => Some(value.clone()),
212        _ => None,
213    }
214}
215
216fn string(record: &BTreeMap<String, Value>, key: &str) -> Option<String> {
217    match record.get(key) {
218        Some(Value::String(value)) => Some(value.clone()),
219        _ => None,
220    }
221}
222
223fn num(record: &BTreeMap<String, Value>, key: &str) -> Option<f64> {
224    record.get(key).and_then(as_f64)
225}
226
227fn as_f64(value: &Value) -> Option<f64> {
228    match value {
229        Value::F64(value) => Some(*value),
230        Value::I64(value) => Some(*value as f64),
231        Value::U64(value) => Some(*value as f64),
232        _ => None,
233    }
234}
235
236#[cfg(test)]
237mod tests {
238    use super::*;
239
240    #[test]
241    fn empty_record_maps_to_empty_scene() {
242        let scene = scene_from_value(&Value::Record(BTreeMap::new()));
243        assert!(scene.nodes.is_empty());
244        assert!(scene.edges.is_empty());
245        assert!(scene.faces.is_empty());
246    }
247
248    #[test]
249    fn unavailable_response_never_includes_a_synthetic_frame() {
250        let request = PoetRenderRequest {
251            kind: "map".into(),
252            width: Some(320),
253            height: Some(180),
254        };
255        let result = response(&request, 320, 180, false, 0, 0, 0, None, None);
256        assert!(!result.ok);
257        assert_eq!(result.honesty, "unavailable");
258        assert!(result.data_uri.is_none());
259        assert!(result.diagnostic.is_some());
260    }
261}