refactor: make all flex stuff use serde

src/nodes/fields/box.rs

@@ -1,10 +1,13 @@
 use super::{Field, FieldTrait, Node};
 use crate::core::client::Client;
 use crate::nodes::spatial::{get_spatial_parent_flex, parse_transform, Spatial};
-use anyhow::{anyhow, ensure, Result};
+use anyhow::{ensure, Result};
 use glam::{vec3, vec3a, Vec3, Vec3A};
+use mint::Vector3;
 use parking_lot::Mutex;
-use stardust_xr::values::parse_vec3;
+use serde::Deserialize;
+use stardust_xr::schemas::flex::deserialize;
+use stardust_xr::values::Transform;
 use std::sync::Arc;
 
 pub struct BoxField {
@@ -13,7 +16,7 @@ pub struct BoxField {
 }
 
 impl BoxField {
-	pub fn add_to(node: &Arc<Node>, size: Vec3) -> Result<()> {
+	pub fn add_to(node: &Arc<Node>, size: Vector3<f32>) -> Result<()> {
 		ensure!(
 			node.spatial.get().is_some(),
 			"Internal: Node does not have a spatial attached!"
@@ -24,7 +27,7 @@ impl BoxField {
 		);
 		let box_field = BoxField {
 			space: node.spatial.get().unwrap().clone(),
-			size: Mutex::new(size),
+			size: Mutex::new(size.into()),
 		};
 		box_field.add_field_methods(node);
 		node.add_local_signal("setSize", BoxField::set_size_flex);
@@ -32,15 +35,13 @@ impl BoxField {
 		Ok(())
 	}
 
-	pub fn set_size(&self, size: Vec3) {
-		*self.size.lock() = size;
+	pub fn set_size(&self, size: Vector3<f32>) {
+		*self.size.lock() = size.into();
 	}
 
 	pub fn set_size_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
-		let root = flexbuffers::Reader::get_root(data)?;
-		let size = parse_vec3(root).ok_or_else(|| anyhow!("Size is invalid"))?;
 		if let Field::Box(box_field) = node.field.get().unwrap().as_ref() {
-			box_field.set_size(size.into());
+			box_field.set_size(deserialize(data)?);
 		}
 		Ok(())
 	}
@@ -63,18 +64,19 @@ impl FieldTrait for BoxField {
 }
 
 pub fn create_box_field_flex(_node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
-	let flex_vec = flexbuffers::Reader::get_root(data)?.get_vector()?;
-	let node = Node::create(
-		&calling_client,
-		"/field",
-		flex_vec.index(0)?.get_str()?,
-		true,
-	);
-	let parent = get_spatial_parent_flex(&calling_client, flex_vec.index(1)?.get_str()?)?;
-	let transform = parse_transform(flex_vec.index(2)?, true, true, false)?;
-	let size = parse_vec3(flex_vec.index(3)?).ok_or_else(|| anyhow!("Size invalid"))?;
+	#[derive(Deserialize)]
+	struct CreateFieldInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
+		transform: Transform,
+		size: Vector3<f32>,
+	}
+	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 = parse_transform(info.transform, true, true, false)?;
 	let node = node.add_to_scenegraph();
 	Spatial::add_to(&node, Some(parent), transform)?;
-	BoxField::add_to(&node, size.into())?;
+	BoxField::add_to(&node, info.size)?;
 	Ok(())
 }

src/nodes/fields/cylinder.rs

@@ -4,7 +4,9 @@ use crate::nodes::spatial::{get_spatial_parent_flex, parse_transform, Spatial};
 use anyhow::{ensure, Result};
 use glam::{swizzles::*, vec2, Vec3A};
 use portable_atomic::AtomicF32;
-use stardust_xr::values::parse_f32;
+use serde::Deserialize;
+use stardust_xr::schemas::flex::deserialize;
+use stardust_xr::values::Transform;
 
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
@@ -42,12 +44,8 @@ impl CylinderField {
 	}
 
 	pub fn set_size_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
-		let flex_vec = flexbuffers::Reader::get_root(data)?.get_vector()?;
-		let length =
-			parse_f32(flex_vec.index(0)?).ok_or_else(|| anyhow::anyhow!("Invalid length"))?;
-		let radius =
-			parse_f32(flex_vec.index(1)?).ok_or_else(|| anyhow::anyhow!("Invalid radius"))?;
 		if let Field::Cylinder(cylinder_field) = node.field.get().unwrap().as_ref() {
+			let (length, radius) = deserialize(data)?;
 			cylinder_field.set_size(length, radius);
 		}
 		Ok(())
@@ -72,19 +70,20 @@ pub fn create_cylinder_field_flex(
 	calling_client: Arc<Client>,
 	data: &[u8],
 ) -> Result<()> {
-	let flex_vec = flexbuffers::Reader::get_root(data)?.get_vector()?;
-	let node = Node::create(
-		&calling_client,
-		"/field",
-		flex_vec.index(0)?.get_str()?,
-		true,
-	);
-	let parent = get_spatial_parent_flex(&calling_client, flex_vec.idx(1).get_str()?)?;
-	let transform = parse_transform(flex_vec.index(2)?, true, true, false)?;
-	let length = parse_f32(flex_vec.index(3)?).ok_or_else(|| anyhow::anyhow!("Invalid length"))?;
-	let radius = parse_f32(flex_vec.index(4)?).ok_or_else(|| anyhow::anyhow!("Invalid radius"))?;
+	#[derive(Deserialize)]
+	struct CreateFieldInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
+		transform: Transform,
+		length: f32,
+		radius: f32,
+	}
+	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 = parse_transform(info.transform, true, true, false)?;
 	let node = node.add_to_scenegraph();
 	Spatial::add_to(&node, Some(parent), transform)?;
-	CylinderField::add_to(&node, dbg!(length), dbg!(radius))?;
+	CylinderField::add_to(&node, dbg!(info.length), dbg!(info.radius))?;
 	Ok(())
 }

src/nodes/fields/mod.rs

@@ -11,8 +11,9 @@ use super::Node;
 use crate::core::client::Client;
 use anyhow::{anyhow, Result};
 use glam::{vec2, vec3a, Vec3, Vec3A};
-use stardust_xr::flex::FlexBuffable;
-use stardust_xr::values::parse_vec3;
+use mint::Vector3;
+use serde::Deserialize;
+use stardust_xr::schemas::flex::{deserialize, serialize};
 
 use std::ops::Deref;
 use std::sync::Arc;
@@ -69,65 +70,79 @@ pub trait FieldTrait {
 }
 
 fn field_distance_flex(node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Result<Vec<u8>> {
-	let flex_vec = flexbuffers::Reader::get_root(data)?.get_vector()?;
+	#[derive(Deserialize)]
+	struct FieldInfoArgs<'a> {
+		reference_space_path: &'a str,
+		point: Vector3<f32>,
+	}
+	let args: FieldInfoArgs = deserialize(data)?;
 	let reference_space = calling_client
 		.scenegraph
-		.get_node(flex_vec.idx(0).as_str())
+		.get_node(args.reference_space_path)
 		.ok_or_else(|| anyhow!("Reference space node does not exist"))?
 		.spatial
 		.get()
 		.ok_or_else(|| anyhow!("Reference space node does not have a spatial"))?
 		.clone();
-	let point = parse_vec3(flex_vec.idx(1)).ok_or_else(|| anyhow!("Point is invalid"))?;
 
 	let distance = node
 		.field
 		.get()
 		.unwrap()
-		.distance(reference_space.as_ref(), point.into());
-	Ok(FlexBuffable::from(distance).build_singleton())
+		.distance(reference_space.as_ref(), args.point.into());
+	Ok(serialize(distance)?)
 }
 fn field_normal_flex(node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Result<Vec<u8>> {
-	let flex_vec = flexbuffers::Reader::get_root(data)?.get_vector()?;
+	#[derive(Deserialize)]
+	struct FieldInfoArgs<'a> {
+		reference_space_path: &'a str,
+		point: Vector3<f32>,
+		radius: Option<f32>,
+	}
+	let args: FieldInfoArgs = deserialize(data)?;
 	let reference_space = calling_client
 		.scenegraph
-		.get_node(flex_vec.idx(0).as_str())
+		.get_node(args.reference_space_path)
 		.ok_or_else(|| anyhow!("Reference space node does not exist"))?
 		.spatial
 		.get()
 		.ok_or_else(|| anyhow!("Reference space node does not have a spatial"))?
 		.clone();
-	let point = parse_vec3(flex_vec.idx(1)).ok_or_else(|| anyhow!("Point is invalid"))?;
 
 	let normal = node.field.get().as_ref().unwrap().normal(
 		reference_space.as_ref(),
-		point.into(),
-		0.001_f32,
+		args.point.into(),
+		args.radius.unwrap_or(0.001),
 	);
-	Ok(FlexBuffable::from(mint::Vector3::from(normal)).build_singleton())
+	Ok(serialize(mint::Vector3::from(normal))?)
 }
 fn field_closest_point_flex(
 	node: &Node,
 	calling_client: Arc<Client>,
 	data: &[u8],
 ) -> Result<Vec<u8>> {
-	let flex_vec = flexbuffers::Reader::get_root(data)?.get_vector()?;
+	#[derive(Deserialize)]
+	struct FieldInfoArgs<'a> {
+		reference_space_path: &'a str,
+		point: Vector3<f32>,
+		radius: Option<f32>,
+	}
+	let args: FieldInfoArgs = deserialize(data)?;
 	let reference_space = calling_client
 		.scenegraph
-		.get_node(flex_vec.idx(0).as_str())
+		.get_node(args.reference_space_path)
 		.ok_or_else(|| anyhow!("Reference space node does not exist"))?
 		.spatial
 		.get()
 		.ok_or_else(|| anyhow!("Reference space node does not have a spatial"))?
 		.clone();
-	let point = parse_vec3(flex_vec.idx(1)).ok_or_else(|| anyhow!("Point is invalid"))?;
 
-	let closest_point =
-		node.field
-			.get()
-			.unwrap()
-			.closest_point(reference_space.as_ref(), point.into(), 0.001_f32);
-	Ok(FlexBuffable::from(mint::Vector3::from(closest_point)).build_singleton())
+	let closest_point = node.field.get().as_ref().unwrap().closest_point(
+		reference_space.as_ref(),
+		args.point.into(),
+		args.radius.unwrap_or(0.001),
+	);
+	Ok(serialize(mint::Vector3::from(closest_point))?)
 }
 
 pub enum Field {

src/nodes/fields/sphere.rs

@@ -1,10 +1,12 @@
 use super::{Field, FieldTrait, Node};
 use crate::core::client::Client;
 use crate::nodes::spatial::{get_spatial_parent_flex, Spatial};
-use anyhow::{anyhow, ensure, Result};
+use anyhow::{ensure, Result};
 use glam::{Mat4, Vec3A};
+use mint::Vector3;
 use portable_atomic::AtomicF32;
-use stardust_xr::values::parse_vec3;
+use serde::Deserialize;
+use stardust_xr::schemas::flex::deserialize;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
@@ -66,16 +68,19 @@ pub fn create_sphere_field_flex(
 	calling_client: Arc<Client>,
 	data: &[u8],
 ) -> Result<()> {
-	let flex_vec = flexbuffers::Reader::get_root(data)?.get_vector()?;
-	let node = Node::create(&calling_client, "/field", flex_vec.idx(0).get_str()?, true);
-	let parent = get_spatial_parent_flex(&calling_client, flex_vec.idx(1).get_str()?)?;
-	let transform = Mat4::from_translation(
-		parse_vec3(flex_vec.idx(2))
-			.ok_or_else(|| anyhow!("Position not found"))?
-			.into(),
-	);
+	#[derive(Deserialize)]
+	struct CreateFieldInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
+		origin: Option<Vector3<f32>>,
+		radius: f32,
+	}
+	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 node = node.add_to_scenegraph();
 	Spatial::add_to(&node, Some(parent), transform)?;
-	SphereField::add_to(&node, flex_vec.idx(3).as_f32())?;
+	SphereField::add_to(&node, info.radius)?;
 	Ok(())
 }