refactor: replace all RwLock with Mutex

src/core/nodelist.rs

@@ -1,25 +1,25 @@
 use crate::nodes::core::Node;
-use parking_lot::RwLock;
+use parking_lot::Mutex;
 use std::sync::Weak;
 
 #[derive(Default)]
 pub struct LifeLinkedNodeList {
-	nodes: RwLock<Vec<Weak<Node>>>,
+	nodes: Mutex<Vec<Weak<Node>>>,
 }
 impl LifeLinkedNodeList {
 	pub fn add(&self, node: Weak<Node>) {
-		self.nodes.write().push(node);
+		self.nodes.lock().push(node);
 	}
 
 	pub fn clear(&self) {
 		self.nodes
-			.read()
+			.lock()
 			.iter()
 			.filter_map(|node| node.upgrade())
 			.for_each(|node| {
 				node.destroy();
 			});
-		self.nodes.write().clear();
+		self.nodes.lock().clear();
 	}
 }
 impl Drop for LifeLinkedNodeList {

src/core/registry.rs

@@ -1,9 +1,9 @@
 use anyhow::{anyhow, Result};
-use parking_lot::RwLock;
+use parking_lot::Mutex;
 use slab::Slab;
 use std::sync::{Arc, Weak};
 
-pub struct Registry<T>(RwLock<Slab<Weak<T>>>);
+pub struct Registry<T>(Mutex<Slab<Weak<T>>>);
 
 impl<T> Registry<T> {
 	pub fn add(&self, t: T) -> Arc<T> {
@@ -12,21 +12,21 @@ impl<T> Registry<T> {
 		t_arc
 	}
 	pub fn add_raw(&self, t: &Arc<T>) {
-		self.0.write().insert(Arc::downgrade(t));
+		self.0.lock().insert(Arc::downgrade(t));
 	}
 	pub fn get_valid_contents(&self) -> Vec<Arc<T>> {
 		self.0
-			.read()
+			.lock()
 			.iter()
 			.filter_map(|(_, item)| item.upgrade())
 			.collect()
 	}
 	pub fn remove(&self, t: &T) {
-		for item in self.0.read().iter() {
+		for item in self.0.lock().iter() {
 			let (idx, item) = item;
 			if let Some(item) = item.upgrade() {
 				if std::ptr::eq(item.as_ref(), t) {
-					self.0.write().remove(idx);
+					self.0.lock().remove(idx);
 					break;
 				}
 			}
@@ -36,6 +36,6 @@ impl<T> Registry<T> {
 
 impl<T> Default for Registry<T> {
 	fn default() -> Self {
-		Registry::<T>(RwLock::new(Slab::new()))
+		Registry::<T>(Mutex::new(Slab::new()))
 	}
 }

src/nodes/data.rs

@@ -9,7 +9,7 @@ use glam::{vec3a, Mat4};
 use lazy_static::lazy_static;
 use libstardustxr::flex::flexbuffer_from_vector_arguments;
 use libstardustxr::{flex_to_quat, flex_to_vec3};
-use parking_lot::RwLock;
+use parking_lot::Mutex;
 use std::sync::{Arc, Weak};
 
 lazy_static! {
@@ -65,7 +65,7 @@ fn mask_get_map_at_root(binary: &[u8]) -> Result<flexbuffers::MapReader<&[u8]>>
 
 #[derive(Default)]
 pub struct PulseSender {
-	mask: RwLock<Mask>,
+	mask: Mutex<Mask>,
 	aliases: LifeLinkedNodeList,
 }
 impl PulseSender {
@@ -91,7 +91,7 @@ impl PulseSender {
 			.get()
 			.unwrap()
 			.mask
-			.write()
+			.lock()
 			.set_mask(data.to_vec(), mask_get_map_at_root);
 		Ok(())
 	}
@@ -112,7 +112,7 @@ impl PulseSender {
 		let mut distance_sorted_receivers: Vec<(f32, &PulseReceiver)> = valid_receivers
 			.iter()
 			.filter(|receiver| receiver.get_field().is_some())
-			.filter(|receiver| mask_matches(&*sender.mask.read(), &*receiver.mask.read()))
+			.filter(|receiver| mask_matches(&*sender.mask.lock(), &*receiver.mask.lock()))
 			.map(|receiver| {
 				(
 					receiver
@@ -158,7 +158,7 @@ impl Drop for PulseSender {
 pub struct PulseReceiver {
 	uid: String,
 	node: Weak<Node>,
-	pub mask: RwLock<Mask>,
+	pub mask: Mutex<Mask>,
 	field: Weak<Field>,
 }
 impl<'a> PulseReceiver {
@@ -188,7 +188,7 @@ impl<'a> PulseReceiver {
 			node.pulse_receiver.get().is_some(),
 			"Internal: Node does not have a pulse receiver aspect"
 		);
-		let receiver_mask = node.pulse_receiver.get().unwrap().mask.read();
+		let receiver_mask = node.pulse_receiver.get().unwrap().mask.lock();
 		let data_mask = Mask {
 			binary: data.to_vec(),
 			get_fn: mask_get_map_at_root,
@@ -211,7 +211,7 @@ impl<'a> PulseReceiver {
 			.get()
 			.unwrap()
 			.mask
-			.write()
+			.lock()
 			.set_mask(data.to_vec(), mask_get_map_at_root);
 		Ok(())
 	}

src/nodes/spatial.rs

@@ -5,13 +5,13 @@ use glam::{Mat4, Quat, Vec3};
 use libstardustxr::flex::flexbuffer_from_vector_arguments;
 use libstardustxr::push_to_vec;
 use libstardustxr::{flex_to_quat, flex_to_vec3};
-use parking_lot::RwLock;
+use parking_lot::Mutex;
 use std::sync::Arc;
 
 pub struct Spatial {
 	// node: Weak<Node>,
-	parent: RwLock<Option<Arc<Spatial>>>,
+	parent: Mutex<Option<Arc<Spatial>>>,
-	transform: RwLock<Mat4>,
+	transform: Mutex<Mat4>,
 }
 
 impl Spatial {
@@ -26,8 +26,8 @@ impl Spatial {
 		);
 		let spatial = Spatial {
 			// node: node.downgrade(),
-			parent: RwLock::new(parent),
+			parent: Mutex::new(parent),
-			transform: RwLock::new(transform),
+			transform: Mutex::new(transform),
 		};
 		node.add_local_method("getTransform", Spatial::get_transform_flex);
 		node.add_local_signal("setTransform", Spatial::set_transform_flex);
@@ -43,16 +43,16 @@ impl Spatial {
 	}
 
 	pub fn local_transform(&self) -> Mat4 {
-		*self.transform.read()
+		*self.transform.lock()
 	}
 	pub fn global_transform(&self) -> Mat4 {
-		match self.parent.read().clone() {
+		match self.parent.lock().clone() {
-			Some(value) => value.global_transform() * *self.transform.read(),
+			Some(value) => value.global_transform() * *self.transform.lock(),
-			None => *self.transform.read(),
+			None => *self.transform.lock(),
 		}
 	}
 	pub fn set_local_transform(&self, transform: Mat4) {
-		*self.transform.write() = transform;
+		*self.transform.lock() = transform;
 	}
 	pub fn set_local_transform_components(
 		&self,
@@ -62,7 +62,7 @@ impl Spatial {
 		scl: Option<Vec3>,
 	) {
 		let reference_to_parent_transform =
-			Spatial::space_to_space_matrix(reference_space, self.parent.read().as_deref());
+			Spatial::space_to_space_matrix(reference_space, self.parent.lock().as_deref());
 		let mut local_transform_in_reference_space =
 			reference_to_parent_transform.inverse() * self.local_transform();
 		let (mut reference_space_scl, mut reference_space_rot, mut reference_space_pos) =