feat: upgrade stardust-xr version

Cargo.toml

@@ -32,7 +32,7 @@ prisma = "0.1.1"
 slog = "2.7.0"
 slog-stdlog = "4.1.1"
 xkbcommon = { version = "0.5.0", default-features = false }
-stardust-xr = "0.4.1"
+stardust-xr = "0.5.2"
 wayland-backend = "=0.1.0-beta.9"
 wayland-scanner = "=0.30.0-beta.9"
 directories = "4.0.1"

src/nodes/fields/sphere.rs

@@ -78,7 +78,11 @@ pub fn create_sphere_field_flex(
 	let info: CreateFieldInfo = deserialize(data)?;
 	let node = Node::create(&calling_client, "/field", info.name, true);
 	let parent = get_spatial_parent_flex(&calling_client, info.parent_path)?;
-	let transform = Mat4::from_translation(info.origin.unwrap_or(Vector3::from([0.0; 3])).into());
+	let transform = Mat4::from_translation(
+		info.origin
+			.unwrap_or_else(|| Vector3::from([0.0; 3]))
+			.into(),
+	);
 	let node = node.add_to_scenegraph();
 	Spatial::add_to(&node, Some(parent), transform)?;
 	SphereField::add_to(&node, info.radius)?;

src/nodes/input/hand.rs

@@ -1,13 +1,14 @@
 use crate::nodes::fields::Field;
 use crate::nodes::spatial::Spatial;
 use glam::{vec3a, Mat4};
-use stardust_xr::schemas::{common::JointT, input::InputDataRaw, input_hand::HandT};
+use stardust_xr::schemas::flat::{Datamap, Hand as FlatHand, InputDataType, Joint};
 use std::sync::Arc;
 
 use super::{DistanceLink, InputSpecialization};
 
+#[derive(Debug, Default)]
 pub struct Hand {
-	pub base: HandT,
+	pub base: FlatHand,
 	pub pinch_strength: f32,
 	pub grab_strength: f32,
 }
@@ -29,15 +30,11 @@ impl InputSpecialization for Hand {
 	}
 	fn serialize(
 		&self,
-		fbb: &mut flatbuffers::FlatBufferBuilder,
 		_distance_link: &DistanceLink,
 		local_to_handler_matrix: Mat4,
-	) -> (
-		InputDataRaw,
-		flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
-	) {
-		let mut hand = self.base.clone();
-		let mut joints: Vec<&mut JointT> = Vec::new();
+	) -> InputDataType {
+		let mut hand = self.base;
+		let mut joints: Vec<&mut Joint> = Vec::new();
 
 		joints.extend([&mut hand.palm, &mut hand.wrist]);
 		if let Some(elbow) = &mut hand.elbow {
@@ -65,26 +62,23 @@ impl InputSpecialization for Hand {
 		]);
 
 		for joint in joints {
-			let rotation: mint::Quaternion<f32> = joint.rotation.clone().into();
-			let position: mint::Vector3<f32> = joint.position.clone().into();
-			let joint_matrix = Mat4::from_rotation_translation(rotation.into(), position.into())
-				* local_to_handler_matrix;
+			let joint_matrix =
+				Mat4::from_rotation_translation(joint.rotation.into(), joint.position.into())
+					* local_to_handler_matrix;
 			let (_, rotation, position) = joint_matrix.to_scale_rotation_translation();
-			let rotation: mint::Quaternion<f32> = rotation.into();
-			let position: mint::Vector3<f32> = position.into();
 			joint.position = position.into();
 			joint.rotation = rotation.into();
 		}
 
-		(InputDataRaw::Hand, hand.pack(fbb).as_union_value())
+		InputDataType::Hand(Box::new(hand))
 	}
-	fn serialize_datamap(&self) -> Vec<u8> {
+	fn serialize_datamap(&self) -> Datamap {
 		let mut fbb = flexbuffers::Builder::default();
 		let mut map = fbb.start_map();
 		map.push("right", self.base.right);
 		map.push("pinchStrength", self.pinch_strength);
 		map.push("grabStrength", self.grab_strength);
 		map.end_map();
-		fbb.view().to_vec()
+		Datamap::new(fbb.view().to_vec()).unwrap()
 	}
 }

src/nodes/input/mod.rs

@@ -17,8 +17,8 @@ use glam::Mat4;
 use nanoid::nanoid;
 use parking_lot::Mutex;
 use serde::Deserialize;
-use stardust_xr::schemas::flex::deserialize;
-use stardust_xr::schemas::input::{InputData, InputDataArgs, InputDataRaw};
+use stardust_xr::schemas::flat::{Datamap, InputDataType};
+use stardust_xr::schemas::{flat::InputData, flex::deserialize};
 use stardust_xr::values::Transform;
 use std::ops::Deref;
 use std::sync::atomic::Ordering;
@@ -31,14 +31,10 @@ pub trait InputSpecialization: Send + Sync {
 	fn distance(&self, space: &Arc<Spatial>, field: &Field) -> f32;
 	fn serialize(
 		&self,
-		fbb: &mut flatbuffers::FlatBufferBuilder,
 		distance_link: &DistanceLink,
 		local_to_handler_matrix: Mat4,
-	) -> (
-		InputDataRaw,
-		flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
-	);
-	fn serialize_datamap(&self) -> Vec<u8>;
+	) -> InputDataType;
+	fn serialize_datamap(&self) -> Datamap;
 }
 pub enum InputType {
 	Pointer(Pointer),
@@ -95,7 +91,7 @@ impl InputMethod {
 	fn distance(&self, to: &Field) -> f32 {
 		self.specialization.lock().distance(&self.spatial, to)
 	}
-	fn serialize_datamap(&self) -> Vec<u8> {
+	fn serialize_datamap(&self) -> Datamap {
 		self.specialization.lock().serialize_datamap()
 	}
 }
@@ -122,32 +118,22 @@ impl DistanceLink {
 		})
 	}
 
