refactor(input): use idl

src/nodes/input/pointer.rs

@@ -1,38 +1,34 @@
-use super::{DistanceLink, InputSpecialization};
-use crate::core::client::Client;
-use crate::nodes::fields::{Field, Ray, RayMarchResult};
-use crate::nodes::input::{InputMethod, InputType};
-use crate::nodes::spatial::{parse_transform, Spatial, Transform};
-use crate::nodes::{Message, Node};
-use glam::{vec3, Mat4};
-use serde::Deserialize;
-use stardust_xr::schemas::flat::{InputDataType, Pointer as FlatPointer};
-use stardust_xr::schemas::flex::deserialize;
-use stardust_xr::values::Datamap;
+use super::{DistanceLink, InputDataTrait, Pointer};
+use crate::nodes::{
+	fields::{Field, Ray, RayMarchResult},
+	spatial::Spatial,
+};
+use glam::{vec3, Mat4, Quat};
+use std::sync::{Arc, Weak};
 
-use std::sync::Arc;
-
-#[derive(Default)]
-pub struct Pointer;
-// impl Default for Pointer {
-// 	fn default() -> Self {
-// 		Pointer {
-// 			grab: Default::default(),
-// 			select: Default::default(),
-// 		}
-// 	}
-// }
+impl Default for Pointer {
+	fn default() -> Self {
+		Pointer {
+			origin: [0.0; 3].into(),
+			orientation: Quat::IDENTITY.into(),
+			deepest_point: [0.0; 3].into(),
+		}
+	}
+}
 impl Pointer {
-	fn ray_march(&self, space: &Arc<Spatial>, field: &Field) -> RayMarchResult {
+	fn ray_march(&self, method_space: &Arc<Spatial>, field: &Field) -> RayMarchResult {
 		field.ray_march(Ray {
 			origin: vec3(0.0, 0.0, 0.0),
 			direction: vec3(0.0, 0.0, -1.0),
-			space: space.clone(),
+			space: Spatial::new(
+				Weak::new(),
+				Some(method_space.clone()),
+				Mat4::from_rotation_translation(self.orientation.into(), self.origin.into()),
+			),
 		})
 	}
 }
-
-impl InputSpecialization for Pointer {
+impl InputDataTrait for Pointer {
 	fn compare_distance(&self, space: &Arc<Spatial>, field: &Field) -> f32 {
 		let ray_info = self.ray_march(space, field);
 		if ray_info.min_distance > 0.0 {
@@ -47,50 +43,20 @@ impl InputSpecialization for Pointer {
 		let ray_info = self.ray_march(space, field);
 		ray_info.min_distance
 	}
-	fn serialize(
-		&self,
-		distance_link: &DistanceLink,
-		local_to_handler_matrix: Mat4,
-	) -> InputDataType {
+	fn update_to(&mut self, distance_link: &DistanceLink, mut local_to_handler_matrix: Mat4) {
+		local_to_handler_matrix =
+			Mat4::from_rotation_translation(self.orientation.into(), self.origin.into())
+				* local_to_handler_matrix;
 		let (_, orientation, origin) = local_to_handler_matrix.to_scale_rotation_translation();
-		let direction = local_to_handler_matrix.transform_vector3(vec3(0.0, 0.0, -1.0));
+
 		let ray_march = self.ray_march(&distance_link.method.spatial, &distance_link.handler.field);
+		let direction = local_to_handler_matrix
+			.transform_vector3(vec3(0.0, 0.0, -1.0))
+			.normalize();
 		let deepest_point = (direction * ray_march.deepest_point_distance) + origin;
 
-		InputDataType::Pointer(FlatPointer {
-			origin: origin.into(),
-			orientation: orientation.into(),
-			deepest_point: deepest_point.into(),
-		})
+		self.origin = origin.into();
+		self.orientation = orientation.into();
+		self.deepest_point = deepest_point.into();
 	}
 }
-
-pub fn create_pointer_flex(
-	_node: Arc<Node>,
-	calling_client: Arc<Client>,
-	message: Message,
-) -> color_eyre::eyre::Result<()> {
-	#[derive(Deserialize)]
-	struct CreatePointerInfo<'a> {
-		name: &'a str,
-		parent_path: &'a str,
-		transform: Transform,
-		datamap: Option<Vec<u8>>,
-	}
-	let info: CreatePointerInfo = deserialize(message.as_ref())?;
-	let node = Node::create_parent_name(&calling_client, "/input/method/pointer", info.name, true);
-	let parent = calling_client
-		.get_node("Spatial parent", info.parent_path)?
-		.get_aspect::<Spatial>()?;
-	let transform = parse_transform(info.transform, true, true, false);
-
-	let node = node.add_to_scenegraph()?;
-	Spatial::add_to(&node, Some(parent.clone()), transform, false);
-	InputMethod::add_to(
-		&node,
-		InputType::Pointer(Pointer),
-		info.datamap
-			.and_then(|datamap| Datamap::from_raw(datamap).ok()),
-	)?;
-	Ok(())
-}