refactor(input): flexible datamaps

src/nodes/input/hand.rs

@@ -1,7 +1,7 @@
 use crate::nodes::fields::Field;
 use crate::nodes::spatial::Spatial;
 use glam::{vec3a, Mat4};
-use stardust_xr::schemas::flat::{Datamap, Hand as FlatHand, InputDataType, Joint};
+use stardust_xr::schemas::flat::{Hand as FlatHand, InputDataType, Joint};
 use std::sync::Arc;
 
 use super::{DistanceLink, InputSpecialization};
@@ -9,8 +9,6 @@ use super::{DistanceLink, InputSpecialization};
 #[derive(Debug, Default)]
 pub struct Hand {
 	pub base: FlatHand,
-	pub pinch_strength: f32,
-	pub grab_strength: f32,
 }
 impl InputSpecialization for Hand {
 	fn distance(&self, space: &Arc<Spatial>, field: &Field) -> f32 {
@@ -72,13 +70,4 @@ impl InputSpecialization for Hand {
 
 		InputDataType::Hand(Box::new(hand))
 	}
-	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();
-		Datamap::new(fbb.view().to_vec()).unwrap()
-	}
 }

src/nodes/input/mod.rs

@@ -34,7 +34,6 @@ pub trait InputSpecialization: Send + Sync {
 		distance_link: &DistanceLink,
 		local_to_handler_matrix: Mat4,
 	) -> InputDataType;
-	fn serialize_datamap(&self) -> Datamap;
 }
 pub enum InputType {
 	Pointer(Pointer),
@@ -58,6 +57,7 @@ pub struct InputMethod {
 	pub spatial: Arc<Spatial>,
 	pub specialization: Mutex<InputType>,
 	pub captures: Registry<InputHandler>,
+	pub datamap: Mutex<Option<Datamap>>,
 }
 impl InputMethod {
 	pub fn new(spatial: Arc<Spatial>, specialization: InputType) -> Arc<InputMethod> {
@@ -67,11 +67,16 @@ impl InputMethod {
 			spatial,
 			specialization: Mutex::new(specialization),
 			captures: Registry::new(),
+			datamap: Mutex::new(None),
 		};
 		INPUT_METHOD_REGISTRY.add(method)
 	}
 	#[allow(dead_code)]
-	pub fn add_to(node: &Arc<Node>, specialization: InputType) -> Result<()> {
+	pub fn add_to(
+		node: &Arc<Node>,
+		specialization: InputType,
+		datamap: Option<Datamap>,
+	) -> Result<()> {
 		ensure!(
 			node.spatial.get().is_some(),
 			"Internal: Node does not have a spatial attached!"
@@ -83,6 +88,7 @@ impl InputMethod {
 			spatial: node.spatial.get().unwrap().clone(),
 			specialization: Mutex::new(specialization),
 			captures: Registry::new(),
+			datamap: Mutex::new(datamap),
 		};
 		let method = INPUT_METHOD_REGISTRY.add(method);
 		let _ = node.input_method.set(method);
@@ -91,9 +97,6 @@ impl InputMethod {
 	fn distance(&self, to: &Field) -> f32 {
 		self.specialization.lock().distance(&self.spatial, to)
 	}
-	fn serialize_datamap(&self) -> Datamap {
-		self.specialization.lock().serialize_datamap()
-	}
 }
 impl Drop for InputMethod {
 	fn drop(&mut self) {
@@ -231,8 +234,9 @@ pub fn create_input_handler_flex(
 pub fn process_input() {
 	for method in INPUT_METHOD_REGISTRY
 		.get_valid_contents()
-		.iter()
+		.into_iter()
 		.filter(|method| *method.enabled.lock())
+		.filter(|method| method.datamap.lock().is_some())
 	{
 		let mut distance_links: Vec<DistanceLink> = INPUT_HANDLER_REGISTRY
 			.get_valid_contents()
@@ -248,12 +252,11 @@ pub fn process_input() {
 				.reverse()
 		});
 
-		let datamap = method.serialize_datamap();
 		let mut last_distance = 0.0;
 		let frame = FRAME.load(Ordering::Relaxed);
 		let captures = method.captures.get_valid_contents();
 		for distance_link in distance_links {
-			distance_link.send_input(frame, datamap.clone());
+			distance_link.send_input(frame, method.datamap.lock().clone().unwrap());
 			if last_distance != distance_link.distance
 				&& captures
 					.iter()

src/nodes/input/pointer.rs

@@ -2,15 +2,11 @@ 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::flat::{Datamap, InputDataType, Pointer as FlatPointer};
-use std::sync::atomic::{AtomicBool, Ordering};
+use stardust_xr::schemas::flat::{InputDataType, Pointer as FlatPointer};
 use std::sync::Arc;
 
 #[derive(Default)]
-pub struct Pointer {
-	grab: AtomicBool,
-	select: AtomicBool,
-}
+pub struct Pointer {}
 // impl Default for Pointer {
 // 	fn default() -> Self {
 // 		Pointer {
@@ -55,12 +51,4 @@ impl InputSpecialization for Pointer {
 			deepest_point: deepest_point.into(),
 		})
 	}
-	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();
-		Datamap::new(fbb.view().to_vec()).unwrap()
-	}
 }

src/nodes/input/tip.rs

@@ -1,17 +1,20 @@
 use super::{DistanceLink, InputSpecialization};
+use crate::core::client::Client;
 use crate::nodes::fields::Field;
-use crate::nodes::spatial::Spatial;
+use crate::nodes::input::{InputMethod, InputType};
+use crate::nodes::spatial::{get_spatial_parent_flex, parse_transform, Spatial};
+use crate::nodes::Node;
+use anyhow::Result;
 use glam::{vec3a, Mat4};
-use portable_atomic::AtomicF32;
+use serde::Deserialize;
 use stardust_xr::schemas::flat::{Datamap, InputDataType, Tip as FlatTip};
-use std::sync::atomic::Ordering;
+use stardust_xr::schemas::flex::deserialize;
+use stardust_xr::values::Transform;
 use std::sync::Arc;
 
 #[derive(Default)]
 pub struct Tip {
-	pub radius: AtomicF32,
-	pub grab: AtomicF32,
-	pub select: AtomicF32,
+	pub radius: f32,
 }
 
 impl InputSpecialization for Tip {
@@ -27,15 +30,8 @@ impl InputSpecialization for Tip {
 		InputDataType::Tip(FlatTip {
 			origin: origin.into(),
 			orientation: orientation.into(),
-			radius: self.radius.load(Ordering::Relaxed),
+			radius: self.radius,
 		})
 	}
-	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();
-		Datamap::new(fbb.view().to_vec()).unwrap()
 	}
 }