1use 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
20pub 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
97pub 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}