-	fn send_input(&self, frame: u64, datamap: &[u8]) {
+	fn send_input(&self, frame: u64, datamap: Datamap) {
 		self.handler.send_input(frame, self, datamap);
 	}
-	fn serialize(&self, datamap: &[u8]) -> Vec<u8> {
-		let mut fbb = flatbuffers::FlatBufferBuilder::with_capacity(1024);
-		let uid = Some(fbb.create_string(&self.method.uid));
-		let datamap = Some(fbb.create_vector(datamap));
-
-		let (input_type, input_data) = self.method.specialization.lock().serialize(
-			&mut fbb,
+	fn serialize(&self, datamap: Datamap) -> Vec<u8> {
+		let input = self.method.specialization.lock().serialize(
 			self,
 			Spatial::space_to_space_matrix(Some(&self.method.spatial), Some(&self.handler.spatial)),
 		);
 
-		let root = InputData::create(
-			&mut fbb,
-			&InputDataArgs {
-				uid,
-				input_type,
-				input: Some(input_data),
-				distance: self.distance,
-				datamap,
-			},
-		);
-		fbb.finish(root, None);
-		Vec::from(fbb.finished_data())
+		let root = InputData {
+			uid: self.method.uid.clone(),
+			input,
+			distance: self.distance,
+			datamap,
+		};
+		root.serialize()
 	}
 }
 
@@ -173,7 +159,7 @@ impl InputHandler {
 		Ok(())
 	}
 
-	fn send_input(&self, frame: u64, distance_link: &DistanceLink, datamap: &[u8]) {
+	fn send_input(&self, frame: u64, distance_link: &DistanceLink, datamap: Datamap) {
 		let data = distance_link.serialize(datamap);
 		let node = self.node.upgrade().unwrap();
 		let method = Arc::downgrade(&distance_link.method);
@@ -263,11 +249,11 @@ pub fn process_input() {
 		});
 
 		let datamap = method.serialize_datamap();
+		let mut last_distance = 0.0;
 		let frame = FRAME.load(Ordering::Relaxed);
 		let captures = method.captures.get_valid_contents();
-		let mut last_distance = 0.0;
 		for distance_link in distance_links {
-			distance_link.send_input(frame, &datamap);
+			distance_link.send_input(frame, datamap.clone());
 			if last_distance != distance_link.distance
 				&& captures
 					.iter()

src/nodes/input/pointer.rs

@@ -2,7 +2,7 @@ use super::{DistanceLink, InputSpecialization};
 use crate::nodes::fields::{ray_march, Field, Ray, RayMarchResult};
 use crate::nodes::spatial::Spatial;
 use glam::{vec3, Mat4};
-use stardust_xr::schemas::{input::InputDataRaw, input_pointer};
+use stardust_xr::schemas::flat::{Datamap, InputDataType, Pointer as FlatPointer};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
@@ -38,13 +38,9 @@ impl InputSpecialization for Pointer {
 	}
 	fn serialize(
 		&self,
-		fbb: &mut flatbuffers::FlatBufferBuilder,
 		distance_link: &DistanceLink,
 		local_to_handler_matrix: Mat4,
-	) -> (
-		InputDataRaw,
-		flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
-	) {
+	) -> InputDataType {
 		let (_, orientation, origin) = local_to_handler_matrix.to_scale_rotation_translation();
 		let direction = local_to_handler_matrix.transform_vector3(vec3(0_f32, 0_f32, 1_f32));
 		let ray_march = self.ray_march(
@@ -53,26 +49,18 @@ impl InputSpecialization for Pointer {
 		);
 		let deepest_point = (direction * ray_march.deepest_point_distance) + origin;
 
-		let origin: mint::Vector3<f32> = origin.into();
-		let orientation: mint::Quaternion<f32> = orientation.into();
-		let deepest_point: mint::Vector3<f32> = deepest_point.into();
-
-		let pointer = input_pointer::Pointer::create(
-			fbb,
-			&input_pointer::PointerArgs {
-				origin: Some(&origin.into()),
-				orientation: Some(&orientation.into()),
-				deepest_point: Some(&deepest_point.into()),
-			},
-		);
-		(InputDataRaw::Pointer, pointer.as_union_value())
+		InputDataType::Pointer(FlatPointer {
+			origin: origin.into(),
+			orientation: orientation.into(),
+			deepest_point: deepest_point.into(),
+		})
 	}
-	fn serialize_datamap(&self) -> Vec<u8> {
+	fn serialize_datamap(&self) -> Datamap {
 		let mut fbb = flexbuffers::Builder::default();
 		let mut map = fbb.start_map();
 		map.push("grab", self.grab.load(Ordering::Relaxed));
 		map.push("select", self.select.load(Ordering::Relaxed));
 		map.end_map();
-		fbb.view().to_vec()
+		Datamap::new(fbb.view().to_vec()).unwrap()
 	}
 }

src/nodes/input/tip.rs

@@ -3,7 +3,7 @@ use crate::nodes::fields::Field;
 use crate::nodes::spatial::Spatial;
 use glam::{vec3a, Mat4};
 use portable_atomic::AtomicF32;
-use stardust_xr::schemas::{input::InputDataRaw, input_tip};
+use stardust_xr::schemas::flat::{Datamap, InputDataType, Tip as FlatTip};
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
@@ -20,34 +20,22 @@ impl InputSpecialization for Tip {
 	}
 	fn serialize(
 		&self,
-		fbb: &mut flatbuffers::FlatBufferBuilder,
 		_distance_link: &DistanceLink,
 		local_to_handler_matrix: Mat4,
-	) -> (
-		InputDataRaw,
-		flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
-	) {
+	) -> InputDataType {
 		let (_, orientation, origin) = local_to_handler_matrix.to_scale_rotation_translation();
-
-		let origin: mint::Vector3<f32> = origin.into();
-		let orientation: mint::Quaternion<f32> = orientation.into();
-
-		let tip = input_tip::Tip::create(
-			fbb,
-			&input_tip::TipArgs {
-				origin: Some(&origin.into()),
-				orientation: Some(&orientation.into()),
-				radius: self.radius.load(Ordering::Relaxed),
-			},
-		);
-		(InputDataRaw::Tip, tip.as_union_value())
+		InputDataType::Tip(FlatTip {
+			origin: origin.into(),
+			orientation: orientation.into(),
+			radius: self.radius.load(Ordering::Relaxed),
+		})
 	}
-	fn serialize_datamap(&self) -> Vec<u8> {
+	fn serialize_datamap(&self) -> Datamap {
 		let mut fbb = flexbuffers::Builder::default();
 		let mut map = fbb.start_map();
 		map.push("grab", self.grab.load(Ordering::Relaxed));
 		map.push("select", self.select.load(Ordering::Relaxed));
 		map.end_map();
-		fbb.view().to_vec()
+		Datamap::new(fbb.view().to_vec()).unwrap()
 	}
 }

src/objects/input/mouse_pointer.rs

@@ -24,7 +24,7 @@ impl MousePointer {
 			self.pointer.spatial.set_local_transform_components(
 				None,
 				Transform {
-					position: Some(ray.pos.into()),
+					position: Some(ray.pos),
 					rotation: Some(
 						glam::Quat::from_rotation_arc(vec3(0.0, 0.0, 1.0), ray.dir.into()).into(),
 					),

src/objects/input/sk_controller.rs

@@ -30,8 +30,8 @@ impl SkController {
 				self.tip.spatial.set_local_transform_components(
 					None,
 					Transform {
-						position: Some(controller.pose.position.into()),
-						rotation: Some(controller.pose.orientation.into()),
+						position: Some(controller.pose.position),
+						rotation: Some(controller.pose.orientation),
 						scale: None,
 					},
 				);

src/objects/input/sk_hand.rs

@@ -3,17 +3,17 @@ use crate::nodes::{
 	spatial::Spatial,
 };
 use glam::Mat4;
-use stardust_xr::schemas::{common::JointT, input_hand::HandT};
+use stardust_xr::schemas::flat::{Hand as FlatHand, Joint};
 use std::sync::{Arc, Weak};
 use stereokit::{
 	input::{Handed, Joint as SkJoint},
 	StereoKit,
 };
 
-fn convert_joint(joint: SkJoint) -> JointT {
-	JointT {
-		position: joint.position.into(),
-		rotation: joint.orientation.into(),
+fn convert_joint(joint: SkJoint) -> Joint {
+	Joint {
+		position: joint.position,
+		rotation: joint.orientation,
 		radius: joint.radius,
 	}
 }
@@ -24,13 +24,14 @@ pub struct SkHand {
 }
 impl SkHand {
 	pub fn new(handed: Handed) -> Self {
-		let mut sk_hand = HandT::default();
-		sk_hand.right = handed == Handed::Right;
 		SkHand {
 			hand: InputMethod::new(
 				Spatial::new(Weak::new(), None, Mat4::IDENTITY),
 				InputType::Hand(Box::new(Hand {
-					base: sk_hand,
+					base: FlatHand {
+						right: handed == Handed::Right,
+						..Default::default()
+					},
 					pinch_strength: 0.0,
 					grab_strength: 0.0,
 				})),
@@ -63,13 +64,13 @@ impl SkHand {
 					finger.metacarpal = convert_joint(sk_finger[0]);
 				}
 
-				hand.base.palm.position = sk_hand.palm.position.into();
-				hand.base.palm.rotation = sk_hand.palm.orientation.into();
+				hand.base.palm.position = sk_hand.palm.position;
+				hand.base.palm.rotation = sk_hand.palm.orientation;
 				hand.base.palm.radius =
 					(sk_hand.fingers[2][0].radius + sk_hand.fingers[2][1].radius) * 0.5;
 
-				hand.base.wrist.position = sk_hand.wrist.position.into();
-				hand.base.wrist.rotation = sk_hand.wrist.orientation.into();
+				hand.base.wrist.position = sk_hand.wrist.position;
+				hand.base.wrist.rotation = sk_hand.wrist.orientation;
 				hand.base.wrist.radius =
 					(sk_hand.fingers[0][0].radius + sk_hand.fingers[4][0].radius) * 0.5;