refactor: use typemap for aspects!

src/core/client.rs

@@ -1,5 +1,6 @@
 use super::{
 	client_state::{ClientState, CLIENT_STATES},
+	destroy_queue,
 	scenegraph::Scenegraph,
 };
 use crate::{
@@ -209,7 +210,9 @@ impl Client {
 		if let Some(flush_join_handle) = self.flush_join_handle.get() {
 			flush_join_handle.abort();
 		}
-		CLIENTS.remove(self);
+		if let Some(client) = CLIENTS.remove(self) {
+			destroy_queue::add(client);
+		}
 	}
 }
 impl Drop for Client {

src/core/client_state.rs

@@ -49,7 +49,7 @@ impl ClientState {
 	}
 	fn spatial_transform(client: &Client, path: &str) -> Option<Mat4> {
 		let node = client.scenegraph.get_node(path)?;
-		let spatial = node.spatial.get()?;
+		let spatial = node.get_aspect::<Spatial>().ok()?;
 		Some(spatial.global_transform())
 	}
 
@@ -81,7 +81,7 @@ impl ClientState {
 						let node = Node::create_parent_name(client, "/spatial/anchor", k, true)
 							.add_to_scenegraph()
 							.unwrap();
-						Spatial::add_to(&node, None, *v, false).unwrap();
+						Spatial::add_to(&node, None, *v, false);
 						k.clone()
 					})
 				})

src/core/destroy_queue.rs

@@ -1,12 +1,22 @@
+use once_cell::sync::Lazy;
 use parking_lot::Mutex;
 use std::any::Any;
+use tokio::sync::mpsc::{self, unbounded_channel};
 
-static MAIN_DESTROY_QUEUE: Mutex<Vec<Box<dyn Any + Send + Sync>>> = Mutex::new(Vec::new());
+static MAIN_DESTROY_QUEUE: Lazy<(
+	mpsc::UnboundedSender<Box<dyn Any + Send + Sync>>,
+	Mutex<mpsc::UnboundedReceiver<Box<dyn Any + Send + Sync>>>,
+)> = Lazy::new(|| {
+	let (tx, rx) = unbounded_channel();
+	(tx, Mutex::new(rx))
+});
 
 pub fn add<T: Any + Sync + Send>(thing: T) {
-	MAIN_DESTROY_QUEUE.lock().push(Box::new(thing));
+	MAIN_DESTROY_QUEUE.0.send(Box::new(thing)).unwrap();
 }
 
 pub fn clear() {
-	MAIN_DESTROY_QUEUE.lock().clear();
+	while let Ok(thing) = MAIN_DESTROY_QUEUE.1.lock().try_recv() {
+		drop(thing)
+	}
 }

src/core/registry.rs

@@ -5,6 +5,7 @@ use rustc_hash::FxHashMap;
 use std::ptr;
 use std::sync::{Arc, Weak};
 
+#[derive(Debug)]
 pub struct Registry<T: Send + Sync + ?Sized>(Mutex<Option<FxHashMap<usize, Weak<T>>>>);
 
 impl<T: Send + Sync + ?Sized> Registry<T> {
@@ -56,7 +57,9 @@ impl<T: Send + Sync + ?Sized> Registry<T> {
 	}
 	pub fn is_empty(&self) -> bool {
 		let registry = self.0.lock();
-		let Some(registry) = &*registry else {return true};
+		let Some(registry) = &*registry else {
+			return true;
+		};
 		if registry.is_empty() {
 			return true;
 		}
@@ -68,6 +71,11 @@ impl<T: Send + Sync + ?Sized> Clone for Registry<T> {
 		Self(Mutex::new(self.0.lock().clone()))
 	}
 }
+impl<T: Send + Sync + ?Sized> Default for Registry<T> {
+	fn default() -> Self {
+		Self::new()
+	}
+}
 
 pub struct OwnedRegistry<T: Send + Sync + ?Sized>(Mutex<Option<FxHashMap<usize, Arc<T>>>>);
 
@@ -98,9 +106,12 @@ impl<T: Send + Sync + ?Sized> OwnedRegistry<T> {
 		self.lock()
 			.contains_key(&(ptr::addr_of!(*t) as *const () as usize))
 	}
-	pub fn remove(&self, t: &T) {
+	pub fn remove(&self, t: &T) -> Option<Arc<T>>
+	where
+		T: Sized,
+	{
 		self.lock()
-			.remove(&(ptr::addr_of!(*t) as *const () as usize));
+			.remove(&(ptr::addr_of!(*t) as *const () as usize))
 	}
 	pub fn clear(&self) {
 		self.lock().clear();

src/core/scenegraph.rs

@@ -1,3 +1,4 @@
+use crate::nodes::alias::Alias;
 use crate::nodes::Node;
 use crate::{core::client::Client, nodes::Message};
 use color_eyre::eyre::Result;
@@ -39,7 +40,7 @@ impl Scenegraph {
 
 	pub fn get_node(&self, path: &str) -> Option<Arc<Node>> {
 		let mut node = self.nodes.lock().get(path)?.clone();
-		while let Some(alias) = node.alias.get() {
+		while let Ok(alias) = node.get_aspect::<Alias>() {
 			if alias.enabled.load(Ordering::Acquire) {
 				node = alias.original.upgrade()?;
 			} else {