cargo update

- Remove unnecessary fenix input
- Remove unnecessary arguments to buildRustPackage
- Remove obsolete/unnecessary hacks
- Minimize code duplication and maximize re-use by using flake.parts
- Split out stardust-xr-server derivation into its own nix file in nix/stardust-xr-server
- Automatically get name of package from Cargo.toml
- Advertise support for riscv64-linux in flake outputs

Cargo.toml

@@ -1,17 +1,13 @@
 [package]
 edition = "2021"
-rust-version = "1.75"
 name = "stardust-xr-server"
-version = "0.44.1"
+version = "0.43.0"
 authors = ["Nova King <technobaboo@proton.me>"]
 description = "Stardust XR reference display server"
 license = "GPLv2"
 repository = "https://github.com/StardustXR/stardust-xr-server/"
 homepage = "https://stardustxr.org"
 
-[workspace]
-members = ["codegen"]
-
 [[bin]]
 name = "stardust-xr-server"
 path = "src/main.rs"
@@ -19,8 +15,7 @@ path = "src/main.rs"
 [features]
 default = ["wayland"]
 wayland = ["dep:smithay", "dep:xkbcommon"]
-xwayland_rootful = []
+xwayland = ["smithay/xwayland"]
-xwayland_rootless = ["smithay/xwayland"]
 profile_tokio = ["dep:console-subscriber", "tokio/tracing"]
 profile_app = ["dep:tracing-tracy"]
 
@@ -63,16 +58,11 @@ tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 global_counter = "0.2.2"
 rand = "0.8.5"
 atty = "0.2.14"
-xkbcommon = { version = "0.7.0", default-features = false, optional = true }
+xkbcommon = { version = "0.6.0", default-features = false, optional = true }
 ctrlc = "3.4.1"
 libc = "0.2.148"
 input-event-codes = "5.16.8"
-nix = "0.27.1"
+drm-fourcc = { version = "2.2.0", features = ["serde"] }
-wayland-scanner = "0.31.1"
-wayland-backend = "0.3.3"
-cluFlock = "1.2.7"
-fxtypemap = "0.2.0"
-toml = "0.8.10"
 
 [dependencies.smithay]
 # git = "https://github.com/technobaboo/smithay.git" # Until we get stereokit to understand OES samplers and external textures
@@ -104,9 +94,7 @@ optional = true
 
 [dependencies.stardust-xr]
 git = "https://github.com/StardustXR/core.git"
-
+branch = "camera-item"
-[dependencies.stardust-xr-server-codegen]
-path = "codegen"
 
 # [patch.crates-io.stereokit]
 # path = "../stereokit-rs"

codegen/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-edition = "2021"
-name = "stardust-xr-server-codegen"
-version = "0.1.0"
-
-[lib]
-proc-macro = true
-
-[dependencies]
-convert_case = "0.6.0"
-quote = "1.0.33"
-mint = "0.5.9"
-proc-macro2 = "1.0.71"
-split-iter = "0.1.0"
-
-[dependencies.stardust-xr-schemas]
-git = "https://github.com/StardustXR/core.git"

codegen/src/lib.rs

@@ -1,563 +0,0 @@
-use convert_case::{Case, Casing};
-use proc_macro2::{Ident, Span, TokenStream};
-use quote::{quote, ToTokens};
-use split_iter::Splittable;
-use stardust_xr_schemas::protocol::*;
-
-fn fold_tokens(a: TokenStream, b: TokenStream) -> TokenStream {
-	quote!(#a #b)
-}
-
-// #[proc_macro]
-// pub fn codegen_root_protocol(_input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-// 	codegen_protocol(ROOT_PROTOCOL)
-// }
-#[proc_macro]
-pub fn codegen_node_protocol(_input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-	codegen_protocol(NODE_PROTOCOL)
-}
-#[proc_macro]
-pub fn codegen_spatial_protocol(_input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-	codegen_protocol(SPATIAL_PROTOCOL)
-}
-#[proc_macro]
-pub fn codegen_field_protocol(_input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-	codegen_protocol(FIELD_PROTOCOL)
-}
-#[proc_macro]
-pub fn codegen_data_protocol(_input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-	codegen_protocol(DATA_PROTOCOL)
-}
-#[proc_macro]
-pub fn codegen_audio_protocol(_input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-	codegen_protocol(AUDIO_PROTOCOL)
-}
-#[proc_macro]
-pub fn codegen_drawable_protocol(_input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-	codegen_protocol(DRAWABLE_PROTOCOL)
-}
-// #[proc_macro]
-// pub fn codegen_input_protocol(_input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-// 	codegen_protocol(INPUT_PROTOCOL)
-// }
-
-fn codegen_protocol(protocol: &'static str) -> proc_macro::TokenStream {
-	let protocol = Protocol::parse(protocol).unwrap();
-	let interface = protocol
-		.interface
-		.map(|p| {
-			let virtual_aspect_name = p.path[1..]
-				.split('/')
-				.map(ToString::to_string)
-				.reduce(|a, b| format!("{a}_{b}"))
-				.unwrap_or_default()
-				+ "_interface";
-			generate_aspect(&Aspect {
-				name: virtual_aspect_name,
-				description: protocol.description.clone(),
-				members: p.members,
-			})
-		})
-		.unwrap_or_default();
-	let custom_enums = protocol
-		.custom_enums
-		.iter()
-		.map(generate_custom_enum)
-		.reduce(fold_tokens)
-		.unwrap_or_default();
-	let custom_unions = protocol
-		.custom_unions
-		.iter()
-		.map(generate_custom_union)
-		.reduce(fold_tokens)
-		.unwrap_or_default();
-	let custom_structs = protocol
-		.custom_structs
-		.iter()
-		.map(generate_custom_struct)
-		.reduce(fold_tokens)
-		.unwrap_or_default();
-	let aspects = protocol
-		.aspects
-		.iter()
-		.map(generate_aspect)
-		.reduce(fold_tokens)
-		.unwrap_or_default();
-	// let nodes = protocol
-	// 	.nodes
-	// 	.iter()
-	// 	.map(generate_node)
-	// 	.reduce(fold_tokens)
-	// 	.unwrap_or_default();
-	quote!(#custom_enums #custom_unions #custom_structs #aspects #interface).into()
-}
-
-fn generate_custom_enum(custom_enum: &CustomEnum) -> TokenStream {
-	let name = Ident::new(&custom_enum.name.to_case(Case::Pascal), Span::call_site());
-	let description = &custom_enum.description;
-
-	let argument_decls = custom_enum
-		.variants
-		.iter()
-		.map(|a| Ident::new(&a.to_case(Case::Pascal), Span::call_site()).to_token_stream())
-		.reduce(|a, b| quote!(#a, #b))
-		.unwrap_or_default();
-
-	quote! {
-		#[doc = #description]
-		#[derive(Debug, Clone, Copy, serde_repr::Deserialize_repr, serde_repr::Serialize_repr)]
-		#[repr(u32)]
-		pub enum #name {#argument_decls}
-	}
-}
-fn generate_custom_union(custom_union: &CustomUnion) -> TokenStream {
-	let name = Ident::new(&custom_union.name.to_case(Case::Pascal), Span::call_site());
-	let description = &custom_union.description;
-
-	let option_decls = custom_union
-		.options
-		.iter()
-		.map(generate_union_option)
-		.reduce(|a, b| quote!(#a, #b))
-		.unwrap_or_default();
-
-	quote! {
-		#[doc = #description]
-		#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-		#[serde(untagged)]
-		pub enum #name {#option_decls}
-	}
-}
-fn generate_union_option(union_option: &UnionOption) -> TokenStream {
-	let name = union_option
-		.name
-		.as_ref()
-		.map(|n| n.to_case(Case::Pascal))
-		.unwrap_or_else(|| argument_type_option_name(&union_option._type));
-	let description = union_option
-		.description
-		.as_ref()
-		.map(|d| quote!(#[doc = #d]))
-		.unwrap_or_default();
-	let identifier = Ident::new(&name, Span::call_site());
-	let _type = generate_argument_type(&union_option._type, false, true);
-	quote! (#description #identifier(#_type))
-}
-fn generate_custom_struct(custom_struct: &CustomStruct) -> TokenStream {
-	let name = Ident::new(&custom_struct.name.to_case(Case::Pascal), Span::call_site());
-	let description = &custom_struct.description;
-
-	let argument_decls = custom_struct
-		.fields
-		.iter()
-		.map(|a| generate_argument_decl(a, true))
-		.map(|d| quote!(pub #d))
-		.reduce(|a, b| quote!(#a, #b))
-		.unwrap_or_default();
-
-	quote! {
-		#[doc = #description]
-		#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-		pub struct #name {#argument_decls}
-	}
-}
-
-// fn generate_node(node: &Node) -> TokenStream {
-// 	let node_name = Ident::new(&node.name, Span::call_site());
-// 	let description = &node.description;
-
-// 	let aspects = node
-// 		.aspects
-// 		.iter()
-// 		.map(|a| {
-// 			let aspect_name = Ident::new(&format!("{a}Aspect"), Span::call_site());
-// 			quote!(impl #aspect_name for #node_name {})
-// 		})
-// 		.reduce(fold_tokens)
-// 		.unwrap_or_default();
-
-// 	quote! {
-// 		#[doc = #description]
-// 		#[derive(Debug)]
-// 		pub struct #node_name (crate::node::Node);
-// 		impl crate::node::NodeType for #node_name {
-// 			fn node(&self) -> &crate::node::Node {
-// 				&self.0
-// 			}
-// 			fn alias(&self) -> Self {
-// 				#node_name(self.0.alias())
-// 			}
-// 			fn from_path(client: &std::sync::Arc<crate::client::Client>, path: String, destroyable: bool) -> Self {
-// 				#node_name(crate::node::Node::from_path(client, path, destroyable))
-// 			}
-// 		}
-// 		impl serde::Serialize for #node_name {
-// 			fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-// 				let node_path = self.0.get_path().map_err(|e| serde::ser::Error::custom(e))?;
-// 				serializer.serialize_str(&node_path)
-// 			}
-// 		}
-// 		#aspects
-// 	}
-// }
-
-fn generate_aspect(aspect: &Aspect) -> TokenStream {
-	let description = &aspect.description;
-	let (client_members, server_members) = aspect.members.iter().split(|m| m.side == Side::Server);
-
-	let client_mod_name = Ident::new(
-		&format!("{}_client", &aspect.name.to_case(Case::Snake)),
-		Span::call_site(),
-	);
-	let client_side_members = client_members
-		.map(generate_member)
-		.reduce(fold_tokens)
-		.map(|t| {
-			quote! {
-				pub mod #client_mod_name {
-					#t
-				}
-			}
-		})
-		.unwrap_or_default();
-
-	let aspect_trait_name = Ident::new(
-		&format!("{}Aspect", &aspect.name.to_case(Case::Pascal)),
-		Span::call_site(),
-	);
-	let server_side_members = server_members
-		.map(generate_member)
-		.reduce(fold_tokens)
-		.unwrap_or_default();
-	let add_node_members = aspect
-		.members
-		.iter()
-		.filter(|m| m.side == Side::Server)
-		.map(generate_handler)
-		.reduce(fold_tokens)
-		.map(|members| {
-			quote! {
-				fn add_node_members(node: &crate::nodes::Node) {
-					#members
-				}
-			}
-		})
-		.unwrap_or_default();
-	let server_side_members = quote! {
-		#[doc = #description]
-		pub trait #aspect_trait_name {
-			#add_node_members
-			#server_side_members
-		}
-	};
-	quote!(#client_side_members #server_side_members)
-}
-
-fn generate_member(member: &Member) -> TokenStream {
-	let name_str = &member.name;
-	let name = Ident::new(&member.name.to_case(Case::Snake), Span::call_site());
-	let description = &member.description;
-
-	let side = member.side;
-	let _type = member._type;
-
-	let first_args = match member.side {
-		Side::Server => {
-			quote!(_node: std::sync::Arc<crate::nodes::Node>, _calling_client: std::sync::Arc<crate::core::client::Client>)
-		}
-		Side::Client => quote!(_node: &crate::nodes::Node),
-	};
-	let argument_decls = member
-		.arguments
-		.iter()
-		.map(|a| generate_argument_decl(a, member.side == Side::Server))
-		.fold(first_args, |a, b| quote!(#a, #b));
-
-	let argument_uses = member
-		.arguments
-		.iter()
-		.map(|a| generate_argument_serialize(&a.name, &a._type, a.optional))
-		.reduce(|a, b| quote!(#a, #b))
-		.unwrap_or_default();
-	let return_type = member
-		.return_type
-		.as_ref()
-		.map(|r| generate_argument_type(&r, false, true))
-		.unwrap_or_else(|| quote!(()));
-
-	match (side, _type) {
-		(Side::Client, MemberType::Method) => {
-			quote! {
-				#[doc = #description]
-				pub async fn #name(#argument_decls) -> color_eyre::eyre::Result<#return_type> {
-					_node.execute_remote_method(#name_str, &(#argument_uses)).await
-				}
-			}
-		}
-		(Side::Client, MemberType::Signal) => {
-			quote! {
-				#[doc = #description]
-				pub fn #name(#argument_decls) -> color_eyre::eyre::Result<()> {
-					let serialized = stardust_xr::schemas::flex::serialize((#argument_uses))?;
-					_node.send_remote_signal(#name_str, serialized)
-				}
-			}
-		}
-		(Side::Server, MemberType::Method) => {
-			quote! {
-				#[doc = #description]
-				fn #name(#argument_decls) -> impl std::future::Future<Output = color_eyre::eyre::Result<#return_type>> + Send + 'static;
-			}
-		}
-		(Side::Server, MemberType::Signal) => {
-			let prefix =
-				if let Some(ArgumentType::Node { _type, return_info }) = &member.return_type {
-					if let Some(return_info) = return_info {
-						let parent_name = Ident::new(
-							&(name_str.to_case(Case::ScreamingSnake) + "_PARENT_PATH"),
-							Span::call_site(),
-						);
-						let parent_path = &return_info.parent;
-						quote!(const #parent_name: &'static str = #parent_path;)
-					} else {
-						TokenStream::default()
-					}
-				} else {
-					TokenStream::default()
-				};
-			quote! {
-				#prefix
-				#[doc = #description]
-				fn #name(#argument_decls) -> color_eyre::eyre::Result<()>;
-			}
-		}
-	}
-}
-fn generate_handler(member: &Member) -> TokenStream {
-	let member_name = &member.name;
-	let member_name_ident = Ident::new(&member_name, Span::call_site());
-
-	let argument_names = member
-		.arguments
-		.iter()
-		.map(generate_argument_name)
-		.reduce(|a, b| quote!(#a, #b));
-	let argument_types = member
-		.arguments
-		.iter()
-		.map(|a| {
-			let _type = convert_deserializeable_argument_type(&a._type);
-			generate_argument_type(&_type, a.optional, true)
-		})
-		.reduce(|a, b| quote!(#a, #b));
-	// dbg!(&argument_types);
-	let deserialize = argument_names
-		.clone()
-		.zip(argument_types)
-		.map(|(argument_names, argument_types)| {
-			quote!(let (#argument_names): (#argument_types) = stardust_xr::schemas::flex::deserialize(_message.as_ref())?;)
-		})
-		.unwrap_or_default();
-	let argument_uses = member
-		.arguments
-		.iter()
-		.map(|a| generate_argument_deserialize(&a.name, &a._type, a.optional))
-		.reduce(|a, b| quote!(#a, #b))
-		.unwrap_or_default();
-	match member._type {
-		MemberType::Signal => quote! {
-			node.add_local_signal(#member_name, |_node, _calling_client, _message| {
-				#deserialize
-				Self::#member_name_ident(_node, _calling_client.clone(), #argument_uses)
-			});
-		},
-		MemberType::Method => quote! {
-			node.add_local_method(#member_name, |_node, _calling_client, _message, _method_response| {
-				_method_response.wrap_async(async move {
-					#deserialize
-					Ok((Self::#member_name_ident(_node, _calling_client.clone(), #argument_uses).await?, Vec::new()))
-				});
-			});
-		},
-	}
-}
-fn generate_argument_name(argument: &Argument) -> TokenStream {
-	Ident::new(&argument.name.to_case(Case::Snake), Span::call_site()).to_token_stream()
-}
-
-fn convert_deserializeable_argument_type(argument_type: &ArgumentType) -> ArgumentType {
-	match argument_type {
-		ArgumentType::Node { .. } => ArgumentType::String,
-		f => f.clone(),
-	}
-}
-fn generate_argument_deserialize(
-	argument_name: &str,
-	argument_type: &ArgumentType,
-	optional: bool,
-) -> TokenStream {
-	let name = Ident::new(&argument_name.to_case(Case::Snake), Span::call_site());
-
-	match argument_type {
-		ArgumentType::Node { .. } => match optional {
-			true => quote!(#name.map(|n| _calling_client.get_node(#argument_name, &n)?)),
-			false => quote!(_calling_client.get_node(#argument_name, &#name)?),
-		},
-		ArgumentType::Color => quote!(color::rgba_linear!(#name[0], #name[1], #name[2], #name[3])),
-		ArgumentType::Vec(v) => {
-			let mapping = generate_argument_deserialize("a", v, false);
-			quote!(#name.into_iter().map(|a| Ok(#mapping)).collect::<color_eyre::eyre::Result<Vec<_>>>()?)
-		}
-		ArgumentType::Map(v) => {
-			let mapping = generate_argument_deserialize("a", v, false);
-			quote!(#name.into_iter().map(|(k, a)| Ok((k, #mapping))).collect::<color_eyre::eyre::Result<rustc_hash::FxHashMap<String, _>>>()?)
-		}
-		_ => quote!(#name),
-	}
-}
-fn generate_argument_serialize(
-	argument_name: &str,
-	argument_type: &ArgumentType,
-	optional: bool,
-) -> TokenStream {
-	let name = Ident::new(&argument_name.to_case(Case::Snake), Span::call_site());
-	match argument_type {
-		ArgumentType::Node {
-			_type,
-			return_info: _,
-		} => match optional {
-			true => quote!(#name.map(|n| n.get_path())),
-			false => quote!(#name.get_path()),
-		},
-		ArgumentType::Color => quote!([#name.c.r, #name.c.g, #name.c.b, #name.a]),
-		ArgumentType::Vec(v) => {
-			let mapping = generate_argument_serialize("a", v, false);
-			quote!(#name.into_iter().map(|a| Ok(#mapping)).collect::<color_eyre::eyre::Result<Vec<_>>>()?)
-		}
-		ArgumentType::Map(v) => {
-			let mapping = generate_argument_serialize("a", v, false);
-			quote!(#name.into_iter().map(|(k, a)| Ok((k, #mapping))).collect::<color_eyre::eyre::Result<rustc_hash::FxHashMap<String, _>>>()?)
-		}
-		_ => quote!(#name),
-	}
-}
-fn generate_argument_decl(argument: &Argument, owned_values: bool) -> TokenStream {
-	let name = Ident::new(&argument.name.to_case(Case::Snake), Span::call_site());
-	let mut _type = generate_argument_type(&argument._type, argument.optional, owned_values);
-	quote!(#name: #_type)
-}
-fn argument_type_option_name(argument_type: &ArgumentType) -> String {
-	match argument_type {
-		ArgumentType::Bool => "Bool".to_string(),
-		ArgumentType::Int => "Int".to_string(),
-		ArgumentType::UInt => "UInt".to_string(),
-		ArgumentType::Float => "Float".to_string(),
-		ArgumentType::Vec2 => "Vec2".to_string(),
-		ArgumentType::Vec3 => "Vec3".to_string(),
-		ArgumentType::Quat => "Quat".to_string(),
-		ArgumentType::Color => "Color".to_string(),
-		ArgumentType::String => "String".to_string(),
-		ArgumentType::Bytes => "Bytes".to_string(),
-		ArgumentType::Vec(v) => format!("{}Vector", argument_type_option_name(&v)),
-		ArgumentType::Map(m) => format!("{}Map", argument_type_option_name(&m)),
-		ArgumentType::Datamap => "Datamap".to_string(),
-		ArgumentType::ResourceID => "ResourceID".to_string(),
-		ArgumentType::Enum(e) => e.clone(),
-		ArgumentType::Union(u) => u.clone(),
-		ArgumentType::Struct(s) => s.clone(),
-		ArgumentType::Node { _type, .. } => _type.clone(),
-	}
-}
-fn generate_argument_type(
-	argument_type: &ArgumentType,
-	optional: bool,
-	owned: bool,
-) -> TokenStream {
-	let _type = match argument_type {
-		ArgumentType::Bool => quote!(bool),
-		ArgumentType::Int => quote!(i32),
-		ArgumentType::UInt => quote!(u32),
-		ArgumentType::Float => quote!(f32),
-		ArgumentType::Vec2 => quote!(mint::Vector2<f32>),
-		ArgumentType::Vec3 => quote!(mint::Vector3<f32>),
-		ArgumentType::Quat => quote!(mint::Quaternion<f32>),
-		ArgumentType::Color => quote!(stardust_xr::values::Color),
-		ArgumentType::Bytes => {
-			if !owned {
-				quote!(&[u8])
-			} else {
-				quote!(Vec<u8>)
-			}
-		}
-		ArgumentType::String => {
-			if !owned {
-				quote!(&str)
-			} else {
-				quote!(String)
-			}
-		}
-		ArgumentType::Vec(t) => {
-			let t = generate_argument_type(&t, false, true);
-			if !owned {
-				quote!(&[#t])
-			} else {
-				quote!(Vec<#t>)
-			}
-		}
-		ArgumentType::Map(t) => {
-			let t = generate_argument_type(&t, false, true);
-
-			if !owned {
-				quote!(&rustc_hash::FxHashMap<String, #t>)
-			} else {
-				quote!(rustc_hash::FxHashMap<String, #t>)
-			}
-		}
-		ArgumentType::Datamap => {
-			if !owned {
-				quote!(&stardust_xr::values::Datamap)
-			} else {
-				quote!(stardust_xr::values::Datamap)
-			}
-		}
-		ArgumentType::ResourceID => {
-			if !owned {
-				quote!(&stardust_xr::values::ResourceID)
-			} else {
-				quote!(stardust_xr::values::ResourceID)
-			}
-		}
-		ArgumentType::Enum(e) => {
-			let enum_name = Ident::new(&e.to_case(Case::Pascal), Span::call_site());
-			quote!(#enum_name)
-		}
-		ArgumentType::Union(u) => {
-			let union_name = Ident::new(&u.to_case(Case::Pascal), Span::call_site());
-			quote!(#union_name)
-		}
-		ArgumentType::Struct(s) => {
-			let struct_name = Ident::new(&s.to_case(Case::Pascal), Span::call_site());
-			if !owned {
-				quote!(&#struct_name)
-			} else {
-				quote!(#struct_name)
-			}
-		}
-		ArgumentType::Node {
-			_type,
-			return_info: _,
-		} => {
-			if !owned {
-				quote!(&std::sync::Arc<crate::nodes::Node>)
-			} else {
-				quote!(std::sync::Arc<crate::nodes::Node>)
-			}
-		}
-	};
-
-	if optional {
-		quote!(Option<#_type>)
-	} else {
-		_type
-	}
-}

flake.lock

@@ -9,11 +9,11 @@
         "rust-analyzer-src": "rust-analyzer-src"
       },
       "locked": {
-        "lastModified": 1700115779,
+        "lastModified": 1678775037,
-        "narHash": "sha256-oajhxEBg+16/KH74CaygAQ6b5KUHS7DwBoL9ecD9qeI=",
+        "narHash": "sha256-chx0tWnXKpcayPkPY3Qh+2hNwptvX8XE3o+fYZ+GNzg=",
         "owner": "nix-community",
         "repo": "fenix",
-        "rev": "4378e7e5f5bdef438eee5ce967f37593b9b5cd16",
+        "rev": "ee59e1c769657b1e27e608f8b981fa8f6b715583",
         "type": "github"
       },
       "original": {
@@ -27,11 +27,11 @@
         "nixpkgs-lib": "nixpkgs-lib"
       },
       "locked": {
-        "lastModified": 1709336216,
+        "lastModified": 1690933134,
-        "narHash": "sha256-Dt/wOWeW6Sqm11Yh+2+t0dfEWxoMxGBvv3JpIocFl9E=",
+        "narHash": "sha256-ab989mN63fQZBFrkk4Q8bYxQCktuHmBIBqUG1jl6/FQ=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "f7b3c975cf067e56e7cda6cb098ebe3fb4d74ca2",
+        "rev": "59cf3f1447cfc75087e7273b04b31e689a8599fb",
         "type": "github"
       },
       "original": {
@@ -42,17 +42,14 @@
     },
     "flake-parts_2": {
       "inputs": {
-        "nixpkgs-lib": [
+        "nixpkgs-lib": "nixpkgs-lib_2"
-          "hercules-ci-effects",
-          "nixpkgs"
-        ]
       },
       "locked": {
-        "lastModified": 1701473968,
+        "lastModified": 1688466019,
-        "narHash": "sha256-YcVE5emp1qQ8ieHUnxt1wCZCC3ZfAS+SRRWZ2TMda7E=",
+        "narHash": "sha256-VeM2akYrBYMsb4W/MmBo1zmaMfgbL4cH3Pu8PGyIwJ0=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "34fed993f1674c8d06d58b37ce1e0fe5eebcb9f5",
+        "rev": "8e8d955c22df93dbe24f19ea04f47a74adbdc5ec",
         "type": "github"
       },
       "original": {
@@ -60,17 +57,39 @@
         "type": "indirect"
       }
     },
+    "flake-parts_3": {
+      "inputs": {
+        "nixpkgs-lib": [
+          "hercules-ci-effects",
+          "hercules-ci-agent",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1688466019,
+        "narHash": "sha256-VeM2akYrBYMsb4W/MmBo1zmaMfgbL4cH3Pu8PGyIwJ0=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "8e8d955c22df93dbe24f19ea04f47a74adbdc5ec",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
     "flatland": {
       "inputs": {
         "fenix": "fenix",
         "nixpkgs": "nixpkgs"
       },
       "locked": {
-        "lastModified": 1709774755,
+        "lastModified": 1694190588,
-        "narHash": "sha256-6tSG4G+SB+l71101XNyEHN/J8pSuJvbNPhKgzqP5sVU=",
+        "narHash": "sha256-tcvp09A54AbXkkXS/P6Ed5TUWzMEuQ9h/fnfLz7gnJc=",
         "owner": "StardustXR",
         "repo": "flatland",
-        "rev": "fef8c317928a1d1798d8cee9af94d219a7c09e8c",
+        "rev": "3867067452761959a95497d6589f9336b347270c",
         "type": "github"
       },
       "original": {
@@ -79,17 +98,53 @@
         "type": "github"
       }
     },
-    "hercules-ci-effects": {
+    "haskell-flake": {
+      "locked": {
+        "lastModified": 1684780604,
+        "narHash": "sha256-2uMZsewmRn7rRtAnnQNw1lj0uZBMh4m6Cs/7dV5YF08=",
+        "owner": "srid",
+        "repo": "haskell-flake",
+        "rev": "74210fa80a49f1b6f67223debdbf1494596ff9f2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "srid",
+        "ref": "0.3.0",
+        "repo": "haskell-flake",
+        "type": "github"
+      }
+    },
+    "hercules-ci-agent": {
       "inputs": {
-        "flake-parts": "flake-parts_2",
+        "flake-parts": "flake-parts_3",
+        "haskell-flake": "haskell-flake",
         "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1708547820,
+        "lastModified": 1688568579,
-        "narHash": "sha256-xU/KC1PWqq5zL9dQ9wYhcdgxAwdeF/dJCLPH3PNZEBg=",
+        "narHash": "sha256-ON0M56wtY/TIIGPkXDlJboAmuYwc73Hi8X9iJGtxOhM=",
+        "owner": "hercules-ci",
+        "repo": "hercules-ci-agent",
+        "rev": "367dd8cd649b57009a6502e878005a1e54ad78c5",
+        "type": "github"
+      },
+      "original": {
+        "id": "hercules-ci-agent",
+        "type": "indirect"
+      }
+    },
+    "hercules-ci-effects": {
+      "inputs": {
+        "flake-parts": "flake-parts_2",
+        "hercules-ci-agent": "hercules-ci-agent",
+        "nixpkgs": "nixpkgs_3"
+      },
+      "locked": {
+        "lastModified": 1689397210,
+        "narHash": "sha256-fVxZnqxMbsDkB4GzGAs/B41K0wt/e+B/fLxmTFF/S20=",
         "owner": "hercules-ci",
         "repo": "hercules-ci-effects",
-        "rev": "0ca27bd58e4d5be3135a4bef66b582e57abe8f4a",
+        "rev": "0a63bfa3f00a3775ea3a6722b247880f1ffe91ce",
         "type": "github"
       },
       "original": {
@@ -100,16 +155,16 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1699781429,
+        "lastModified": 1678703398,
-        "narHash": "sha256-UYefjidASiLORAjIvVsUHG6WBtRhM67kTjEY4XfZOFs=",
+        "narHash": "sha256-Y1mW3dBsoWLHpYm+UIHb5VZ7rx024NNHaF16oZBx++o=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "e44462d6021bfe23dfb24b775cc7c390844f773d",
+        "rev": "67f26c1cfc5d5783628231e776a81c1ade623e0b",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-unstable",
+        "ref": "nixos-22.11",
         "repo": "nixpkgs",
         "type": "github"
       }
@@ -117,11 +172,29 @@
     "nixpkgs-lib": {
       "locked": {
         "dir": "lib",
-        "lastModified": 1709237383,
+        "lastModified": 1690881714,
-        "narHash": "sha256-cy6ArO4k5qTx+l5o+0mL9f5fa86tYUX3ozE1S+Txlds=",
+        "narHash": "sha256-h/nXluEqdiQHs1oSgkOOWF+j8gcJMWhwnZ9PFabN6q0=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1536926ef5621b09bba54035ae2bb6d806d72ac8",
+        "rev": "9e1960bc196baf6881340d53dccb203a951745a2",
+        "type": "github"
+      },
+      "original": {
+        "dir": "lib",
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-lib_2": {
+      "locked": {
+        "dir": "lib",
+        "lastModified": 1688049487,
+        "narHash": "sha256-100g4iaKC9MalDjUW9iN6Jl/OocTDtXdeAj7pEGIRh4=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "4bc72cae107788bf3f24f30db2e2f685c9298dc9",
         "type": "github"
       },
       "original": {
@@ -134,11 +207,11 @@
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1703637592,
+        "lastModified": 1688322751,
-        "narHash": "sha256-8MXjxU0RfFfzl57Zy3OfXCITS0qWDNLzlBAdwxGZwfY=",
+        "narHash": "sha256-eW62dC5f33oKZL7VWlomttbUnOTHrAbte9yNUNW8rbk=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "cfc3698c31b1fb9cdcf10f36c9643460264d0ca8",
+        "rev": "0fbe93c5a7cac99f90b60bdf5f149383daaa615f",
         "type": "github"
       },
       "original": {
@@ -150,11 +223,26 @@
     },
     "nixpkgs_3": {
       "locked": {
-        "lastModified": 1709479366,
+        "lastModified": 1689393711,
-        "narHash": "sha256-n6F0n8UV6lnTZbYPl1A9q1BS0p4hduAv1mGAP17CVd0=",
+        "narHash": "sha256-l3gyTPy/qWLDk1CY1EgYwlsxcGxN2aVd7MlCzQa69rk=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "27fcd46fa18df36d270174246e7bd8f1787129ff",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_4": {
+      "locked": {
+        "lastModified": 1692734709,
+        "narHash": "sha256-SCFnyHCyYjwEmgUsHDDuU0TsbVMKeU1vwkR+r7uS2Rg=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "b8697e57f10292a6165a20f03d2f42920dfaf973",
+        "rev": "b85ed9dcbf187b909ef7964774f8847d554fab3b",
         "type": "github"
       },
       "original": {
@@ -169,17 +257,17 @@
         "flake-parts": "flake-parts",
         "flatland": "flatland",
         "hercules-ci-effects": "hercules-ci-effects",
-        "nixpkgs": "nixpkgs_3"
+        "nixpkgs": "nixpkgs_4"
       }
     },
     "rust-analyzer-src": {
       "flake": false,
       "locked": {
-        "lastModified": 1700077026,
+        "lastModified": 1678695923,
-        "narHash": "sha256-Vf7ykubXsriSjBbeYAm8bzBIvSOYVUmRiCQ3iLL/E+U=",
+        "narHash": "sha256-rDhiiU8P6sf6mgj5IKgCuTRN9uYeqWr6xl4XLkKnMWg=",
         "owner": "rust-lang",
         "repo": "rust-analyzer",
-        "rev": "58de0b130a763f3a2d373f508ac0c18a8e7d0acd",
+        "rev": "95497533524537b1cc7a2870ce94b0b14503be8b",
         "type": "github"
       },
       "original": {

flake.nix

@@ -53,7 +53,7 @@
         effects = let
           pkgs = nixpkgs.legacyPackages.x86_64-linux;
           hci-effects = hercules-ci-effects.lib.withPkgs pkgs;
-        in { ref, rev, ... }: {
+        in { branch, rev, ... }: {
           gnome-graphical-test = hci-effects.mkEffect {
             secretsMap."stardustxrDiscord" = "stardustxrDiscord";
             secretsMap."stardustxrIpfs" = "stardustxrIpfs";
@@ -67,7 +67,7 @@
               export ADDRESS="https://ipfs.stardustxr.org/ipfs/$CID"
               ${pkgs.discord-sh}/bin/discord.sh \
                 --description "\`stardustxr/server\` has been modified, here's how it renders \`weston-cliptest\` on \`flatland\` via \`monado-service\` inside of the \`gnome-graphical-test\`" \
-                --field "Ref;${ref}" \
+                --field "Branch;${branch}" \
                 --field "Commit ID;${rev}" \
                 --field "Flatland Revision;${flatland.rev}" \
                 --field "Reproducer;\`nix build github:stardustxr/server/${rev}#gnome-graphical-test\`" \

src/core/buffers.rs

@@ -0,0 +1,50 @@
+use std::ffi::c_void;
+
+use color_eyre::eyre::{ensure, Result};
+use smithay::backend::{egl::EGLContext, renderer::gles::GlesRenderer};
+use stereokit as sk;
+
+struct EGLRawHandles {
+	display: *const c_void,
+	config: *const c_void,
+	context: *const c_void,
+}
+fn get_sk_egl() -> Result<EGLRawHandles> {
+	ensure!(
+		unsafe { sk::sys::backend_graphics_get() }
+			== sk::sys::backend_graphics__backend_graphics_opengles_egl,
+		"StereoKit is not running using EGL!"
+	);
+
+	Ok(unsafe {
+		EGLRawHandles {
+			display: sk::sys::backend_opengl_egl_get_display() as *const c_void,
+			config: sk::sys::backend_opengl_egl_get_config() as *const c_void,
+			context: sk::sys::backend_opengl_egl_get_context() as *const c_void,
+		}
+	})
+}
+
+pub struct BufferManager {
+	pub renderer: GlesRenderer,
+}
+impl BufferManager {
+	pub fn new() -> Result<Self> {
+		let egl_raw_handles = get_sk_egl()?;
+		let renderer = unsafe {
+			GlesRenderer::new(EGLContext::from_raw(
+				egl_raw_handles.display,
+				egl_raw_handles.config,
+				egl_raw_handles.context,
+			)?)?
+		};
+
+		Ok(BufferManager { renderer })
+	}
+
+	pub fn make_context_current(&self) {
+		unsafe {
+			let _ = self.renderer.egl_context().make_current();
+		}
+	}
+}

src/core/client.rs

@@ -1,6 +1,5 @@
 use super::{
 	client_state::{ClientState, CLIENT_STATES},
-	destroy_queue,
 	scenegraph::Scenegraph,
 };
 use crate::{
@@ -16,7 +15,7 @@ use stardust_xr::{
 	messenger::{self, MessageSenderHandle},
 	schemas::flex::serialize,
 };
-use std::{fmt::Debug, fs, iter::FromIterator, path::PathBuf, sync::Arc};
+use std::{fs, iter::FromIterator, path::PathBuf, sync::Arc};
 use tokio::{net::UnixStream, task::JoinHandle};
 use tracing::info;
 
@@ -210,22 +209,7 @@ impl Client {
 		if let Some(flush_join_handle) = self.flush_join_handle.get() {
 			flush_join_handle.abort();
 		}
-		if let Some(client) = CLIENTS.remove(self) {
+		CLIENTS.remove(self);
-			destroy_queue::add(client);
-		}
-	}
-}
-impl Debug for Client {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		f.debug_struct("Client")
-			.field("pid", &self.pid)
-			.field("exe", &self.exe)
-			.field("dispatch_join_handle", &self.dispatch_join_handle)
-			.field("flush_join_handle", &self.flush_join_handle)
-			.field("disconnect_status", &self.disconnect_status)
-			.field("base_resource_prefixes", &self.base_resource_prefixes)
-			.field("state", &self.state)
-			.finish()
 	}
 }
 impl Drop for Client {

src/core/client_state.rs

@@ -4,11 +4,7 @@ use glam::Mat4;
 use parking_lot::Mutex;
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
-use std::{
+use std::{io::Write, path::PathBuf, sync::Arc};
-	path::{Path, PathBuf},
-	process::Command,
-	sync::Arc,
-};
 
 lazy_static::lazy_static! {
 	pub static ref CLIENT_STATES: Mutex<FxHashMap<String, Arc<ClientState>>> = Default::default();
@@ -33,7 +29,7 @@ impl LaunchInfo {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ClientState {
 	pub launch_info: Option<LaunchInfo>,
-	pub data: Vec<u8>,
+	pub data: Option<Vec<u8>>,
 	pub root: Mat4,
 	pub spatial_anchors: FxHashMap<String, Mat4>,
 }
@@ -41,7 +37,7 @@ impl ClientState {
 	pub fn from_deserialized(client: &Client, state: ClientStateInternal) -> Self {
 		ClientState {
 			launch_info: LaunchInfo::from_client(client),
-			data: state.data.unwrap_or_default(),
+			data: state.data,
 			root: Self::spatial_transform(client, &state.root.unwrap_or_default())
 				.unwrap_or_default(),
 			spatial_anchors: state
@@ -53,7 +49,7 @@ impl ClientState {
 	}
 	fn spatial_transform(client: &Client, path: &str) -> Option<Mat4> {
 		let node = client.scenegraph.get_node(path)?;
-		let spatial = node.get_aspect::<Spatial>().ok()?;
+		let spatial = node.spatial.get()?;
 		Some(spatial.global_transform())
 	}
 
@@ -62,61 +58,42 @@ impl ClientState {
 		CLIENT_STATES.lock().insert(token.clone(), Arc::new(self));
 		token
 	}
-	pub fn from_file(file: &Path) -> Option<Self> {
+	pub fn to_file(self) {
-		let file_string = std::fs::read_to_string(file).ok()?;
+		let project_dirs = directories::ProjectDirs::from("", "", "stardust").unwrap();
-		toml::from_str(&file_string).ok()
+		let state_dir = project_dirs.state_dir().unwrap();
+		std::fs::create_dir_all(state_dir).unwrap();
+		let mut file = std::fs::File::create(state_dir.join(nanoid::nanoid!())).unwrap();
+		file.write_all(&stardust_xr::schemas::flex::flexbuffers::to_vec(self).unwrap())
+			.unwrap();
 	}
-	pub fn to_file(self, directory: &Path) {
-		let app_name = self
-			.launch_info
-			.as_ref()
-			.map(|l| l.cmdline.get(0).unwrap().split('/').last().unwrap())
-			.unwrap_or("unknown");
-		let state_file_path = directory
-			.join(format!("{app_name}-{}", nanoid::nanoid!()))
-			.with_extension("toml");
-
-		std::fs::write(state_file_path, toml::to_string(&self).unwrap()).unwrap();
-	}
-
 	pub fn apply_to(&self, client: &Arc<Client>) -> ClientStateInternal {
 		if let Some(root) = client.root.get() {
 			root.set_transform(self.root)
 		}
 		ClientStateInternal {
-			data: Some(self.data.clone()),
+			data: self.data.clone(),
 			root: Some("/".to_string()),
 			spatial_anchors: self
 				.spatial_anchors
 				.iter()
 				.map(|(k, v)| {
 					(k.clone(), {
-						let node = Node::create_parent_name(client, "/spatial/anchor", k, true)
+						let node = Node::create(client, "/spatial/anchor", k, true)
 							.add_to_scenegraph()
 							.unwrap();
-						Spatial::add_to(&node, None, *v, false);
+						Spatial::add_to(&node, None, *v, false).unwrap();
 						k.clone()
 					})
 				})
 				.collect(),
 		}
 	}
-	pub fn launch_command(self) -> Option<Command> {
-		let launch_info = self.launch_info.as_ref()?;
-		let mut cmdline = launch_info.cmdline.iter();
-		let mut command = Command::new(cmdline.next()?);
-		command.args(cmdline);
-		command.current_dir(&launch_info.cwd);
-		command.envs(launch_info.env.iter());
-		command.env("STARDUST_STARTUP_TOKEN", self.token());
-		Some(command)
-	}
 }
 impl Default for ClientState {
 	fn default() -> Self {
 		Self {
 			launch_info: None,
-			data: Default::default(),
+			data: None,
 			root: Mat4::IDENTITY,
 			spatial_anchors: Default::default(),
 		}

src/core/destroy_queue.rs

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

src/core/idl_utils.rs

@@ -1,11 +0,0 @@
-#[macro_export]
-macro_rules! create_interface {
-	($iface:ident, $aspect:ident, $path:expr) => {
-		pub fn create_interface(client: &Arc<Client>) -> Result<()> {
-			let node = Node::create_path(client, $path, false);
-			<$iface as $aspect>::add_node_members(&node);
-			node.add_to_scenegraph()?;
-			Ok(())
-		}
-	};
-}

src/core/mod.rs

@@ -3,9 +3,10 @@ pub mod client_state;
 pub mod delta;
 pub mod destroy_queue;
 pub mod eventloop;
-pub mod idl_utils;
 pub mod node_collections;
 pub mod registry;
 pub mod resource;
 pub mod scenegraph;
 pub mod task;
+pub mod typed_datamap;
+pub mod buffers;

src/core/registry.rs

@@ -5,7 +5,6 @@ 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> {
@@ -57,9 +56,7 @@ impl<T: Send + Sync + ?Sized> Registry<T> {
 	}
 	pub fn is_empty(&self) -> bool {
 		let registry = self.0.lock();
-		let Some(registry) = &*registry else {
+		let Some(registry) = &*registry else {return true};
-			return true;
-		};
 		if registry.is_empty() {
 			return true;
 		}
@@ -71,11 +68,6 @@ 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>>>>);
 
@@ -106,12 +98,9 @@ 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) -> Option<Arc<T>>
+	pub fn remove(&self, t: &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/resource.rs

@@ -1,46 +1,83 @@
-use stardust_xr::values::ResourceID;
+use color_eyre::eyre::eyre;
+use serde::{de::Visitor, Deserialize};
 use std::{ffi::OsStr, path::PathBuf};
 
-use super::client::Client;
+#[derive(Debug)]
-
+pub enum ResourceID {
-lazy_static::lazy_static! {
+	File(PathBuf),
-	static ref THEMES: Vec<PathBuf> = std::env::var("STARDUST_THEMES").map(|s| s.split(":").map(PathBuf::from).collect()).unwrap_or_default();
+	Namespaced { namespace: String, path: PathBuf },
 }
-
+impl ResourceID {
-fn has_extension(path: &PathBuf, extensions: &[&OsStr]) -> bool {
+	pub fn get_file(&self, prefixes: &[PathBuf], extensions: &[&OsStr]) -> Option<PathBuf> {
-	if let Some(path_extension) = path.extension() {
+		match self {
-		extensions.contains(&path_extension)
+			ResourceID::File(file) => (file.is_absolute()
-	} else {
+				&& file.exists() && Self::has_extension(file, extensions))
-		false
+			.then_some(file.clone()),
-	}
+			ResourceID::Namespaced { namespace, path } => {
-}
+				let file_name = path.file_name()?;
-
+				prefixes
-pub fn get_resource_file(
+					.iter()
-	resource: &ResourceID,
+					.filter_map(|prefix| {
-	client: &Client,
+						let prefixed_path = prefix.clone().join(namespace).join(path);
-	extensions: &[&OsStr],
+						let parent = prefixed_path.parent()?;
-) -> Option<PathBuf> {
+						std::fs::read_dir(parent).ok()
-	match resource {
+					})
-		ResourceID::Direct(file) => {
+					.flatten()
-			(file.is_absolute() && file.exists() && has_extension(file, extensions))
+					.filter_map(|item| item.ok())
-				.then_some(file.clone())
+					.map(|dir_entry| dir_entry.path())
+					.filter(|path| path.file_stem() == Some(file_name))
+					.find(|path| Self::has_extension(path, extensions))
+			}
 		}
-		ResourceID::Namespaced { namespace, path } => {
+	}
-			let file_name = path.file_name()?;
+
-			let base_prefixes = client.base_resource_prefixes.lock().clone();
+	fn has_extension(path: &PathBuf, extensions: &[&OsStr]) -> bool {
-			THEMES
+		if let Some(path_extension) = path.extension() {
-				.iter()
+			extensions.contains(&path_extension)
-				.chain(base_prefixes.iter())
+		} else {
-				.filter_map(|prefix| {
+			false
-					let prefixed_path = prefix.clone().join(namespace).join(path);
-					let parent = prefixed_path.parent()?;
-					std::fs::read_dir(parent).ok()
-				})
-				.flatten()
-				.filter_map(|item| item.ok())
-				.map(|dir_entry| dir_entry.path())
-				.filter(|path| path.file_stem() == Some(file_name))
-				.find(|path| has_extension(path, extensions))
 		}
 	}
 }
+impl<'de> Deserialize<'de> for ResourceID {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: serde::Deserializer<'de>,
+	{
+		deserializer.deserialize_any(ResourceVisitor)
+	}
+}
+
+struct ResourceVisitor;
+impl<'de> Visitor<'de> for ResourceVisitor {
+	type Value = ResourceID;
+
+	fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+		formatter.write_str("A string containing an absolute path to file or \"[namespace]:[path]\" for a namespaced resource")
+	}
+
+	fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+	where
+		E: serde::de::Error,
+	{
+		Ok(if v.starts_with('/') {
+			let path = PathBuf::from(v);
+			path.metadata().map_err(serde::de::Error::custom)?;
+			ResourceID::File(path)
+		} else if let Some((namespace, path)) = v.split_once(':') {
+			ResourceID::Namespaced {
+				namespace: namespace.to_string(),
+				path: PathBuf::from(path),
+			}
+		} else {
+			return Err(serde::de::Error::custom(eyre!("Invalid format for string")));
+		})
+	}
+
+	fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+	where
+		E: serde::de::Error,
+	{
+		self.visit_str(&v)
+	}
+}

src/core/scenegraph.rs

@@ -1,4 +1,3 @@
-use crate::nodes::alias::Alias;
 use crate::nodes::Node;
 use crate::{core::client::Client, nodes::Message};
 use color_eyre::eyre::Result;
@@ -6,11 +5,8 @@ use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use portable_atomic::Ordering;
 use rustc_hash::FxHashMap;
-use serde::Serialize;
 use stardust_xr::scenegraph;
 use stardust_xr::scenegraph::ScenegraphError;
-use stardust_xr::schemas::flex::serialize;
-use std::future::Future;
 use std::os::fd::OwnedFd;
 use std::sync::{Arc, Weak};
 use tokio::sync::oneshot;
@@ -40,8 +36,8 @@ impl Scenegraph {
 
 	pub fn get_node(&self, path: &str) -> Option<Arc<Node>> {
 		let mut node = self.nodes.lock().get(path)?.clone();
-		while let Ok(alias) = node.get_aspect::<Alias>() {
+		while let Some(alias) = node.alias.get() {
-			if alias.enabled.load(Ordering::Acquire) {
+			if alias.enabled.load(Ordering::Relaxed) {
 				node = alias.original.upgrade()?;
 			} else {
 				return None;
@@ -61,35 +57,11 @@ impl MethodResponseSender {
 	pub fn send(self, t: Result<Message, ScenegraphError>) {
 		let _ = self.0.send(t.map(|m| (m.data, m.fds)));
 	}
-	// pub fn send_method_return<T: Serialize>(
-	// 	self,
-	// 	result: color_eyre::eyre::Result<(T, Vec<OwnedFd>)>,
-	// ) {
-	// 	let _ = self.0.send(map_method_return(result));
-	// }
 	pub fn wrap_sync<F: FnOnce() -> color_eyre::eyre::Result<Message>>(self, f: F) {
 		self.send(f().map_err(|e| ScenegraphError::MethodError {
 			error: e.to_string(),
 		}))
 	}
-	pub fn wrap_async<T: Serialize>(
-		self,
-		f: impl Future<Output = color_eyre::eyre::Result<(T, Vec<OwnedFd>)>> + Send + 'static,
-	) {
-		tokio::task::spawn(async move { self.0.send(map_method_return(f.await)) });
-	}
-}
-fn map_method_return<T: Serialize>(
-	result: color_eyre::eyre::Result<(T, Vec<OwnedFd>)>,
-) -> Result<(Vec<u8>, Vec<OwnedFd>), ScenegraphError> {
-	let (value, fds) = result.map_err(|e| ScenegraphError::MethodError {
-		error: e.to_string(),
-	})?;
-
-	let serialized_value = serialize(value).map_err(|e| ScenegraphError::MethodError {
-		error: format!("Internal: Serialization failed: {e}"),
-	})?;
-	Ok((serialized_value, fds))
 }
 impl scenegraph::Scenegraph for Scenegraph {
 	fn send_signal(

src/core/typed_datamap.rs

@@ -0,0 +1,56 @@
+#![allow(unused)]
+
+use std::ops::{Deref, DerefMut};
+
+use color_eyre::eyre::Result;
+use once_cell::sync::Lazy;
+use serde::{de::DeserializeOwned, Serialize};
+use stardust_xr::schemas::{
+	flat::Datamap,
+	flex::flexbuffers::{FlexbufferSerializer, Reader, ReaderError},
+};
+
+use crate::nodes::Message;
+
+pub struct TypedDatamap<T: DeserializeOwned + Serialize>(T);
+impl<T: DeserializeOwned + Serialize> TypedDatamap<T> {
+	pub fn new(data: T) -> Self {
+		TypedDatamap(data)
+	}
+	pub fn from_flex(message: Message) -> Result<Self> {
+		let root = Reader::get_root(message.as_ref())?;
+		T::deserialize(root).map(Self::new).map_err(|e| e.into())
+	}
+	pub fn to_datamap(&mut self) -> Result<Datamap> {
+		let mut serializer = FlexbufferSerializer::default();
+		self.0.serialize(&mut serializer)?;
+		Datamap::new(serializer.take_buffer()).map_err(|e| e.into())
+	}
+	pub fn serialize(&mut self) -> Option<Vec<u8>> {
+		let mut serializer = FlexbufferSerializer::default();
+		self.0.serialize(&mut serializer).ok()?;
+		// check if this is actually a map
+		Reader::get_root(serializer.view()).ok()?.get_map().ok()?;
+		Some(serializer.take_buffer())
+	}
+}
+impl<T: DeserializeOwned + Serialize> Default for TypedDatamap<T>
+where
+	T: Default,
+{
+	fn default() -> Self {
+		Self(T::default())
+	}
+}
+impl<T: DeserializeOwned + Serialize> Deref for TypedDatamap<T> {
+	type Target = T;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+impl<T: DeserializeOwned + Serialize> DerefMut for TypedDatamap<T> {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.0
+	}
+}

src/main.rs

@@ -5,7 +5,8 @@ mod objects;
 mod wayland;
 
 use crate::core::client::CLIENTS;
-use crate::core::destroy_queue;
+use crate::core::client_state::ClientState;
+use crate::core::{destroy_queue, buffers};
 use crate::nodes::items::camera;
 use crate::nodes::{audio, drawable, hmd, input};
 use crate::objects::input::eye_pointer::EyePointer;
@@ -13,17 +14,16 @@ use crate::objects::input::mouse_pointer::MousePointer;
 use crate::objects::input::sk_controller::SkController;
 use crate::objects::input::sk_hand::SkHand;
 use crate::objects::play_space::PlaySpace;
-use crate::wayland::X_DISPLAY;
 
 use self::core::eventloop::EventLoop;
 use clap::Parser;
-use core::client_state::ClientState;
 use directories::ProjectDirs;
 use once_cell::sync::OnceCell;
+use smithay::reexports::nix;
 use stardust_xr::server;
-use std::os::unix::fs::PermissionsExt;
+use std::os::unix::process::CommandExt;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
-use std::process::{Child, Command, Stdio};
+use std::process::{Command, Stdio};
 use std::sync::Arc;
 use std::time::Duration;
 use stereokit::{
@@ -56,10 +56,6 @@ struct CliArgs {
 	/// Run a script when ready for clients to connect. If this is not set the script at $HOME/.config/stardust/startup will be ran if it exists.
 	#[clap(id = "PATH", short = 'e', long = "execute-startup-script", action)]
 	startup_script: Option<PathBuf>,
-
-	/// Restore the session with the given ID (or `latest`), ignoring the startup script. Sessions are stored in directories at `~/.local/state/stardust/`.
-	#[clap(id = "SESSION_ID", long = "restore", action)]
-	restore: Option<String>,
 }
 
 static STARDUST_INSTANCE: OnceCell<String> = OnceCell::new();
@@ -123,7 +119,6 @@ fn main() {
 		overlay_app: cli_args.overlay_priority.is_some(),
 		overlay_priority: cli_args.overlay_priority.unwrap_or(u32::MAX),
 		disable_desktop_input_window: true,
-		render_scaling: 2.0,
 		..Default::default()
 	}
 	.init()
@@ -131,8 +126,6 @@ fn main() {
 	let _ = SK_MULTITHREAD.set(sk.multithreaded());
 	info!("Init StereoKit");
 
-	sk.render_set_multisample(0);
-
 	sk.material_set_shader(
 		sk.material_find("default/material_pbr").unwrap(),
 		sk.shader_find("default/shader_pbr_clip").unwrap(),
@@ -201,30 +194,65 @@ fn main() {
 	let (info_sender, info_receiver) = oneshot::channel::<EventLoopInfo>();
 	let event_thread = std::thread::Builder::new()
 		.name("event_loop".to_owned())
-		.spawn({
+		.spawn(move || event_loop(info_sender))
-			let project_dirs = project_dirs.clone();
-			move || event_loop(info_sender, project_dirs.clone())
-		})
 		.unwrap();
 	let event_loop_info = info_receiver.blocking_recv().unwrap();
 	let _tokio_handle = event_loop_info.tokio_handle.enter();
 
+	let mut buffer_manager = buffers::BufferManager::new().expect("Could not initialize buffer manager");
+
 	#[cfg(feature = "wayland")]
-	let mut wayland = wayland::Wayland::new().expect("Could not initialize wayland");
+	let mut wayland = wayland::Wayland::new(&buffer_manager).expect("Could not initialize wayland");
 	info!("Stardust ready!");
 
-	let mut startup_children = project_dirs
+	let mut startup_child = (|| {
-		.as_ref()
+		let project_dirs = project_dirs.as_ref()?;
-		.map(|project_dirs| {
+		let startup_script_path = cli_args
-			launch_start(
+			.startup_script
-				&cli_args,
+			.clone()
-				project_dirs,
+			.and_then(|p| p.canonicalize().ok())
-				&event_loop_info,
+			.unwrap_or_else(|| project_dirs.config_dir().join("startup"));
-				#[cfg(feature = "wayland")]
+		let mut startup_command = Command::new("bash");
-				&wayland,
+		startup_command.arg(startup_script_path);
-			)
+		startup_command.arg("&");
-		})
+
-		.unwrap_or_default();
+		startup_command.stdin(Stdio::null());
+		startup_command.stdout(Stdio::null());
+		startup_command.stderr(Stdio::null());
+		startup_command.env(
+			"FLAT_WAYLAND_DISPLAY",
+			std::env::var_os("WAYLAND_DISPLAY").unwrap_or_default(),
+		);
+		startup_command.env(
+			"STARDUST_INSTANCE",
+			event_loop_info
+				.socket_path
+				.file_name()
+				.expect("Stardust socket path not found"),
+		);
+		#[cfg(feature = "wayland")]
+		{
+			if let Some(wayland_socket) = wayland.socket_name.as_ref() {
+				startup_command.env("WAYLAND_DISPLAY", &wayland_socket);
+			}
+			#[cfg(feature = "xwayland")]
+			startup_command.env("DISPLAY", format!(":{}", wayland.xwayland_state.display));
+			startup_command.env("GDK_BACKEND", "wayland");
+			startup_command.env("QT_QPA_PLATFORM", "wayland");
+			startup_command.env("MOZ_ENABLE_WAYLAND", "1");
+			startup_command.env("CLUTTER_BACKEND", "wayland");
+			startup_command.env("SDL_VIDEODRIVER", "wayland");
+		}
+		unsafe {
+			startup_command.pre_exec(|| {
+				nix::unistd::setsid()
+					.map(|_| ())
+					.map_err(|_| std::io::ErrorKind::Other.into())
+			})
+		};
+		let child = startup_command.spawn().ok()?;
+		Some(child)
+	})();
 
 	let mut last_frame_delta = Duration::ZERO;
 	let mut sleep_duration = Duration::ZERO;
@@ -234,8 +262,8 @@ fn main() {
 				let _span = debug_span!("StereoKit step");
 				let _span = _span.enter();
 
+				camera::send_rendered();
 				hmd::frame(sk);
-				camera::update(sk);
 				#[cfg(feature = "wayland")]
 				wayland.frame_event(sk);
 				destroy_queue::clear();
@@ -267,14 +295,20 @@ fn main() {
 				);
 
 				#[cfg(feature = "wayland")]
-				wayland.update(sk);
+				wayland.update(sk, &mut buffer_manager);
 				drawable::draw(sk);
 				audio::update(sk);
-				#[cfg(feature = "wayland")]
+
-				wayland.make_context_current();
+				buffer_manager.make_context_current();
+
+				camera::update(sk, &mut buffer_manager);
 			},
 			|_sk| {
 				info!("Cleanly shut down StereoKit");
+
+				if let Some(mut startup_child) = startup_child.take() {
+					let _ = startup_child.kill();
+				}
 			},
 		)
 	});
@@ -287,9 +321,6 @@ fn main() {
 		.join()
 		.expect("Failed to cleanly shut down event loop")
 		.unwrap();
-	for mut startup_child in startup_children.drain(..) {
-		let _ = startup_child.kill();
-	}
 
 	info!("Cleanly shut down Stardust");
 }
@@ -317,12 +348,9 @@ fn adaptive_sleep(
 	});
 }
 
-// #[tokio::main]
+#[tokio::main]
-#[tokio::main(flavor = "current_thread")]
+// #[tokio::main(flavor = "current_thread")]
-async fn event_loop(
+async fn event_loop(info_sender: oneshot::Sender<EventLoopInfo>) -> color_eyre::eyre::Result<()> {
-	info_sender: oneshot::Sender<EventLoopInfo>,
-	project_dirs: Option<ProjectDirs>,
-) -> color_eyre::eyre::Result<()> {
 	let socket_path =
 		server::get_free_socket_path().expect("Unable to find a free stardust socket path");
 	STARDUST_INSTANCE.set(socket_path.file_name().unwrap().to_string_lossy().into_owned()).expect("Someone hasn't done their job, yell at Nova because how is this set multiple times what the hell");
@@ -339,9 +367,7 @@ async fn event_loop(
 
 	STOP_NOTIFIER.notified().await;
 	println!("Stopping...");
-	if let Some(project_dirs) = project_dirs {
+	save_clients().await;
-		save_session(&project_dirs).await;
-	}
 
 	info!("Cleanly shut down event loop");
 
@@ -352,121 +378,16 @@ async fn event_loop(
 	Ok(())
 }
 
-fn launch_start(
+async fn save_clients() {
-	cli_args: &CliArgs,
-	project_dirs: &ProjectDirs,
-	event_loop_info: &EventLoopInfo,
-	#[cfg(feature = "wayland")] wayland: &wayland::Wayland,
-) -> Vec<Child> {
-	if let Some(session_id) = &cli_args.restore {
-		let session_dir = project_dirs.state_dir().unwrap().join(session_id);
-		return restore_session(&session_dir, event_loop_info, wayland);
-	}
-	let startup_script_path = cli_args
-		.startup_script
-		.clone()
-		.and_then(|p| p.canonicalize().ok())
-		.unwrap_or_else(|| project_dirs.config_dir().join("startup"));
-	run_script(&startup_script_path, event_loop_info, wayland)
-}
-
-fn restore_session(
-	session_dir: &Path,
-	event_loop_info: &EventLoopInfo,
-	#[cfg(feature = "wayland")] wayland: &wayland::Wayland,
-) -> Vec<Child> {
-	let Ok(clients) = session_dir.read_dir() else {
-		return Vec::new();
-	};
-	clients
-		.filter_map(Result::ok)
-		.filter_map(|c| ClientState::from_file(&c.path()))
-		.filter_map(ClientState::launch_command)
-		.filter_map(|startup_command| {
-			run_client(
-				startup_command,
-				event_loop_info,
-				#[cfg(feature = "wayland")]
-				wayland,
-			)
-		})
-		.collect()
-}
-
-fn run_script(
-	script_path: &Path,
-	event_loop_info: &EventLoopInfo,
-	#[cfg(feature = "wayland")] wayland: &wayland::Wayland,
-) -> Vec<Child> {
-	let _ = std::fs::set_permissions(script_path, std::fs::Permissions::from_mode(0o755));
-	let startup_command = Command::new(script_path);
-	run_client(
-		startup_command,
-		event_loop_info,
-		#[cfg(feature = "wayland")]
-		wayland,
-	)
-	.map(|c| vec![c])
-	.unwrap_or_default()
-}
-
-fn run_client(
-	mut command: Command,
-	event_loop_info: &EventLoopInfo,
-	#[cfg(feature = "wayland")] wayland: &wayland::Wayland,
-) -> Option<Child> {
-	command.stdin(Stdio::null());
-	command.stdout(Stdio::null());
-	command.stderr(Stdio::null());
-	command.env(
-		"FLAT_WAYLAND_DISPLAY",
-		std::env::var_os("WAYLAND_DISPLAY").unwrap_or_default(),
-	);
-	command.env(
-		"STARDUST_INSTANCE",
-		event_loop_info
-			.socket_path
-			.file_name()
-			.expect("Stardust socket path not found"),
-	);
-	#[cfg(feature = "wayland")]
-	{
-		if let Some(wayland_socket) = wayland.socket_name.as_ref() {
-			command.env("WAYLAND_DISPLAY", &wayland_socket);
-		}
-		command.env(
-			"DISPLAY",
-			format!(":{}", X_DISPLAY.get().cloned().unwrap_or_default()),
-		);
-		command.env("GDK_BACKEND", "wayland");
-		command.env("QT_QPA_PLATFORM", "wayland");
-		command.env("MOZ_ENABLE_WAYLAND", "1");
-		command.env("CLUTTER_BACKEND", "wayland");
-		command.env("SDL_VIDEODRIVER", "wayland");
-	}
-	let child = command.spawn().ok()?;
-	Some(child)
-}
-
-async fn save_session(project_dirs: &ProjectDirs) {
-	let session_id = nanoid::nanoid!();
-	let state_dir = project_dirs.state_dir().unwrap();
-	let session_dir = state_dir.join(&session_id);
-	std::fs::create_dir_all(&session_dir).unwrap();
-	let _ = std::fs::remove_dir_all(state_dir.join("latest"));
-	std::os::unix::fs::symlink(&session_dir, state_dir.join("latest")).unwrap();
-
 	let local_set = LocalSet::new();
 	for client in CLIENTS.get_vec() {
-		let session_dir = session_dir.clone();
 		local_set.spawn_local(async move {
 			tokio::select! {
 				biased;
-				s = client.save_state() => {s.map(|s| s.to_file(&session_dir));},
+				s = client.save_state() => {s.map(ClientState::to_file);},
 				_ = tokio::time::sleep(Duration::from_millis(100)) => (),
 			}
 		});
 	}
 	local_set.await;
-	println!("Session ID for restore is {session_id}");
 }

src/nodes/alias.rs

@@ -1,4 +1,4 @@
-use super::{Aspect, Node};
+use super::Node;
 use crate::core::client::Client;
 use color_eyre::eyre::{ensure, Result};
 use portable_atomic::AtomicBool;
@@ -35,7 +35,7 @@ impl Alias {
 			"Node already exists"
 		);
 
-		let node = Node::create_parent_name(client, parent, name, true).add_to_scenegraph()?;
+		let node = Node::create(client, parent, name, true).add_to_scenegraph()?;
 		let alias = Alias {
 			enabled: Arc::new(AtomicBool::new(true)),
 			node: Arc::downgrade(&node),
@@ -43,10 +43,7 @@ impl Alias {
 			info,
 		};
 		let alias = original.aliases.add(alias);
-		node.add_aspect_raw(alias);
+		let _ = node.alias.set(alias);
 		Ok(node)
 	}
 }
-impl Aspect for Alias {
-	const NAME: &'static str = "Alias";
-}

src/nodes/audio.rs

@@ -1,25 +1,23 @@
-use super::{Aspect, Node};
+use super::{Message, Node};
 use crate::core::client::Client;
 use crate::core::destroy_queue;
 use crate::core::registry::Registry;
-use crate::core::resource::get_resource_file;
+use crate::core::resource::ResourceID;
-use crate::create_interface;
+use crate::nodes::spatial::{find_spatial_parent, parse_transform, Spatial};
-use crate::nodes::spatial::{Spatial, Transform};
+use color_eyre::eyre::{ensure, eyre, Result};
-use color_eyre::eyre::{eyre, Result};
 use glam::{vec3, Vec4Swizzles};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use send_wrapper::SendWrapper;
-use stardust_xr::values::ResourceID;
+use serde::Deserialize;
-
+use stardust_xr::schemas::flex::deserialize;
+use stardust_xr::values::Transform;
 use std::ops::DerefMut;
-use std::sync::Arc;
+use std::{ffi::OsStr, path::PathBuf, sync::Arc};
-use std::{ffi::OsStr, path::PathBuf};
 use stereokit::{Sound as SkSound, SoundInstance, StereoKitDraw};
 
 static SOUND_REGISTRY: Registry<Sound> = Registry::new();
 
-stardust_xr_server_codegen::codegen_audio_protocol!();
 pub struct Sound {
 	space: Arc<Spatial>,
 
@@ -30,16 +28,26 @@ pub struct Sound {
 	stop: Mutex<Option<()>>,
 	play: Mutex<Option<()>>,
 }
+
 impl Sound {
 	pub fn add_to(node: &Arc<Node>, resource_id: ResourceID) -> Result<Arc<Sound>> {
-		let pending_audio_path = get_resource_file(
+		ensure!(
-			&resource_id,
+			node.spatial.get().is_some(),
-			&*node.get_client().ok_or_else(|| eyre!("Client not found"))?,
+			"Internal: Node does not have a spatial attached!"
-			&[OsStr::new("wav"), OsStr::new("mp3")],
+		);
-		)
+		let pending_audio_path = resource_id
-		.ok_or_else(|| eyre!("Resource not found"))?;
+			.get_file(
+				&node
+					.get_client()
+					.ok_or_else(|| eyre!("Client not found"))?
+					.base_resource_prefixes
+					.lock()
+					.clone(),
+				&[OsStr::new("wav"), OsStr::new("mp3")],
+			)
+			.ok_or_else(|| eyre!("Resource not found"))?;
 		let sound = Sound {
-			space: node.get_aspect::<Spatial>().unwrap().clone(),
+			space: node.spatial.get().unwrap().clone(),
 			volume: 1.0,
 			pending_audio_path,
 			sk_sound: OnceCell::new(),
@@ -48,8 +56,9 @@ impl Sound {
 			play: Mutex::new(None),
 		};
 		let sound_arc = SOUND_REGISTRY.add(sound);
-		node.add_aspect_raw(sound_arc.clone());
+		node.add_local_signal("play", Sound::play_flex);
-		<Sound as SoundAspect>::add_node_members(node);
+		node.add_local_signal("stop", Sound::stop_flex);
+		let _ = node.sound.set(sound_arc.clone());
 		Ok(sound_arc)
 	}
 
@@ -62,7 +71,7 @@ impl Sound {
 				sk.sound_inst_stop(instance);
 			}
 		}
-		if self.instance.lock().is_none() && self.play.lock().take().is_some() {
+		if self.play.lock().is_some() && self.instance.lock().is_none() {
 			self.instance.lock().replace(sk.sound_play(
 				sound.as_ref(),
 				vec3(0.0, 0.0, 0.0),
@@ -73,30 +82,19 @@ impl Sound {
 			sk.sound_inst_set_pos(*instance, self.space.global_transform().w_axis.xyz());
 		}
 	}
-}
+
-impl Aspect for Sound {
+	fn play_flex(node: &Node, _calling_client: Arc<Client>, _message: Message) -> Result<()> {
-	const NAME: &'static str = "Sound";
+		let sound = node.sound.get().unwrap();
-}
-impl SoundAspect for Sound {
-	fn play(node: Arc<Node>, _calling_client: Arc<Client>) -> Result<()> {
-		let sound = node.get_aspect::<Sound>().unwrap();
 		sound.play.lock().replace(());
 		Ok(())
 	}
-	fn stop(node: Arc<Node>, _calling_client: Arc<Client>) -> Result<()> {
+
-		let sound = node.get_aspect::<Sound>().unwrap();
+	pub fn stop_flex(node: &Node, _calling_client: Arc<Client>, _message: Message) -> Result<()> {
+		let sound = node.sound.get().unwrap();
 		sound.stop.lock().replace(());
 		Ok(())
 	}
 }
-impl Drop for Sound {
-	fn drop(&mut self) {
-		if let Some(sk_sound) = self.sk_sound.take() {
-			destroy_queue::add(sk_sound);
-		}
-		SOUND_REGISTRY.remove(self);
-	}
-}
 
 pub fn update(sk: &impl StereoKitDraw) {
 	for sound in SOUND_REGISTRY.get_valid_contents() {
@@ -104,25 +102,35 @@ pub fn update(sk: &impl StereoKitDraw) {
 	}
 }
 
-create_interface!(AudioInterface, AudioInterfaceAspect, "/audio");
+pub fn create_interface(client: &Arc<Client>) -> Result<()> {
-struct AudioInterface;
+	let node = Node::create(client, "", "audio", false);
-impl AudioInterfaceAspect for AudioInterface {
+	node.add_local_signal("create_sound", create_flex);
-	#[doc = "Create a sound node. WAV and MP3 are supported."]
+	node.add_to_scenegraph().map(|_| ())
-	fn create_sound(
+}
-		_node: Arc<Node>,
+
-		calling_client: Arc<Client>,
+pub fn create_flex(_node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
-		name: String,
+	#[derive(Deserialize)]
-		parent: Arc<Node>,
+	struct CreateSoundInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
 		transform: Transform,
 		resource: ResourceID,
-	) -> Result<()> {
+	}
-		let node =
+	let info: CreateSoundInfo = deserialize(message.as_ref())?;
-			Node::create_parent_name(&calling_client, Self::CREATE_SOUND_PARENT_PATH, &name, true);
+	let node = Node::create(&calling_client, "/audio/sound", info.name, true);
-		let parent = parent.get_aspect::<Spatial>()?;
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
-		let transform = transform.to_mat4(true, true, true);
+	let transform = parse_transform(info.transform, true, true, true);
-		let node = node.add_to_scenegraph()?;
+	let node = node.add_to_scenegraph()?;
-		Spatial::add_to(&node, Some(parent.clone()), transform, false);
+	Spatial::add_to(&node, Some(parent), transform, false)?;
-		Sound::add_to(&node, resource)?;
+	Sound::add_to(&node, info.resource)?;
-		Ok(())
+	Ok(())
+}
+
+impl Drop for Sound {
+	fn drop(&mut self) {
+		if let Some(instance) = self.instance.lock().take() {
+			destroy_queue::add(instance);
+		}
+		SOUND_REGISTRY.remove(self);
 	}
 }

src/nodes/data.rs

@@ -1,20 +1,24 @@
 use super::alias::AliasInfo;
 use super::fields::Field;
 use super::spatial::{parse_transform, Spatial};
-use super::{Alias, Aspect, Node};
+use super::{Alias, Message, Node};
 use crate::core::client::Client;
 use crate::core::node_collections::LifeLinkedNodeMap;
 use crate::core::registry::Registry;
-use crate::create_interface;
+use crate::core::scenegraph::MethodResponseSender;
-use crate::nodes::fields::FIELD_ALIAS_INFO;
+use crate::nodes::fields::{find_field, FIELD_ALIAS_INFO};
-use crate::nodes::spatial::Transform;
+use crate::nodes::spatial::find_spatial_parent;
 use color_eyre::eyre::{bail, ensure, eyre, Result};
+use glam::vec3a;
 use lazy_static::lazy_static;
+use mint::{Quaternion, Vector3};
 use nanoid::nanoid;
 use parking_lot::Mutex;
 use rustc_hash::FxHashMap;
-use stardust_xr::schemas::flex::flexbuffers;
+use serde::{Deserialize, Serialize};
-use stardust_xr::values::Datamap;
+use stardust_xr::schemas::flex::{deserialize, flexbuffers, serialize};
+use stardust_xr::values::Transform;
+use std::fmt::Display;
 use std::sync::{Arc, Weak};
 
 lazy_static! {
@@ -24,17 +28,11 @@ lazy_static! {
 static PULSE_SENDER_REGISTRY: Registry<PulseSender> = Registry::new();
 pub static PULSE_RECEIVER_REGISTRY: Registry<PulseReceiver> = Registry::new();
 
-pub fn get_mask(datamap: &Datamap) -> Result<flexbuffers::MapReader<&[u8]>> {
+pub fn mask_matches(mask_map_lesser: &Mask, mask_map_greater: &Mask) -> bool {
-	flexbuffers::Reader::get_root(datamap.raw().as_slice())
-		.map_err(|_| eyre!("Mask is not a valid flexbuffer"))?
-		.get_map()
-		.map_err(|_| eyre!("Mask is not a valid map"))
-}
-pub fn mask_matches(mask_map_lesser: &Datamap, mask_map_greater: &Datamap) -> bool {
 	(|| -> Result<_> {
-		for key in get_mask(mask_map_lesser)?.iter_keys() {
+		for key in mask_map_lesser.get_mask()?.iter_keys() {
-			let lesser_key = get_mask(mask_map_lesser)?.index(key)?;
+			let lesser_key = mask_map_lesser.get_mask()?.index(key)?;
-			let greater_key = get_mask(mask_map_greater)?.index(key)?;
+			let greater_key = mask_map_greater.get_mask()?.index(key)?;
 			// otherwise zero-length vectors don't count the same as a single type vector
 			if lesser_key.flexbuffer_type().is_heterogenous_vector()
 				&& lesser_key.as_vector().len() == 0
@@ -53,24 +51,57 @@ pub fn mask_matches(mask_map_lesser: &Datamap, mask_map_greater: &Datamap) -> bo
 	.is_ok()
 }
 
-stardust_xr_server_codegen::codegen_data_protocol!();
+pub struct Mask(pub Vec<u8>);
+impl Mask {
+	pub fn from_struct<T: Default + Serialize>() -> Self {
+		let mut serializer = flexbuffers::FlexbufferSerializer::new();
+		T::default().serialize(&mut serializer).unwrap();
+		Mask(serializer.take_buffer())
+	}
+	pub fn get_mask(&self) -> Result<flexbuffers::MapReader<&[u8]>> {
+		flexbuffers::Reader::get_root(self.0.as_slice())
+			.map_err(|_| eyre!("Mask is not a valid flexbuffer"))?
+			.get_map()
+			.map_err(|_| eyre!("Mask is not a valid map"))
+	}
+}
+impl Display for Mask {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		flexbuffers::Reader::get_root(self.0.as_slice())
+			.unwrap()
+			.to_string()
+			.fmt(f)
+	}
+}
+
+#[derive(Serialize, Deserialize)]
+struct SendDataInfo<'a> {
+	uid: &'a str,
+	data: Vec<u8>,
+}
 
 pub struct PulseSender {
+	uid: String,
 	node: Weak<Node>,
-	pub mask: Datamap,
+	pub mask: Mask,
 	aliases: LifeLinkedNodeMap<String>,
 }
 impl PulseSender {
-	pub fn add_to(node: &Arc<Node>, mask: Datamap) -> Result<Arc<PulseSender>> {
+	pub fn add_to(node: &Arc<Node>, mask: Mask) -> Result<Arc<PulseSender>> {
+		ensure!(
+			node.spatial.get().is_some(),
+			"Internal: Node does not have a spatial attached!"
+		);
+
 		let sender = PulseSender {
+			uid: nanoid!(),
 			node: Arc::downgrade(node),
 			mask,
 			aliases: LifeLinkedNodeMap::default(),
 		};
-
-		// <PulseSender as PulseSenderAspect>::add_node_members(node);
 		let sender = PULSE_SENDER_REGISTRY.add(sender);
-		node.add_aspect_raw(sender.clone());
+		let _ = node.pulse_sender.set(sender.clone());
+		node.add_local_signal("send_data", PulseSender::send_data_flex);
 		for receiver in PULSE_RECEIVER_REGISTRY.get_valid_contents() {
 			sender.handle_new_receiver(&receiver);
 		}
@@ -80,61 +111,97 @@ impl PulseSender {
 		if !mask_matches(&self.mask, &receiver.mask) {
 			return;
 		}
-		let Some(tx_node) = self.node.upgrade() else {
+		let Some(tx_node) = self.node.upgrade() else {return};
-			return;
+		let Some(tx_client) = tx_node.get_client() else {return};
-		};
+		let Some(rx_node) = receiver.node.upgrade() else {return};
-		let Some(tx_client) = tx_node.get_client() else {
-			return;
-		};
-		let Some(rx_node) = receiver.node.upgrade() else {
-			return;
-		};
 		// Receiver itself
-		let Ok(rx_alias) = Alias::create(
+		let rx_alias = Alias::create(
 			&tx_client,
 			tx_node.get_path(),
 			receiver.uid.as_str(),
 			&rx_node,
 			AliasInfo {
-				server_methods: vec!["send_data"],
+				server_methods: vec!["sendData", "getTransform"],
 				..Default::default()
 			},
-		) else {
+		);
-			return;
+		if let Ok(rx_alias) = rx_alias {
-		};
+			self.aliases.add(receiver.uid.clone(), &rx_alias);
-		self.aliases.add(receiver.uid.clone(), &rx_alias);
 
-		// Receiver's field
+			if let Some(rx_field_node) = receiver.field.spatial_ref().node.upgrade() {
-		let Ok(rx_field_alias) = Alias::create(
+				// Receiver's field
-			&tx_client,
+				let rx_field_alias = Alias::create(
-			rx_alias.get_path(),
+					&tx_client,
-			"field",
+					rx_alias.get_path(),
-			&rx_node.get_aspect::<PulseReceiver>().unwrap().field_node,
+					"field",
-			FIELD_ALIAS_INFO.clone(),
+					&rx_field_node,
-		) else {
+					FIELD_ALIAS_INFO.clone(),
-			return;
+				);
-		};
+				if let Ok(rx_field_alias) = rx_field_alias {
-		self.aliases
+					self.aliases
-			.add(receiver.uid.clone() + "-field", &rx_field_alias);
+						.add(receiver.uid.clone() + "-field", &rx_field_alias);
+				}
+			}
+		}
 
-		let _ =
+		#[derive(Serialize)]
-			pulse_sender_client::new_receiver(&tx_node, &receiver.uid, &rx_alias, &rx_field_alias);
+		struct NewReceiverInfo<'a> {
+			uid: &'a str,
+			distance: f32,
+			position: Vector3<f32>,
+			rotation: Quaternion<f32>,
+		}
+
+		let (_, rotation, position) = Spatial::space_to_space_matrix(
+			rx_node.spatial.get().map(|s| s.as_ref()),
+			tx_node.spatial.get().map(|s| s.as_ref()),
+		)
+		.to_scale_rotation_translation();
+
+		let info = NewReceiverInfo {
+			uid: &receiver.uid,
+			distance: receiver
+				.field
+				.distance(tx_node.spatial.get().unwrap(), vec3a(0.0, 0.0, 0.0)),
+			position: position.into(),
+			rotation: rotation.into(),
+		};
+
+		let Ok(data) = serialize(info) else {return};
+		let _ = tx_node.send_remote_signal("new_receiver", data);
 	}
 
 	fn handle_drop_receiver(&self, receiver: &PulseReceiver) {
 		let uid = receiver.uid.as_str();
 		self.aliases.remove(uid);
 		self.aliases.remove(&(uid.to_string() + "-field"));
-		let Some(tx_node) = self.node.upgrade() else {
+		let Some(tx_node) = self.node.upgrade() else {return};
-			return;
+		let Ok(data) = serialize(&uid) else {return};
-		};
+		let _ = tx_node.send_remote_signal("drop_receiver", data);
-		let _ = pulse_sender_client::drop_receiver(&tx_node, uid);
+	}
+
+	fn send_data_flex(node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
+		let info: SendDataInfo = deserialize(message.as_ref())?;
+		let receiver_node = calling_client.get_node("Pulse receiver", info.uid)?;
+		let receiver =
+			receiver_node.get_aspect("Pulse Receiver", "pulse receiver", |n| &n.pulse_receiver)?;
+		let receiver_mask = &receiver_node
+			.get_aspect("Pulse receiver", "pulse receiver", |node| {
+				&node.pulse_receiver
+			})?
+			.mask;
+
+		let data_mask = Mask(info.data);
+		data_mask.get_mask()?;
+		ensure!(
+			mask_matches(receiver_mask, &data_mask),
+			"Message ({}) does not contain the same keys as the receiver's mask ({})",
+			data_mask,
+			receiver_mask
+		);
+		receiver.send_data(&node.pulse_sender.get().unwrap().uid, data_mask.0)
 	}
 }
-impl Aspect for PulseSender {
-	const NAME: &'static str = "PulseSender";
-}
-impl PulseSenderAspect for PulseSender {}
 impl Drop for PulseSender {
 	fn drop(&mut self) {
 		PULSE_SENDER_REGISTRY.remove(self);
@@ -144,52 +211,39 @@ impl Drop for PulseSender {
 pub struct PulseReceiver {
 	uid: String,
 	pub node: Weak<Node>,
-	pub field_node: Arc<Node>,
+	pub field: Arc<Field>,
-	pub mask: Datamap,
+	pub mask: Mask,
 }
 impl PulseReceiver {
-	pub fn add_to(
+	pub fn add_to(node: &Arc<Node>, field: Arc<Field>, mask: Mask) -> Result<Arc<PulseReceiver>> {
-		node: &Arc<Node>,
+		ensure!(
-		field_node: Arc<Node>,
+			node.spatial.get().is_some(),
-		mask: Datamap,
+			"Internal: Node does not have a spatial attached!"
-	) -> Result<Arc<PulseReceiver>> {
+		);
+
 		let receiver = PulseReceiver {
 			uid: nanoid!(),
 			node: Arc::downgrade(node),
-			field_node,
+			field,
 			mask,
 		};
 		let receiver = PULSE_RECEIVER_REGISTRY.add(receiver);
 
-		<PulseReceiver as PulseReceiverAspect>::add_node_members(node);
-		node.add_aspect_raw(receiver.clone());
 		for sender in PULSE_SENDER_REGISTRY.get_valid_contents() {
 			sender.handle_new_receiver(&receiver);
 		}
+		let _ = node.pulse_receiver.set(receiver.clone());
 		Ok(receiver)
 	}
-}
-impl Aspect for PulseReceiver {
-	const NAME: &'static str = "PulseReceiver";
-}
-impl PulseReceiverAspect for PulseReceiver {
-	fn send_data(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		sender: Arc<Node>,
-		data: Datamap,
-	) -> Result<()> {
-		let this_receiver = node.get_aspect::<PulseReceiver>().unwrap();
 
-		ensure!(
+	pub fn send_data(&self, uid: &str, data: Vec<u8>) -> Result<()> {
-			mask_matches(&this_receiver.mask, &data),
+		if let Some(node) = self.node.upgrade() {
-			"Message ({data:?}) does not contain the same keys as the receiver's mask ({:?})",
+			node.send_remote_signal("data", serialize(SendDataInfo { uid, data })?)?;
-			this_receiver.mask
+		}
-		);
-		pulse_receiver_client::data(&node, &sender.uid, &data)?;
 		Ok(())
 	}
 }
+
 impl Drop for PulseReceiver {
 	fn drop(&mut self) {
 		PULSE_RECEIVER_REGISTRY.remove(self);
@@ -199,64 +253,76 @@ impl Drop for PulseReceiver {
 	}
 }
 
-create_interface!(DataInterface, DataInterfaceAspect, "/data");
+pub fn create_interface(client: &Arc<Client>) -> Result<()> {
-struct DataInterface;
+	let node = Node::create(client, "", "data", false);
-impl DataInterfaceAspect for DataInterface {
+	node.add_local_signal("create_pulse_sender", create_pulse_sender_flex);
-	fn create_pulse_sender(
+	node.add_local_signal("create_pulse_receiver", create_pulse_receiver_flex);
-		_node: Arc<Node>,
+	node.add_local_method("register_keymap", register_keymap_flex);
-		calling_client: Arc<Client>,
+	node.add_local_method("get_keymap", get_keymap_flex);
-		name: String,
+	node.add_to_scenegraph().map(|_| ())
-		parent: Arc<Node>,
+}
+
+pub fn create_pulse_sender_flex(
+	_node: &Node,
+	calling_client: Arc<Client>,
+	message: Message,
+) -> Result<()> {
+	#[derive(Deserialize)]
+	struct CreatePulseSenderInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
 		transform: Transform,
-		mask: Datamap,
+		mask: Vec<u8>,
-	) -> Result<()> {
-		get_mask(&mask)?;
-		let node = Node::create_parent_name(
-			&calling_client,
-			Self::CREATE_PULSE_SENDER_PARENT_PATH,
-			&name,
-			true,
-		);
-		let parent = parent.get_aspect::<Spatial>()?;
-		let transform = transform.to_mat4(true, true, false);
-
-		let node = node.add_to_scenegraph()?;
-		Spatial::add_to(&node, Some(parent.clone()), transform, false);
-		PulseSender::add_to(&node, mask)?;
-		Ok(())
 	}
+	let info: CreatePulseSenderInfo = deserialize(message.as_ref())?;
+	let node = Node::create(&calling_client, "/data/sender", info.name, true);
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
+	let transform = parse_transform(info.transform, true, true, false);
 
-	fn create_pulse_receiver(
+	let mask = Mask(info.mask);
-		_node: Arc<Node>,
+	mask.get_mask()?;
-		calling_client: Arc<Client>,
+
-		name: String,
+	let node = node.add_to_scenegraph()?;
-		parent: Arc<Node>,
+	Spatial::add_to(&node, Some(parent), transform, false)?;
+	PulseSender::add_to(&node, mask)?;
+	Ok(())
+}
+
+pub fn create_pulse_receiver_flex(
+	_node: &Node,
+	calling_client: Arc<Client>,
+	message: Message,
+) -> Result<()> {
+	#[derive(Deserialize)]
+	struct CreatePulseReceiverInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
 		transform: Transform,
-		field: Arc<Node>,
+		field_path: &'a str,
-		mask: Datamap,
+		mask: Vec<u8>,
-	) -> Result<()> {
-		get_mask(&mask)?;
-		let node = Node::create_parent_name(
-			&calling_client,
-			Self::CREATE_PULSE_RECEIVER_PARENT_PATH,
-			&name,
-			true,
-		);
-		let parent = parent.get_aspect::<Spatial>()?;
-		let transform = parse_transform(transform, true, true, false);
-		let _ = field.get_aspect::<Field>()?;
-
-		let node = node.add_to_scenegraph()?;
-		Spatial::add_to(&node, Some(parent.clone()), transform, false);
-		PulseReceiver::add_to(&node, field, mask)?;
-		Ok(())
 	}
+	let info: CreatePulseReceiverInfo = deserialize(message.as_ref())?;
+	let node = Node::create(&calling_client, "/data/receiver", info.name, true);
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
+	let transform = parse_transform(info.transform, true, true, false);
+	let field = find_field(&calling_client, info.field_path)?;
+	let mask = Mask(info.mask);
+	mask.get_mask()?;
 
-	async fn register_keymap(
+	let node = node.add_to_scenegraph()?;
-		_node: Arc<Node>,
+	Spatial::add_to(&node, Some(parent), transform, false)?;
-		_calling_client: Arc<Client>,
+	PulseReceiver::add_to(&node, field, mask)?;
-		keymap: String,
+	Ok(())
-	) -> Result<String> {
+}
+
+pub fn register_keymap_flex(
+	_node: &Node,
+	_calling_client: Arc<Client>,
+	message: Message,
+	response: MethodResponseSender,
+) {
+	response.wrap_sync(move || {
+		let keymap: String = deserialize(message.as_ref())?;
 		let mut keymaps = KEYMAPS.lock();
 		if let Some(found_keymap_id) = keymaps
 			.iter()
@@ -264,25 +330,26 @@ impl DataInterfaceAspect for DataInterface {
 			.map(|(k, _v)| k)
 			.last()
 		{
-			return Ok(found_keymap_id.clone());
+			return Ok(serialize(found_keymap_id)?.into());
 		}
 
 		let generated_id = nanoid!();
 		keymaps.insert(generated_id.clone(), keymap);
 
-		Ok(generated_id)
+		Ok(serialize(generated_id)?.into())
-	}
+	});
-
+}
-	async fn get_keymap(
+pub fn get_keymap_flex(
-		_node: Arc<Node>,
+	_node: &Node,
-		_calling_client: Arc<Client>,
+	_calling_client: Arc<Client>,
-		keymap_id: String,
+	message: Message,
-	) -> Result<String> {
+	response: MethodResponseSender,
-		let keymaps = KEYMAPS.lock();
+) {
-		let Some(keymap) = keymaps.get(&keymap_id) else {
+	response.wrap_sync(move || {
-			bail!("Could not find keymap. Try registering it")
+		let keymap_id: &str = deserialize(message.as_ref())?;
-		};
+		let keymaps = KEYMAPS.lock();
-
+		let Some(keymap) = keymaps.get(keymap_id) else {bail!("Could not find keymap. Try registering it")};
-		Ok(keymap.clone())
+
-	}
+		Ok(serialize(keymap)?.into())
+	});
 }

src/nodes/drawable/lines.rs

@@ -1,48 +1,68 @@
-use super::{Line, LinesAspect};
 use crate::{
 	core::{client::Client, registry::Registry},
-	nodes::{spatial::Spatial, Aspect, Node},
+	nodes::{
+		spatial::{find_spatial_parent, parse_transform, Spatial},
+		Message, Node,
+	},
 };
-use color_eyre::eyre::Result;
+use color_eyre::eyre::{bail, ensure, Result};
 use glam::Vec3A;
+use mint::Vector3;
 use parking_lot::Mutex;
 use portable_atomic::{AtomicBool, Ordering};
-use prisma::Lerp;
+use prisma::{Flatten, Lerp, Rgba};
+use serde::Deserialize;
+use stardust_xr::{schemas::flex::deserialize, values::Transform};
 use std::{collections::VecDeque, sync::Arc};
 use stereokit::{bounds_grow_to_fit_pt, Bounds, Color128, LinePoint as SkLinePoint, StereoKitDraw};
 
+use super::Drawable;
+
 static LINES_REGISTRY: Registry<Lines> = Registry::new();
 
+#[derive(Debug, Clone, Deserialize)]
+struct LinePointRaw {
+	point: Vector3<f32>,
+	thickness: f32,
+	color: [f32; 4],
+}
+
+#[derive(Debug, Clone)]
+struct LineData {
+	points: Vec<LinePointRaw>,
+	cyclic: bool,
+}
+
 pub struct Lines {
 	enabled: Arc<AtomicBool>,
 	space: Arc<Spatial>,
-	data: Mutex<Vec<Line>>,
+	data: Mutex<LineData>,
 }
 impl Lines {
-	pub fn add_to(node: &Arc<Node>, lines: Vec<Line>) -> Result<Arc<Lines>> {
+	fn add_to(node: &Arc<Node>, points: Vec<LinePointRaw>, cyclic: bool) -> Result<Arc<Lines>> {
-		let _ = node
+		ensure!(
-			.get_aspect::<Spatial>()
+			node.drawable.get().is_none(),
-			.unwrap()
+			"Internal: Node already has a drawable attached!"
-			.bounding_box_calc
+		);
-			.set(|node| {
+
-				let mut bounds = Bounds::default();
+		let _ = node.spatial.get().unwrap().bounding_box_calc.set(|node| {
-				if let Ok(lines) = node.get_aspect::<Lines>() {
+			let mut bounds = Bounds::default();
-					for line in &*lines.data.lock() {
+			let Some(Drawable::Lines(lines)) = node.drawable.get() else {return bounds};
-						for point in &line.points {
+			for point in &lines.data.lock().points {
-							bounds = bounds_grow_to_fit_pt(bounds, point.point);
+				bounds = bounds_grow_to_fit_pt(bounds, point.point);
-						}
+			}
-					}
+
-				}
+			bounds
-				bounds
+		});
-			});
 
 		let lines = LINES_REGISTRY.add(Lines {
 			enabled: node.enabled.clone(),
-			space: node.get_aspect::<Spatial>()?.clone(),
+			space: node.get_aspect("Lines", "spatial", |n| &n.spatial)?.clone(),
-			data: Mutex::new(lines),
+			data: Mutex::new(LineData { points, cyclic }),
 		});
-		<Lines as LinesAspect>::add_node_members(node);
+		node.add_local_signal("set_points", Lines::set_points_flex);
-		node.add_aspect_raw(lines.clone());
+		node.add_local_signal("set_cyclic", Lines::set_cyclic_flex);
+		let _ = node.drawable.set(Drawable::Lines(lines.clone()));
 
 		Ok(lines)
 	}
@@ -50,55 +70,57 @@ impl Lines {
 	fn draw(&self, draw_ctx: &impl StereoKitDraw) {
 		let transform_mat = self.space.global_transform();
 		let data = self.data.lock().clone();
-		for line in &data {
+		let mut points: VecDeque<SkLinePoint> = data
-			let mut points: VecDeque<SkLinePoint> = line
+			.points
-				.points
+			.iter()
-				.iter()
+			.map(|p| SkLinePoint {
-				.map(|p| SkLinePoint {
+				pt: transform_mat.transform_point3a(Vec3A::from(p.point)).into(),
-					pt: transform_mat.transform_point3a(Vec3A::from(p.point)).into(),
+				thickness: p.thickness,
-					thickness: p.thickness,
+				color: p.color.map(|c| (c * 255.0) as u8).into(),
-					color: stereokit::sys::color128::from([
+			})
-						p.color.c.r,
+			.collect();
-						p.color.c.g,
+		if data.cyclic && !points.is_empty() {
-						p.color.c.b,
+			let first = data.points.first().unwrap();
-						p.color.a,
+			let last = data.points.last().unwrap();
-					])
+			let color = Rgba::from_slice(&first.color).lerp(&Rgba::from_slice(&last.color), 0.5);
+			let connect_point = SkLinePoint {
+				pt: transform_mat
+					.transform_point3a(Vec3A::from(first.point).lerp(Vec3A::from(last.point), 0.5))
 					.into(),
-				})
+				thickness: (first.thickness + last.thickness) * 0.5,
-				.collect();
+				color: Color128::from([color.red(), color.green(), color.blue(), color.alpha()])
-			if line.cyclic && !points.is_empty() {
+					.into(),
-				let first = line.points.first().unwrap();
+			};
-				let last = line.points.last().unwrap();
+			points.push_front(connect_point.clone());
-
+			points.push_back(connect_point);
-				let color = Color128 {
-					r: first.color.c.r.lerp(&last.color.c.r, 0.5),
-					g: first.color.c.g.lerp(&last.color.c.g, 0.5),
-					b: first.color.c.b.lerp(&last.color.c.b, 0.5),
-					a: first.color.a.lerp(&last.color.a, 0.5),
-				};
-				let connect_point = SkLinePoint {
-					pt: transform_mat
-						.transform_point3a(
-							Vec3A::from(first.point).lerp(Vec3A::from(last.point), 0.5),
-						)
-						.into(),
-					thickness: (first.thickness + last.thickness) * 0.5,
-					color: color.into(),
-				};
-				points.push_front(connect_point.clone());
-				points.push_back(connect_point);
-			}
-			draw_ctx.line_add_listv(points.make_contiguous());
 		}
+		draw_ctx.line_add_listv(points.make_contiguous());
 	}
-}
+
-impl Aspect for Lines {
+	pub fn set_points_flex(
-	const NAME: &'static str = "Lines";
+		node: &Node,
-}
+		_calling_client: Arc<Client>,
-impl LinesAspect for Lines {
+		message: Message,
-	fn set_lines(node: Arc<Node>, _calling_client: Arc<Client>, lines: Vec<Line>) -> Result<()> {
+	) -> Result<()> {
-		let lines_aspect = node.get_aspect::<Lines>()?;
+		let Some(Drawable::Lines(lines)) = node.drawable.get() else {bail!("Not a drawable??")};
-		*lines_aspect.data.lock() = lines;
+
+		let mut points: Vec<LinePointRaw> = deserialize(message.as_ref())?;
+		for p in &mut points {
+			p.color[0] = p.color[0].powf(2.2);
+			p.color[1] = p.color[1].powf(2.2);
+			p.color[2] = p.color[2].powf(2.2);
+		}
+		lines.data.lock().points = points;
+		Ok(())
+	}
+	pub fn set_cyclic_flex(
+		node: &Node,
+		_calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		let Some(Drawable::Lines(lines)) = node.drawable.get() else {bail!("Not a drawable??")};
+
+		lines.data.lock().cyclic = deserialize(message.as_ref())?;
 		Ok(())
 	}
 }
@@ -115,3 +137,29 @@ pub fn draw_all(draw_ctx: &impl StereoKitDraw) {
 		}
 	}
 }
+
+pub fn create_flex(_node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
+	#[derive(Deserialize)]
+	struct CreateTextInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
+		transform: Transform,
+		points: Vec<LinePointRaw>,
+		cyclic: bool,
+	}
+	let mut info: CreateTextInfo = deserialize(message.as_ref())?;
+	let node = Node::create(&calling_client, "/drawable/lines", info.name, true);
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
+	let transform = parse_transform(info.transform, true, true, true);
+
+	for p in &mut info.points {
+		p.color[0] = p.color[0].powf(2.2);
+		p.color[1] = p.color[1].powf(2.2);
+		p.color[2] = p.color[2].powf(2.2);
+	}
+
+	let node = node.add_to_scenegraph()?;
+	Spatial::add_to(&node, Some(parent), transform, false)?;
+	Lines::add_to(&node, info.points, info.cyclic)?;
+	Ok(())
+}

src/nodes/drawable/mod.rs

@@ -3,22 +3,39 @@ pub mod model;
 pub mod shaders;
 pub mod text;
 
-use self::{lines::Lines, model::Model, text::Text};
+use self::{
-use super::{
+	lines::Lines,
-	spatial::{Spatial, Transform},
+	model::{Model, ModelPart},
-	Node,
+	text::Text,
 };
-use crate::{
-	core::{client::Client, resource::get_resource_file},
-	create_interface,
-};
-use color_eyre::eyre::{self, Result};
-use parking_lot::Mutex;
-use stardust_xr::values::ResourceID;
-use std::{ffi::OsStr, path::PathBuf, sync::Arc};
-use stereokit::StereoKitDraw;
 
-// #[instrument(level = "debug", skip(sk))]
+use super::{Message, Node};
+use crate::core::client::Client;
+use color_eyre::eyre::Result;
+use parking_lot::Mutex;
+use serde::Deserialize;
+use stardust_xr::schemas::flex::deserialize;
+use std::{path::PathBuf, sync::Arc};
+use stereokit::StereoKitDraw;
+use tracing::instrument;
+
+pub fn create_interface(client: &Arc<Client>) -> Result<()> {
+	let node = Node::create(client, "", "drawable", false);
+	node.add_local_signal("create_lines", lines::create_flex);
+	node.add_local_signal("create_model", model::create_flex);
+	node.add_local_signal("create_text", text::create_flex);
+	node.add_local_signal("set_sky_file", set_sky_file_flex);
+	node.add_to_scenegraph().map(|_| ())
+}
+
+pub enum Drawable {
+	Lines(Arc<Lines>),
+	Model(Arc<Model>),
+	ModelPart(Arc<ModelPart>),
+	Text(Arc<Text>),
+}
+
+#[instrument(level = "debug", skip(sk))]
 pub fn draw(sk: &impl StereoKitDraw) {
 	lines::draw_all(sk);
 	model::draw_all(sk);
@@ -39,83 +56,21 @@ pub fn draw(sk: &impl StereoKitDraw) {
 static QUEUED_SKYLIGHT: Mutex<Option<PathBuf>> = Mutex::new(None);
 static QUEUED_SKYTEX: Mutex<Option<PathBuf>> = Mutex::new(None);
 
-stardust_xr_server_codegen::codegen_drawable_protocol!();
+fn set_sky_file_flex(_node: &Node, _calling_client: Arc<Client>, message: Message) -> Result<()> {
-create_interface!(DrawableInterface, DrawableInterfaceAspect, "/drawable");
+	#[derive(Deserialize)]
-
+	struct SkyFileInfo {
-pub struct DrawableInterface;
+		path: PathBuf,
-impl DrawableInterfaceAspect for DrawableInterface {
+		skytex: Option<bool>,
-	fn set_sky_tex(_node: Arc<Node>, calling_client: Arc<Client>, tex: ResourceID) -> Result<()> {
+		skylight: Option<bool>,
-		let resource_path = get_resource_file(&tex, &calling_client, &[OsStr::new("hdr")])
+	}
-			.ok_or(eyre::eyre!("Could not find resource"))?;
+	let info: SkyFileInfo = deserialize(message.as_ref())?;
-		QUEUED_SKYTEX.lock().replace(resource_path);
+	info.path.metadata()?;
-		Ok(())
+	if info.skytex.unwrap_or_default() {
+		QUEUED_SKYTEX.lock().replace(info.path.clone());
+	}
+	if info.skylight.unwrap_or_default() {
+		QUEUED_SKYLIGHT.lock().replace(info.path);
 	}
 
-	fn set_sky_light(
+	Ok(())
-		_node: Arc<Node>,
-		calling_client: Arc<Client>,
-		light: ResourceID,
-	) -> Result<()> {
-		let resource_path = get_resource_file(&light, &calling_client, &[OsStr::new("hdr")])
-			.ok_or(eyre::eyre!("Could not find resource"))?;
-		QUEUED_SKYLIGHT.lock().replace(resource_path);
-		Ok(())
-	}
-
-	fn create_lines(
-		_node: Arc<Node>,
-		calling_client: Arc<Client>,
-		name: String,
-		parent: Arc<Node>,
-		transform: Transform,
-		lines: Vec<Line>,
-	) -> Result<()> {
-		let node =
-			Node::create_parent_name(&calling_client, Self::CREATE_LINES_PARENT_PATH, &name, true);
-		let parent = parent.get_aspect::<Spatial>()?;
-		let transform = transform.to_mat4(true, true, true);
-
-		let node = node.add_to_scenegraph()?;
-		Spatial::add_to(&node, Some(parent.clone()), transform, false);
-		Lines::add_to(&node, lines)?;
-		Ok(())
-	}
-
-	fn load_model(
-		_node: Arc<Node>,
-		calling_client: Arc<Client>,
-		name: String,
-		parent: Arc<Node>,
-		transform: Transform,
-		model: ResourceID,
-	) -> Result<()> {
-		let node =
-			Node::create_parent_name(&calling_client, Self::LOAD_MODEL_PARENT_PATH, &name, true);
-		let parent = parent.get_aspect::<Spatial>()?;
-		let transform = transform.to_mat4(true, true, true);
-		let node = node.add_to_scenegraph()?;
-		Spatial::add_to(&node, Some(parent.clone()), transform, false);
-		Model::add_to(&node, model)?;
-		Ok(())
-	}
-
-	fn create_text(
-		_node: Arc<Node>,
-		calling_client: Arc<Client>,
-		name: String,
-		parent: Arc<Node>,
-		transform: Transform,
-		text: String,
-		style: TextStyle,
-	) -> Result<()> {
-		let node =
-			Node::create_parent_name(&calling_client, Self::CREATE_TEXT_PARENT_PATH, &name, true);
-		let parent = parent.get_aspect::<Spatial>()?;
-		let transform = transform.to_mat4(true, true, true);
-
-		let node = node.add_to_scenegraph()?;
-		Spatial::add_to(&node, Some(parent.clone()), transform, false);
-		Text::add_to(&node, text, style)?;
-		Ok(())
-	}
 }

src/nodes/drawable/model.rs

@@ -1,31 +1,53 @@
-use super::{MaterialParameter, ModelAspect, ModelPartAspect, Node};
+use super::Node;
 use crate::core::client::Client;
-use crate::core::destroy_queue;
 use crate::core::node_collections::LifeLinkedNodeMap;
 use crate::core::registry::Registry;
-use crate::core::resource::get_resource_file;
+use crate::core::resource::ResourceID;
-use crate::nodes::spatial::Spatial;
+use crate::nodes::drawable::Drawable;
-use crate::nodes::Aspect;
+use crate::nodes::spatial::{find_spatial_parent, parse_transform, Spatial};
+use crate::nodes::Message;
 use crate::SK_MULTITHREAD;
-use color_eyre::eyre::{eyre, Result};
+use color_eyre::eyre::{bail, ensure, eyre, Result};
+use glam::Mat4;
+use mint::{ColumnMatrix4, Vector2, Vector3, Vector4};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use portable_atomic::{AtomicBool, Ordering};
 use rustc_hash::FxHashMap;
-use stardust_xr::values::ResourceID;
+use serde::Deserialize;
-
+use stardust_xr::schemas::flex::deserialize;
+use stardust_xr::values::Transform;
 use std::ffi::OsStr;
 use std::path::PathBuf;
 use std::sync::{Arc, Weak};
 use stereokit::named_colors::WHITE;
 use stereokit::{
 	Bounds, Color128, Material, Model as SKModel, RenderLayer, Shader, StereoKitDraw,
-	StereoKitMultiThread, Transparency,
+	StereoKitMultiThread,
 };
 
 static MODEL_REGISTRY: Registry<Model> = Registry::new();
-static HOLDOUT_MATERIAL: OnceCell<Arc<Material>> = OnceCell::new();
 
+#[derive(Deserialize, Debug)]
+#[serde(tag = "t", content = "c")]
+pub enum MaterialParameter {
+	Float(f32),
+	Vector2(Vector2<f32>),
+	Vector3(Vector3<f32>),
+	Vector4(Vector4<f32>),
+	Color([f32; 4]),
+	Int(i32),
+	Int2(Vector2<i32>),
+	Int3(Vector3<i32>),
+	Int4(Vector4<i32>),
+	Bool(bool),
+	UInt(u32),
+	UInt2(Vector2<u32>),
+	UInt3(Vector3<u32>),
+	UInt4(Vector4<u32>),
+	Matrix(ColumnMatrix4<f32>),
+	Texture(ResourceID),
+}
 impl MaterialParameter {
 	fn apply_to_material(
 		&self,
@@ -35,37 +57,56 @@ impl MaterialParameter {
 		parameter_name: &str,
 	) {
 		match self {
-			MaterialParameter::Bool(val) => {
+			MaterialParameter::Float(val) => {
-				sk.material_set_bool(material, parameter_name, *val);
+				sk.material_set_float(material, parameter_name, *val);
+			}
+			MaterialParameter::Vector2(val) => {
+				sk.material_set_vector2(material, parameter_name, *val);
+			}
+			MaterialParameter::Vector3(val) => {
+				sk.material_set_vector3(material, parameter_name, *val);
+			}
+			MaterialParameter::Vector4(val) => {
+				sk.material_set_vector4(material, parameter_name, *val);
+			}
+			MaterialParameter::Color(val) => {
+				sk.material_set_color(material, parameter_name, Color128::from(val.clone()));
 			}
 			MaterialParameter::Int(val) => {
 				sk.material_set_int(material, parameter_name, *val);
 			}
+			MaterialParameter::Int2(val) => {
+				sk.material_set_int2(material, parameter_name, val.x, val.y);
+			}
+			MaterialParameter::Int3(val) => {
+				sk.material_set_int3(material, parameter_name, val.x, val.y, val.z);
+			}
+			MaterialParameter::Int4(val) => {
+				sk.material_set_int4(material, parameter_name, val.w, val.x, val.y, val.z);
+			}
+			MaterialParameter::Bool(val) => {
+				sk.material_set_bool(material, parameter_name, *val);
+			}
 			MaterialParameter::UInt(val) => {
 				sk.material_set_uint(material, parameter_name, *val);
 			}
-			MaterialParameter::Float(val) => {
+			MaterialParameter::UInt2(val) => {
-				sk.material_set_float(material, parameter_name, *val);
+				sk.material_set_uint2(material, parameter_name, val.x, val.y);
 			}
-			MaterialParameter::Vec2(val) => {
+			MaterialParameter::UInt3(val) => {
-				sk.material_set_vector2(material, parameter_name, *val);
+				sk.material_set_uint3(material, parameter_name, val.x, val.y, val.z);
 			}
-			MaterialParameter::Vec3(val) => {
+			MaterialParameter::UInt4(val) => {
-				sk.material_set_vector3(material, parameter_name, *val);
+				sk.material_set_uint4(material, parameter_name, val.w, val.x, val.y, val.z);
 			}
-			MaterialParameter::Color(val) => {
+			MaterialParameter::Matrix(val) => {
-				sk.material_set_color(
+				sk.material_set_matrix(material, parameter_name, Mat4::from(*val));
-					material,
-					parameter_name,
-					Color128::new(val.c.r, val.c.g, val.c.b, val.a),
-				);
 			}
 			MaterialParameter::Texture(resource) => {
-				let Some(texture_path) =
+				let Some(texture_path) = resource.get_file(
-					get_resource_file(&resource, &client, &[OsStr::new("png"), OsStr::new("jpg")])
+					&client.base_resource_prefixes.lock().clone(),
-				else {
+					&[OsStr::new("png"), OsStr::new("jpg")],
-					return;
+				) else {return};
-				};
 				if let Ok(tex) = sk.tex_create_file(texture_path, true, 0) {
 					sk.material_set_texture(material, parameter_name, &tex);
 				}
@@ -84,22 +125,6 @@ pub struct ModelPart {
 }
 impl ModelPart {
 	fn create_for_model(sk: &impl StereoKitMultiThread, model: &Arc<Model>, sk_model: &SKModel) {
-		HOLDOUT_MATERIAL.get_or_init(|| {
-			let mat = sk.material_copy(Material::UNLIT);
-			sk.material_set_transparency(&mat, Transparency::None);
-			sk.material_set_color(
-				&mat,
-				"color",
-				stereokit::sys::color128 {
-					r: 0.0,
-					g: 0.0,
-					b: 0.0,
-					a: 0.0,
-				},
-			);
-			Arc::new(mat)
-		});
-
 		let first_root_part = sk.model_node_get_root(sk_model);
 		let mut current_option_part = Some(first_root_part);
 
@@ -133,50 +158,40 @@ impl ModelPart {
 			.and_then(|id| model.parts.get(&id));
 		let parent_part = parent_node
 			.as_ref()
-			.and_then(|node| node.get_aspect::<ModelPart>().ok());
+			.and_then(|node| match node.drawable.get() {
+				Some(Drawable::ModelPart(model_part)) => Some(model_part),
+				_ => None,
+			});
 
 		let stardust_model_part = model.space.node()?;
 		let client = stardust_model_part.get_client()?;
 		let mut part_path = parent_part.map(|n| n.path.clone()).unwrap_or_default();
 		part_path.push(sk.model_node_get_name(sk_model, id)?);
-		let node = client.scenegraph.add_node(Node::create_parent_name(
+		let node = client.scenegraph.add_node(Node::create(
 			&client,
 			stardust_model_part.get_path(),
 			part_path.to_str()?,
 			false,
 		));
 		let spatial_parent = parent_node
-			.and_then(|n| n.get_aspect::<Spatial>().ok())
+			.and_then(|n| n.spatial.get().cloned())
 			.unwrap_or_else(|| model.space.clone());
 		let space = Spatial::add_to(
 			&node,
 			Some(spatial_parent),
 			sk.model_node_get_transform_local(sk_model, id),
 			false,
-		);
+		)
+		.ok()?;
 
-		let _ = node
+		let _ = node.spatial.get().unwrap().bounding_box_calc.set(|node| {
-			.get_aspect::<Spatial>()
+			let Some(Drawable::ModelPart(model_part)) = node.drawable.get() else {return Bounds::default()};
-			.unwrap()
+			let Some(sk) = SK_MULTITHREAD.get() else {return Bounds::default()};
-			.bounding_box_calc
+			let Some(model) = model_part.model.upgrade() else {return Bounds::default()};
-			.set(|node| {
+			let Some(sk_model) = model.sk_model.get() else {return Bounds::default()};
-				let Ok(model_part) = node.get_aspect::<ModelPart>() else {
+			let Some(sk_mesh) = sk.model_node_get_mesh(sk_model, model_part.id) else {return Bounds::default()};
-					return Bounds::default();
+			sk.mesh_get_bounds(sk_mesh)
-				};
+		});
-				let Some(sk) = SK_MULTITHREAD.get() else {
-					return Bounds::default();
-				};
-				let Some(model) = model_part.model.upgrade() else {
-					return Bounds::default();
-				};
-				let Some(sk_model) = model.sk_model.get() else {
-					return Bounds::default();
-				};
-				let Some(sk_mesh) = sk.model_node_get_mesh(sk_model, model_part.id) else {
-					return Bounds::default();
-				};
-				sk.mesh_get_bounds(sk_mesh)
-			});
 
 		let model_part = Arc::new(ModelPart {
 			id,
@@ -186,12 +201,32 @@ impl ModelPart {
 			pending_material_parameters: Mutex::new(FxHashMap::default()),
 			pending_material_replacement: Mutex::new(None),
 		});
-		<ModelPart as ModelPartAspect>::add_node_members(&node);
+		node.add_local_signal(
-		node.add_aspect_raw(model_part.clone());
+			"set_material_parameter",
+			ModelPart::set_material_parameter_flex,
+		);
+		let _ = node.drawable.set(Drawable::ModelPart(model_part.clone()));
 		model.parts.add(id, &node);
 		Some(model_part)
 	}
 
+	fn set_material_parameter_flex(
+		node: &Node,
+		_calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		let Some(Drawable::ModelPart(model_part)) = node.drawable.get() else {bail!("Not a drawable??")};
+
+		let (name, value): (String, MaterialParameter) = deserialize(message.as_ref())?;
+
+		model_part
+			.pending_material_parameters
+			.lock()
+			.insert(name, value);
+
+		Ok(())
+	}
+
 	pub fn replace_material(&self, replacement: Arc<Material>) {
 		self.pending_material_replacement
 			.lock()
@@ -199,27 +234,17 @@ impl ModelPart {
 	}
 
 	fn update(&self, sk: &impl StereoKitDraw) {
-		let Some(model) = self.model.upgrade() else {
+		let Some(model) = self.model.upgrade() else {return};
-			return;
+		let Some(sk_model) = model.sk_model.get() else {return};
-		};
+		let Some(node) = model.space.node() else {return};
-		let Some(sk_model) = model.sk_model.get() else {
+		let Some(client) = node.get_client() else {return};
-			return;
-		};
-		let Some(node) = model.space.node() else {
-			return;
-		};
-		let Some(client) = node.get_client() else {
-			return;
-		};
 		if let Some(material_replacement) = self.pending_material_replacement.lock().take() {
 			sk.model_node_set_material(sk_model, self.id, material_replacement.as_ref().as_ref());
 		}
 
 		let mut material_parameters = self.pending_material_parameters.lock();
 		for (parameter_name, parameter_value) in material_parameters.drain() {
-			let Some(material) = sk.model_node_get_material(sk_model, self.id) else {
+			let Some(material) = sk.model_node_get_material(sk_model, self.id) else {continue};
-				continue;
-			};
 			let new_material = sk.material_copy(material);
 			parameter_value.apply_to_material(&client, sk, &new_material, parameter_name.as_str());
 			sk.model_node_set_material(sk_model, self.id, &new_material);
@@ -232,33 +257,6 @@ impl ModelPart {
 		);
 	}
 }
-impl Aspect for ModelPart {
-	const NAME: &'static str = "ModelPart";
-}
-impl ModelPartAspect for ModelPart {
-	#[doc = "Set this model part's material to one that cuts a hole in the world. Often used for overlays/passthrough where you want to show the background through an object."]
-	fn apply_holdout_material(node: Arc<Node>, _calling_client: Arc<Client>) -> Result<()> {
-		let model_part = node.get_aspect::<ModelPart>()?;
-		model_part.replace_material(HOLDOUT_MATERIAL.get().unwrap().clone());
-		Ok(())
-	}
-
-	#[doc = "Set the material parameter with `parameter_name` to `value`"]
-	fn set_material_parameter(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		parameter_name: String,
-		value: MaterialParameter,
-	) -> Result<()> {
-		let model_part = node.get_aspect::<ModelPart>()?;
-		model_part
-			.pending_material_parameters
-			.lock()
-			.insert(parameter_name, value);
-
-		Ok(())
-	}
-}
 
 pub struct Model {
 	self_ref: Weak<Model>,
@@ -273,17 +271,31 @@ unsafe impl Sync for Model {}
 
 impl Model {
 	pub fn add_to(node: &Arc<Node>, resource_id: ResourceID) -> Result<Arc<Model>> {
-		let pending_model_path = get_resource_file(
+		ensure!(
-			&resource_id,
+			node.spatial.get().is_some(),
-			&*node.get_client().ok_or_else(|| eyre!("Client not found"))?,
+			"Internal: Node does not have a spatial attached!"
-			&[OsStr::new("glb"), OsStr::new("gltf")],
+		);
-		)
+		ensure!(
-		.ok_or_else(|| eyre!("Resource not found"))?;
+			node.drawable.get().is_none(),
+			"Internal: Node already has a drawable attached!"
+		);
+
+		let pending_model_path = resource_id
+			.get_file(
+				&node
+					.get_client()
+					.ok_or_else(|| eyre!("Client not found"))?
+					.base_resource_prefixes
+					.lock()
+					.clone(),
+				&[OsStr::new("glb"), OsStr::new("gltf")],
+			)
+			.ok_or_else(|| eyre!("Resource not found"))?;
 
 		let model = Arc::new_cyclic(|self_ref| Model {
 			self_ref: self_ref.clone(),
 			enabled: node.enabled.clone(),
-			space: node.get_aspect::<Spatial>().unwrap().clone(),
+			space: node.spatial.get().unwrap().clone(),
 			_resource_id: resource_id,
 			sk_model: OnceCell::new(),
 			parts: LifeLinkedNodeMap::default(),
@@ -296,18 +308,15 @@ impl Model {
 		);
 		ModelPart::create_for_model(sk, &model.self_ref.upgrade().unwrap(), &sk_model);
 		let _ = model.sk_model.set(sk_model);
-		node.add_aspect_raw(model.clone());
+		let _ = node.drawable.set(Drawable::Model(model.clone()));
 		Ok(model)
 	}
 
 	fn draw(&self, sk: &impl StereoKitDraw) {
-		let Some(sk_model) = self.sk_model.get() else {
+		let Some(sk_model) = self.sk_model.get() else {return};
-			return;
-		};
 		for model_node_node in self.parts.nodes() {
-			if let Ok(model_node) = model_node_node.get_aspect::<ModelPart>() {
+			let Some(Drawable::ModelPart(model_node)) = model_node_node.drawable.get() else {continue};
-				model_node.update(sk);
+			model_node.update(sk);
-			};
 		}
 
 		sk.model_draw(
@@ -318,15 +327,9 @@ impl Model {
 		);
 	}
 }
-impl Aspect for Model {
+
-	const NAME: &'static str = "Model";
-}
-impl ModelAspect for Model {}
 impl Drop for Model {
 	fn drop(&mut self) {
-		if let Some(sk_model) = self.sk_model.take() {
-			destroy_queue::add(sk_model);
-		}
 		MODEL_REGISTRY.remove(self);
 	}
 }
@@ -338,3 +341,21 @@ pub fn draw_all(sk: &impl StereoKitDraw) {
 		}
 	}
 }
+
+pub fn create_flex(_node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
+	#[derive(Deserialize)]
+	struct CreateModelInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
+		transform: Transform,
+		resource: ResourceID,
+	}
+	let info: CreateModelInfo = deserialize(message.as_ref())?;
+	let node = Node::create(&calling_client, "/drawable/model", info.name, true);
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
+	let transform = parse_transform(info.transform, true, true, true);
+	let node = node.add_to_scenegraph()?;
+	Spatial::add_to(&node, Some(parent), transform, false)?;
+	Model::add_to(&node, info.resource)?;
+	Ok(())
+}

src/nodes/drawable/text.rs

@@ -1,79 +1,107 @@
 use crate::{
-	core::{client::Client, destroy_queue, registry::Registry, resource::get_resource_file},
+	core::{client::Client, destroy_queue, registry::Registry, resource::ResourceID},
-	nodes::{spatial::Spatial, Aspect, Node},
+	nodes::{
+		drawable::Drawable,
+		spatial::{find_spatial_parent, parse_transform, Spatial},
+		Message, Node,
+	},
 };
-use color_eyre::eyre::{eyre, Result};
+use color_eyre::eyre::{bail, ensure, eyre, Result};
 use glam::{vec3, Mat4, Vec2};
+use mint::Vector2;
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use portable_atomic::{AtomicBool, Ordering};
+use prisma::{Flatten, Rgba};
+use serde::Deserialize;
+use stardust_xr::{schemas::flex::deserialize, values::Transform};
 use std::{ffi::OsStr, path::PathBuf, sync::Arc};
-use stereokit::{
+use stereokit::{named_colors::WHITE, Color128, StereoKitDraw, TextAlign, TextFit, TextStyle};
-	named_colors::WHITE, Color128, StereoKitDraw, TextAlign, TextFit, TextStyle as SkTextStyle,
-};
-
-use super::{TextAspect, TextStyle};
 
 static TEXT_REGISTRY: Registry<Text> = Registry::new();
 
-fn convert_align(x_align: super::XAlign, y_align: super::YAlign) -> TextAlign {
+struct TextData {
-	let x_align = match x_align {
+	text: String,
-		super::XAlign::Left => TextAlign::XLeft,
+	character_height: f32,
-		super::XAlign::Center => TextAlign::XCenter,
+	text_align: TextAlign,
-		super::XAlign::Right => TextAlign::XRight,
+	bounds: Option<Vec2>,
-	} as u32;
+	fit: TextFit,
-	let y_align = match y_align {
+	bounds_align: TextAlign,
-		super::YAlign::Top => TextAlign::YTop,
+	color: Rgba<f32>,
-		super::YAlign::Center => TextAlign::YCenter,
-		super::YAlign::Bottom => TextAlign::YBottom,
-	} as u32;
-
-	unsafe { std::mem::transmute(x_align | y_align) }
 }
 
 pub struct Text {
 	enabled: Arc<AtomicBool>,
 	space: Arc<Spatial>,
 	font_path: Option<PathBuf>,
-	style: OnceCell<SkTextStyle>,
+	style: OnceCell<TextStyle>,
 
-	text: Mutex<String>,
+	data: Mutex<TextData>,
-	data: Mutex<TextStyle>,
 }
 impl Text {
-	pub fn add_to(node: &Arc<Node>, text: String, style: TextStyle) -> Result<Arc<Text>> {
+	#[allow(clippy::too_many_arguments)]
+	pub fn add_to(
+		node: &Arc<Node>,
+		font_resource_id: Option<ResourceID>,
+		text: String,
+		character_height: f32,
+		text_align: TextAlign,
+		bounds: Option<Vector2<f32>>,
+		fit: TextFit,
+		bounds_align: TextAlign,
+		color: Rgba<f32>,
+	) -> Result<Arc<Text>> {
+		ensure!(
+			node.spatial.get().is_some(),
+			"Internal: Node does not have a spatial attached!"
+		);
+		ensure!(
+			node.drawable.get().is_none(),
+			"Internal: Node already has a drawable attached!"
+		);
+
 		let client = node.get_client().ok_or_else(|| eyre!("Client not found"))?;
 		let text = TEXT_REGISTRY.add(Text {
 			enabled: node.enabled.clone(),
-			space: node.get_aspect::<Spatial>().unwrap().clone(),
+			space: node.spatial.get().unwrap().clone(),
-			font_path: style.font.as_ref().and_then(|res| {
+			font_path: font_resource_id.and_then(|res| {
-				get_resource_file(&res, &client, &[OsStr::new("ttf"), OsStr::new("otf")])
+				res.get_file(
+					&client.base_resource_prefixes.lock().clone(),
+					&[OsStr::new("ttf"), OsStr::new("otf")],
+				)
 			}),
 			style: OnceCell::new(),
 
-			text: Mutex::new(text),
+			data: Mutex::new(TextData {
-			data: Mutex::new(style),
+				text,
+				character_height,
+				text_align,
+				bounds: bounds.map(|b| b.into()),
+				fit,
+				bounds_align,
+				color,
+			}),
 		});
-		<Text as TextAspect>::add_node_members(node);
+		node.add_local_signal("set_character_height", Text::set_character_height_flex);
-		node.add_aspect_raw(text.clone());
+		node.add_local_signal("set_text", Text::set_text_flex);
+		let _ = node.drawable.set(Drawable::Text(text.clone()));
 
 		Ok(text)
 	}
 
 	fn draw(&self, sk: &impl StereoKitDraw) {
-		let style =
+		let style = self
-			self.style
+			.style
-				.get_or_try_init(|| -> Result<SkTextStyle, color_eyre::eyre::Error> {
+			.get_or_try_init(|| -> Result<TextStyle, color_eyre::eyre::Error> {
-					let font = self
+				let font = self
-						.font_path
+					.font_path
-						.as_deref()
+					.as_deref()
-						.and_then(|path| sk.font_create(path).ok())
+					.and_then(|path| sk.font_create(path).ok())
-						.unwrap_or_else(|| sk.font_find("default/font").unwrap());
+					.unwrap_or_else(|| sk.font_find("default/font").unwrap());
-					Ok(unsafe { sk.text_make_style(font, 1.0, WHITE) })
+				Ok(unsafe { sk.text_make_style(font, 1.0, WHITE) })
-				});
+			});
 
 		if let Ok(style) = style {
-			let text = self.text.lock();
 			let data = self.data.lock();
 			let transform = self.space.global_transform()
 				* Mat4::from_scale(vec3(
@@ -81,55 +109,61 @@ impl Text {
 					data.character_height,
 					data.character_height,
 				));
-			if let Some(bounds) = &data.bounds {
+			if let Some(bounds) = data.bounds {
 				sk.text_add_in(
-					&*text,
+					&data.text,
 					transform,
-					Vec2::from(bounds.bounds) / data.character_height,
+					bounds / data.character_height,
-					match bounds.fit {
+					data.fit,
-						super::TextFit::Wrap => TextFit::Wrap,
-						super::TextFit::Clip => TextFit::Clip,
-						super::TextFit::Squeeze => TextFit::Squeeze,
-						super::TextFit::Exact => TextFit::Exact,
-						super::TextFit::Overflow => TextFit::Overflow,
-					},
 					*style,
-					convert_align(bounds.anchor_align_x.clone(), bounds.anchor_align_y.clone()),
+					data.bounds_align,
-					convert_align(data.text_align_x.clone(), data.text_align_y.clone()),
+					data.text_align,
 					vec3(0.0, 0.0, 0.0),
-					Color128::from([data.color.c.r, data.color.c.g, data.color.c.b, data.color.a]),
+					Color128::from([
+						data.color.red(),
+						data.color.green(),
+						data.color.blue(),
+						data.color.alpha(),
+					]),
 				);
 			} else {
 				sk.text_add_at(
-					&*text,
+					&data.text,
 					transform,
 					*style,
-					TextAlign::Center,
+					data.bounds_align,
-					convert_align(data.text_align_x.clone(), data.text_align_y.clone()),
+					data.text_align,
 					vec3(0.0, 0.0, 0.0),
-					Color128::from([data.color.c.r, data.color.c.g, data.color.c.b, data.color.a]),
+					Color128::from([
+						data.color.red(),
+						data.color.green(),
+						data.color.blue(),
+						data.color.alpha(),
+					]),
 				);
 			}
 		}
 	}
-}
+
-impl Aspect for Text {
+	pub fn set_character_height_flex(
-	const NAME: &'static str = "Text";
+		node: &Node,
-}
-impl TextAspect for Text {
-	fn set_character_height(
-		node: Arc<Node>,
 		_calling_client: Arc<Client>,
-		height: f32,
+		message: Message,
 	) -> Result<()> {
-		let this_text = node.get_aspect::<Text>()?;
+		let Some(Drawable::Text(text)) = node.drawable.get() else {bail!("Not a drawable??")};
-		this_text.data.lock().character_height = height;
+
+		text.data.lock().character_height = deserialize(message.as_ref())?;
 		Ok(())
 	}
 
-	fn set_text(node: Arc<Node>, _calling_client: Arc<Client>, text: String) -> Result<()> {
+	pub fn set_text_flex(
-		let this_text = node.get_aspect::<Text>()?;
+		node: &Node,
-		*this_text.text.lock() = text;
+		_calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		let Some(Drawable::Text(text)) = node.drawable.get() else {bail!("Not a drawable??")};
+
+		text.data.lock().text = deserialize(message.as_ref())?;
 		Ok(())
 	}
 }
@@ -149,3 +183,40 @@ pub fn draw_all(sk: &impl StereoKitDraw) {
 		}
 	}
 }
+
+pub fn create_flex(_node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
+	#[derive(Deserialize)]
+	struct CreateTextInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
+		transform: Transform,
+		text: String,
+		font_resource: Option<ResourceID>,
+		character_height: f32,
+		text_align: TextAlign,
+		bounds: Option<Vector2<f32>>,
+		fit: TextFit,
+		bounds_align: TextAlign,
+		color: [f32; 4],
+	}
+	let info: CreateTextInfo = deserialize(message.as_ref())?;
+	let node = Node::create(&calling_client, "/drawable/text", info.name, true);
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
+	let transform = parse_transform(info.transform, true, true, true);
+	let color = Rgba::from_slice(&info.color);
+
+	let node = node.add_to_scenegraph()?;
+	Spatial::add_to(&node, Some(parent), transform, false)?;
+	Text::add_to(
+		&node,
+		info.font_resource,
+		info.text,
+		info.character_height,
+		info.text_align,
+		info.bounds,
+		info.fit,
+		info.bounds_align,
+		color,
+	)?;
+	Ok(())
+}

src/nodes/fields/box.rs

@@ -1,11 +1,14 @@
-use super::{BoxFieldAspect, FieldTrait, Node};
+use super::{Field, FieldTrait, Node};
-use crate::nodes::fields::FieldAspect;
+use crate::core::client::Client;
-use crate::nodes::spatial::Spatial;
+use crate::nodes::spatial::{find_spatial_parent, parse_transform, Spatial};
-use crate::{core::client::Client, nodes::fields::Field};
+use crate::nodes::Message;
-use color_eyre::eyre::Result;
+use color_eyre::eyre::{ensure, Result};
 use glam::{vec3, vec3a, Vec3, Vec3A};
 use mint::Vector3;
 use parking_lot::Mutex;
+use serde::Deserialize;
+use stardust_xr::schemas::flex::deserialize;
+use stardust_xr::values::Transform;
 use std::sync::Arc;
 
 pub struct BoxField {
@@ -14,19 +17,40 @@ pub struct BoxField {
 }
 
 impl BoxField {
-	pub fn add_to(node: &Arc<Node>, size: Vector3<f32>) {
+	pub fn add_to(node: &Arc<Node>, size: Vector3<f32>) -> Result<Arc<Field>> {
+		ensure!(
+			node.spatial.get().is_some(),
+			"Internal: Node does not have a spatial attached!"
+		);
+		ensure!(
+			node.field.get().is_none(),
+			"Internal: Node already has a field attached!"
+		);
 		let box_field = BoxField {
-			space: node.get_aspect::<Spatial>().unwrap().clone(),
+			space: node.spatial.get().unwrap().clone(),
 			size: Mutex::new(size.into()),
 		};
-		<BoxField as FieldAspect>::add_node_members(node);
+		box_field.add_field_methods(node);
-		<BoxField as BoxFieldAspect>::add_node_members(node);
+		node.add_local_signal("set_size", BoxField::set_size_flex);
-		node.add_aspect(Field::Box(box_field));
+		let field = Arc::new(Field::Box(box_field));
+		let _ = node.field.set(field.clone());
+		Ok(field)
 	}
 
 	pub fn set_size(&self, size: Vector3<f32>) {
 		*self.size.lock() = size.into();
 	}
+
+	pub fn set_size_flex(
+		node: &Node,
+		_calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		let Field::Box(box_field) = node.field.get().unwrap().as_ref() else { return Ok(()) };
+		box_field.set_size(deserialize(message.as_ref())?);
+
+		Ok(())
+	}
 }
 
 impl FieldTrait for BoxField {
@@ -44,17 +68,25 @@ impl FieldTrait for BoxField {
 		self.space.as_ref()
 	}
 }
-impl BoxFieldAspect for BoxField {
+
-	fn set_size(
+pub fn create_box_field_flex(
-		node: Arc<Node>,
+	_node: &Node,
-		_calling_client: Arc<Client>,
+	calling_client: Arc<Client>,
-		size: mint::Vector3<f32>,
+	message: Message,
-	) -> Result<()> {
+) -> Result<()> {
-		let this_field = node.get_aspect::<Field>()?;
+	#[derive(Deserialize)]
-		let Field::Box(this_field) = &*this_field else {
+	struct CreateFieldInfo<'a> {
-			return Ok(());
+		name: &'a str,
-		};
+		parent_path: &'a str,
-		this_field.set_size(size.into());
+		transform: Transform,
-		Ok(())
+		size: Vector3<f32>,
 	}
+	let info: CreateFieldInfo = deserialize(message.as_ref())?;
+	let node = Node::create(&calling_client, "/field", info.name, true);
+	let parent = find_spatial_parent(&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, false)?;
+	BoxField::add_to(&node, info.size)?;
+	Ok(())
 }

src/nodes/fields/cylinder.rs

@@ -1,10 +1,13 @@
-use super::{CylinderFieldAspect, Field, FieldTrait, Node};
+use super::{Field, FieldTrait, Node};
 use crate::core::client::Client;
-use crate::nodes::fields::FieldAspect;
+use crate::nodes::spatial::{find_spatial_parent, parse_transform, Spatial};
-use crate::nodes::spatial::Spatial;
+use crate::nodes::Message;
-use color_eyre::eyre::Result;
+use color_eyre::eyre::{ensure, Result};
 use glam::{swizzles::*, vec2, Vec3A};
 use portable_atomic::AtomicF32;
+use serde::Deserialize;
+use stardust_xr::schemas::flex::deserialize;
+use stardust_xr::values::Transform;
 
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
@@ -16,22 +19,43 @@ pub struct CylinderField {
 }
 
 impl CylinderField {
-	pub fn add_to(node: &Arc<Node>, length: f32, radius: f32) {
+	pub fn add_to(node: &Arc<Node>, length: f32, radius: f32) -> Result<()> {
+		ensure!(
+			node.spatial.get().is_some(),
+			"Internal: Node does not have a spatial attached!"
+		);
+		ensure!(
+			node.field.get().is_none(),
+			"Internal: Node already has a field attached!"
+		);
 		let cylinder_field = CylinderField {
-			space: node.get_aspect::<Spatial>().unwrap().clone(),
+			space: node.spatial.get().unwrap().clone(),
 			length: AtomicF32::new(length.abs()),
 			radius: AtomicF32::new(radius.abs()),
 		};
-		<CylinderField as FieldAspect>::add_node_members(node);
+		cylinder_field.add_field_methods(node);
-		<CylinderField as CylinderFieldAspect>::add_node_members(node);
+		node.add_local_signal("set_size", CylinderField::set_size_flex);
-		node.add_aspect(Field::Cylinder(cylinder_field));
+		let _ = node.field.set(Arc::new(Field::Cylinder(cylinder_field)));
+		Ok(())
 	}
 
 	pub fn set_size(&self, length: f32, radius: f32) {
 		self.length.store(length.abs(), Ordering::Relaxed);
 		self.radius.store(radius.abs(), Ordering::Relaxed);
 	}
+
+	pub fn set_size_flex(
+		node: &Node,
+		_calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		let Field::Cylinder(cylinder_field) = node.field.get().unwrap().as_ref() else { return Ok(()) };
+		let (length, radius) = deserialize(message.as_ref())?;
+		cylinder_field.set_size(length, radius);
+		Ok(())
+	}
 }
+
 impl FieldTrait for CylinderField {
 	fn local_distance(&self, p: Vec3A) -> f32 {
 		let radius = self.radius.load(Ordering::Relaxed);
@@ -44,18 +68,26 @@ impl FieldTrait for CylinderField {
 		self.space.as_ref()
 	}
 }
-impl CylinderFieldAspect for CylinderField {
+
-	fn set_size(
+pub fn create_cylinder_field_flex(
-		node: Arc<Node>,
+	_node: &Node,
-		_calling_client: Arc<Client>,
+	calling_client: Arc<Client>,
+	message: Message,
+) -> Result<()> {
+	#[derive(Deserialize)]
+	struct CreateFieldInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
+		transform: Transform,
 		length: f32,
 		radius: f32,
-	) -> Result<()> {
-		let this_field = node.get_aspect::<Field>()?;
-		let Field::Cylinder(this_field) = &*this_field else {
-			return Ok(());
-		};
-		this_field.set_size(length, radius);
-		Ok(())
 	}
+	let info: CreateFieldInfo = deserialize(message.as_ref())?;
+	let node = Node::create(&calling_client, "/field", info.name, true);
+	let parent = find_spatial_parent(&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, false)?;
+	CylinderField::add_to(&node, info.length, info.radius)?;
+	Ok(())
 }

src/nodes/fields/mod.rs

@@ -3,34 +3,39 @@ mod cylinder;
 mod sphere;
 mod torus;
 
-use self::cylinder::CylinderField;
+use self::cylinder::{create_cylinder_field_flex, CylinderField};
-use self::r#box::BoxField;
+use self::r#box::{create_box_field_flex, BoxField};
-use self::sphere::SphereField;
+use self::sphere::{create_sphere_field_flex, SphereField};
-use self::torus::TorusField;
+use self::torus::{create_torus_field_flex, TorusField};
 
 use super::alias::AliasInfo;
 use super::spatial::Spatial;
-use super::{Aspect, Node};
+use super::{Message, Node};
 use crate::core::client::Client;
-use crate::create_interface;
+use crate::core::scenegraph::MethodResponseSender;
-use crate::nodes::spatial::Transform;
+use crate::nodes::spatial::find_reference_space;
 use color_eyre::eyre::Result;
-use glam::{vec2, vec3a, Mat4, Vec3, Vec3A};
+use glam::{vec2, vec3a, Vec3, Vec3A};
 use mint::Vector3;
 use once_cell::sync::Lazy;
+use serde::{Deserialize, Serialize};
+use stardust_xr::schemas::flex::{deserialize, serialize};
+
 use std::ops::Deref;
 use std::sync::Arc;
 
-// TODO: get SDFs working properly with non-uniform scale and so on, output distance relative to the spatial it's compared against
-
 pub static FIELD_ALIAS_INFO: Lazy<AliasInfo> = Lazy::new(|| AliasInfo {
 	server_methods: vec!["distance", "normal", "closest_point", "ray_march"],
 	..Default::default()
 });
 
-stardust_xr_server_codegen::codegen_field_protocol!();
+pub trait FieldTrait {
-
+	fn add_field_methods(&self, node: &Arc<Node>) {
-pub trait FieldTrait: Send + Sync + 'static {
+		node.add_local_method("distance", field_distance_flex);
+		node.add_local_method("normal", field_normal_flex);
+		node.add_local_method("closest_point", field_closest_point_flex);
+		node.add_local_method("ray_march", field_ray_march_flex);
+	}
 	fn spatial_ref(&self) -> &Spatial;
 
 	fn local_distance(&self, p: Vec3A) -> f32;
@@ -76,8 +81,6 @@ pub trait FieldTrait: Send + Sync + 'static {
 
 	fn ray_march(&self, ray: Ray) -> RayMarchResult {
 		let mut result = RayMarchResult {
-			ray_origin: ray.origin.into(),
-			ray_direction: ray.direction.into(),
 			min_distance: f32::MAX,
 			deepest_point_distance: 0_f32,
 			ray_length: 0_f32,
@@ -87,9 +90,7 @@ pub trait FieldTrait: Send + Sync + 'static {
 		let ray_to_field_matrix =
 			Spatial::space_to_space_matrix(Some(&ray.space), Some(self.spatial_ref()));
 		let mut ray_point = ray_to_field_matrix.transform_point3a(ray.origin.into());
-		let ray_direction = ray_to_field_matrix
+		let ray_direction = ray_to_field_matrix.transform_vector3a(ray.direction.into());
-			.transform_vector3a(ray.direction.into())
-			.normalize();
 
 		while result.ray_steps < MAX_RAY_STEPS && result.ray_length < MAX_RAY_LENGTH {
 			let distance = self.local_distance(ray_point);
@@ -109,60 +110,6 @@ pub trait FieldTrait: Send + Sync + 'static {
 		result
 	}
 }
-impl<Fi: FieldTrait + 'static> FieldAspect for Fi {
-	async fn distance(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		space: Arc<Node>,
-		point: mint::Vector3<f32>,
-	) -> Result<f32> {
-		let reference_space = space.get_aspect::<Spatial>()?;
-		let this_field = node.get_aspect::<Field>()?;
-		Ok((*this_field).distance(reference_space.as_ref(), point.into()))
-	}
-
-	async fn normal(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		space: Arc<Node>,
-		point: mint::Vector3<f32>,
-	) -> Result<Vector3<f32>> {
-		let reference_space = space.get_aspect::<Spatial>()?;
-		let this_field = node.get_aspect::<Field>()?;
-		Ok(this_field
-			.normal(reference_space.as_ref(), point.into(), 0.001)
-			.into())
-	}
-
-	async fn closest_point(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		space: Arc<Node>,
-		point: mint::Vector3<f32>,
-	) -> Result<Vector3<f32>> {
-		let reference_space = space.get_aspect::<Spatial>()?;
-		let this_field = node.get_aspect::<Field>()?;
-		Ok(this_field
-			.closest_point(reference_space.as_ref(), point.into(), 0.001)
-			.into())
-	}
-
-	async fn ray_march(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		space: Arc<Node>,
-		ray_origin: mint::Vector3<f32>,
-		ray_direction: mint::Vector3<f32>,
-	) -> Result<RayMarchResult> {
-		let reference_space = space.get_aspect::<Spatial>()?;
-		let this_field = node.get_aspect::<Field>()?;
-		Ok(this_field.ray_march(Ray {
-			origin: ray_origin.into(),
-			direction: ray_direction.into(),
-			space: reference_space.clone(),
-		}))
-	}
-}
 
 pub struct Ray {
 	pub origin: Vec3,
@@ -170,6 +117,14 @@ pub struct Ray {
 	pub space: Arc<Spatial>,
 }
 
+#[derive(Debug, Serialize)]
+pub struct RayMarchResult {
+	pub min_distance: f32,
+	pub deepest_point_distance: f32,
+	pub ray_length: f32,
+	pub ray_steps: u32,
+}
+
 // const MIN_RAY_STEPS: u32 = 0;
 const MAX_RAY_STEPS: u32 = 1000;
 
@@ -179,15 +134,107 @@ const MAX_RAY_MARCH: f32 = f32::MAX;
 // const MIN_RAY_LENGTH: f32 = 0_f32;
 const MAX_RAY_LENGTH: f32 = 1000_f32;
 
+fn field_distance_flex(
+	node: &Node,
+	calling_client: Arc<Client>,
+	message: Message,
+	response: MethodResponseSender,
+) {
+	response.wrap_sync(move || {
+		#[derive(Deserialize)]
+		struct FieldInfoArgs<'a> {
+			reference_space_path: &'a str,
+			point: Vector3<f32>,
+		}
+		let args: FieldInfoArgs = deserialize(message.as_ref())?;
+		let reference_space = find_reference_space(&calling_client, args.reference_space_path)?;
+
+		let distance = node
+			.field
+			.get()
+			.unwrap()
+			.distance(reference_space.as_ref(), args.point.into());
+		Ok(serialize(distance)?.into())
+	});
+}
+fn field_normal_flex(
+	node: &Node,
+	calling_client: Arc<Client>,
+	message: Message,
+	response: MethodResponseSender,
+) {
+	response.wrap_sync(move || {
+		#[derive(Deserialize)]
+		struct FieldInfoArgs<'a> {
+			reference_space_path: &'a str,
+			point: Vector3<f32>,
+		}
+		let args: FieldInfoArgs = deserialize(message.as_ref())?;
+		let reference_space = find_reference_space(&calling_client, args.reference_space_path)?;
+
+		let normal = node.field.get().as_ref().unwrap().normal(
+			reference_space.as_ref(),
+			args.point.into(),
+			0.001,
+		);
+		Ok(serialize(mint::Vector3::from(normal))?.into())
+	});
+}
+fn field_closest_point_flex(
+	node: &Node,
+	calling_client: Arc<Client>,
+	message: Message,
+	response: MethodResponseSender,
+) {
+	response.wrap_sync(move || {
+		#[derive(Deserialize)]
+		struct FieldInfoArgs<'a> {
+			reference_space_path: &'a str,
+			point: Vector3<f32>,
+		}
+		let args: FieldInfoArgs = deserialize(message.as_ref())?;
+		let reference_space = find_reference_space(&calling_client, args.reference_space_path)?;
+
+		let closest_point = node.field.get().as_ref().unwrap().closest_point(
+			reference_space.as_ref(),
+			args.point.into(),
+			0.001,
+		);
+		Ok(serialize(mint::Vector3::from(closest_point))?.into())
+	});
+}
+fn field_ray_march_flex(
+	node: &Node,
+	calling_client: Arc<Client>,
+	message: Message,
+	response: MethodResponseSender,
+) {
+	response.wrap_sync(move || {
+		#[derive(Deserialize)]
+		struct FieldInfoArgs<'a> {
+			reference_space_path: &'a str,
+			ray_origin: Vector3<f32>,
+			ray_direction: Vector3<f32>,
+		}
+		let args: FieldInfoArgs = deserialize(message.as_ref())?;
+		let reference_space = find_reference_space(&calling_client, args.reference_space_path)?;
+
+		let ray_march_result = node.field.get().unwrap().ray_march(Ray {
+			origin: args.ray_origin.into(),
+			direction: args.ray_direction.into(),
+			space: reference_space,
+		});
+		Ok(serialize(ray_march_result)?.into())
+	});
+}
+
 pub enum Field {
 	Box(BoxField),
 	Cylinder(CylinderField),
 	Sphere(SphereField),
 	Torus(TorusField),
 }
-impl Aspect for Field {
+
-	const NAME: &'static str = "Field";
-}
 impl Deref for Field {
 	type Target = dyn FieldTrait;
 	fn deref(&self) -> &Self::Target {
@@ -199,171 +246,19 @@ impl Deref for Field {
 		}
 	}
 }
-// impl FieldTrait for Field {
-// 	fn spatial_ref(&self) -> &Spatial {
-// 		match self {
-// 			Field::Box(field) => field.spatial_ref(),
-// 			Field::Cylinder(field) => field.spatial_ref(),
-// 			Field::Sphere(field) => field.spatial_ref(),
-// 			Field::Torus(field) => field.spatial_ref(),
-// 		}
-// 	}
-// 	fn local_distance(&self, p: Vec3A) -> f32 {
-// 		match self {
-// 			Field::Box(field) => field.local_distance(p),
-// 			Field::Cylinder(field) => field.local_distance(p),
-// 			Field::Sphere(field) => field.local_distance(p),
-// 			Field::Torus(field) => field.local_distance(p),
-// 		}
-// 	}
-// 	fn local_normal(&self, p: Vec3A, r: f32) -> Vec3A {
-// 		match self {
-// 			Field::Box(field) => field.local_normal(p, r),
-// 			Field::Cylinder(field) => field.local_normal(p, r),
-// 			Field::Sphere(field) => field.local_normal(p, r),
-// 			Field::Torus(field) => field.local_normal(p, r),
-// 		}
-// 	}
-// 	fn local_closest_point(&self, p: Vec3A, r: f32) -> Vec3A {
-// 		match self {
-// 			Field::Box(field) => field.local_closest_point(p, r),
-// 			Field::Cylinder(field) => field.local_closest_point(p, r),
-// 			Field::Sphere(field) => field.local_closest_point(p, r),
-// 			Field::Torus(field) => field.local_closest_point(p, r),
-// 		}
-// 	}
-// 	fn distance(&self, reference_space: &Spatial, p: Vec3A) -> f32 {
-// 		match self {
-// 			Field::Box(field) => field.distance(reference_space, p),
-// 			Field::Cylinder(field) => field.distance(reference_space, p),
-// 			Field::Sphere(field) => field.distance(reference_space, p),
-// 			Field::Torus(field) => field.distance(reference_space, p),
-// 		}
-// 	}
-// 	fn normal(&self, reference_space: &Spatial, p: Vec3A, r: f32) -> Vec3A {
-// 		match self {
-// 			Field::Box(field) => field.normal(reference_space, p, r),
-// 			Field::Cylinder(field) => field.normal(reference_space, p, r),
-// 			Field::Sphere(field) => field.normal(reference_space, p, r),
-// 			Field::Torus(field) => field.normal(reference_space, p, r),
-// 		}
-// 	}
-// 	fn closest_point(&self, reference_space: &Spatial, p: Vec3A, r: f32) -> Vec3A {
-// 		match self {
-// 			Field::Box(field) => field.closest_point(reference_space, p, r),
-// 			Field::Cylinder(field) => field.closest_point(reference_space, p, r),
-// 			Field::Sphere(field) => field.closest_point(reference_space, p, r),
-// 			Field::Torus(field) => field.closest_point(reference_space, p, r),
-// 		}
-// 	}
-// 	fn ray_march(&self, ray: Ray) -> RayMarchResult {
-// 		match self {
-// 			Field::Box(field) => field.ray_march(ray),
-// 			Field::Cylinder(field) => field.ray_march(ray),
-// 			Field::Sphere(field) => field.ray_march(ray),
-// 			Field::Torus(field) => field.ray_march(ray),
-// 		}
-// 	}
-// }
 
-create_interface!(FieldInterface, FieldInterfaceAspect, "/field");
+pub fn create_interface(client: &Arc<Client>) -> Result<()> {
-pub struct FieldInterface;
+	let node = Node::create(client, "", "field", false);
-impl FieldInterfaceAspect for FieldInterface {
+	node.add_local_signal("create_box_field", create_box_field_flex);
-	fn create_box_field(
+	node.add_local_signal("create_cylinder_field", create_cylinder_field_flex);
-		_node: Arc<Node>,
+	node.add_local_signal("create_sphere_field", create_sphere_field_flex);
-		calling_client: Arc<Client>,
+	node.add_local_signal("create_torus_field", create_torus_field_flex);
-		name: String,
+	node.add_to_scenegraph().map(|_| ())
-		parent: Arc<Node>,
-		transform: Transform,
-		size: mint::Vector3<f32>,
-	) -> Result<()> {
-		let transform = transform.to_mat4(true, true, false);
-		let parent = parent.get_aspect::<Spatial>()?;
-		let node = Node::create_parent_name(
-			&calling_client,
-			Self::CREATE_BOX_FIELD_PARENT_PATH,
-			&name,
-			true,
-		)
-		.add_to_scenegraph()?;
-		Spatial::add_to(&node, Some(parent.clone()), transform, false);
-		BoxField::add_to(&node, size);
-		Ok(())
-	}
-
-	fn create_cylinder_field(
-		_node: Arc<Node>,
-		calling_client: Arc<Client>,
-		name: String,
-		parent: Arc<Node>,
-		transform: Transform,
-		length: f32,
-		radius: f32,
-	) -> Result<()> {
-		let transform = transform.to_mat4(true, true, false);
-		let parent = parent.get_aspect::<Spatial>()?;
-		let node = Node::create_parent_name(
-			&calling_client,
-			Self::CREATE_CYLINDER_FIELD_PARENT_PATH,
-			&name,
-			true,
-		)
-		.add_to_scenegraph()?;
-		Spatial::add_to(&node, Some(parent.clone()), transform, false);
-		CylinderField::add_to(&node, length, radius);
-		Ok(())
-	}
-
-	fn create_sphere_field(
-		_node: Arc<Node>,
-		calling_client: Arc<Client>,
-		name: String,
-		parent: Arc<Node>,
-		position: mint::Vector3<f32>,
-		radius: f32,
-	) -> Result<()> {
-		let parent = parent.get_aspect::<Spatial>()?;
-		let node = Node::create_parent_name(
-			&calling_client,
-			Self::CREATE_SPHERE_FIELD_PARENT_PATH,
-			&name,
-			true,
-		)
-		.add_to_scenegraph()?;
-		Spatial::add_to(
-			&node,
-			Some(parent.clone()),
-			Mat4::from_translation(position.into()),
-			false,
-		);
-		SphereField::add_to(&node, radius);
-		Ok(())
-	}
-
-	fn create_torus_field(
-		_node: Arc<Node>,
-		calling_client: Arc<Client>,
-		name: String,
-		parent: Arc<Node>,
-		transform: Transform,
-		radius_a: f32,
-		radius_b: f32,
-	) -> Result<()> {
-		let transform = transform.to_mat4(true, true, false);
-		let parent = parent.get_aspect::<Spatial>()?;
-		let node = Node::create_parent_name(
-			&calling_client,
-			Self::CREATE_TORUS_FIELD_PARENT_PATH,
-			&name,
-			true,
-		)
-		.add_to_scenegraph()?;
-		Spatial::add_to(&node, Some(parent.clone()), transform, false);
-		TorusField::add_to(&node, radius_a, radius_b);
-		Ok(())
-	}
 }
 
 pub fn find_field(client: &Client, path: &str) -> Result<Arc<Field>> {
-	client.get_node("Field", path)?.get_aspect::<Field>()
+	client
+		.get_node("Field", path)?
+		.get_aspect("Field", "info", |n| &n.field)
+		.cloned()
 }

src/nodes/fields/sphere.rs

@@ -1,10 +1,13 @@
-use super::{Field, FieldTrait, Node, SphereFieldAspect};
+use super::{Field, FieldTrait, Node};
 use crate::core::client::Client;
-use crate::nodes::fields::FieldAspect;
+use crate::nodes::spatial::{find_spatial_parent, Spatial};
-use crate::nodes::spatial::Spatial;
+use crate::nodes::Message;
-use color_eyre::eyre::Result;
+use color_eyre::eyre::{ensure, Result};
-use glam::Vec3A;
+use glam::{Mat4, Vec3A};
+use mint::Vector3;
 use portable_atomic::AtomicF32;
+use serde::Deserialize;
+use stardust_xr::schemas::flex::deserialize;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
@@ -14,19 +17,38 @@ pub struct SphereField {
 }
 
 impl SphereField {
-	pub fn add_to(node: &Arc<Node>, radius: f32) {
+	pub fn add_to(node: &Arc<Node>, radius: f32) -> Result<()> {
+		ensure!(
+			node.spatial.get().is_some(),
+			"Internal: Node does not have a spatial attached!"
+		);
+		ensure!(
+			node.field.get().is_none(),
+			"Internal: Node already has a field attached!"
+		);
 		let sphere_field = SphereField {
-			space: node.get_aspect::<Spatial>().unwrap().clone(),
+			space: node.spatial.get().unwrap().clone(),
 			radius: AtomicF32::new(radius),
 		};
-		<SphereField as FieldAspect>::add_node_members(node);
+		sphere_field.add_field_methods(node);
-		<SphereField as SphereFieldAspect>::add_node_members(node);
+		node.add_local_signal("set_radius", SphereField::set_radius_flex);
-		node.add_aspect(Field::Sphere(sphere_field));
+		let _ = node.field.set(Arc::new(Field::Sphere(sphere_field)));
+		Ok(())
 	}
 
 	pub fn set_radius(&self, radius: f32) {
 		self.radius.store(radius, Ordering::Relaxed);
 	}
+
+	pub fn set_radius_flex(
+		node: &Node,
+		_calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		let Field::Sphere(sphere_field) = node.field.get().unwrap().as_ref() else { return Ok(()) };
+		sphere_field.set_radius(deserialize(message.as_ref())?);
+		Ok(())
+	}
 }
 
 impl FieldTrait for SphereField {
@@ -43,13 +65,29 @@ impl FieldTrait for SphereField {
 		self.space.as_ref()
 	}
 }
-impl SphereFieldAspect for SphereField {
+
-	fn set_radius(node: Arc<Node>, _calling_client: Arc<Client>, radius: f32) -> Result<()> {
+pub fn create_sphere_field_flex(
-		let this_field = node.get_aspect::<Field>()?;
+	_node: &Node,
-		let Field::Sphere(this_field) = &*this_field else {
+	calling_client: Arc<Client>,
-			return Ok(());
+	message: Message,
-		};
+) -> Result<()> {
-		this_field.set_radius(radius);
+	#[derive(Deserialize)]
-		Ok(())
+	struct CreateFieldInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
+		origin: Option<Vector3<f32>>,
+		radius: f32,
 	}
+	let info: CreateFieldInfo = deserialize(message.as_ref())?;
+	let node = Node::create(&calling_client, "/field", info.name, true);
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
+	let transform = Mat4::from_translation(
+		info.origin
+			.unwrap_or_else(|| Vector3::from([0.0; 3]))
+			.into(),
+	);
+	let node = node.add_to_scenegraph()?;
+	Spatial::add_to(&node, Some(parent), transform, false)?;
+	SphereField::add_to(&node, info.radius)?;
+	Ok(())
 }

src/nodes/fields/torus.rs

@@ -1,10 +1,13 @@
-use super::{Field, FieldTrait, Node, TorusFieldAspect};
+use super::{Field, FieldTrait, Node};
 use crate::core::client::Client;
-use crate::nodes::fields::FieldAspect;
+use crate::nodes::spatial::{find_spatial_parent, parse_transform, Spatial};
-use crate::nodes::spatial::Spatial;
+use crate::nodes::Message;
-use color_eyre::eyre::Result;
+use color_eyre::eyre::{ensure, Result};
 use glam::{swizzles::*, vec2, Vec3A};
 use portable_atomic::AtomicF32;
+use serde::Deserialize;
+use stardust_xr::schemas::flex::deserialize;
+use stardust_xr::values::Transform;
 
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
@@ -16,22 +19,44 @@ pub struct TorusField {
 }
 
 impl TorusField {
-	pub fn add_to(node: &Arc<Node>, radius_a: f32, radius_b: f32) {
+	pub fn add_to(node: &Arc<Node>, radius_a: f32, radius_b: f32) -> Result<()> {
+		ensure!(
+			node.spatial.get().is_some(),
+			"Internal: Node does not have a spatial attached!"
+		);
+		ensure!(
+			node.field.get().is_none(),
+			"Internal: Node already has a field attached!"
+		);
 		let torus_field = TorusField {
-			space: node.get_aspect::<Spatial>().unwrap().clone(),
+			space: node.spatial.get().unwrap().clone(),
 			radius_a: AtomicF32::new(radius_a.abs()),
 			radius_b: AtomicF32::new(radius_b.abs()),
 		};
-		<TorusField as FieldAspect>::add_node_members(node);
+		torus_field.add_field_methods(node);
-		<TorusField as TorusFieldAspect>::add_node_members(node);
+		node.add_local_signal("set_size", TorusField::set_size_flex);
-		node.add_aspect(Field::Torus(torus_field));
+		let _ = node.field.set(Arc::new(Field::Torus(torus_field)));
+		Ok(())
 	}
 
 	pub fn set_size(&self, radius_a: f32, radius_b: f32) {
 		self.radius_a.store(radius_a.abs(), Ordering::Relaxed);
 		self.radius_b.store(radius_b.abs(), Ordering::Relaxed);
 	}
+
+	pub fn set_size_flex(
+		node: &Node,
+		_calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		let Field::Torus(torus_field) = node.field.get().unwrap().as_ref() else { return Ok(()) };
+		let (radius_a, radius_b) = deserialize(message.as_ref())?;
+		torus_field.set_size(radius_a, radius_b);
+
+		Ok(())
+	}
 }
+
 impl FieldTrait for TorusField {
 	fn local_distance(&self, p: Vec3A) -> f32 {
 		let radius_a = self.radius_a.load(Ordering::Relaxed);
@@ -43,18 +68,26 @@ impl FieldTrait for TorusField {
 		self.space.as_ref()
 	}
 }
-impl TorusFieldAspect for TorusField {
+
-	fn set_size(
+pub fn create_torus_field_flex(
-		node: Arc<Node>,
+	_node: &Node,
-		_calling_client: Arc<Client>,
+	calling_client: Arc<Client>,
+	message: Message,
+) -> Result<()> {
+	#[derive(Deserialize)]
+	struct CreateFieldInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
+		transform: Transform,
 		radius_a: f32,
 		radius_b: f32,
-	) -> Result<()> {
-		let this_field = node.get_aspect::<Field>()?;
-		let Field::Torus(this_field) = &*this_field else {
-			return Ok(());
-		};
-		this_field.set_size(radius_a, radius_b);
-		Ok(())
 	}
+	let info: CreateFieldInfo = deserialize(message.as_ref())?;
+	let node = Node::create(&calling_client, "/field", info.name, true);
+	let parent = find_spatial_parent(&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, false)?;
+	TorusField::add_to(&node, info.radius_a, info.radius_b)?;
+	Ok(())
 }

src/nodes/hmd.rs

@@ -13,14 +13,17 @@ lazy_static::lazy_static! {
 }
 
 fn create() -> Arc<Node> {
-	let node = Arc::new(Node::create_parent_name(&INTERNAL_CLIENT, "", "hmd", false));
+	let node = Arc::new(Node::create(&INTERNAL_CLIENT, "", "hmd", false));
-	Spatial::add_to(&node, None, Mat4::IDENTITY, false);
+	Spatial::add_to(&node, None, Mat4::IDENTITY, false).expect("Unable to make spatial for HMD");
 
 	node
 }
 
 pub fn frame(sk: &impl StereoKitMultiThread) {
-	let spatial = HMD.get_aspect::<Spatial>().unwrap();
+	let spatial = HMD
+		.spatial
+		.get()
+		.expect("Unable to get spatial to update HMD");
 	let hmd_pose = sk.input_head();
 	*spatial.transform.lock() = Mat4::from_scale_rotation_translation(
 		vec3(1.0, 1.0, 1.0),

src/nodes/input/mod.rs

@@ -9,22 +9,23 @@ use self::tip::Tip;
 use super::{
 	alias::{Alias, AliasInfo},
 	fields::{find_field, Field, FIELD_ALIAS_INFO},
-	spatial::{parse_transform, Spatial},
+	spatial::{find_spatial_parent, parse_transform, Spatial},
-	Aspect, Message, Node,
+	Message, Node,
 };
+use crate::core::registry::Registry;
 use crate::core::{client::Client, node_collections::LifeLinkedNodeMap};
-use crate::{core::registry::Registry, nodes::spatial::Transform};
+use color_eyre::eyre::{ensure, Result};
-use color_eyre::eyre::Result;
 use glam::Mat4;
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use portable_atomic::AtomicBool;
 use serde::Deserialize;
-use stardust_xr::schemas::{flat::InputDataType, flex::serialize};
+use stardust_xr::schemas::{flat::InputData, flex::deserialize};
-use stardust_xr::{
+use stardust_xr::schemas::{
-	schemas::{flat::InputData, flex::deserialize},
+	flat::{Datamap, InputDataType},
-	values::Datamap,
+	flex::serialize,
 };
+use stardust_xr::values::Transform;
 use std::ops::Deref;
 use std::sync::atomic::Ordering;
 use std::sync::{Arc, Weak};
@@ -76,6 +77,11 @@ impl InputMethod {
 		specialization: InputType,
 		datamap: Option<Datamap>,
 	) -> Result<Arc<InputMethod>> {
+		ensure!(
+			node.spatial.get().is_some(),
+			"Internal: Node does not have a spatial attached!"
+		);
+
 		node.add_local_signal("capture", InputMethod::capture_flex);
 		node.add_local_signal("set_datamap", InputMethod::set_datamap_flex);
 		node.add_local_signal("set_handlers", InputMethod::set_handlers_flex);
@@ -84,7 +90,7 @@ impl InputMethod {
 			node: Arc::downgrade(node),
 			uid: node.uid.clone(),
 			enabled: Mutex::new(true),
-			spatial: node.get_aspect::<Spatial>().unwrap().clone(),
+			spatial: node.spatial.get().unwrap().clone(),
 			specialization: Mutex::new(specialization),
 			captures: Registry::new(),
 			datamap: Mutex::new(datamap),
@@ -96,38 +102,28 @@ impl InputMethod {
 			method.make_alias(&handler);
 		}
 		let method = INPUT_METHOD_REGISTRY.add(method);
-		node.add_aspect_raw(method.clone());
+		let _ = node.input_method.set(method.clone());
 		Ok(method)
 	}
 	fn get(node: &Node) -> Result<Arc<Self>> {
-		node.get_aspect::<Self>()
+		node.get_aspect("Input Method", "input method", |n| &n.input_method)
+			.cloned()
 	}
 
-	fn capture_flex(node: Arc<Node>, calling_client: Arc<Client>, message: Message) -> Result<()> {
+	fn capture_flex(node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
-		let method = InputMethod::get(&node)?;
+		let method = InputMethod::get(node)?;
 		let handler = InputHandler::find(&calling_client, deserialize(message.as_ref())?)?;
 
 		method.captures.add_raw(&handler);
 		node.send_remote_signal("capture", message)
 	}
-	fn set_datamap_flex(
+	fn set_datamap_flex(node: &Node, _calling_client: Arc<Client>, message: Message) -> Result<()> {
-		node: Arc<Node>,
+		let method = InputMethod::get(node)?;
-		_calling_client: Arc<Client>,
+		method.datamap.lock().replace(Datamap::new(message.data)?);
-		message: Message,
-	) -> Result<()> {
-		let method = InputMethod::get(&node)?;
-		method
-			.datamap
-			.lock()
-			.replace(Datamap::from_raw(message.data)?);
 		Ok(())
 	}
-	fn set_handlers_flex(
+	fn set_handlers_flex(node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
-		node: Arc<Node>,
+		let method = InputMethod::get(node)?;
-		calling_client: Arc<Client>,
-		message: Message,
-	) -> Result<()> {
-		let method = InputMethod::get(&node)?;
 		let handler_paths: Vec<&str> = deserialize(message.as_ref())?;
 		let handlers: Vec<Weak<InputHandler>> = handler_paths
 			.into_iter()
@@ -143,15 +139,9 @@ impl InputMethod {
 	}
 
 	fn make_alias(&self, handler: &InputHandler) {
-		let Some(method_node) = self.node.upgrade() else {
+		let Some(method_node) = self.node.upgrade() else {return};
-			return;
+		let Some(handler_node) = handler.node.upgrade() else {return};
-		};
+		let Some(client) = handler_node.get_client() else {return};
-		let Some(handler_node) = handler.node.upgrade() else {
-			return;
-		};
-		let Some(client) = handler_node.get_client() else {
-			return;
-		};
 		let Ok(method_alias) = Alias::create(
 			&client,
 			handler_node.get_path(),
@@ -161,40 +151,26 @@ impl InputMethod {
 				server_signals: vec!["capture"],
 				..Default::default()
 			},
-		) else {
+		) else {return};
-			return;
-		};
 		method_alias.enabled.store(false, Ordering::Relaxed);
 		handler
 			.method_aliases
 			.add(self as *const InputMethod as usize, &method_alias);
 	}
 
-	fn compare_distance(&self, to: &InputHandler) -> f32 {
+	fn compare_distance(&self, to: &Field) -> f32 {
-		let distance = self
+		self.specialization
-			.specialization
 			.lock()
-			.compare_distance(&self.spatial, &to.field);
+			.compare_distance(&self.spatial, to)
-		if self.captures.contains(to) {
-			distance * 0.5
-		} else {
-			distance
-		}
 	}
 	fn true_distance(&self, to: &Field) -> f32 {
 		self.specialization.lock().true_distance(&self.spatial, to)
 	}
 
 	fn handle_new_handler(&self, handler: &InputHandler) {
-		let Some(method_node) = self.node.upgrade() else {
+		let Some(method_node) = self.node.upgrade() else {return};
-			return;
+		let Some(method_client) = method_node.get_client() else {return};
-		};
+		let Some(handler_node) = handler.node.upgrade() else {return};
-		let Some(method_client) = method_node.get_client() else {
-			return;
-		};
-		let Some(handler_node) = handler.node.upgrade() else {
-			return;
-		};
 		// Receiver itself
 		let Ok(handler_alias) = Alias::create(
 			&method_client,
@@ -202,49 +178,38 @@ impl InputMethod {
 			handler.uid.as_str(),
 			&handler_node,
 			AliasInfo {
-				server_methods: vec!["get_transform"],
+				server_methods: vec!["getTransform"],
 				..Default::default()
 			},
-		) else {
+		) else {return};
-			return;
-		};
 		self.handler_aliases
 			.add(handler.uid.clone(), &handler_alias);
 
 		if let Some(handler_field_node) = handler.field.spatial_ref().node.upgrade() {
 			// Handler's field
 			let Ok(rx_field_alias) = Alias::create(
-				&method_client,
+					&method_client,
-				handler_alias.get_path(),
+					handler_alias.get_path(),
-				"field",
+					"field",
-				&handler_field_node,
+					&handler_field_node,
-				FIELD_ALIAS_INFO.clone(),
+					FIELD_ALIAS_INFO.clone(),
-			) else {
+				) else {return};
-				return;
-			};
 			self.handler_aliases
 				.add(handler.uid.clone() + "-field", &rx_field_alias);
 		}
 
-		let Ok(data) = serialize(&handler.uid) else {
+		let Ok(data) = serialize(&handler.uid) else {return};
-			return;
-		};
 		let _ = method_node.send_remote_signal("handler_created", data);
 	}
 	fn handle_drop_handler(&self, handler: &InputHandler) {
 		let uid = handler.uid.as_str();
 		self.handler_aliases.remove(uid);
 		self.handler_aliases.remove(&(uid.to_string() + "-field"));
-		let Some(tx_node) = self.node.upgrade() else {
+		let Some(tx_node) = self.node.upgrade() else {return};
-			return;
+		let Ok(data) = serialize(&uid) else {return};
-		};
-		let Ok(data) = serialize(&uid) else { return };
 		let _ = tx_node.send_remote_signal("handler_destroyed", data);
 	}
 }
-impl Aspect for InputMethod {
-	const NAME: &'static str = "InputMethod";
-}
 impl Drop for InputMethod {
 	fn drop(&mut self) {
 		INPUT_METHOD_REGISTRY.remove(self);
@@ -259,17 +224,17 @@ pub struct DistanceLink {
 impl DistanceLink {
 	fn from(method: Arc<InputMethod>, handler: Arc<InputHandler>) -> Self {
 		DistanceLink {
-			distance: method.compare_distance(&handler),
+			distance: method.compare_distance(&handler.field),
 			method,
 			handler,
 		}
 	}
 
-	fn send_input(&self, order: u32, captured: bool, datamap: Datamap) {
+	fn send_input(&self, order: u32, datamap: Datamap) {
-		self.handler.send_input(order, captured, self, datamap);
+		self.handler.send_input(order, self, datamap);
 	}
 	#[instrument(level = "debug", skip(self))]
-	fn serialize(&self, order: u32, captured: bool, datamap: Datamap) -> Vec<u8> {
+	fn serialize(&self, order: u32, datamap: Datamap) -> Vec<u8> {
 		let input = self.method.specialization.lock().serialize(
 			self,
 			Spatial::space_to_space_matrix(Some(&self.method.spatial), Some(&self.handler.spatial)),
@@ -281,7 +246,6 @@ impl DistanceLink {
 			distance: self.method.true_distance(&self.handler.field),
 			datamap,
 			order,
-			captured,
 		};
 		root.serialize()
 	}
@@ -297,11 +261,16 @@ pub struct InputHandler {
 }
 impl InputHandler {
 	pub fn add_to(node: &Arc<Node>, field: &Arc<Field>) -> Result<()> {
+		ensure!(
+			node.spatial.get().is_some(),
+			"Internal: Node does not have a spatial attached!"
+		);
+
 		let handler = InputHandler {
 			enabled: node.enabled.clone(),
 			uid: node.uid.clone(),
 			node: Arc::downgrade(node),
-			spatial: node.get_aspect::<Spatial>().unwrap().clone(),
+			spatial: node.spatial.get().unwrap().clone(),
 			field: field.clone(),
 			method_aliases: LifeLinkedNodeMap::default(),
 		};
@@ -310,30 +279,23 @@ impl InputHandler {
 			method.handle_new_handler(&handler);
 		}
 		let handler = INPUT_HANDLER_REGISTRY.add(handler);
-		node.add_aspect_raw(handler);
+		let _ = node.input_handler.set(handler);
 		Ok(())
 	}
 	fn find(client: &Client, path: &str) -> Result<Arc<Self>> {
-		client.get_node("Input Handler", path)?.get_aspect::<Self>()
+		InputHandler::get(&*client.get_node("Input Handler", path)?)
+	}
+	fn get(node: &Node) -> Result<Arc<Self>> {
+		node.get_aspect("Input Handler", "input handler", |n| &n.input_handler)
+			.cloned()
 	}
 
 	#[instrument(level = "debug", skip(self, distance_link))]
-	fn send_input(
+	fn send_input(&self, order: u32, distance_link: &DistanceLink, datamap: Datamap) {
-		&self,
+		let Some(node) = self.node.upgrade() else {return};
-		order: u32,
+		let _ = node.send_remote_signal("input", distance_link.serialize(order, datamap));
-		captured: bool,
-		distance_link: &DistanceLink,
-		datamap: Datamap,
-	) {
-		let Some(node) = self.node.upgrade() else {
-			return;
-		};
-		let _ = node.send_remote_signal("input", distance_link.serialize(order, captured, datamap));
 	}
 }
-impl Aspect for InputHandler {
-	const NAME: &'static str = "InputHandler";
-}
 impl PartialEq for InputHandler {
 	fn eq(&self, other: &Self) -> bool {
 		self.spatial == other.spatial
@@ -349,7 +311,7 @@ impl Drop for InputHandler {
 }
 
 pub fn create_interface(client: &Arc<Client>) -> Result<()> {
-	let node = Node::create_path(client, "/input", false);
+	let node = Node::create(client, "", "input", false);
 	node.add_local_signal("create_input_handler", create_input_handler_flex);
 	node.add_local_signal("create_input_method_pointer", pointer::create_pointer_flex);
 	node.add_local_signal("create_input_method_tip", tip::create_tip_flex);
@@ -357,7 +319,7 @@ pub fn create_interface(client: &Arc<Client>) -> Result<()> {
 }
 
 pub fn create_input_handler_flex(
-	_node: Arc<Node>,
+	_node: &Node,
 	calling_client: Arc<Client>,
 	message: Message,
 ) -> Result<()> {
@@ -369,15 +331,13 @@ pub fn create_input_handler_flex(
 		field_path: &'a str,
 	}
 	let info: CreateInputHandlerInfo = deserialize(message.as_ref())?;
-	let parent = calling_client
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
-		.get_node("Spatial parent", info.parent_path)?
-		.get_aspect::<Spatial>()?;
 	let transform = parse_transform(info.transform, true, true, true);
 	let field = find_field(&calling_client, info.field_path)?;
 
-	let node = Node::create_parent_name(&calling_client, "/input/handler", info.name, true)
+	let node =
-		.add_to_scenegraph()?;
+		Node::create(&calling_client, "/input/handler", info.name, true).add_to_scenegraph()?;
-	Spatial::add_to(&node, Some(parent.clone()), transform, false);
+	Spatial::add_to(&node, Some(parent), transform, false)?;
 	InputHandler::add_to(&node, &field)?;
 	Ok(())
 }
@@ -395,7 +355,7 @@ pub fn process_input() {
 	const LIMIT: usize = 50;
 	for method in methods {
 		for alias in method.node.upgrade().unwrap().aliases.get_valid_contents() {
-			alias.enabled.store(false, Ordering::Release);
+			alias.enabled.store(false, Ordering::Relaxed);
 		}
 
 		debug_span!("Process input method").in_scope(|| {
@@ -436,24 +396,23 @@ pub fn process_input() {
 			let captures = method.captures.take_valid_contents();
 			// Iterate over the distance links and send input to them
 			for (i, distance_link) in distance_links.into_iter().enumerate() {
+				if i > LIMIT {
+					break;
+				}
+
 				if let Some(method_alias) = distance_link
 					.handler
 					.method_aliases
 					.get(&(Arc::as_ptr(&distance_link.method) as usize))
-					.and_then(|a| a.get_aspect::<Alias>().ok())
+					.and_then(|a| a.alias.get().cloned())
 				{
-					method_alias.enabled.store(true, Ordering::Release);
+					method_alias.enabled.store(true, Ordering::Relaxed);
 				}
-				let captured = captures.contains(&distance_link.handler);
+				distance_link.send_input(i as u32, method.datamap.lock().clone().unwrap());
-				distance_link.send_input(
-					i as u32,
-					captured,
-					method.datamap.lock().clone().unwrap(),
-				);
 
 				// If the current distance link is in the list of captured input handlers,
 				// break out of the loop to avoid sending input to the remaining distance links
-				if captured {
+				if captures.contains(&distance_link.handler) {
 					break;
 				}
 			}

src/nodes/input/pointer.rs

@@ -2,14 +2,13 @@ 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::spatial::{find_spatial_parent, parse_transform, Spatial};
 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::flat::{Datamap, InputDataType, Pointer as FlatPointer};
 use stardust_xr::schemas::flex::deserialize;
-use stardust_xr::values::Datamap;
+use stardust_xr::values::Transform;
-
 use std::sync::Arc;
 
 #[derive(Default)]
@@ -66,7 +65,7 @@ impl InputSpecialization for Pointer {
 }
 
 pub fn create_pointer_flex(
-	_node: Arc<Node>,
+	_node: &Node,
 	calling_client: Arc<Client>,
 	message: Message,
 ) -> color_eyre::eyre::Result<()> {
@@ -78,19 +77,16 @@ pub fn create_pointer_flex(
 		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 node = Node::create(&calling_client, "/input/method/pointer", info.name, true);
-	let parent = calling_client
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
-		.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);
+	Spatial::add_to(&node, Some(parent), transform, false)?;
 	InputMethod::add_to(
 		&node,
 		InputType::Pointer(Pointer),
-		info.datamap
+		info.datamap.and_then(|datamap| Datamap::new(datamap).ok()),
-			.and_then(|datamap| Datamap::from_raw(datamap).ok()),
 	)?;
 	Ok(())
 }

src/nodes/input/tip.rs

@@ -2,15 +2,14 @@ use super::{DistanceLink, InputSpecialization};
 use crate::core::client::Client;
 use crate::nodes::fields::Field;
 use crate::nodes::input::{InputMethod, InputType};
-use crate::nodes::spatial::{parse_transform, Spatial, Transform};
+use crate::nodes::spatial::{find_spatial_parent, parse_transform, Spatial};
 use crate::nodes::{Message, Node};
 use color_eyre::eyre::Result;
 use glam::{vec3a, Mat4};
 use serde::Deserialize;
-use stardust_xr::schemas::flat::{InputDataType, Tip as FlatTip};
+use stardust_xr::schemas::flat::{Datamap, InputDataType, Tip as FlatTip};
 use stardust_xr::schemas::flex::deserialize;
-use stardust_xr::values::Datamap;
+use stardust_xr::values::Transform;
-
 use std::sync::Arc;
 
 #[derive(Default)]
@@ -18,9 +17,8 @@ pub struct Tip {
 	pub radius: f32,
 }
 impl Tip {
-	fn set_radius(node: Arc<Node>, _calling_client: Arc<Client>, message: Message) -> Result<()> {
+	fn set_radius(node: &Node, _calling_client: Arc<Client>, message: Message) -> Result<()> {
-		let input_method = node.get_aspect::<InputMethod>()?;
+		if let InputType::Tip(tip) = &mut *node.input_method.get().unwrap().specialization.lock() {
-		if let InputType::Tip(tip) = &mut *input_method.specialization.lock() {
 			tip.radius = deserialize(message.as_ref())?;
 		}
 		Ok(())
@@ -47,11 +45,7 @@ impl InputSpecialization for Tip {
 	}
 }
 
-pub fn create_tip_flex(
+pub fn create_tip_flex(_node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
-	_node: Arc<Node>,
-	calling_client: Arc<Client>,
-	message: Message,
-) -> Result<()> {
 	#[derive(Deserialize)]
 	struct CreateTipInfo<'a> {
 		name: &'a str,
@@ -61,21 +55,18 @@ pub fn create_tip_flex(
 		datamap: Option<Vec<u8>>,
 	}
 	let info: CreateTipInfo = deserialize(message.as_ref())?;
-	let node = Node::create_parent_name(&calling_client, "/input/method/tip", info.name, true);
+	let node = Node::create(&calling_client, "/input/method/tip", info.name, true);
-	let parent = calling_client
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
-		.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);
+	Spatial::add_to(&node, Some(parent), transform, false)?;
 	InputMethod::add_to(
 		&node,
 		InputType::Tip(Tip {
 			radius: info.radius,
 		}),
-		info.datamap
+		info.datamap.and_then(|datamap| Datamap::new(datamap).ok()),
-			.and_then(|datamap| Datamap::from_raw(datamap).ok()),
 	)?;
 	node.add_local_signal("set_radius", Tip::set_radius);
 	Ok(())

src/nodes/items/camera.rs

@@ -1,18 +1,19 @@
 use super::{Item, ItemType};
 use crate::{
 	core::{
+		buffers::BufferManager,
 		client::{Client, INTERNAL_CLIENT},
 		registry::Registry,
 		scenegraph::MethodResponseSender,
 	},
 	nodes::{
-		drawable::{model::ModelPart, shaders::UNLIT_SHADER_BYTES},
+		drawable::{model::ModelPart, shaders::UNLIT_SHADER_BYTES, Drawable},
 		items::TypeInfo,
-		spatial::{parse_transform, Spatial, Transform},
+		spatial::{find_spatial_parent, parse_transform, Spatial},
 		Message, Node,
 	},
 };
-use color_eyre::eyre::{bail, eyre, Result};
+use color_eyre::eyre::{bail, Result};
 use glam::Mat4;
 use lazy_static::lazy_static;
 use mint::{RowMatrix4, Vector2};
@@ -20,17 +21,30 @@ use nanoid::nanoid;
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use serde::Deserialize;
-use stardust_xr::schemas::flex::{deserialize, serialize};
+use smithay::backend::{
-use std::sync::Arc;
+	allocator::{
-use stereokit::{
+		dmabuf::{Dmabuf, DmabufFlags},
-	Color128, Material, Rect, RenderLayer, StereoKitDraw, Tex, TextureType, Transparency,
+		Buffer,
+	},
+	renderer::ImportDma,
 };
+use stardust_xr::{
+	scenegraph::ScenegraphError,
+	schemas::flex::{deserialize, serialize},
+	values::{BufferInfo, Transform},
+};
+use std::{ffi::c_void, sync::Arc};
+use stereokit::{
+	Color128, Material, Rect, RenderLayer, StereoKitDraw, Tex, TextureFormat, TextureType,
+	Transparency,
+};
+use tokio::sync::mpsc::{self, error::SendError};
 
 lazy_static! {
 	pub(super) static ref ITEM_TYPE_INFO_CAMERA: TypeInfo = TypeInfo {
 		type_name: "camera",
-		aliased_local_signals: vec!["apply_preview_material", "frame"],
+		aliased_local_signals: vec!["apply_preview_material", "set_proj_matrix"],
-		aliased_local_methods: vec![],
+		aliased_local_methods: vec!["render"],
 		aliased_remote_signals: vec![],
 		ui: Default::default(),
 		items: Registry::new(),
@@ -40,7 +54,7 @@ lazy_static! {
 
 struct FrameInfo {
 	proj_matrix: Mat4,
-	px_size: Vector2<u32>,
+	preview_size: Vector2<u32>,
 }
 
 pub struct CameraItem {
@@ -48,62 +62,139 @@ pub struct CameraItem {
 	frame_info: Mutex<FrameInfo>,
 	sk_tex: OnceCell<Tex>,
 	sk_mat: OnceCell<Arc<Material>>,
-	applied_to: Registry<ModelPart>,
+	render_requests_tx: mpsc::UnboundedSender<(Dmabuf, MethodResponseSender)>,
-	apply_to: Registry<ModelPart>,
+	render_requests_rx: Mutex<mpsc::UnboundedReceiver<(Dmabuf, MethodResponseSender)>>,
+	rendered_notifiers: Mutex<Vec<MethodResponseSender>>,
+	applied_preview_to: Registry<ModelPart>,
+	apply_preview_to: Registry<ModelPart>,
 }
 impl CameraItem {
-	pub fn add_to(node: &Arc<Node>, proj_matrix: Mat4, px_size: Vector2<u32>) {
+	pub fn add_to(node: &Arc<Node>, proj_matrix: Mat4, preview_size: Vector2<u32>) {
+		let (render_requests_tx, render_requests_rx) = mpsc::unbounded_channel();
+		let camera_specialization = CameraItem {
+			space: node.spatial.get().unwrap().clone(),
+			frame_info: Mutex::new(FrameInfo {
+				proj_matrix,
+				preview_size,
+			}),
+			sk_tex: OnceCell::new(),
+			sk_mat: OnceCell::new(),
+			render_requests_tx,
+			render_requests_rx: Mutex::new(render_requests_rx),
+			rendered_notifiers: Mutex::new(Vec::new()),
+			applied_preview_to: Registry::new(),
+			apply_preview_to: Registry::new(),
+		};
 		Item::add_to(
 			node,
 			nanoid!(),
 			&ITEM_TYPE_INFO_CAMERA,
-			ItemType::Camera(CameraItem {
+			ItemType::Camera(camera_specialization),
-				space: node.get_aspect::<Spatial>().unwrap().clone(),
-				frame_info: Mutex::new(FrameInfo {
-					proj_matrix,
-					px_size,
-				}),
-				sk_tex: OnceCell::new(),
-				sk_mat: OnceCell::new(),
-				applied_to: Registry::new(),
-				apply_to: Registry::new(),
-			}),
 		);
-		node.add_local_method("frame", CameraItem::frame_flex);
+		node.add_local_method("render", CameraItem::render_flex);
 		node.add_local_signal(
 			"apply_preview_material",
 			CameraItem::apply_preview_material_flex,
 		);
+		node.add_local_signal("set_proj_matrix", CameraItem::set_proj_matrix_flex);
 	}
 
-	fn frame_flex(
+	fn render_flex(
-		node: Arc<Node>,
+		node: &Node,
 		_calling_client: Arc<Client>,
-		_message: Message,
+		message: Message,
 		response: MethodResponseSender,
 	) {
-		response.wrap_sync(move || {
+		let Some(item) = node.item.get() else {
-			let ItemType::Camera(_camera) = &node.get_aspect::<Item>().unwrap().specialization
+			let _ = response.send(Err(ScenegraphError::MethodError {
-			else {
+				error: "Item not found".to_string(),
-				return Err(eyre!("Wrong item type?"));
+			}));
-			};
+			return;
-			Ok(serialize(())?.into())
+		};
-		});
+		let ItemType::Camera(camera) = &item.specialization else {
+			let _ = response.send(Err(ScenegraphError::MethodError {
+				error: "Wrong item type?".to_string(),
+			}));
+			return;
+		};
+
+		let buffer_info: BufferInfo = match deserialize(&message.data) {
+			Ok(i) => i,
+			Err(e) => {
+				let _ = response.send(Err(ScenegraphError::MethodError {
+					error: e.to_string(),
+				}));
+				return;
+			}
+		};
+		let mut builder = Dmabuf::builder(
+			(buffer_info.width as i32, buffer_info.height as i32),
+			buffer_info.fourcc.try_into().unwrap(),
+			DmabufFlags::from_bits_truncate(buffer_info.flags),
+		);
+		for (fd, plane) in message.fds.into_iter().zip(buffer_info.planes) {
+			builder.add_plane(
+				fd,
+				plane.idx,
+				plane.offset,
+				plane.stride,
+				plane.modifier.try_into().unwrap(),
+			);
+		}
+		let buffer_to_render = builder.build().unwrap();
+
+		if let Err(SendError((_dmabuf, sender))) =
+			camera.render_requests_tx.send((buffer_to_render, response))
+		{
+			sender.send(Err(ScenegraphError::MethodError {
+				error: "Internal: sender broke????".to_string(),
+			}));
+		}
 	}
 
 	fn apply_preview_material_flex(
-		node: Arc<Node>,
+		node: &Node,
 		calling_client: Arc<Client>,
 		message: Message,
 	) -> Result<()> {
-		let ItemType::Camera(camera) = &node.get_aspect::<Item>().unwrap().specialization else {
+		let Some(item) = node.item.get() else {
+			bail!("Item not found?")
+		};
+		let ItemType::Camera(camera) = &item.specialization else {
 			bail!("Wrong item type?")
 		};
-		let model_part_node =
+
-			calling_client.get_node("Model part", deserialize(&message.data).unwrap())?;
+		let model_part_path = deserialize(&message.data)?;
-		let model_part = model_part_node.get_aspect::<ModelPart>()?;
+		let model_part_node = calling_client.get_node("Model part", model_part_path)?;
-		camera.applied_to.add_raw(&model_part);
+		let Drawable::ModelPart(model_part) =
-		camera.apply_to.add_raw(&model_part);
+			model_part_node.get_aspect("Model part", "model part", |n| &n.drawable)?
+		else {
+			bail!("Drawable is not a model node")
+		};
+
+		camera.applied_preview_to.add_raw(model_part);
+		camera.apply_preview_to.add_raw(model_part);
+
+		Ok(())
+	}
+
+	fn set_proj_matrix_flex(
+		node: &Node,
+		_calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		let Some(item) = node.item.get() else {
+			bail!("Item not found?")
+		};
+		let ItemType::Camera(camera) = &item.specialization else {
+			bail!("Wrong item type?")
+		};
+
+		let proj_matrix: RowMatrix4<f32> = deserialize(&message.data)?;
+
+		let mut frame_info = camera.frame_info.lock();
+		frame_info.proj_matrix = proj_matrix.into();
+
 		Ok(())
 	}
 
@@ -111,33 +202,40 @@ impl CameraItem {
 		Ok(serialize(id)?.into())
 	}
 
-	pub fn update(&self, sk: &impl StereoKitDraw) {
+	pub fn update(&self, sk: &impl StereoKitDraw, buffer_manager: &mut BufferManager) {
 		let frame_info = self.frame_info.lock();
-		let sk_tex = self.sk_tex.get_or_init(|| {
+		self.render_preview(sk, &*frame_info);
-			sk.tex_gen_color(
+		self.render_dmabuf(sk, buffer_manager, &*frame_info);
-				Color128::default(),
+	}
-				frame_info.px_size.x as i32,
+
-				frame_info.px_size.y as i32,
+	fn render_preview(&self, sk: &impl StereoKitDraw, frame_info: &FrameInfo) {
-				TextureType::RENDER_TARGET,
+		if !self.apply_preview_to.is_empty() {
-				stereokit::TextureFormat::RGBA32Linear,
+			let sk_tex = self.sk_tex.get_or_init(|| {
-			)
+				sk.tex_gen_color(
-		});
+					Color128::default(),
-		let sk_mat = self.sk_mat.get_or_init(|| {
+					frame_info.preview_size.x as i32,
-			let shader = sk.shader_create_mem(&UNLIT_SHADER_BYTES).unwrap();
+					frame_info.preview_size.y as i32,
-			let mat = sk.material_create(&shader);
+					TextureType::RENDER_TARGET,
-			sk.material_set_texture(&mat, "diffuse", sk_tex.as_ref());
+					TextureFormat::RGBA32Linear,
-			sk.material_set_transparency(&mat, Transparency::Blend);
+				)
-			Arc::new(mat)
+			});
-		});
+			let sk_mat = self.sk_mat.get_or_init(|| {
-		for model_part in self.apply_to.take_valid_contents() {
+				let shader = sk.shader_create_mem(&UNLIT_SHADER_BYTES).unwrap();
-			model_part.replace_material(sk_mat.clone())
+				let mat = sk.material_create(&shader);
+				sk.material_set_texture(&mat, "diffuse", sk_tex.as_ref());
+				sk.material_set_transparency(&mat, Transparency::Blend);
+				Arc::new(mat)
+			});
+			for model_part in self.apply_preview_to.take_valid_contents() {
+				model_part.replace_material(sk_mat.clone())
+			}
 		}
 
-		if !self.applied_to.is_empty() {
+		if !self.applied_preview_to.is_empty() {
 			sk.render_to(
-				sk_tex,
+				self.sk_tex.get().unwrap(),
-				frame_info.proj_matrix,
 				self.space.global_transform(),
+				frame_info.proj_matrix,
 				RenderLayer::all(),
 				stereokit::RenderClear::All,
 				Rect {
@@ -149,19 +247,87 @@ impl CameraItem {
 			);
 		}
 	}
+
+	fn render_dmabuf(
+		&self,
+		sk: &impl StereoKitDraw,
+		buffer_manager: &mut BufferManager,
+		frame_info: &FrameInfo,
+	) {
+		let mut render_notifiers = self.rendered_notifiers.lock();
+		let mut render_requests_rx = self.render_requests_rx.lock();
+		while let Ok((buffer_to_render, render_response_sender)) = render_requests_rx.try_recv() {
+			let imported_dmabuf = buffer_manager
+				.renderer
+				.import_dmabuf(&buffer_to_render, None);
+			let smithay_tex = match imported_dmabuf {
+				Ok(t) => t,
+				Err(e) => {
+					let _ = render_response_sender.send(Err(ScenegraphError::MethodError {
+						error: e.to_string(),
+					}));
+					continue;
+				}
+			};
+
+			let sk_tex = sk.tex_create(TextureType::IMAGE_NO_MIPS, TextureFormat::RGBA32);
+			unsafe {
+				sk.tex_set_surface(
+					&sk_tex,
+					smithay_tex.tex_id() as usize as *mut c_void,
+					TextureType::RENDER_TARGET,
+					smithay::backend::renderer::gles::ffi::SRGB8_ALPHA8.into(),
+					buffer_to_render.size().w,
+					buffer_to_render.size().h,
+					1,
+					false,
+				);
+			}
+
+			sk.render_to(
+				sk_tex,
+				self.space.global_transform(),
+				frame_info.proj_matrix,
+				RenderLayer::all(),
+				stereokit::RenderClear::All,
+				Rect {
+					x: 0.0,
+					y: 0.0,
+					w: 0.0,
+					h: 0.0,
+				},
+			);
+			render_notifiers.push(render_response_sender);
+		}
+	}
+
+	pub fn send_rendered(&self) {
+		for notifier in self.rendered_notifiers.lock().drain(..) {
+			let _ = notifier.send(Ok(Vec::new().into()));
+		}
+	}
 }
 
-pub fn update(sk: &impl StereoKitDraw) {
+pub fn update(sk: &impl StereoKitDraw, buffer_manager: &mut BufferManager) {
 	for camera in ITEM_TYPE_INFO_CAMERA.items.get_valid_contents() {
 		let ItemType::Camera(camera) = &camera.specialization else {
 			continue;
 		};
-		camera.update(sk);
+		camera.update(sk, buffer_manager);
+	}
+}
+
+pub fn send_rendered() {
+	for camera in ITEM_TYPE_INFO_CAMERA.items.get_valid_contents() {
+		let ItemType::Camera(camera) = &camera.specialization else {
+			continue;
+		};
+		camera.send_rendered();
 	}
 }
 
 pub(super) fn create_camera_item_flex(
-	_node: Arc<Node>,
+	_node: &Node,
 	calling_client: Arc<Client>,
 	message: Message,
 ) -> Result<()> {
@@ -171,23 +337,21 @@ pub(super) fn create_camera_item_flex(
 		parent_path: &'a str,
 		transform: Transform,
 		proj_matrix: RowMatrix4<f32>,
-		px_size: Vector2<u32>,
+		preview_size: Vector2<u32>,
 	}
 	let info: CreateCameraItemInfo = deserialize(message.as_ref())?;
 	let parent_name = format!("/item/{}/item", ITEM_TYPE_INFO_CAMERA.type_name);
-	let space = calling_client
+	let space = find_spatial_parent(&calling_client, info.parent_path)?;
-		.get_node("Spatial parent", info.parent_path)?
-		.get_aspect::<Spatial>()?;
 	let transform = parse_transform(info.transform, true, true, false);
 
-	let node = Node::create_parent_name(&INTERNAL_CLIENT, &parent_name, info.name, false)
+	let node =
-		.add_to_scenegraph()?;
+		Node::create(&INTERNAL_CLIENT, &parent_name, info.name, false).add_to_scenegraph()?;
-	Spatial::add_to(&node, None, transform * space.global_transform(), false);
+	Spatial::add_to(&node, None, transform * space.global_transform(), false)?;
-	CameraItem::add_to(&node, info.proj_matrix.into(), info.px_size);
+	CameraItem::add_to(&node, info.proj_matrix.into(), info.preview_size);
-	node.get_aspect::<Item>().unwrap().make_alias_named(
+	// TODO: this means ANY client can render anywhere with no limits, this needs to be changed!!
-		&calling_client,
+	node.item
-		&parent_name,
+		.get()
-		info.name,
+		.unwrap()
-	)?;
+		.make_alias_named(&calling_client, &parent_name, info.name)?;
 	Ok(())
 }

src/nodes/items/environment.rs

@@ -7,7 +7,7 @@ use crate::{
 	},
 	nodes::{
 		items::TypeInfo,
-		spatial::{parse_transform, Spatial, Transform},
+		spatial::{find_spatial_parent, parse_transform, Spatial},
 		Message, Node,
 	},
 };
@@ -15,7 +15,10 @@ use color_eyre::eyre::{eyre, Result};
 use lazy_static::lazy_static;
 use nanoid::nanoid;
 use serde::Deserialize;
-use stardust_xr::schemas::flex::{deserialize, serialize};
+use stardust_xr::{
+	schemas::flex::{deserialize, serialize},
+	values::Transform,
+};
 use std::sync::Arc;
 
 lazy_static! {
@@ -45,17 +48,15 @@ impl EnvironmentItem {
 	}
 
 	fn get_path_flex(
-		node: Arc<Node>,
+		node: &Node,
 		_calling_client: Arc<Client>,
 		_message: Message,
 		response: MethodResponseSender,
 	) {
 		response.wrap_sync(move || {
-			let ItemType::Environment(environment_item) =
+			let ItemType::Environment(environment_item) = &node.item.get().unwrap().specialization else {
-				&node.get_aspect::<Item>().unwrap().specialization
+			return Err(eyre!("Wrong item type?"))
-			else {
+		};
-				return Err(eyre!("Wrong item type?"));
-			};
 			Ok(serialize(environment_item.path.as_str())?.into())
 		});
 	}
@@ -66,7 +67,7 @@ impl EnvironmentItem {
 }
 
 pub(super) fn create_environment_item_flex(
-	_node: Arc<Node>,
+	_node: &Node,
 	calling_client: Arc<Client>,
 	message: Message,
 ) -> Result<()> {
@@ -79,19 +80,16 @@ pub(super) fn create_environment_item_flex(
 	}
 	let info: CreateEnvironmentItemInfo = deserialize(message.as_ref())?;
 	let parent_name = format!("/item/{}/item", ITEM_TYPE_INFO_ENVIRONMENT.type_name);
-	let space = calling_client
+	let space = find_spatial_parent(&calling_client, info.parent_path)?;
-		.get_node("Spatial parent", info.parent_path)?
-		.get_aspect::<Spatial>()?;
 	let transform = parse_transform(info.transform, true, true, false);
 
-	let node = Node::create_parent_name(&INTERNAL_CLIENT, &parent_name, info.name, false)
+	let node =
-		.add_to_scenegraph()?;
+		Node::create(&INTERNAL_CLIENT, &parent_name, info.name, false).add_to_scenegraph()?;
-	Spatial::add_to(&node, None, transform * space.global_transform(), false);
+	Spatial::add_to(&node, None, transform * space.global_transform(), false)?;
 	EnvironmentItem::add_to(&node, info.item_data);
-	node.get_aspect::<Item>().unwrap().make_alias_named(
+	node.item
-		&calling_client,
+		.get()
-		&parent_name,
+		.unwrap()
-		info.name,
+		.make_alias_named(&calling_client, &parent_name, info.name)?;
-	)?;
 	Ok(())
 }

src/nodes/items/mod.rs

@@ -6,14 +6,13 @@ use self::camera::CameraItem;
 use self::environment::{EnvironmentItem, ITEM_TYPE_INFO_ENVIRONMENT};
 use self::panel::{PanelItemTrait, ITEM_TYPE_INFO_PANEL};
 use super::fields::Field;
-use super::spatial::{parse_transform, Spatial};
+use super::spatial::{find_spatial_parent, parse_transform, Spatial};
-use super::{Alias, Aspect, Message, Node};
+use super::{Alias, Message, Node};
 use crate::core::client::Client;
 use crate::core::node_collections::LifeLinkedNodeMap;
 use crate::core::registry::Registry;
 use crate::nodes::alias::AliasInfo;
 use crate::nodes::fields::find_field;
-use crate::nodes::spatial::Transform;
 use color_eyre::eyre::{ensure, eyre, Result};
 use lazy_static::lazy_static;
 use nanoid::nanoid;
@@ -21,7 +20,7 @@ use parking_lot::Mutex;
 use portable_atomic::Ordering;
 use serde::Deserialize;
 use stardust_xr::schemas::flex::{deserialize, serialize};
-
+use stardust_xr::values::Transform;
 use std::hash::Hash;
 use std::sync::{Arc, Weak};
 
@@ -108,7 +107,7 @@ impl Item {
 		if let Some(ui) = type_info.ui.lock().upgrade() {
 			ui.handle_create_item(&item);
 		}
-		node.add_aspect_raw(item.clone());
+		let _ = node.item.set(item.clone());
 
 		// if let Some(auto_acceptor) = node.get_client().and_then(|client| {
 		// 	client
@@ -156,20 +155,13 @@ impl Item {
 		self.make_alias_named(client, parent, &self.uid)
 	}
 
-	fn release_flex(
+	fn release_flex(node: &Node, _calling_client: Arc<Client>, _message: Message) -> Result<()> {
-		node: Arc<Node>,
+		let item = node.get_aspect("Item", "item", |n| &n.item)?;
-		_calling_client: Arc<Client>,
+		release(item);
-		_message: Message,
-	) -> Result<()> {
-		let item = node.get_aspect::<Item>()?;
-		release(&item);
 
 		Ok(())
 	}
 }
-impl Aspect for Item {
-	const NAME: &'static str = "Item";
-}
 impl Drop for Item {
 	fn drop(&mut self) {
 		self.type_info.items.remove(self);
@@ -227,7 +219,7 @@ impl ItemUI {
 			acceptor_field_aliases: Default::default(),
 		});
 		*type_info.ui.lock() = Arc::downgrade(&ui);
-		node.add_aspect_raw(ui.clone());
+		let _ = node.item_ui.set(ui.clone());
 
 		for item in type_info.items.get_valid_contents() {
 			ui.handle_create_item(&item);
@@ -238,9 +230,7 @@ impl ItemUI {
 		Ok(())
 	}
 	fn send_state(&self, state: &str, name: &str) {
-		let Ok(serialized_data) = serialize(name) else {
+		let Ok(serialized_data) = serialize(name) else {return};
-			return;
-		};
 		let _ = self
 			.node
 			.upgrade()
@@ -249,20 +239,14 @@ impl ItemUI {
 	}
 
 	fn handle_create_item(&self, item: &Item) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
+		let Some(client) = node.get_client() else {return};
-		};
-		let Some(client) = node.get_client() else {
-			return;
-		};
 
 		if let Ok(alias_node) = item.make_alias(&client, &(node.get_path().to_string() + "/item")) {
 			self.item_aliases.add(item.uid.clone(), &alias_node);
 		}
 
-		let Ok(serialized_data) = item.specialization.serialize_start_data(&item.uid) else {
+		let Ok(serialized_data) =  item.specialization.serialize_start_data(&item.uid) else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("create_item", serialized_data);
 	}
 	fn handle_destroy_item(&self, item: &Item) {
@@ -270,45 +254,29 @@ impl ItemUI {
 		self.send_state("destroy_item", item.uid.as_str());
 	}
 	fn handle_capture_item(&self, item: &Item, acceptor: &ItemAcceptor) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 
-		let Ok(message) = serialize((item.uid.as_str(), acceptor.uid.as_str())) else {
+		let Ok(message) = serialize((item.uid.as_str(), acceptor.uid.as_str())) else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("capture_item", message);
 	}
 	fn handle_release_item(&self, item: &Item, acceptor: &ItemAcceptor) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 
-		let Ok(message) = serialize((item.uid.as_str(), acceptor.uid.as_str())) else {
+		let Ok(message) = serialize((item.uid.as_str(), acceptor.uid.as_str())) else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("release_item", message);
 	}
 	fn handle_create_acceptor(&self, acceptor: &ItemAcceptor) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
+		let Some(client) = node.get_client() else {return};
-		};
-		let Some(client) = node.get_client() else {
-			return;
-		};
 
 		let Ok((alias, field_alias)) = acceptor.make_aliases(
 			&client,
 			&format!("/item/{}/acceptor", self.type_info.type_name),
-		) else {
+		) else {return};
-			return;
-		};
 		self.acceptor_aliases.add(acceptor.uid.clone(), &alias);
 		self.acceptor_field_aliases
 			.add(acceptor.uid.clone(), &field_alias);
-		let Ok(message) = serialize(&acceptor.uid) else {
+		let Ok(message) = serialize(&acceptor.uid) else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("create_acceptor", message);
 	}
 	fn handle_destroy_acceptor(&self, acceptor: &ItemAcceptor) {
@@ -317,9 +285,6 @@ impl ItemUI {
 		self.acceptor_field_aliases.remove(&acceptor.uid);
 	}
 }
-impl Aspect for ItemUI {
-	const NAME: &'static str = "Item";
-}
 impl Drop for ItemUI {
 	fn drop(&mut self) {
 		*self.type_info.ui.lock() = Weak::new();
@@ -348,19 +313,19 @@ impl ItemAcceptor {
 		if let Some(ui) = type_info.ui.lock().upgrade() {
 			ui.handle_create_acceptor(&acceptor);
 		}
-		node.add_aspect_raw(acceptor);
+		let _ = node.item_acceptor.set(acceptor);
 	}
 
-	fn capture_flex(node: Arc<Node>, calling_client: Arc<Client>, message: Message) -> Result<()> {
+	fn capture_flex(node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
 		if !node.enabled.load(Ordering::Relaxed) {
 			return Ok(());
 		}
 
-		let acceptor = node.get_aspect::<ItemAcceptor>().unwrap();
+		let acceptor = node.item_acceptor.get().unwrap();
 		let item_path: &str = deserialize(message.as_ref())?;
 		let item_node = calling_client.get_node("Item", item_path)?;
-		let item = item_node.get_aspect::<Item>()?;
+		let item = item_node.get_aspect("Item", "item", |n| &n.item)?;
-		capture(&item, &acceptor);
+		capture(item, acceptor);
 
 		Ok(())
 	}
@@ -389,39 +354,26 @@ impl ItemAcceptor {
 		Ok((acceptor_alias, acceptor_field_alias))
 	}
 	fn handle_capture(&self, item: &Arc<Item>) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
+		let Some(client) = node.get_client() else {return};
-		};
-		let Some(client) = node.get_client() else {
-			return;
-		};
 
 		self.accepted_registry.add_raw(item);
 		if let Ok(alias_node) = item.make_alias(&client, &node.path) {
 			self.accepted_aliases.add(item.uid.clone(), &alias_node);
 		}
 
-		let Ok(serialized_data) = item.specialization.serialize_start_data(&item.uid) else {
+		let Ok(serialized_data) =  item.specialization.serialize_start_data(&item.uid) else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("capture", serialized_data);
 	}
 	fn handle_release(&self, item: &Item) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 
 		self.accepted_registry.remove(item);
 		self.accepted_aliases.remove(&item.uid);
-		let Ok(message) = serialize(&item.uid) else {
+		let Ok(message) = serialize(&item.uid) else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("release", message);
 	}
 }
-impl Aspect for ItemAcceptor {
-	const NAME: &'static str = "ItemAcceptor";
-}
 impl Drop for ItemAcceptor {
 	fn drop(&mut self) {
 		self.type_info.acceptors.remove(self);
@@ -435,7 +387,7 @@ impl Drop for ItemAcceptor {
 }
 
 pub fn create_interface(client: &Arc<Client>) -> Result<()> {
-	let node = Node::create_parent_name(client, "", "item", false);
+	let node = Node::create(client, "", "item", false);
 	node.add_local_signal("create_camera_item", camera::create_camera_item_flex);
 	node.add_local_signal(
 		"create_environment_item",
@@ -456,7 +408,7 @@ fn type_info(name: &str) -> Result<&'static TypeInfo> {
 }
 
 pub fn register_item_ui_flex(
-	_node: Arc<Node>,
+	_node: &Node,
 	calling_client: Arc<Client>,
 	message: Message,
 ) -> Result<()> {
@@ -466,14 +418,14 @@ pub fn register_item_ui_flex(
 	}
 	let info: RegisterItemUIInfo = deserialize(message.as_ref())?;
 	let type_info = type_info(info.item_type)?;
-	let ui = Node::create_parent_name(&calling_client, "/item", type_info.type_name, true)
+	let ui =
-		.add_to_scenegraph()?;
+		Node::create(&calling_client, "/item", type_info.type_name, true).add_to_scenegraph()?;
 	ItemUI::add_to(&ui, type_info)?;
 	Ok(())
 }
 
 fn create_item_acceptor_flex(
-	_node: Arc<Node>,
+	_node: &Node,
 	calling_client: Arc<Client>,
 	message: Message,
 ) -> Result<()> {
@@ -486,21 +438,19 @@ fn create_item_acceptor_flex(
 		item_type: &'a str,
 	}
 	let info: CreateItemAcceptorInfo = deserialize(message.as_ref())?;
-	let space = calling_client
+	let space = find_spatial_parent(&calling_client, info.parent_path)?;
-		.get_node("Reference space", info.parent_path)?
-		.get_aspect::<Spatial>()?;
 	let transform = parse_transform(info.transform, true, true, false);
 	let field = find_field(&calling_client, info.field_path)?;
 	let type_info = type_info(info.item_type)?;
 
-	let node = Node::create_parent_name(
+	let node = Node::create(
 		&calling_client,
 		&format!("/item/{}/acceptor", type_info.type_name),
 		info.name,
 		true,
 	)
 	.add_to_scenegraph()?;
-	Spatial::add_to(&node, Some(space.clone()), transform, false);
+	Spatial::add_to(&node, Some(space), transform, false)?;
 	ItemAcceptor::add_to(&node, type_info, field);
 	Ok(())
 }

src/nodes/items/panel.rs

@@ -4,13 +4,13 @@ use crate::{
 		registry::Registry,
 	},
 	nodes::{
-		drawable::model::ModelPart,
+		drawable::{model::ModelPart, Drawable},
 		items::{Item, ItemType, TypeInfo},
 		spatial::Spatial,
 		Message, Node,
 	},
 };
-use color_eyre::eyre::{eyre, Result};
+use color_eyre::eyre::{bail, eyre, Result};
 use glam::Mat4;
 use lazy_static::lazy_static;
 use mint::Vector2;
@@ -23,7 +23,7 @@ use serde::{
 };
 use stardust_xr::schemas::flex::{deserialize, serialize};
 use std::sync::{Arc, Weak};
-use tracing::{debug, info};
+use tracing::debug;
 
 lazy_static! {
 	pub static ref ITEM_TYPE_INFO_PANEL: TypeInfo = TypeInfo {
@@ -95,8 +95,8 @@ impl<'de> Visitor<'de> for SurfaceIDVisitor {
 
 	fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
 		let Some(discrim) = seq.next_element()? else {
-			return Err(A::Error::missing_field("discrim"));
+            return Err(A::Error::missing_field("discrim"));
-		};
+        };
 
 		// idk if you wanna check for extraneous elements
 		// I didn't bother
@@ -106,8 +106,8 @@ impl<'de> Visitor<'de> for SurfaceIDVisitor {
 			"Toplevel" => Ok(SurfaceID::Toplevel),
 			"Child" => {
 				let Some(text) = seq.next_element()? else {
-					return Err(A::Error::missing_field("child_text"));
+                    return Err(A::Error::missing_field("child_text"));
-				};
+                };
 				Ok(SurfaceID::Child(text))
 			}
 			_ => Err(A::Error::unknown_variant(
@@ -203,9 +203,7 @@ pub trait Backend: Send + Sync + 'static {
 }
 
 pub fn panel_item_from_node(node: &Node) -> Option<Arc<dyn PanelItemTrait>> {
-	let ItemType::Panel(panel_item) = &node.get_aspect::<Item>().ok()?.specialization else {
+	let ItemType::Panel(panel_item) = &node.item.get()?.specialization else {return None};
-		return None;
-	};
 	Some(panel_item.clone())
 }
 
@@ -220,7 +218,7 @@ pub struct PanelItem<B: Backend + ?Sized> {
 	pub backend: Box<B>,
 }
 impl<B: Backend + ?Sized> PanelItem<B> {
-	pub fn create(backend: Box<B>, pid: Option<i32>) -> (Arc<Node>, Arc<PanelItem<B>>) {
+	pub fn create(backend: Box<B>, pid: Option<i32>) -> Arc<PanelItem<B>> {
 		debug!(?pid, "Create panel item");
 
 		let startup_settings = pid
@@ -228,13 +226,10 @@ impl<B: Backend + ?Sized> PanelItem<B> {
 			.and_then(|env| state(&env));
 
 		let uid = nanoid!();
-		let node = Arc::new(Node::create_parent_name(
+		let node = Node::create(&INTERNAL_CLIENT, "/item/panel/item", &uid, true)
-			&INTERNAL_CLIENT,
+			.add_to_scenegraph()
-			"/item/panel/item",
+			.unwrap();
-			&uid,
+		let spatial = Spatial::add_to(&node, None, Mat4::IDENTITY, false).unwrap();
-			true,
-		));
-		let spatial = Spatial::add_to(&node, None, Mat4::IDENTITY, false);
 		if let Some(startup_settings) = &startup_settings {
 			spatial.set_local_transform(startup_settings.root);
 		}
@@ -256,7 +251,10 @@ impl<B: Backend + ?Sized> PanelItem<B> {
 		node.add_local_signal("apply_surface_material", Self::apply_surface_material_flex);
 		node.add_local_signal("close_toplevel", Self::close_toplevel_flex);
 		node.add_local_signal("auto_size_toplevel", Self::auto_size_toplevel_flex);
-		node.add_local_signal("set_toplevel_size", Self::set_toplevel_size_flex);
+		node.add_local_signal(
+			"set_toplevel_size_changed",
+			Self::set_toplevel_size_changed_flex,
+		);
 
 		node.add_local_signal("pointer_motion", Self::pointer_motion_flex);
 		node.add_local_signal("pointer_button", Self::pointer_button_flex);
@@ -269,12 +267,10 @@ impl<B: Backend + ?Sized> PanelItem<B> {
 		node.add_local_signal("touch_up", Self::touch_up_flex);
 		node.add_local_signal("reset_touches", Self::reset_touches_flex);
 
-		(node, panel_item)
+		panel_item
 	}
 	pub fn drop_toplevel(&self) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		node.destroy();
 	}
 }
@@ -282,88 +278,60 @@ impl<B: Backend + ?Sized> PanelItem<B> {
 // Remote signals
 impl<B: Backend + ?Sized> PanelItem<B> {
 	pub fn toplevel_parent_changed(&self, parent: &str) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("toplevel_parent_changed", serialize(parent).unwrap());
 	}
 	pub fn toplevel_title_changed(&self, title: &str) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("toplevel_title_changed", serialize(title).unwrap());
 	}
 	pub fn toplevel_app_id_changed(&self, app_id: &str) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("toplevel_app_id_changed", serialize(app_id).unwrap());
 	}
 	pub fn toplevel_fullscreen_active(&self, active: bool) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("toplevel_fullscreen_active", serialize(active).unwrap());
 	}
 	pub fn toplevel_move_request(&self) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("toplevel_move_request", Vec::<u8>::new());
 	}
 	pub fn toplevel_resize_request(&self, up: bool, down: bool, left: bool, right: bool) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		let _ = node.send_remote_signal(
 			"toplevel_resize_request",
 			serialize((up, down, left, right)).unwrap(),
 		);
 	}
 	pub fn toplevel_size_changed(&self, size: Vector2<u32>) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("toplevel_size_changed", serialize(size).unwrap());
 	}
 
 	pub fn set_cursor(&self, geometry: Option<Geometry>) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("set_cursor", serialize(geometry).unwrap());
 	}
 
 	pub fn new_child(&self, uid: &str, info: ChildInfo) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("new_child", serialize((uid, info)).unwrap());
 	}
 	pub fn reposition_child(&self, uid: &str, geometry: Geometry) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("reposition_child", serialize((uid, geometry)).unwrap());
 	}
 	pub fn drop_child(&self, uid: &str) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 		let _ = node.send_remote_signal("drop_child", serialize(uid).unwrap());
 	}
 }
 // Local signals
 macro_rules! flex_no_args {
 	($fn_name: ident, $trait_fn: ident) => {
-		fn $fn_name(
+		fn $fn_name(node: &Node, _calling_client: Arc<Client>, _message: Message) -> Result<()> {
-			node: Arc<Node>,
+			let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
-			_calling_client: Arc<Client>,
-			_message: Message,
-		) -> Result<()> {
-			let Some(panel_item) = panel_item_from_node(&node) else {
-				return Ok(());
-			};
 			panel_item.$trait_fn();
 			Ok(())
 		}
@@ -371,10 +339,8 @@ macro_rules! flex_no_args {
 }
 macro_rules! flex_deserialize {
 	($fn_name: ident, $trait_fn: ident) => {
-		fn $fn_name(node: Arc<Node>, _calling_client: Arc<Client>, message: Message) -> Result<()> {
+		fn $fn_name(node: &Node, _calling_client: Arc<Client>, message: Message) -> Result<()> {
-			let Some(panel_item) = panel_item_from_node(&node) else {
+			let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
-				return Ok(());
-			};
 			panel_item.$trait_fn(deserialize(message.as_ref())?);
 			Ok(())
 		}
@@ -382,13 +348,11 @@ macro_rules! flex_deserialize {
 }
 impl<B: Backend + ?Sized> PanelItem<B> {
 	fn apply_surface_material_flex(
-		node: Arc<Node>,
+		node: &Node,
 		calling_client: Arc<Client>,
 		message: Message,
 	) -> Result<()> {
-		let Some(panel_item) = panel_item_from_node(&node) else {
+		let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
-			return Ok(());
-		};
 
 		#[derive(Debug, Deserialize)]
 		struct SurfaceMaterialInfo<'a> {
@@ -402,26 +366,24 @@ impl<B: Backend + ?Sized> PanelItem<B> {
 			.scenegraph
 			.get_node(info.model_node_path)
 			.ok_or_else(|| eyre!("Model node not found"))?;
-		let model_part = model_node.get_aspect::<ModelPart>()?;
+		let Some(Drawable::ModelPart(model_part)) = model_node.drawable.get() else {bail!("Node is not a model")};
 		debug!(?info, "Apply surface material");
 
-		panel_item.apply_surface_material(info.surface, &model_part);
+		panel_item.apply_surface_material(info.surface, model_part);
 
 		Ok(())
 	}
 
 	flex_no_args!(close_toplevel_flex, close_toplevel);
 	flex_no_args!(auto_size_toplevel_flex, auto_size_toplevel);
-	flex_deserialize!(set_toplevel_size_flex, set_toplevel_size);
+	flex_deserialize!(set_toplevel_size_changed_flex, set_toplevel_size);
 
 	fn pointer_motion_flex(
-		node: Arc<Node>,
+		node: &Node,
 		_calling_client: Arc<Client>,
 		message: Message,
 	) -> Result<()> {
-		let Some(panel_item) = panel_item_from_node(&node) else {
+		let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
-			return Ok(());
-		};
 
 		let (surface_id, position): (SurfaceID, Vector2<f32>) = deserialize(message.as_ref())?;
 		debug!(?surface_id, ?position, "Pointer deactivate");
@@ -431,13 +393,11 @@ impl<B: Backend + ?Sized> PanelItem<B> {
 		Ok(())
 	}
 	fn pointer_button_flex(
-		node: Arc<Node>,
+		node: &Node,
 		_calling_client: Arc<Client>,
 		message: Message,
 	) -> Result<()> {
-		let Some(panel_item) = panel_item_from_node(&node) else {
+		let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
-			return Ok(());
-		};
 
 		let (surface_id, button, state): (SurfaceID, u32, u32) = deserialize(message.as_ref())?;
 		debug!(?surface_id, button, state, "Pointer button");
@@ -446,13 +406,11 @@ impl<B: Backend + ?Sized> PanelItem<B> {
 		Ok(())
 	}
 	fn pointer_scroll_flex(
-		node: Arc<Node>,
+		node: &Node,
 		_calling_client: Arc<Client>,
 		message: Message,
 	) -> Result<()> {
-		let Some(panel_item) = panel_item_from_node(&node) else {
+		let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
-			return Ok(());
-		};
 
 		#[derive(Debug, Deserialize)]
 		struct PointerScrollInfo {
@@ -469,13 +427,11 @@ impl<B: Backend + ?Sized> PanelItem<B> {
 	}
 
 	fn keyboard_keys_flex(
-		node: Arc<Node>,
+		node: &Node,
 		_calling_client: Arc<Client>,
 		message: Message,
 	) -> Result<()> {
-		let Some(panel_item) = panel_item_from_node(&node) else {
+		let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
-			return Ok(());
-		};
 		let (surface_id, keymap_id, keys): (SurfaceID, &str, Vec<i32>) =
 			deserialize(message.as_ref())?;
 		debug!(?keys, "Set keyboard key state");
@@ -485,22 +441,14 @@ impl<B: Backend + ?Sized> PanelItem<B> {
 		Ok(())
 	}
 	pub fn grab_keyboard(&self, sid: Option<SurfaceID>) {
-		let Some(node) = self.node.upgrade() else {
+		let Some(node) = self.node.upgrade() else {return};
-			return;
-		};
 
-		let Ok(message) = serialize(sid) else { return };
+		let Ok(message) = serialize(sid) else {return};
 		let _ = node.send_remote_signal("grab_keyboard", message);
 	}
 
-	fn touch_down_flex(
+	fn touch_down_flex(node: &Node, _calling_client: Arc<Client>, message: Message) -> Result<()> {
-		node: Arc<Node>,
+		let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
-		_calling_client: Arc<Client>,
-		message: Message,
-	) -> Result<()> {
-		let Some(panel_item) = panel_item_from_node(&node) else {
-			return Ok(());
-		};
 
 		let (surface_id, id, position): (SurfaceID, u32, Vector2<f32>) =
 			deserialize(message.as_ref())?;
@@ -510,14 +458,8 @@ impl<B: Backend + ?Sized> PanelItem<B> {
 
 		Ok(())
 	}
-	fn touch_move_flex(
+	fn touch_move_flex(node: &Node, _calling_client: Arc<Client>, message: Message) -> Result<()> {
-		node: Arc<Node>,
+		let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
-		_calling_client: Arc<Client>,
-		message: Message,
-	) -> Result<()> {
-		let Some(panel_item) = panel_item_from_node(&node) else {
-			return Ok(());
-		};
 
 		let (id, position): (u32, Vector2<f32>) = deserialize(message.as_ref())?;
 		debug!(?position, "Touch move");
@@ -596,6 +538,5 @@ impl<B: Backend + ?Sized> Backend for PanelItem<B> {
 impl<B: Backend + ?Sized> Drop for PanelItem<B> {
 	fn drop(&mut self) {
 		// Dropped panel item, basically just a debug breakpoint place
-		info!("Dropped panel item {}", self.uid);
 	}
 }

src/nodes/mod.rs

@@ -11,15 +11,15 @@ pub mod spatial;
 
 use color_eyre::eyre::{eyre, Result};
 use nanoid::nanoid;
+use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use portable_atomic::{AtomicBool, Ordering};
 use rustc_hash::FxHashMap;
-use serde::{de::DeserializeOwned, Serialize};
 use stardust_xr::messenger::MessageSenderHandle;
 use stardust_xr::scenegraph::ScenegraphError;
-use stardust_xr::schemas::flex::{deserialize, serialize};
+use stardust_xr::schemas::flex::deserialize;
-use std::any::{Any, TypeId};
 use std::fmt::Debug;
+use std::future::Future;
 use std::os::fd::OwnedFd;
 use std::sync::{Arc, Weak};
 use std::vec::Vec;
@@ -29,6 +29,14 @@ use crate::core::registry::Registry;
 use crate::core::scenegraph::MethodResponseSender;
 
 use self::alias::Alias;
+use self::audio::Sound;
+use self::data::{PulseReceiver, PulseSender};
+use self::drawable::Drawable;
+use self::fields::Field;
+use self::input::{InputHandler, InputMethod};
+use self::items::{Item, ItemAcceptor, ItemUI};
+use self::spatial::zone::Zone;
+use self::spatial::Spatial;
 
 #[derive(Default)]
 pub struct Message {
@@ -49,10 +57,8 @@ impl AsRef<[u8]> for Message {
 	}
 }
 
-pub type Signal = fn(Arc<Node>, Arc<Client>, Message) -> Result<()>;
+pub type Signal = fn(&Node, Arc<Client>, Message) -> Result<()>;
-pub type Method = fn(Arc<Node>, Arc<Client>, Message, MethodResponseSender);
+pub type Method = fn(&Node, Arc<Client>, Message, MethodResponseSender);
-
-stardust_xr_server_codegen::codegen_node_protocol!();
 
 pub struct Node {
 	pub enabled: Arc<AtomicBool>,
@@ -63,10 +69,35 @@ pub struct Node {
 	// trailing_slash_pos: usize,
 	local_signals: Mutex<FxHashMap<String, Signal>>,
 	local_methods: Mutex<FxHashMap<String, Method>>,
-	aliases: Registry<Alias>,
-	aspects: Aspects,
 	destroyable: bool,
+
+	pub alias: OnceCell<Arc<Alias>>,
+	aliases: Registry<Alias>,
+
+	pub spatial: OnceCell<Arc<Spatial>>,
+	pub field: OnceCell<Arc<Field>>,
+	pub zone: OnceCell<Arc<Zone>>,
+
+	// Data
+	pub pulse_sender: OnceCell<Arc<PulseSender>>,
+	pub pulse_receiver: OnceCell<Arc<PulseReceiver>>,
+
+	// Drawable
+	pub drawable: OnceCell<Drawable>,
+
+	// Input
+	pub input_method: OnceCell<Arc<InputMethod>>,
+	pub input_handler: OnceCell<Arc<InputHandler>>,
+
+	// Item
+	pub item: OnceCell<Arc<Item>>,
+	pub item_acceptor: OnceCell<Arc<ItemAcceptor>>,
+	pub item_ui: OnceCell<Arc<ItemUI>>,
+
+	// Sound
+	pub sound: OnceCell<Arc<Sound>>,
 }
+
 impl Node {
 	pub fn get_client(&self) -> Option<Arc<Client>> {
 		self.client.upgrade()
@@ -78,32 +109,39 @@ impl Node {
 		self.path.as_str()
 	}
 
-	pub fn create_parent_name(
+	pub fn create(client: &Arc<Client>, parent: &str, name: &str, destroyable: bool) -> Self {
-		client: &Arc<Client>,
-		parent: &str,
-		name: &str,
-		destroyable: bool,
-	) -> Self {
 		let mut path = parent.to_string();
 		path.push('/');
 		path.push_str(name);
-		Self::create_path(client, path, destroyable)
-	}
-	pub fn create_path(client: &Arc<Client>, path: impl ToString, destroyable: bool) -> Self {
 		let node = Node {
 			enabled: Arc::new(AtomicBool::new(true)),
 			uid: nanoid!(),
 			client: Arc::downgrade(client),
 			message_sender_handle: client.message_sender_handle.clone(),
-			path: path.to_string(),
+			path,
 			// trailing_slash_pos: parent.len(),
 			local_signals: Default::default(),
 			local_methods: Default::default(),
-			aliases: Default::default(),
-			aspects: Default::default(),
 			destroyable,
+
+			alias: OnceCell::new(),
+			aliases: Registry::new(),
+
+			spatial: OnceCell::new(),
+			field: OnceCell::new(),
+			zone: OnceCell::new(),
+			pulse_sender: OnceCell::new(),
+			pulse_receiver: OnceCell::new(),
+			drawable: OnceCell::new(),
+			input_method: OnceCell::new(),
+			input_handler: OnceCell::new(),
+			item: OnceCell::new(),
+			item_acceptor: OnceCell::new(),
+			item_ui: OnceCell::new(),
+			sound: OnceCell::new(),
 		};
-		<Node as NodeAspect>::add_node_members(&node);
+		node.add_local_signal("set_enabled", Node::set_enabled_flex);
+		node.add_local_signal("destroy", Node::destroy_flex);
 		node
 	}
 	pub fn add_to_scenegraph(self) -> Result<Arc<Node>> {
@@ -119,9 +157,18 @@ impl Node {
 		}
 	}
 
+	pub fn set_enabled_flex(
+		node: &Node,
+		_calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		node.enabled
+			.store(deserialize(message.as_ref())?, Ordering::Relaxed);
+		Ok(())
+	}
 	// very much up for debate if we should allow this, as you can match objects using this
 	// pub fn get_client_pid_flex(
-	// 	node: Arc<Node>,
+	// 	node: &Node,
 	// 	_calling_client: Arc<Client>,
 	// 	_message: Message,
 	// ) -> Result<Message> {
@@ -132,6 +179,16 @@ impl Node {
 	// 	let pid = client.pid.ok_or_else(|| eyre!("Client PID is unknown"))?;
 	// 	Ok(serialize(pid)?.into())
 	// }
+	pub fn destroy_flex(
+		node: &Node,
+		_calling_client: Arc<Client>,
+		_message: Message,
+	) -> Result<()> {
+		if node.destroyable {
+			node.destroy();
+		}
+		Ok(())
+	}
 
 	pub fn add_local_signal(&self, name: &str, signal: Signal) {
 		self.local_signals.lock().insert(name.to_string(), signal);
@@ -140,23 +197,27 @@ impl Node {
 		self.local_methods.lock().insert(name.to_string(), method);
 	}
 
-	pub fn add_aspect<A: Aspect>(&self, aspect: A) -> Arc<A> {
+	pub fn get_aspect<F, T>(
-		self.aspects.add(aspect)
+		&self,
-	}
+		node_name: &'static str,
-	pub fn add_aspect_raw<A: Aspect>(&self, aspect: Arc<A>) {
+		aspect_type: &'static str,
-		self.aspects.add_raw(aspect)
+		aspect_fn: F,
-	}
+	) -> Result<&T>
-	pub fn get_aspect<A: Aspect>(&self) -> Result<Arc<A>> {
+	where
-		self.aspects.get()
+		F: FnOnce(&Node) -> &OnceCell<T>,
+	{
+		aspect_fn(self)
+			.get()
+			.ok_or_else(|| eyre!("{} is not a {} node", node_name, aspect_type))
 	}
 
 	pub fn send_local_signal(
-		self: Arc<Self>,
+		&self,
 		calling_client: Arc<Client>,
 		method: &str,
 		message: Message,
 	) -> Result<(), ScenegraphError> {
-		if let Ok(alias) = self.get_aspect::<Alias>() {
+		if let Some(alias) = self.alias.get() {
 			if !alias.info.server_signals.iter().any(|e| e == &method) {
 				return Err(ScenegraphError::SignalNotFound);
 			}
@@ -178,13 +239,13 @@ impl Node {
 		}
 	}
 	pub fn execute_local_method(
-		self: Arc<Self>,
+		&self,
 		calling_client: Arc<Client>,
 		method: &str,
 		message: Message,
 		response: MethodResponseSender,
 	) {
-		if let Ok(alias) = self.get_aspect::<Alias>() {
+		if let Some(alias) = self.alias.get() {
 			if !alias.info.server_methods.iter().any(|e| e == &method) {
 				response.send(Err(ScenegraphError::MethodNotFound));
 				return;
@@ -234,26 +295,29 @@ impl Node {
 		}
 		Ok(())
 	}
-	pub async fn execute_remote_method_typed<S: Serialize, D: DeserializeOwned>(
+	pub fn execute_remote_method(
 		&self,
 		method: &str,
-		input: S,
+		message: impl Into<Message>,
-		fds: Vec<OwnedFd>,
+	) -> Result<impl Future<Output = Result<Message>>> {
-	) -> Result<(D, Vec<OwnedFd>)> {
+		let message = message.into();
 		let message_sender_handle = self
 			.message_sender_handle
 			.as_ref()
 			.ok_or(eyre!("Messenger does not exist for this node"))?;
 
-		let serialized = serialize(input)?;
+		let future =
-		let result = message_sender_handle
+			message_sender_handle.method(self.path.as_str(), method, &message.data, message.fds)?;
-			.method(self.path.as_str(), method, &serialized, fds)?
-			.await
-			.map_err(|e| eyre!(e))?;
 
-		let (message, fds) = result.into_components();
+		Ok(async {
-		let deserialized: D = deserialize(&message)?;
+			match future.await {
-		Ok((deserialized, fds))
+				Ok(m) => {
+					let (data, fds) = m.into_components();
+					Ok(Message { data, fds })
+				}
+				Err(e) => Err(eyre!(e)),
+			}
+		})
 	}
 }
 impl Debug for Node {
@@ -264,54 +328,8 @@ impl Debug for Node {
 			.finish()
 	}
 }
-impl NodeAspect for Node {
-	fn set_enabled(node: Arc<Node>, _calling_client: Arc<Client>, enabled: bool) -> Result<()> {
-		node.enabled.store(enabled, Ordering::Relaxed);
-		Ok(())
-	}
-
-	fn destroy(node: Arc<Node>, _calling_client: Arc<Client>) -> Result<()> {
-		if node.destroyable {
-			node.destroy();
-		}
-		Ok(())
-	}
-}
 impl Drop for Node {
 	fn drop(&mut self) {
 		// Debug breakpoint
 	}
 }
-
-pub trait Aspect: Any + Send + Sync + 'static {
-	const NAME: &'static str;
-}
-
-#[derive(Default)]
-struct Aspects(Mutex<FxHashMap<TypeId, Arc<dyn Any + Send + Sync + 'static>>>);
-impl Aspects {
-	fn add<A: Aspect>(&self, t: A) -> Arc<A> {
-		let aspect = Arc::new(t);
-		self.add_raw(aspect.clone());
-		aspect
-	}
-	fn add_raw<A: Aspect>(&self, aspect: Arc<A>) {
-		self.0.lock().insert(Self::type_key::<A>(), aspect);
-	}
-	fn get<A: Aspect + Any + Send + Sync + 'static>(&self) -> Result<Arc<A>> {
-		self.0
-			.lock()
-			.get(&Self::type_key::<A>())
-			.and_then(|a| Arc::downcast(a.clone()).ok())
-			.ok_or(eyre!("Couldn't get aspect {}", A::NAME.to_lowercase()))
-	}
-
-	fn type_key<A: 'static>() -> TypeId {
-		TypeId::of::<A>()
-	}
-}
-impl Drop for Aspects {
-	fn drop(&mut self) {
-		self.0.lock().clear()
-	}
-}

src/nodes/root.rs

@@ -4,18 +4,17 @@ use crate::core::client::Client;
 use crate::core::client_state::{ClientState, ClientStateInternal};
 use crate::core::registry::Registry;
 use crate::core::scenegraph::MethodResponseSender;
-#[cfg(feature = "wayland")]
 use crate::wayland::WAYLAND_DISPLAY;
-#[cfg(feature = "xwayland")]
-use crate::wayland::X_DISPLAY;
 use crate::STARDUST_INSTANCE;
 use color_eyre::eyre::Result;
 use glam::Mat4;
 use rustc_hash::FxHashMap;
 use stardust_xr::schemas::flex::{deserialize, serialize};
+use tracing::instrument;
+
+use std::future::Future;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
-use tracing::instrument;
 
 static ROOT_REGISTRY: Registry<Root> = Registry::new();
 
@@ -25,7 +24,7 @@ pub struct Root {
 }
 impl Root {
 	pub fn create(client: &Arc<Client>) -> Result<Arc<Self>> {
-		let node = Node::create_parent_name(client, "", "", false);
+		let node = Node::create(client, "", "", false);
 		node.add_local_signal("subscribe_frame", Root::subscribe_frame_flex);
 		node.add_local_signal("set_base_prefixes", Root::set_base_prefixes_flex);
 		node.add_local_method("state_token", Root::state_token_flex);
@@ -43,7 +42,7 @@ impl Root {
 	}
 
 	fn subscribe_frame_flex(
-		_node: Arc<Node>,
+		_node: &Node,
 		calling_client: Arc<Client>,
 		_message: Message,
 	) -> Result<()> {
@@ -68,7 +67,7 @@ impl Root {
 	}
 
 	fn set_base_prefixes_flex(
-		_node: Arc<Node>,
+		_node: &Node,
 		calling_client: Arc<Client>,
 		message: Message,
 	) -> Result<()> {
@@ -77,7 +76,7 @@ impl Root {
 	}
 
 	fn state_token_flex(
-		_node: Arc<Node>,
+		_node: &Node,
 		calling_client: Arc<Client>,
 		message: Message,
 		response: MethodResponseSender,
@@ -90,15 +89,15 @@ impl Root {
 	}
 
 	pub fn set_transform(&self, transform: Mat4) {
-		let spatial = self.node.get_aspect::<Spatial>().unwrap();
+		let spatial = self.node.spatial.get().unwrap();
 		spatial.set_spatial_parent(None).unwrap();
 		spatial.set_local_transform(transform);
 	}
-	pub async fn save_state(&self) -> Result<ClientStateInternal> {
+	pub fn save_state(&self) -> impl Future<Output = Result<ClientStateInternal>> {
-		self.node
+		let future = self
-			.execute_remote_method_typed("save_state", (), Vec::new())
+			.node
-			.await
+			.execute_remote_method("save_state", Message::default());
-			.map(|(m, _)| m)
+		async move { Ok(deserialize(&future?.await?.data)?) }
 	}
 }
 
@@ -114,7 +113,7 @@ macro_rules! var_env_insert {
 	};
 }
 pub fn get_connection_environment_flex(
-	_node: Arc<Node>,
+	_node: &Node,
 	_calling_client: Arc<Client>,
 	_message: Message,
 	response: MethodResponseSender,
@@ -126,10 +125,7 @@ pub fn get_connection_environment_flex(
 		{
 			var_env_insert!(env, WAYLAND_DISPLAY);
 			#[cfg(feature = "xwayland")]
-			env.insert(
+			var_env_insert!(env, DISPLAY);
-				"DISPLAY".to_string(),
-				format!(":{}", X_DISPLAY.get().unwrap()),
-			);
 			env.insert("GDK_BACKEND".to_string(), "wayland".to_string());
 			env.insert("QT_QPA_PLATFORM".to_string(), "wayland".to_string());
 			env.insert("MOZ_ENABLE_WAYLAND".to_string(), "1".to_string());

src/nodes/spatial/mod.rs

@@ -1,66 +1,49 @@
 pub mod zone;
 
-use self::zone::Zone;
+use self::zone::{create_zone_flex, Zone};
-use super::fields::Field;
+use super::{Message, Node};
-use super::{Aspect, Node};
 use crate::core::client::Client;
 use crate::core::registry::Registry;
-use crate::create_interface;
+use crate::core::scenegraph::MethodResponseSender;
-use color_eyre::eyre::{eyre, Result};
+use color_eyre::eyre::{ensure, eyre, Result};
 use glam::{vec3a, Mat4, Quat};
 use mint::Vector3;
 use nanoid::nanoid;
-use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
+use serde::Deserialize;
+use stardust_xr::schemas::flex::{deserialize, serialize};
+use stardust_xr::values::Transform;
 use std::fmt::Debug;
 use std::ptr;
-use std::sync::{Arc, Weak};
+use std::sync::{Arc, OnceLock, Weak};
 use stereokit::{bounds_grow_to_fit_box, Bounds};
 
-stardust_xr_server_codegen::codegen_spatial_protocol!();
-impl Transform {
-	pub fn to_mat4(self, position: bool, rotation: bool, scale: bool) -> Mat4 {
-		let position = position
-			.then_some(self.translation)
-			.flatten()
-			.unwrap_or_else(|| Vector3::from([0.0; 3]));
-		let rotation = rotation
-			.then_some(self.rotation)
-			.flatten()
-			.unwrap_or_else(|| Quat::IDENTITY.into());
-		let scale = scale
-			.then_some(self.scale)
-			.flatten()
-			.unwrap_or_else(|| Vector3::from([1.0; 3]));
-
-		Mat4::from_scale_rotation_translation(scale.into(), rotation.into(), position.into())
-	}
-}
-
 static ZONEABLE_REGISTRY: Registry<Spatial> = Registry::new();
 
 pub struct Spatial {
 	uid: String,
 	pub(super) node: Weak<Node>,
+	self_ref: Weak<Spatial>,
 	parent: Mutex<Option<Arc<Spatial>>>,
 	old_parent: Mutex<Option<Arc<Spatial>>>,
 	pub(super) transform: Mutex<Mat4>,
 	zone: Mutex<Weak<Zone>>,
 	children: Registry<Spatial>,
-	pub(super) bounding_box_calc: OnceCell<fn(&Node) -> Bounds>,
+	pub(super) bounding_box_calc: OnceLock<fn(&Node) -> Bounds>,
 }
 
 impl Spatial {
 	pub fn new(node: Weak<Node>, parent: Option<Arc<Spatial>>, transform: Mat4) -> Arc<Self> {
-		Arc::new(Spatial {
+		Arc::new_cyclic(|self_ref| Spatial {
 			uid: nanoid!(),
 			node,
+			self_ref: self_ref.clone(),
 			parent: Mutex::new(parent),
 			old_parent: Mutex::new(None),
 			transform: Mutex::new(transform),
 			zone: Mutex::new(Weak::new()),
 			children: Registry::new(),
-			bounding_box_calc: OnceCell::default(),
+			bounding_box_calc: OnceLock::default(),
 		})
 	}
 	pub fn add_to(
@@ -68,18 +51,29 @@ impl Spatial {
 		parent: Option<Arc<Spatial>>,
 		transform: Mat4,
 		zoneable: bool,
-	) -> Arc<Spatial> {
+	) -> Result<Arc<Spatial>> {
-		let spatial = Spatial::new(Arc::downgrade(node), parent.clone(), transform);
+		ensure!(
-		<Spatial as SpatialAspect>::add_node_members(node);
+			node.spatial.get().is_none(),
+			"Internal: Node already has a Spatial aspect!"
+		);
+		let spatial = Spatial::new(Arc::downgrade(node), parent, transform);
+		node.add_local_method("get_bounding_box", Spatial::get_bounding_box_flex);
+		node.add_local_method("get_transform", Spatial::get_transform_flex);
+		node.add_local_signal("set_transform", Spatial::set_transform_flex);
+		node.add_local_signal("set_spatial_parent", Spatial::set_spatial_parent_flex);
+		node.add_local_signal(
+			"set_spatial_parent_in_place",
+			Spatial::set_spatial_parent_in_place_flex,
+		);
+		node.add_local_signal("set_zoneable", Spatial::set_zoneable_flex);
+		node.add_local_method("field_distance", Spatial::field_distance_flex);
+		node.add_local_method("field_normal", Spatial::field_normal_flex);
+		node.add_local_method("field_closest_point", Spatial::field_closest_point_flex);
 		if zoneable {
 			ZONEABLE_REGISTRY.add_raw(&spatial);
 		}
-		if let Some(parent) = parent {
+		let _ = node.spatial.set(spatial.clone());
-			parent.children.add_raw(&spatial);
+		Ok(spatial)
-		}
-		<Spatial as SpatialAspect>::add_node_members(node);
-		node.add_aspect_raw(spatial.clone());
-		spatial
 	}
 
 	pub fn node(&self) -> Option<Arc<Node>> {
@@ -94,9 +88,7 @@ impl Spatial {
 
 	// the output bounds are probably way bigger than they need to be
 	pub fn get_bounding_box(&self) -> Bounds {
-		let Some(node) = self.node() else {
+		let Some(node) = self.node() else {return Bounds::default()};
-			return Bounds::default();
-		};
 		let mut bounds = self
 			.bounding_box_calc
 			.get()
@@ -116,12 +108,10 @@ impl Spatial {
 		*self.transform.lock()
 	}
 	pub fn global_transform(&self) -> Mat4 {
-		let parent_transform = self
+		match self.get_parent() {
-			.get_parent()
+			Some(value) => value.global_transform() * *self.transform.lock(),
-			.as_deref()
+			None => *self.transform.lock(),
-			.map(Self::global_transform)
+		}
-			.unwrap_or_default();
-		parent_transform * self.local_transform()
 	}
 	pub fn set_local_transform(&self, transform: Mat4) {
 		*self.transform.lock() = transform;
@@ -147,7 +137,7 @@ impl Spatial {
 		let (mut reference_space_scl, mut reference_space_rot, mut reference_space_pos) =
 			local_transform_in_reference_space.to_scale_rotation_translation();
 
-		if let Some(pos) = transform.translation {
+		if let Some(pos) = transform.position {
 			reference_space_pos = pos.into()
 		}
 		if let Some(rot) = transform.rotation {
@@ -187,21 +177,23 @@ impl Spatial {
 	fn get_parent(&self) -> Option<Arc<Spatial>> {
 		self.parent.lock().clone()
 	}
-	fn set_parent(self: &Arc<Self>, new_parent: Option<&Arc<Spatial>>) {
+	fn set_parent(&self, new_parent: Option<Arc<Spatial>>) {
 		if let Some(parent) = self.get_parent() {
-			parent.children.remove(&self);
+			parent.children.remove(self);
 		}
 		if let Some(new_parent) = &new_parent {
-			new_parent.children.add_raw(self);
+			new_parent
+				.children
+				.add_raw(&self.self_ref.upgrade().unwrap());
 		}
 
-		*self.parent.lock() = new_parent.cloned();
+		*self.parent.lock() = new_parent;
 	}
 
-	pub fn set_spatial_parent(self: &Arc<Self>, parent: Option<&Arc<Spatial>>) -> Result<()> {
+	pub fn set_spatial_parent(&self, parent: Option<Arc<Spatial>>) -> Result<()> {
 		let is_ancestor = parent
 			.as_ref()
-			.map(|parent| self.is_ancestor_of((*parent).clone()))
+			.map(|parent| self.is_ancestor_of(parent.clone()))
 			.unwrap_or(false);
 		if is_ancestor {
 			return Err(eyre!("Setting spatial parent would cause a loop"));
@@ -210,27 +202,232 @@ impl Spatial {
 
 		Ok(())
 	}
-	pub fn set_spatial_parent_in_place(
+
-		self: &Arc<Self>,
+	pub fn set_spatial_parent_in_place(&self, parent: Option<Arc<Spatial>>) -> Result<()> {
-		parent: Option<&Arc<Spatial>>,
-	) -> Result<()> {
 		let is_ancestor = parent
 			.as_ref()
-			.map(|parent| self.is_ancestor_of((*parent).clone()))
+			.map(|parent| self.is_ancestor_of(parent.clone()))
 			.unwrap_or(false);
 		if is_ancestor {
 			return Err(eyre!("Setting spatial parent would cause a loop"));
 		}
 
 		self.set_local_transform(Spatial::space_to_space_matrix(
-			Some(&self),
+			Some(self),
-			parent.map(AsRef::as_ref),
+			parent.as_deref(),
 		));
 		self.set_parent(parent);
 
 		Ok(())
 	}
 
+	pub fn get_bounding_box_flex(
+		node: &Node,
+		calling_client: Arc<Client>,
+		message: Message,
+		response: MethodResponseSender,
+	) {
+		response.wrap_sync(move || {
+			let this_spatial = node
+				.spatial
+				.get()
+				.ok_or_else(|| eyre!("Node doesn't have a spatial?"))?;
+			let relative_spatial_path: Option<&str> = deserialize(message.as_ref())?;
+			let bounds = if let Some(relative_spatial_path) = relative_spatial_path {
+				let relative_spatial =
+					find_reference_space(&calling_client, relative_spatial_path)?;
+				let center =
+					Spatial::space_to_space_matrix(Some(&this_spatial), Some(&relative_spatial))
+						.transform_point3([0.0; 3].into());
+				let bounds: Bounds = Bounds {
+					center,
+					dimensions: [0.0; 3].into(),
+				};
+				bounds_grow_to_fit_box(
+					bounds,
+					this_spatial.get_bounding_box(),
+					Some(Spatial::space_to_space_matrix(
+						Some(&this_spatial),
+						Some(&relative_spatial),
+					)),
+				)
+			} else {
+				this_spatial.get_bounding_box()
+			};
+
+			Ok(serialize((
+				mint::Vector3::from(bounds.center),
+				mint::Vector3::from(bounds.dimensions),
+			))?
+			.into())
+		});
+	}
+
+	pub fn get_transform_flex(
+		node: &Node,
+		calling_client: Arc<Client>,
+		message: Message,
+		response: MethodResponseSender,
+	) {
+		response.wrap_sync(move || {
+			let this_spatial = node
+				.spatial
+				.get()
+				.ok_or_else(|| eyre!("Node doesn't have a spatial?"))?;
+			let relative_spatial =
+				find_reference_space(&calling_client, deserialize(message.as_ref())?)?;
+
+			let (scale, rotation, position) = Spatial::space_to_space_matrix(
+				Some(this_spatial.as_ref()),
+				Some(relative_spatial.as_ref()),
+			)
+			.to_scale_rotation_translation();
+
+			Ok(serialize((
+				mint::Vector3::from(position),
+				mint::Quaternion::from(rotation),
+				mint::Vector3::from(scale),
+			))?
+			.into())
+		});
+	}
+	pub fn set_transform_flex(
+		node: &Node,
+		calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		#[derive(Deserialize)]
+		struct TransformArgs<'a> {
+			reference_space_path: Option<&'a str>,
+			transform: Transform,
+		}
+		let transform_args: TransformArgs = deserialize(message.as_ref())?;
+		let reference_space_transform = transform_args
+			.reference_space_path
+			.map(|path| find_reference_space(&calling_client, path))
+			.transpose()?;
+
+		node.spatial.get().unwrap().set_local_transform_components(
+			reference_space_transform.as_deref(),
+			transform_args.transform,
+		);
+		Ok(())
+	}
+	pub fn set_spatial_parent_flex(
+		node: &Node,
+		calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		let parent = find_spatial_parent(&calling_client, deserialize(message.as_ref())?)?;
+		node.spatial.get().unwrap().set_spatial_parent(Some(parent))
+	}
+	pub fn set_spatial_parent_in_place_flex(
+		node: &Node,
+		calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		let parent = find_spatial_parent(&calling_client, deserialize(message.as_ref())?)?;
+		node.spatial
+			.get()
+			.unwrap()
+			.set_spatial_parent_in_place(Some(parent))?;
+		Ok(())
+	}
+	pub fn set_zoneable_flex(
+		node: &Node,
+		_calling_client: Arc<Client>,
+		message: Message,
+	) -> Result<()> {
+		let zoneable: bool = deserialize(message.as_ref())?;
+		let spatial = node.spatial.get().unwrap();
+		if zoneable {
+			ZONEABLE_REGISTRY.add_raw(spatial);
+		} else {
+			ZONEABLE_REGISTRY.remove(spatial);
+			zone::release(spatial);
+		}
+		Ok(())
+	}
+
+	pub fn field_distance_flex(
+		node: &Node,
+		calling_client: Arc<Client>,
+		message: Message,
+		response: MethodResponseSender,
+	) {
+		response.wrap_sync(move || {
+			let (point, fields): (Vector3<f32>, Vec<Option<&str>>) = deserialize(message.as_ref())?;
+			let spatial = node.spatial.get().unwrap();
+
+			let output = fields
+				.into_iter()
+				.map(|f| {
+					calling_client
+						.get_node("Field", f?)
+						.ok()?
+						.get_aspect("Field", "field", |n| &n.field)
+						.ok()
+						.cloned()
+				})
+				.map(|f| f.map(|f| f.distance(spatial, point.into())))
+				.collect::<Vec<Option<f32>>>();
+
+			Ok(serialize(output)?.into())
+		});
+	}
+	pub fn field_normal_flex(
+		node: &Node,
+		calling_client: Arc<Client>,
+		message: Message,
+		response: MethodResponseSender,
+	) {
+		response.wrap_sync(move || {
+			let (point, fields): (Vector3<f32>, Vec<Option<&str>>) = deserialize(message.as_ref())?;
+			let spatial = node.spatial.get().unwrap();
+
+			let output = fields
+				.into_iter()
+				.map(|f| {
+					calling_client
+						.get_node("Field", f?)
+						.ok()?
+						.get_aspect("Field", "field", |n| &n.field)
+						.ok()
+						.cloned()
+				})
+				.map(|f| f.map(|f| Vector3::from(f.normal(spatial, point.into(), 0.001))))
+				.collect::<Vec<_>>();
+
+			Ok(serialize(output)?.into())
+		});
+	}
+	pub fn field_closest_point_flex(
+		node: &Node,
+		calling_client: Arc<Client>,
+		message: Message,
+		response: MethodResponseSender,
+	) {
+		response.wrap_sync(move || {
+			let (point, fields): (Vector3<f32>, Vec<Option<&str>>) = deserialize(message.as_ref())?;
+			let spatial = node.spatial.get().unwrap();
+
+			let output = fields
+				.into_iter()
+				.map(|f| {
+					calling_client
+						.get_node("Field", f?)
+						.ok()?
+						.get_aspect("Field", "field", |n| &n.field)
+						.ok()
+						.cloned()
+				})
+				.map(|f| f.map(|f| Vector3::from(f.closest_point(spatial, point.into(), 0.001))))
+				.collect::<Vec<_>>();
+
+			Ok(serialize(output)?.into())
+		});
+	}
+
 	pub(self) fn zone_distance(&self) -> f32 {
 		self.zone
 			.lock()
@@ -240,128 +437,6 @@ impl Spatial {
 			.unwrap_or(f32::MAX)
 	}
 }
-impl Aspect for Spatial {
-	const NAME: &'static str = "Spatial";
-}
-impl SpatialAspect for Spatial {
-	async fn get_local_bounding_box(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-	) -> Result<BoundingBox> {
-		let this_spatial = node.get_aspect::<Spatial>()?;
-		let bounds = this_spatial.get_bounding_box();
-
-		Ok(BoundingBox {
-			center: mint::Vector3::from(bounds.center),
-			size: mint::Vector3::from(bounds.dimensions),
-		})
-	}
-
-	async fn get_relative_bounding_box(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		relative_to: Arc<Node>,
-	) -> Result<BoundingBox> {
-		let this_spatial = node.get_aspect::<Spatial>()?;
-		let relative_spatial = relative_to.get_aspect::<Spatial>()?;
-		let center = Spatial::space_to_space_matrix(Some(&this_spatial), Some(&relative_spatial))
-			.transform_point3([0.0; 3].into());
-		let bounds = bounds_grow_to_fit_box(
-			Bounds {
-				center,
-				dimensions: [0.0; 3].into(),
-			},
-			this_spatial.get_bounding_box(),
-			Some(Spatial::space_to_space_matrix(
-				Some(&this_spatial),
-				Some(&relative_spatial),
-			)),
-		);
-
-		Ok(BoundingBox {
-			center: mint::Vector3::from(bounds.center),
-			size: mint::Vector3::from(bounds.dimensions),
-		})
-	}
-
-	async fn get_transform(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		relative_to: Arc<Node>,
-	) -> Result<Transform> {
-		let this_spatial = node.get_aspect::<Spatial>()?;
-		let relative_spatial = relative_to.get_aspect::<Spatial>()?;
-
-		let (scale, rotation, position) = Spatial::space_to_space_matrix(
-			Some(this_spatial.as_ref()),
-			Some(relative_spatial.as_ref()),
-		)
-		.to_scale_rotation_translation();
-
-		Ok(Transform {
-			translation: Some(position.into()),
-			rotation: Some(rotation.into()),
-			scale: Some(scale.into()),
-		})
-	}
-
-	fn set_local_transform(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		transform: Transform,
-	) -> Result<()> {
-		let this_spatial = node.get_aspect::<Spatial>()?;
-		this_spatial.set_local_transform_components(None, transform);
-		Ok(())
-	}
-	fn set_relative_transform(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		relative_to: Arc<Node>,
-		transform: Transform,
-	) -> Result<()> {
-		let this_spatial = node.get_aspect::<Spatial>()?;
-		let relative_spatial = relative_to.get_aspect::<Spatial>()?;
-
-		this_spatial.set_local_transform_components(Some(&relative_spatial), transform);
-		Ok(())
-	}
-
-	fn set_spatial_parent(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		parent: Arc<Node>,
-	) -> Result<()> {
-		let this_spatial = node.get_aspect::<Spatial>()?;
-		let parent = parent.get_aspect::<Spatial>()?;
-
-		this_spatial.set_spatial_parent(Some(&parent))?;
-		Ok(())
-	}
-
-	fn set_spatial_parent_in_place(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		parent: Arc<Node>,
-	) -> Result<()> {
-		let this_spatial = node.get_aspect::<Spatial>()?;
-		let parent = parent.get_aspect::<Spatial>()?;
-
-		this_spatial.set_spatial_parent_in_place(Some(&parent))?;
-		Ok(())
-	}
-
-	fn set_zoneable(node: Arc<Node>, _calling_client: Arc<Client>, zoneable: bool) -> Result<()> {
-		let spatial = node.get_aspect::<Spatial>()?;
-		if zoneable {
-			ZONEABLE_REGISTRY.add_raw(&spatial);
-		} else {
-			ZONEABLE_REGISTRY.remove(&spatial);
-			zone::release(&spatial);
-		}
-		Ok(())
-	}
-}
 impl PartialEq for Spatial {
 	fn eq(&self, other: &Self) -> bool {
 		self.uid == other.uid
@@ -379,14 +454,14 @@ impl Debug for Spatial {
 }
 impl Drop for Spatial {
 	fn drop(&mut self) {
-		zone::release_drop(self);
 		ZONEABLE_REGISTRY.remove(self);
+		zone::release(self);
 	}
 }
 
 pub fn parse_transform(transform: Transform, position: bool, rotation: bool, scale: bool) -> Mat4 {
 	let position = position
-		.then_some(transform.translation)
+		.then_some(transform.position)
 		.flatten()
 		.unwrap_or_else(|| Vector3::from([0.0; 3]));
 	let rotation = rotation
@@ -401,41 +476,53 @@ pub fn parse_transform(transform: Transform, position: bool, rotation: bool, sca
 	Mat4::from_scale_rotation_translation(scale.into(), rotation.into(), position.into())
 }
 
-pub struct SpatialInterface;
+pub fn find_spatial(
-impl SpatialInterfaceAspect for SpatialInterface {
+	calling_client: &Arc<Client>,
-	fn create_spatial(
+	node_name: &'static str,
-		_node: Arc<Node>,
+	node_path: &str,
-		calling_client: Arc<Client>,
+) -> color_eyre::eyre::Result<Arc<Spatial>> {
-		name: String,
+	calling_client
-		parent: Arc<Node>,
+		.get_node(node_name, node_path)?
-		transform: Transform,
+		.get_aspect(node_name, "spatial", |n| &n.spatial)
-		zoneable: bool,
+		.cloned()
-	) -> Result<()> {
+}
-		let parent = parent.get_aspect::<Spatial>()?;
+pub fn find_spatial_parent(
-		let transform = parse_transform(transform, true, true, true);
+	calling_client: &Arc<Client>,
-		let node = Node::create_parent_name(&calling_client, "/spatial/spatial", &name, true)
+	node_path: &str,
-			.add_to_scenegraph()?;
+) -> color_eyre::eyre::Result<Arc<Spatial>> {
-		Spatial::add_to(&node, Some(parent.clone()), transform, zoneable);
+	find_spatial(calling_client, "Spatial parent", node_path)
-		Ok(())
+}
-	}
+pub fn find_reference_space(
-	fn create_zone(
+	calling_client: &Arc<Client>,
-		_node: Arc<Node>,
+	node_path: &str,
-		calling_client: Arc<Client>,
+) -> color_eyre::eyre::Result<Arc<Spatial>> {
-		name: String,
+	find_spatial(calling_client, "Reference space", node_path)
-		parent: Arc<Node>,
-		transform: Transform,
-		field: Arc<Node>,
-	) -> Result<()> {
-		let parent = parent.get_aspect::<Spatial>()?;
-		let transform = parse_transform(transform, true, true, false);
-		let field = field.get_aspect::<Field>()?;
-
-		let node = Node::create_parent_name(&calling_client, "/spatial/zone", &name, true)
-			.add_to_scenegraph()?;
-		let space = Spatial::add_to(&node, Some(parent.clone()), transform, false);
-		Zone::add_to(&node, space, &field);
-		Ok(())
-	}
 }
 
-create_interface!(SpatialInterface, SpatialInterfaceAspect, "/spatial");
+pub fn create_interface(client: &Arc<Client>) -> Result<()> {
+	let node = Node::create(client, "", "spatial", false);
+	node.add_local_signal("create_spatial", create_spatial_flex);
+	node.add_local_signal("create_zone", create_zone_flex);
+	node.add_to_scenegraph().map(|_| ())
+}
+
+pub fn create_spatial_flex(
+	_node: &Node,
+	calling_client: Arc<Client>,
+	message: Message,
+) -> Result<()> {
+	#[derive(Deserialize)]
+	struct CreateSpatialInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
+		transform: Transform,
+		zoneable: bool,
+	}
+	let info: CreateSpatialInfo = deserialize(message.as_ref())?;
+	let node = Node::create(&calling_client, "/spatial/spatial", info.name, true);
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
+	let transform = parse_transform(info.transform, true, true, true);
+	let node = node.add_to_scenegraph()?;
+	Spatial::add_to(&node, Some(parent), transform, info.zoneable)?;
+	Ok(())
+}

src/nodes/spatial/zone.rs

@@ -1,15 +1,22 @@
-use super::{Spatial, ZoneAspect, ZONEABLE_REGISTRY};
+use super::{find_spatial, Spatial, ZONEABLE_REGISTRY};
 use crate::{
 	core::{client::Client, registry::Registry},
 	nodes::{
 		alias::{Alias, AliasInfo},
-		fields::Field,
+		fields::{find_field, Field},
-		Aspect, Node,
+		spatial::{find_spatial_parent, parse_transform},
+		Message, Node,
 	},
 };
+use color_eyre::eyre::Result;
 use glam::vec3a;
 use parking_lot::Mutex;
 use rustc_hash::FxHashMap;
+use serde::Deserialize;
+use stardust_xr::{
+	schemas::flex::{deserialize, serialize},
+	values::Transform,
+};
 use std::sync::{Arc, Weak};
 
 pub fn capture(spatial: &Arc<Spatial>, zone: &Arc<Zone>) {
@@ -24,34 +31,22 @@ pub fn capture(spatial: &Arc<Spatial>, zone: &Arc<Zone>) {
 		*spatial.old_parent.lock() = spatial.get_parent();
 		*spatial.zone.lock() = Arc::downgrade(zone);
 		zone.captured.add_raw(spatial);
-		let Some(node) = zone.spatial.node.upgrade() else {
+		let Some(node) = zone.spatial.node.upgrade() else {return};
-			return;
+		let Ok(message) = serialize(&spatial.uid) else {return};
-		};
+		let _ = node.send_remote_signal("capture", message);
-		let _ = super::zone_client::capture(&node, &spatial.uid);
 	}
 }
-pub fn release(spatial: &Arc<Spatial>) {
+pub fn release(spatial: &Spatial) {
-	let _ = spatial.set_spatial_parent_in_place(spatial.old_parent.lock().take().as_ref());
+	let _ = spatial.set_spatial_parent_in_place(spatial.old_parent.lock().take());
 	let mut spatial_zone = spatial.zone.lock();
 	if let Some(spatial_zone) = spatial_zone.upgrade() {
-		let Some(node) = spatial_zone.spatial.node.upgrade() else {
+		let Some(node) = spatial_zone.spatial.node.upgrade() else {return};
-			return;
-		};
 		spatial_zone.captured.remove(spatial);
-		let _ = super::zone_client::release(&node, &spatial.uid);
+		let Ok(message) = serialize(&spatial.uid) else {return};
+		let _ = node.send_remote_signal("release", message);
 	}
 	*spatial_zone = Weak::new();
 }
-pub(super) fn release_drop(spatial: &Spatial) {
-	let spatial_zone = spatial.zone.lock();
-	if let Some(spatial_zone) = spatial_zone.upgrade() {
-		let Some(node) = spatial_zone.spatial.node.upgrade() else {
-			return;
-		};
-		spatial_zone.captured.remove(spatial);
-		let _ = super::zone_client::release(&node, &spatial.uid);
-	}
-}
 
 pub struct Zone {
 	spatial: Arc<Spatial>,
@@ -67,28 +62,33 @@ impl Zone {
 			zoneables: Mutex::new(FxHashMap::default()),
 			captured: Registry::new(),
 		});
-		<Zone as ZoneAspect>::add_node_members(node);
+		node.add_local_signal("capture", Zone::capture_flex);
-		node.add_aspect_raw(zone.clone());
+		node.add_local_signal("release", Zone::release_flex);
+		node.add_local_signal("update", Zone::update);
+		let _ = node.zone.set(zone.clone());
 		zone
 	}
-}
+	fn capture_flex(node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
-impl Aspect for Zone {
+		let zone = node.zone.get().unwrap();
-	const NAME: &'static str = "Zone";
+		let capture_path: &str = deserialize(message.as_ref())?;
-}
+		let spatial = find_spatial(&calling_client, "Spatial", capture_path)?;
-impl ZoneAspect for Zone {
+		capture(&spatial, zone);
-	fn update(node: Arc<Node>, _calling_client: Arc<Client>) -> color_eyre::eyre::Result<()> {
+		Ok(())
-		let zone = node.get_aspect::<Zone>()?;
+	}
-		let Some(field) = zone.field.upgrade() else {
+	fn release_flex(_node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
-			return Err(color_eyre::eyre::eyre!("Zone's field has been destroyed"));
+		let capture_path: &str = deserialize(message.as_ref())?;
-		};
+		let spatial = find_spatial(&calling_client, "Spatial", capture_path)?;
+		release(&spatial);
+		Ok(())
+	}
+	fn update(node: &Node, _calling_client: Arc<Client>, _message: Message) -> Result<()> {
+		let zone = node.zone.get().unwrap();
+		let Some(field) = zone.field.upgrade() else { return Err(color_eyre::eyre::eyre!("Zone's field has been destroyed")) };
 		let Some((zone_client, zone_node)) = zone
 			.spatial
 			.node
 			.upgrade()
-			.and_then(|n| n.get_client().zip(Some(n)))
+			.and_then(|n| n.get_client().zip(Some(n))) else { return Err(color_eyre::eyre::eyre!("No client on node?")) };
-		else {
-			return Err(color_eyre::eyre::eyre!("No client on node?"));
-		};
 		let mut old_zoneables = zone.zoneables.lock();
 		for (_uid, zoneable) in old_zoneables.iter() {
 			zoneable.destroy();
@@ -130,41 +130,17 @@ impl ZoneAspect for Zone {
 			})
 			.collect::<FxHashMap<String, Arc<Node>>>();
 
-		for (uid, zoneable) in zoneables
+		for entered_uid in zoneables.keys().filter(|k| !old_zoneables.contains_key(*k)) {
-			.iter()
+			node.send_remote_signal("enter", serialize(entered_uid)?)?;
-			.filter(|(k, _)| !old_zoneables.contains_key(*k))
-		{
-			super::zone_client::enter(&node, uid, zoneable)?;
 		}
 		for left_uid in old_zoneables.keys().filter(|k| !zoneables.contains_key(*k)) {
-			super::zone_client::leave(&node, &left_uid)?;
+			node.send_remote_signal("leave", serialize(left_uid)?)?;
 		}
 
 		*old_zoneables = zoneables;
 
 		Ok(())
 	}
-
-	fn capture(
-		node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		spatial: Arc<Node>,
-	) -> color_eyre::eyre::Result<()> {
-		let zone = node.get_aspect::<Zone>()?;
-		let spatial = spatial.get_aspect()?;
-		capture(&spatial, &zone);
-		Ok(())
-	}
-
-	fn release(
-		_node: Arc<Node>,
-		_calling_client: Arc<Client>,
-		spatial: Arc<Node>,
-	) -> color_eyre::eyre::Result<()> {
-		let spatial = spatial.get_aspect()?;
-		release(&spatial);
-		Ok(())
-	}
 }
 impl Drop for Zone {
 	fn drop(&mut self) {
@@ -173,3 +149,23 @@ impl Drop for Zone {
 		}
 	}
 }
+
+pub fn create_zone_flex(_node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
+	#[derive(Deserialize)]
+	struct CreateZoneInfo<'a> {
+		name: &'a str,
+		parent_path: &'a str,
+		transform: Transform,
+		field_path: &'a str,
+	}
+	let info: CreateZoneInfo = deserialize(message.as_ref())?;
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
+	let transform = parse_transform(info.transform, true, true, false);
+	let field = find_field(&calling_client, info.field_path)?;
+
+	let node =
+		Node::create(&calling_client, "/spatial/zone", info.name, true).add_to_scenegraph()?;
+	let space = Spatial::add_to(&node, Some(parent), transform, false)?;
+	Zone::add_to(&node, space, &field);
+	Ok(())
+}

src/objects/input/eye_pointer.rs

@@ -10,7 +10,7 @@ use color_eyre::eyre::Result;
 use glam::Mat4;
 use nanoid::nanoid;
 use serde::Serialize;
-use stardust_xr::{schemas::flex::flexbuffers, values::Datamap};
+use stardust_xr::schemas::{flat::Datamap, flex::flexbuffers};
 use std::sync::Arc;
 use stereokit::StereoKitMultiThread;
 
@@ -28,9 +28,8 @@ pub struct EyePointer {
 }
 impl EyePointer {
 	pub fn new() -> Result<Self> {
-		let node = Node::create_parent_name(&INTERNAL_CLIENT, "", &nanoid!(), false)
+		let node = Node::create(&INTERNAL_CLIENT, "", &nanoid!(), false).add_to_scenegraph()?;
-			.add_to_scenegraph()?;
+		let spatial = Spatial::add_to(&node, None, Mat4::IDENTITY, false).unwrap();
-		let spatial = Spatial::add_to(&node, None, Mat4::IDENTITY, false);
 		let pointer =
 			InputMethod::add_to(&node, InputType::Pointer(Pointer::default()), None).unwrap();
 
@@ -49,7 +48,7 @@ impl EyePointer {
 			let mut map = fbb.start_map();
 			map.push("eye", 2);
 			map.end_map();
-			*self.pointer.datamap.lock() = Datamap::from_raw(fbb.take_buffer()).ok();
+			*self.pointer.datamap.lock() = Datamap::new(fbb.take_buffer()).ok();
 		}
 	}
 }

src/objects/input/mouse_pointer.rs

@@ -1,10 +1,8 @@
 use crate::{
-	core::client::INTERNAL_CLIENT,
+	core::{client::INTERNAL_CLIENT, typed_datamap::TypedDatamap},
 	nodes::{
-		data::{
+		data::{mask_matches, Mask, PulseSender, KEYMAPS, PULSE_RECEIVER_REGISTRY},
-			mask_matches, pulse_receiver_client, PulseSender, KEYMAPS, PULSE_RECEIVER_REGISTRY,
+		fields::Ray,
-		},
-		fields::{Field, Ray},
 		input::{pointer::Pointer, InputMethod, InputType},
 		spatial::Spatial,
 		Node,
@@ -14,7 +12,6 @@ use color_eyre::eyre::Result;
 use glam::{vec2, vec3, Mat4, Vec2, Vec3};
 use nanoid::nanoid;
 use serde::{Deserialize, Serialize};
-use stardust_xr::values::Datamap;
 use std::{convert::TryFrom, sync::Arc};
 use stereokit::{ray_from_mouse, ButtonState, Key, StereoKitMultiThread};
 use xkbcommon::xkb::{Context, Keymap, FORMAT_TEXT_V1};
@@ -22,12 +19,9 @@ use xkbcommon::xkb::{Context, Keymap, FORMAT_TEXT_V1};
 #[derive(Default, Deserialize, Serialize)]
 struct MouseEvent {
 	select: f32,
-	middle: f32,
-	context: f32,
 	grab: f32,
 	scroll_continuous: Vec2,
 	scroll_discrete: Vec2,
-	raw_input_events: Vec<u32>,
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -52,15 +46,14 @@ pub struct MousePointer {
 	node: Arc<Node>,
 	spatial: Arc<Spatial>,
 	pointer: Arc<InputMethod>,
-	mouse_datamap: MouseEvent,
+	mouse_datamap: TypedDatamap<MouseEvent>,
-	keyboard_datamap: KeyboardEvent,
+	keyboard_datamap: TypedDatamap<KeyboardEvent>,
 	keyboard_sender: Arc<PulseSender>,
 }
 impl MousePointer {
 	pub fn new() -> Result<Self> {
-		let node = Node::create_parent_name(&INTERNAL_CLIENT, "", &nanoid!(), false)
+		let node = Node::create(&INTERNAL_CLIENT, "", &nanoid!(), false).add_to_scenegraph()?;
-			.add_to_scenegraph()?;
+		let spatial = Spatial::add_to(&node, None, Mat4::IDENTITY, false).unwrap();
-		let spatial = Spatial::add_to(&node, None, Mat4::IDENTITY, false);
 		let pointer =
 			InputMethod::add_to(&node, InputType::Pointer(Pointer::default()), None).unwrap();
 
@@ -71,11 +64,8 @@ impl MousePointer {
 				.get_as_string(FORMAT_TEXT_V1),
 		);
 
-		let keyboard_sender = PulseSender::add_to(
+		let keyboard_sender =
-			&node,
+			PulseSender::add_to(&node, Mask::from_struct::<KeyboardEvent>()).unwrap();
-			Datamap::from_typed(KeyboardEvent::default()).unwrap(),
-		)
-		.unwrap();
 
 		Ok(MousePointer {
 			node,
@@ -106,22 +96,7 @@ impl MousePointer {
 				} else {
 					0.0f32
 				};
-			self.mouse_datamap.middle =
+			self.mouse_datamap.grab = if sk.input_key(Key::MouseRight).contains(ButtonState::ACTIVE)
-				if sk.input_key(Key::MouseCenter).contains(ButtonState::ACTIVE) {
-					1.0f32
-				} else {
-					0.0f32
-				};
-			self.mouse_datamap.context =
-				if sk.input_key(Key::MouseRight).contains(ButtonState::ACTIVE) {
-					1.0f32
-				} else {
-					0.0f32
-				};
-			self.mouse_datamap.grab = if sk.input_key(Key::MouseBack).contains(ButtonState::ACTIVE)
-				|| sk
-					.input_key(Key::MouseForward)
-					.contains(ButtonState::ACTIVE)
 			{
 				1.0f32
 			} else {
@@ -129,7 +104,7 @@ impl MousePointer {
 			};
 			self.mouse_datamap.scroll_continuous = vec2(0.0, mouse.scroll_change / 120.0);
 			self.mouse_datamap.scroll_discrete = vec2(0.0, mouse.scroll_change / 120.0);
-			*self.pointer.datamap.lock() = Datamap::from_typed(&self.mouse_datamap).ok();
+			*self.pointer.datamap.lock() = self.mouse_datamap.to_datamap().ok();
 		}
 		self.send_keyboard_input(sk);
 	}
@@ -140,7 +115,7 @@ impl MousePointer {
 			.into_iter()
 			.filter(|rx| mask_matches(&rx.mask, &self.keyboard_sender.mask))
 			.map(|rx| {
-				let result = rx.field_node.get_aspect::<Field>().unwrap().ray_march(Ray {
+				let result = rx.field.ray_march(Ray {
 					origin: vec3(0.0, 0.0, 0.0),
 					direction: vec3(0.0, 0.0, -1.0),
 					space: self.spatial.clone(),
@@ -176,12 +151,8 @@ impl MousePointer {
 
 			self.keyboard_datamap.keys = keys;
 			if !self.keyboard_datamap.keys.is_empty() {
-				pulse_receiver_client::data(
+				rx.send_data(&self.node.uid, self.keyboard_datamap.serialize().unwrap())
-					&rx.node.upgrade().unwrap(),
+					.unwrap();
-					&self.node.uid,
-					&Datamap::from_typed(&self.keyboard_datamap).unwrap(),
-				)
-				.unwrap();
 			}
 		}
 	}

src/objects/input/sk_controller.rs

@@ -1,5 +1,5 @@
 use crate::{
-	core::client::INTERNAL_CLIENT,
+	core::{client::INTERNAL_CLIENT, typed_datamap::TypedDatamap},
 	nodes::{
 		input::{tip::Tip, InputMethod, InputType},
 		spatial::Spatial,
@@ -9,7 +9,6 @@ use crate::{
 use color_eyre::eyre::Result;
 use glam::{Mat4, Vec2, Vec3};
 use serde::{Deserialize, Serialize};
-use stardust_xr::values::Datamap;
 use std::sync::Arc;
 use stereokit::{
 	named_colors::WHITE, ButtonState, Handed, Model, RenderLayer, StereoKitDraw,
@@ -28,11 +27,11 @@ pub struct SkController {
 	input: Arc<InputMethod>,
 	model: Model,
 	handed: Handed,
-	datamap: ControllerDatamap,
+	datamap: TypedDatamap<ControllerDatamap>,
 }
 impl SkController {
 	pub fn new(sk: &impl StereoKitMultiThread, handed: Handed) -> Result<Self> {
-		let _node = Node::create_parent_name(
+		let _node = Node::create(
 			&INTERNAL_CLIENT,
 			"",
 			if handed == Handed::Left {
@@ -43,7 +42,7 @@ impl SkController {
 			false,
 		)
 		.add_to_scenegraph()?;
-		Spatial::add_to(&_node, None, Mat4::IDENTITY, false);
+		Spatial::add_to(&_node, None, Mat4::IDENTITY, false)?;
 		let model = sk.model_create_mem("cursor.glb", include_bytes!("cursor.glb"), None)?;
 		let tip = InputType::Tip(Tip::default());
 		let input = InputMethod::add_to(&_node, tip, None)?;
@@ -74,6 +73,6 @@ impl SkController {
 		self.datamap.select = controller.trigger;
 		self.datamap.grab = controller.grip;
 		self.datamap.scroll = controller.stick;
-		*self.input.datamap.lock() = Datamap::from_typed(&self.datamap).ok();
+		*self.input.datamap.lock() = self.datamap.to_datamap().ok();
 	}
 }

src/objects/input/sk_hand.rs

@@ -1,5 +1,5 @@
 use crate::{
-	core::client::INTERNAL_CLIENT,
+	core::{client::INTERNAL_CLIENT, typed_datamap::TypedDatamap},
 	nodes::{
 		input::{hand::Hand, InputMethod, InputType},
 		spatial::Spatial,
@@ -10,10 +10,7 @@ use color_eyre::eyre::Result;
 use glam::Mat4;
 use nanoid::nanoid;
 use serde::{Deserialize, Serialize};
-use stardust_xr::{
+use stardust_xr::schemas::flat::{Hand as FlatHand, Joint};
-	schemas::flat::{Hand as FlatHand, Joint},
-	values::Datamap,
-};
 use std::sync::Arc;
 use stereokit::{ButtonState, HandJoint, Handed, StereoKitMultiThread};
 
@@ -36,13 +33,12 @@ pub struct SkHand {
 	_node: Arc<Node>,
 	input: Arc<InputMethod>,
 	handed: Handed,
-	datamap: HandDatamap,
+	datamap: TypedDatamap<HandDatamap>,
 }
 impl SkHand {
 	pub fn new(handed: Handed) -> Result<Self> {
-		let _node = Node::create_parent_name(&INTERNAL_CLIENT, "", &nanoid!(), false)
+		let _node = Node::create(&INTERNAL_CLIENT, "", &nanoid!(), false).add_to_scenegraph()?;
-			.add_to_scenegraph()?;
+		Spatial::add_to(&_node, None, Mat4::IDENTITY, false)?;
-		Spatial::add_to(&_node, None, Mat4::IDENTITY, false);
 		let hand = InputType::Hand(Box::new(Hand {
 			base: FlatHand {
 				right: handed == Handed::Right,
@@ -102,6 +98,6 @@ impl SkHand {
 		}
 		self.datamap.pinch_strength = sk_hand.pinch_activation;
 		self.datamap.grab_strength = sk_hand.grip_activation;
-		*self.input.datamap.lock() = Datamap::from_typed(&self.datamap).ok();
+		*self.input.datamap.lock() = self.datamap.to_datamap().ok();
 	}
 }

src/objects/play_space.rs

@@ -5,13 +5,12 @@ use glam::Mat4;
 use mint::Vector2;
 use nanoid::nanoid;
 use serde::{Deserialize, Serialize};
-use stardust_xr::values::Datamap;
 use stereokit::StereoKitMultiThread;
 
 use crate::{
 	core::client::INTERNAL_CLIENT,
 	nodes::{
-		data::PulseReceiver,
+		data::{Mask, PulseReceiver},
 		fields::{r#box::BoxField, Field},
 		spatial::Spatial,
 		Node,
@@ -40,17 +39,12 @@ pub struct PlaySpace {
 }
 impl PlaySpace {
 	pub fn new() -> Result<Self> {
-		let node = Node::create_parent_name(&INTERNAL_CLIENT, "", &nanoid!(), false)
+		let node = Node::create(&INTERNAL_CLIENT, "", &nanoid!(), false).add_to_scenegraph()?;
-			.add_to_scenegraph()?;
+		let spatial = Spatial::add_to(&node, None, Mat4::IDENTITY, false)?;
-		let spatial = Spatial::add_to(&node, None, Mat4::IDENTITY, false);
+		let field = BoxField::add_to(&node, [0.0; 3].into())?;
-		BoxField::add_to(&node, [0.0; 3].into());
-		let field = node.get_aspect::<Field>()?.clone();
 
-		let pulse_rx = PulseReceiver::add_to(
+		let pulse_rx =
-			&node,
+			PulseReceiver::add_to(&node, field.clone(), Mask::from_struct::<PlaySpaceMap>())?;
-			node.clone(),
-			Datamap::from_typed(PlaySpaceMap::default())?,
-		)?;
 
 		Ok(PlaySpace {
 			_node: node,
@@ -66,9 +60,7 @@ impl PlaySpace {
 				pose.orientation,
 				pose.position,
 			));
-		let Field::Box(box_field) = self.field.as_ref() else {
+		let Field::Box(box_field) = self.field.as_ref() else {return};
-			return;
-		};
 		box_field.set_size(
 			[
 				sk.world_get_bounds_size().x,

src/wayland/drm.rs

@@ -1,144 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-
-// Re-export only the actual code, and then only use this re-export
-// The `generated` module below is just some boilerplate to properly isolate stuff
-// and avoid exposing internal details.
-//
-// You can use all the types from my_protocol as if they went from `wayland_client::protocol`.
-pub use generated::wl_drm;
-
-#[allow(non_upper_case_globals, non_camel_case_types)]
-mod generated {
-	use smithay::reexports::wayland_server::{self, protocol::*};
-
-	pub mod __interfaces {
-		use smithay::reexports::wayland_server::protocol::__interfaces::*;
-		wayland_scanner::generate_interfaces!("src/wayland/wayland-drm.xml");
-	}
-	use self::__interfaces::*;
-
-	wayland_scanner::generate_server_code!("src/wayland/wayland-drm.xml");
-}
-
-use super::state::WaylandState;
-use smithay::{
-	backend::allocator::{
-		dmabuf::{Dmabuf, DmabufFlags},
-		Fourcc, Modifier,
-	},
-	reexports::wayland_server::{
-		Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
-	},
-};
-use std::convert::TryFrom;
-
-impl GlobalDispatch<wl_drm::WlDrm, (), WaylandState> for WaylandState {
-	fn bind(
-		state: &mut WaylandState,
-		_dh: &DisplayHandle,
-		_client: &Client,
-		resource: New<wl_drm::WlDrm>,
-		_global_data: &(),
-		data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		let drm_instance = data_init.init(resource, ());
-
-		drm_instance.device("/dev/dri/renderD128".to_string());
-		if drm_instance.version() >= 2 {
-			drm_instance.capabilities(wl_drm::Capability::Prime as u32);
-		}
-		for format in state.drm_formats.iter() {
-			if let Ok(converted) = wl_drm::Format::try_from(*format as u32) {
-				drm_instance.format(converted as u32);
-			}
-		}
-	}
-
-	fn can_view(_client: Client, _global_dataa: &()) -> bool {
-		true
-	}
-}
-
-impl Dispatch<wl_drm::WlDrm, (), WaylandState> for WaylandState {
-	fn request(
-		state: &mut WaylandState,
-		_client: &Client,
-		drm: &wl_drm::WlDrm,
-		request: wl_drm::Request,
-		_data: &(),
-		_dh: &DisplayHandle,
-		data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		match request {
-			wl_drm::Request::Authenticate { .. } => drm.authenticated(),
-			wl_drm::Request::CreateBuffer { .. } => drm.post_error(
-				wl_drm::Error::InvalidName,
-				String::from("Flink handles are unsupported, use PRIME"),
-			),
-			wl_drm::Request::CreatePlanarBuffer { .. } => drm.post_error(
-				wl_drm::Error::InvalidName,
-				String::from("Flink handles are unsupported, use PRIME"),
-			),
-			wl_drm::Request::CreatePrimeBuffer {
-				id,
-				name,
-				width,
-				height,
-				format,
-				offset0,
-				stride0,
-				..
-			} => {
-				let format = match Fourcc::try_from(format) {
-					Ok(format) => {
-						if !state.drm_formats.contains(&format) {
-							drm.post_error(
-								wl_drm::Error::InvalidFormat,
-								String::from("Format not advertised by wl_drm"),
-							);
-							return;
-						}
-						format
-					}
-					Err(_) => {
-						drm.post_error(
-							wl_drm::Error::InvalidFormat,
-							String::from("Format unknown / not advertised by wl_drm"),
-						);
-						return;
-					}
-				};
-
-				if width < 1 || height < 1 {
-					drm.post_error(
-						wl_drm::Error::InvalidFormat,
-						String::from("width or height not positive"),
-					);
-					return;
-				}
-
-				let mut dma = Dmabuf::builder(
-					(width, height),
-					format,
-					Modifier::Invalid,
-					DmabufFlags::empty(),
-				);
-				dma.add_plane(name, 0, offset0 as u32, stride0 as u32);
-				match dma.build() {
-					Some(dmabuf) => {
-						state.dmabuf_tx.send((dmabuf.clone(), None)).unwrap();
-						data_init.init(id, dmabuf);
-					}
-					None => {
-						// Buffer import failed. The protocol documentation heavily implies killing the
-						// client is the right thing to do here.
-						drm.post_error(
-							wl_drm::Error::InvalidName,
-							"dmabuf global was destroyed on server",
-						);
-					}
-				}
-			}
-		}
-	}
-}

src/wayland/mod.rs

@@ -5,42 +5,28 @@ mod seat;
 mod state;
 mod surface;
 // mod xdg_activation;
-mod drm;
-mod utils;
 mod xdg_shell;
-#[cfg(feature = "xwayland_rootful")]
+#[cfg(feature = "xwayland")]
-pub mod xwayland_rootful;
+pub mod xwayland;
-#[cfg(feature = "xwayland_rootful")]
-use self::xwayland_rootful::X11Lock;
-#[cfg(feature = "xwayland_rootful")]
-use crate::wayland::xwayland_rootful::start_xwayland;
-#[cfg(feature = "xwayland_rootless")]
-pub mod xwayland_rootless;
-#[cfg(feature = "xwayland_rootless")]
-use self::xwayland_rootless::XWaylandState;
 
 use self::{state::WaylandState, surface::CORE_SURFACES};
+use crate::core::buffers::BufferManager;
 use crate::wayland::seat::SeatData;
 use crate::{core::task, wayland::state::ClientState};
-use color_eyre::eyre::{ensure, Result};
+use color_eyre::eyre::Result;
 use global_counter::primitive::exact::CounterU32;
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use sk::StereoKitDraw;
 use smithay::backend::allocator::dmabuf::Dmabuf;
-use smithay::backend::egl::EGLContext;
-use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::backend::renderer::ImportDma;
-use smithay::output::Output;
 use smithay::reexports::wayland_server::backend::ClientId;
 use smithay::reexports::wayland_server::DisplayHandle;
 use smithay::reexports::wayland_server::{Display, ListeningSocket};
-use smithay::wayland::dmabuf;
 use std::ffi::OsStr;
 use std::os::fd::OwnedFd;
 use std::os::unix::prelude::AsRawFd;
 use std::{
-	ffi::c_void,
 	os::unix::{net::UnixListener, prelude::FromRawFd},
 	sync::Arc,
 };
@@ -51,31 +37,9 @@ use tokio::{
 };
 use tracing::{debug_span, info, instrument};
 
-pub static X_DISPLAY: OnceCell<u32> = OnceCell::new();
 pub static WAYLAND_DISPLAY: OnceCell<String> = OnceCell::new();
 pub static SERIAL_COUNTER: CounterU32 = CounterU32::new(0);
 
-struct EGLRawHandles {
-	display: *const c_void,
-	config: *const c_void,
-	context: *const c_void,
-}
-fn get_sk_egl() -> Result<EGLRawHandles> {
-	ensure!(
-		unsafe { sk::sys::backend_graphics_get() }
-			== sk::sys::backend_graphics__backend_graphics_opengles_egl,
-		"StereoKit is not running using EGL!"
-	);
-
-	Ok(unsafe {
-		EGLRawHandles {
-			display: sk::sys::backend_opengl_egl_get_display() as *const c_void,
-			config: sk::sys::backend_opengl_egl_get_config() as *const c_void,
-			context: sk::sys::backend_opengl_egl_get_context() as *const c_void,
-		}
-	})
-}
-
 pub struct DisplayWrapper(Mutex<Display<WaylandState>>, DisplayHandle);
 impl DisplayWrapper {
 	pub fn handle(&self) -> DisplayHandle {
@@ -98,35 +62,21 @@ pub struct Wayland {
 	display: Arc<DisplayWrapper>,
 	pub socket_name: Option<String>,
 	join_handle: JoinHandle<Result<()>>,
-	renderer: GlesRenderer,
+	dmabuf_rx: UnboundedReceiver<Dmabuf>,
-	output: Output,
+	wayland_state: Arc<Mutex<WaylandState>>,
-	dmabuf_rx: UnboundedReceiver<(Dmabuf, Option<dmabuf::ImportNotifier>)>,
+	#[cfg(feature = "xwayland")]
-	#[cfg(feature = "xwayland_rootful")]
+	pub xwayland_state: xwayland::XWaylandState,
-	pub x_lock: X11Lock,
-	#[cfg(feature = "xwayland_rootless")]
-	pub xwayland_state: XWaylandState,
 }
 impl Wayland {
-	pub fn new() -> Result<Self> {
+	pub fn new(buffer_manager: &BufferManager) -> Result<Self> {
-		let egl_raw_handles = get_sk_egl()?;
-		let renderer = unsafe {
-			GlesRenderer::new(EGLContext::from_raw(
-				egl_raw_handles.display,
-				egl_raw_handles.config,
-				egl_raw_handles.context,
-			)?)?
-		};
-
 		let display: Display<WaylandState> = Display::new()?;
 		let display_handle = display.handle();
 
 		let (dmabuf_tx, dmabuf_rx) = mpsc::unbounded_channel();
 		let display = Arc::new(DisplayWrapper(Mutex::new(display), display_handle.clone()));
-
+		#[cfg(feature = "xwayland")]
-		#[cfg(feature = "xwayland_rootless")]
+		let xwayland_state = xwayland::XWaylandState::create(&display_handle)?;
-		let xwayland_state = XWaylandState::create(&display_handle)?;
+		let wayland_state = WaylandState::new(display_handle, &buffer_manager.renderer, dmabuf_tx);
-		let wayland_state = WaylandState::new(display_handle, &renderer, dmabuf_tx);
-		let output = wayland_state.lock().output.clone();
 
 		let socket = ListeningSocket::bind_auto("wayland", 0..33)?;
 		let socket_name = socket
@@ -136,21 +86,17 @@ impl Wayland {
 		if let Some(socket_name) = &socket_name {
 			let _ = WAYLAND_DISPLAY.set(socket_name.clone());
 		}
-		#[cfg(feature = "xwayland_rootful")]
-		let x_display = start_xwayland(socket.as_raw_fd())?;
 		info!(socket_name, "Wayland active");
 
-		let join_handle = Wayland::start_loop(display.clone(), socket, wayland_state)?;
+		let join_handle = Wayland::start_loop(display.clone(), socket, wayland_state.clone())?;
+
 		Ok(Wayland {
 			display,
 			socket_name,
 			join_handle,
-			renderer,
-			output,
 			dmabuf_rx,
-			#[cfg(feature = "xwayland_rootful")]
+			wayland_state,
-			x_lock: x_display,
+			#[cfg(feature = "xwayland")]
-			#[cfg(feature = "xwayland_rootless")]
 			xwayland_state,
 		})
 	}
@@ -187,7 +133,7 @@ impl Wayland {
 					e = dispatch_poll_listener.readable() => { // Dispatch
 						let mut guard = e?;
 						debug_span!("Dispatch wayland event").in_scope(|| -> Result<(), color_eyre::Report> {
-							display.dispatch_clients(&mut state.lock())?;
+							display.dispatch_clients(&mut *state.lock())?;
 							display.flush_clients(None);
 							Ok(())
 						})?;
@@ -198,31 +144,27 @@ impl Wayland {
 		})?)
 	}
 
-	#[instrument(level = "debug", name = "Wayland frame", skip(self, sk))]
+	#[instrument(
-	pub fn update(&mut self, sk: &impl StereoKitDraw) {
+		level = "debug",
-		while let Ok((dmabuf, notifier)) = self.dmabuf_rx.try_recv() {
+		name = "Wayland frame",
-			if self.renderer.import_dmabuf(&dmabuf, None).is_err() {
+		skip(self, sk, buffer_manager)
-				if let Some(notifier) = notifier {
+	)]
-					notifier.failed();
+	pub fn update(&mut self, sk: &impl StereoKitDraw, buffer_manager: &mut BufferManager) {
-				}
+		while let Ok(dmabuf) = self.dmabuf_rx.try_recv() {
-			}
+			let _ = buffer_manager.renderer.import_dmabuf(&dmabuf, None);
 		}
 		for core_surface in CORE_SURFACES.get_valid_contents() {
-			core_surface.process(sk, &mut self.renderer);
+			core_surface.process(sk, &mut buffer_manager.renderer);
 		}
 
 		self.display.flush_clients(None);
 	}
 
 	pub fn frame_event(&self, sk: &impl StereoKitDraw) {
-		for core_surface in CORE_SURFACES.get_valid_contents() {
+		let output = self.wayland_state.lock().output.clone();
-			core_surface.frame(sk, self.output.clone());
-		}
-	}
 
-	pub fn make_context_current(&self) {
+		for core_surface in CORE_SURFACES.get_valid_contents() {
-		unsafe {
+			core_surface.frame(sk, output.clone());
-			let _ = self.renderer.egl_context().make_current();
 		}
 	}
 }

src/wayland/state.rs

@@ -1,13 +1,8 @@
-use super::DisplayWrapper;
+use crate::wayland::seat::SeatData;
-use crate::wayland::{drm::wl_drm::WlDrm, seat::SeatData};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use smithay::{
-	backend::{
+	backend::{allocator::dmabuf::Dmabuf, egl::EGLDevice, renderer::gles::GlesRenderer},
-		allocator::{dmabuf::Dmabuf, Fourcc},
-		egl::EGLDevice,
-		renderer::gles::GlesRenderer,
-	},
 	delegate_dmabuf, delegate_output, delegate_shm,
 	output::{Mode, Output, Scale, Subpixel},
 	reexports::{
@@ -18,10 +13,7 @@ use smithay::{
 		wayland_protocols_misc::server_decoration::server::org_kde_kwin_server_decoration_manager::Mode as DecorationMode,
 		wayland_server::{
 			backend::{ClientData, ClientId, DisconnectReason},
-			protocol::{
+			protocol::{wl_buffer::WlBuffer, wl_data_device_manager::WlDataDeviceManager},
-				wl_buffer::WlBuffer, wl_data_device_manager::WlDataDeviceManager,
-				wl_output::WlOutput,
-			},
 			DisplayHandle,
 		},
 	},
@@ -31,8 +23,8 @@ use smithay::{
 		compositor::{CompositorClientState, CompositorState},
 		dmabuf::{
 			self, DmabufFeedback, DmabufFeedbackBuilder, DmabufGlobal, DmabufHandler, DmabufState,
+			ImportError,
 		},
-		output::OutputHandler,
 		shell::kde::decoration::KdeDecorationState,
 		shm::{ShmHandler, ShmState},
 	},
@@ -41,6 +33,8 @@ use std::sync::{Arc, Weak};
 use tokio::sync::mpsc::UnboundedSender;
 use tracing::{info, warn};
 
+use super::DisplayWrapper;
+
 pub struct ClientState {
 	pub id: OnceCell<ClientId>,
 	pub compositor_state: CompositorClientState,
@@ -49,9 +43,7 @@ pub struct ClientState {
 }
 impl ClientState {
 	pub fn flush(&self) {
-		let Some(display) = self.display.upgrade() else {
+		let Some(display) = self.display.upgrade() else {return};
-			return;
-		};
 		let _ = display.flush_clients(self.id.get().cloned());
 	}
 }
@@ -78,8 +70,7 @@ pub struct WaylandState {
 	pub kde_decoration_state: KdeDecorationState,
 	pub shm_state: ShmState,
 	dmabuf_state: (DmabufState, DmabufGlobal, Option<DmabufFeedback>),
-	pub drm_formats: Vec<Fourcc>,
+	dmabuf_tx: UnboundedSender<Dmabuf>,
-	pub dmabuf_tx: UnboundedSender<(Dmabuf, Option<dmabuf::ImportNotifier>)>,
 	pub output: Output,
 }
 
@@ -87,7 +78,7 @@ impl WaylandState {
 	pub fn new(
 		display_handle: DisplayHandle,
 		renderer: &GlesRenderer,
-		dmabuf_tx: UnboundedSender<(Dmabuf, Option<dmabuf::ImportNotifier>)>,
+		dmabuf_tx: UnboundedSender<Dmabuf>,
 	) -> Arc<Mutex<Self>> {
 		let compositor_state = CompositorState::new::<Self>(&display_handle);
 		// let xdg_activation_state = XdgActivationState::new::<Self, _>(&display_handle);
@@ -96,14 +87,13 @@ impl WaylandState {
 		let shm_state = ShmState::new::<Self>(&display_handle, vec![]);
 		let render_node = EGLDevice::device_for_display(renderer.egl_context().display())
 			.and_then(|device| device.try_get_render_node());
+
 		let dmabuf_formats = renderer
 			.egl_context()
 			.dmabuf_render_formats()
 			.iter()
 			.cloned()
 			.collect::<Vec<_>>();
-		let drm_formats = dmabuf_formats.iter().map(|f| f.code).collect();
-
 		let dmabuf_default_feedback = match render_node {
 			Ok(Some(node)) => DmabufFeedbackBuilder::new(node.dev_id(), dmabuf_formats.clone())
 				.build()
@@ -157,7 +147,6 @@ impl WaylandState {
 		display_handle.create_global::<Self, WlDataDeviceManager, _>(3, ());
 		display_handle.create_global::<Self, XdgWmBase, _>(5, ());
 		display_handle.create_global::<Self, ZxdgDecorationManagerV1, _>(1, ());
-		display_handle.create_global::<Self, WlDrm, _>(2, ());
 
 		info!("Init Wayland compositor");
 
@@ -170,7 +159,6 @@ impl WaylandState {
 				// xdg_activation_state,
 				kde_decoration_state,
 				shm_state,
-				drm_formats,
 				dmabuf_state,
 				dmabuf_tx,
 				output,
@@ -200,14 +188,10 @@ impl DmabufHandler for WaylandState {
 		&mut self,
 		_global: &DmabufGlobal,
 		dmabuf: Dmabuf,
-		notifier: dmabuf::ImportNotifier,
+	) -> Result<(), dmabuf::ImportError> {
-	) {
+		self.dmabuf_tx.send(dmabuf).map_err(|_| ImportError::Failed)
-		self.dmabuf_tx.send((dmabuf, Some(notifier))).unwrap();
 	}
 }
-impl OutputHandler for WaylandState {
-	fn output_bound(&mut self, _output: Output, _wl_output: WlOutput) {}
-}
 delegate_dmabuf!(WaylandState);
 delegate_shm!(WaylandState);
 delegate_output!(WaylandState);

src/wayland/surface.rs

@@ -1,4 +1,4 @@
-use super::{state::WaylandState, utils::get_data};
+use super::state::WaylandState;
 use crate::{
 	core::{delta::Delta, destroy_queue, registry::Registry},
 	nodes::drawable::{model::ModelPart, shaders::PANEL_SHADER_BYTES},
@@ -77,13 +77,13 @@ impl CoreSurface {
 	}
 
 	pub fn from_wl_surface(surf: &WlSurface) -> Option<Arc<CoreSurface>> {
-		get_data(surf)
+		compositor::with_states(surf, |data| {
+			data.data_map.get::<Arc<CoreSurface>>().cloned()
+		})
 	}
 
 	pub fn process(&self, sk: &impl StereoKitDraw, renderer: &mut GlesRenderer) {
-		let Some(wl_surface) = self.wl_surface() else {
+		let Some(wl_surface) = self.wl_surface() else {return};
-			return;
-		};
 
 		let sk_tex = self
 			.sk_tex
@@ -124,23 +124,13 @@ impl CoreSurface {
 			let Some(renderer_surface_state) = data
 				.data_map
 				.get::<RendererSurfaceStateUserData>()
-				.map(RefCell::borrow)
+				.map(RefCell::borrow) else {return};
-			else {
-				return;
-			};
 			let Some(smithay_tex) = renderer_surface_state
 				.texture::<GlesRenderer>(renderer.id())
-				.cloned()
+				.cloned() else {return};
-			else {
-				return;
-			};
 
-			let Some(sk_tex) = self.sk_tex.get() else {
+			let Some(sk_tex) = self.sk_tex.get() else {return};
-				return;
+			let Some(sk_mat) = self.sk_mat.get() else {return};
-			};
-			let Some(sk_mat) = self.sk_mat.get() else {
-				return;
-			};
 			unsafe {
 				sk.tex_set_surface(
 					sk_tex.as_ref(),
@@ -159,9 +149,7 @@ impl CoreSurface {
 				sk.material_set_queue_offset(sk_mat.as_ref().as_ref(), *material_offset as i32);
 			}
 
-			let Some(surface_size) = renderer_surface_state.surface_size() else {
+			let Some(surface_size) = renderer_surface_state.surface_size() else {return};
-				return;
-			};
 			let new_mapped_data = CoreSurfaceData {
 				size: Vector2::from([surface_size.w as u32, surface_size.h as u32]),
 				wl_tex: Some(SendWrapper::new(smithay_tex)),
@@ -176,9 +164,7 @@ impl CoreSurface {
 	}
 
 	pub fn frame(&self, sk: &impl StereoKitDraw, output: Output) {
-		let Some(wl_surface) = self.wl_surface() else {
+		let Some(wl_surface) = self.wl_surface() else {return};
-			return;
-		};
 
 		send_frames_surface_tree(
 			&wl_surface,
@@ -210,7 +196,10 @@ impl CoreSurface {
 		self.weak_surface.upgrade().ok()
 	}
 
-	pub fn with_states<T, F: FnOnce(&SurfaceData) -> T>(&self, f: F) -> Option<T> {
+	pub fn with_states<F, T>(&self, f: F) -> Option<T>
+	where
+		F: FnOnce(&SurfaceData) -> T,
+	{
 		self.wl_surface()
 			.map(|wl_surface| compositor::with_states(&wl_surface, f))
 	}

src/wayland/utils.rs

@@ -1,14 +0,0 @@
-use smithay::{reexports::wayland_server::protocol::wl_surface::WlSurface, wayland::compositor};
-use std::sync::Arc;
-
-pub fn insert_data<T: Send + Sync + 'static>(wl_surface: &WlSurface, data: T) {
-	insert_data_raw(wl_surface, Arc::new(data))
-}
-pub fn insert_data_raw<T: Send + Sync + 'static>(wl_surface: &WlSurface, data: Arc<T>) {
-	compositor::with_states(wl_surface, |d| {
-		d.data_map.insert_if_missing_threadsafe(move || data)
-	});
-}
-pub fn get_data<T: Send + Sync + 'static>(wl_surface: &WlSurface) -> Option<Arc<T>> {
-	compositor::with_states(wl_surface, |d| d.data_map.get::<Arc<T>>().cloned())
-}

src/wayland/wayland-drm.xml

@@ -1,189 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<protocol name="drm">
-
-    <copyright>
-        Copyright © 2008-2011 Kristian Høgsberg
-        Copyright © 2010-2011 Intel Corporation
-
-        Permission to use, copy, modify, distribute, and sell this
-        software and its documentation for any purpose is hereby granted
-        without fee, provided that\n the above copyright notice appear in
-        all copies and that both that copyright notice and this permission
-        notice appear in supporting documentation, and that the name of
-        the copyright holders not be used in advertising or publicity
-        pertaining to distribution of the software without specific,
-        written prior permission. The copyright holders make no
-        representations about the suitability of this software for any
-        purpose. It is provided "as is" without express or implied
-        warranty.
-
-        THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
-        SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-        FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
-        SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-        WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-        AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-        ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
-        THIS SOFTWARE.
-    </copyright>
-
-    <!-- drm support. This object is created by the server and published
-       using the display's global event. -->
-    <interface name="wl_drm" version="2">
-        <enum name="error">
-            <entry name="authenticate_fail" value="0" />
-            <entry name="invalid_format" value="1" />
-            <entry name="invalid_name" value="2" />
-        </enum>
-
-        <enum name="format">
-            <!-- The drm format codes match the #defines in drm_fourcc.h.
-           The formats actually supported by the compositor will be
-           reported by the format event. New codes must not be added,
-           unless directly taken from drm_fourcc.h. -->
-            <entry name="c8" value="0x20203843" />
-            <entry name="rgb332" value="0x38424752" />
-            <entry name="bgr233" value="0x38524742" />
-            <entry name="xrgb4444" value="0x32315258" />
-            <entry name="xbgr4444" value="0x32314258" />
-            <entry name="rgbx4444" value="0x32315852" />
-            <entry name="bgrx4444" value="0x32315842" />
-            <entry name="argb4444" value="0x32315241" />
-            <entry name="abgr4444" value="0x32314241" />
-            <entry name="rgba4444" value="0x32314152" />
-            <entry name="bgra4444" value="0x32314142" />
-            <entry name="xrgb1555" value="0x35315258" />
-            <entry name="xbgr1555" value="0x35314258" />
-            <entry name="rgbx5551" value="0x35315852" />
-            <entry name="bgrx5551" value="0x35315842" />
-            <entry name="argb1555" value="0x35315241" />
-            <entry name="abgr1555" value="0x35314241" />
-            <entry name="rgba5551" value="0x35314152" />
-            <entry name="bgra5551" value="0x35314142" />
-            <entry name="rgb565" value="0x36314752" />
-            <entry name="bgr565" value="0x36314742" />
-            <entry name="rgb888" value="0x34324752" />
-            <entry name="bgr888" value="0x34324742" />
-            <entry name="xrgb8888" value="0x34325258" />
-            <entry name="xbgr8888" value="0x34324258" />
-            <entry name="rgbx8888" value="0x34325852" />
-            <entry name="bgrx8888" value="0x34325842" />
-            <entry name="argb8888" value="0x34325241" />
-            <entry name="abgr8888" value="0x34324241" />
-            <entry name="rgba8888" value="0x34324152" />
-            <entry name="bgra8888" value="0x34324142" />
-            <entry name="xrgb2101010" value="0x30335258" />
-            <entry name="xbgr2101010" value="0x30334258" />
-            <entry name="rgbx1010102" value="0x30335852" />
-            <entry name="bgrx1010102" value="0x30335842" />
-            <entry name="argb2101010" value="0x30335241" />
-            <entry name="abgr2101010" value="0x30334241" />
-            <entry name="rgba1010102" value="0x30334152" />
-            <entry name="bgra1010102" value="0x30334142" />
-            <entry name="yuyv" value="0x56595559" />
-            <entry name="yvyu" value="0x55595659" />
-            <entry name="uyvy" value="0x59565955" />
-            <entry name="vyuy" value="0x59555956" />
-            <entry name="ayuv" value="0x56555941" />
-            <entry name="xyuv8888" value="0x56555958" />
-            <entry name="nv12" value="0x3231564e" />
-            <entry name="nv21" value="0x3132564e" />
-            <entry name="nv16" value="0x3631564e" />
-            <entry name="nv61" value="0x3136564e" />
-            <entry name="yuv410" value="0x39565559" />
-            <entry name="yvu410" value="0x39555659" />
-            <entry name="yuv411" value="0x31315559" />
-            <entry name="yvu411" value="0x31315659" />
-            <entry name="yuv420" value="0x32315559" />
-            <entry name="yvu420" value="0x32315659" />
-            <entry name="yuv422" value="0x36315559" />
-            <entry name="yvu422" value="0x36315659" />
-            <entry name="yuv444" value="0x34325559" />
-            <entry name="yvu444" value="0x34325659" />
-            <entry name="abgr16f" value="0x48344241" />
-            <entry name="xbgr16f" value="0x48344258" />
-        </enum>
-
-        <!-- Call this request with the magic received from drmGetMagic().
-         It will be passed on to the drmAuthMagic() or
-         DRIAuthConnection() call.  This authentication must be
-         completed before create_buffer could be used. -->
-        <request name="authenticate">
-            <arg name="id" type="uint" />
-        </request>
-
-        <!-- Create a wayland buffer for the named DRM buffer.  The DRM
-         surface must have a name using the flink ioctl -->
-        <request name="create_buffer">
-            <arg name="id" type="new_id" interface="wl_buffer" />
-            <arg name="name" type="uint" />
-            <arg name="width" type="int" />
-            <arg name="height" type="int" />
-            <arg name="stride" type="uint" />
-            <arg name="format" type="uint" />
-        </request>
-
-        <!-- Create a wayland buffer for the named DRM buffer.  The DRM
-         surface must have a name using the flink ioctl -->
-        <request name="create_planar_buffer">
-            <arg name="id" type="new_id" interface="wl_buffer" />
-            <arg name="name" type="uint" />
-            <arg name="width" type="int" />
-            <arg name="height" type="int" />
-            <arg name="format" type="uint" />
-            <arg name="offset0" type="int" />
-            <arg name="stride0" type="int" />
-            <arg name="offset1" type="int" />
-            <arg name="stride1" type="int" />
-            <arg name="offset2" type="int" />
-            <arg name="stride2" type="int" />
-        </request>
-
-        <!-- Notification of the path of the drm device which is used by
-         the server.  The client should use this device for creating
-         local buffers.  Only buffers created from this device should
-         be be passed to the server using this drm object's
-         create_buffer request. -->
-        <event name="device">
-            <arg name="name" type="string" />
-        </event>
-
-        <event name="format">
-            <arg name="format" type="uint" />
-        </event>
-
-        <!-- Raised if the authenticate request succeeded -->
-        <event name="authenticated" />
-
-        <enum name="capability" since="2">
-            <description summary="wl_drm capability bitmask">
-                Bitmask of capabilities.
-            </description>
-            <entry name="prime" value="1" summary="wl_drm prime available" />
-        </enum>
-
-        <event name="capabilities">
-            <arg name="value" type="uint" />
-        </event>
-
-        <!-- Version 2 additions -->
-
-        <!-- Create a wayland buffer for the prime fd.  Use for regular and planar
-         buffers.  Pass 0 for offset and stride for unused planes. -->
-        <request name="create_prime_buffer" since="2">
-            <arg name="id" type="new_id" interface="wl_buffer" />
-            <arg name="name" type="fd" />
-            <arg name="width" type="int" />
-            <arg name="height" type="int" />
-            <arg name="format" type="uint" />
-            <arg name="offset0" type="int" />
-            <arg name="stride0" type="int" />
-            <arg name="offset1" type="int" />
-            <arg name="stride1" type="int" />
-            <arg name="offset2" type="int" />
-            <arg name="stride2" type="int" />
-        </request>
-
-    </interface>
-
-</protocol>

src/wayland/xdg_shell/backend.rs

@@ -1,310 +0,0 @@
-use super::{popup::PopupData, surface::XdgSurfaceData, ToplevelData};
-use crate::{
-	nodes::{
-		data::KEYMAPS,
-		drawable::model::ModelPart,
-		items::panel::{Backend, ChildInfo, PanelItem, PanelItemInitData, SurfaceID},
-	},
-	wayland::{
-		seat::{CursorInfo, KeyboardEvent, PointerEvent, SeatData},
-		state::ClientState,
-		surface::CoreSurface,
-		utils, SERIAL_COUNTER,
-	},
-};
-use color_eyre::eyre::{eyre, Result};
-use mint::Vector2;
-use parking_lot::Mutex;
-use rustc_hash::FxHashMap;
-use smithay::reexports::{
-	wayland_protocols::xdg::shell::server::xdg_toplevel::XdgToplevel,
-	wayland_server::{protocol::wl_surface::WlSurface, Resource, Weak},
-};
-use std::sync::Arc;
-use tokio::sync::watch;
-use tracing::debug;
-
-pub struct XdgToplevelState {
-	pub fullscreen: bool,
-	pub activated: bool,
-}
-
-pub struct XdgBackend {
-	toplevel: Weak<XdgToplevel>,
-	toplevel_wl_surface: Weak<WlSurface>,
-	pub toplevel_state: Mutex<XdgToplevelState>,
-	popups: Mutex<FxHashMap<String, Weak<WlSurface>>>,
-	pub cursor: watch::Receiver<Option<CursorInfo>>,
-	pub seat: Arc<SeatData>,
-	pointer_grab: Mutex<Option<SurfaceID>>,
-	keyboard_grab: Mutex<Option<SurfaceID>>,
-}
-impl XdgBackend {
-	pub fn create(
-		toplevel_wl_surface: WlSurface,
-		toplevel: XdgToplevel,
-		seat: Arc<SeatData>,
-	) -> Self {
-		let cursor = seat.new_surface(&toplevel_wl_surface);
-		XdgBackend {
-			toplevel: toplevel.downgrade(),
-			toplevel_wl_surface: toplevel_wl_surface.downgrade(),
-			toplevel_state: Mutex::new(XdgToplevelState {
-				fullscreen: false,
-				activated: false,
-			}),
-			popups: Mutex::new(FxHashMap::default()),
-			cursor,
-			seat,
-			pointer_grab: Mutex::new(None),
-			keyboard_grab: Mutex::new(None),
-		}
-	}
-	fn wl_surface_from_id(&self, id: &SurfaceID) -> Option<WlSurface> {
-		match id {
-			SurfaceID::Cursor => self.cursor.borrow().as_ref()?.surface.upgrade().ok(),
-			SurfaceID::Toplevel => self.toplevel_wl_surface(),
-			SurfaceID::Child(popup) => {
-				let popups = self.popups.lock();
-				popups.get(popup)?.upgrade().ok()
-			}
-		}
-	}
-	fn toplevel_wl_surface(&self) -> Option<WlSurface> {
-		self.toplevel_wl_surface.upgrade().ok()
-	}
-
-	pub fn configure(&self, size: Option<Vector2<u32>>) {
-		let Ok(xdg_toplevel) = self.toplevel.upgrade() else {
-			return;
-		};
-		let Some(wl_surface) = self.toplevel_wl_surface() else {
-			return;
-		};
-		let Some(xdg_surface_data) = wl_surface.data::<XdgSurfaceData>() else {
-			return;
-		};
-		let Some(core_surface) = CoreSurface::from_wl_surface(&wl_surface) else {
-			return;
-		};
-		let Some(surface_size) = core_surface.size() else {
-			return;
-		};
-
-		xdg_toplevel.configure(
-			size.unwrap_or(surface_size).x as i32,
-			size.unwrap_or(surface_size).y as i32,
-			self.states()
-				.into_iter()
-				.flat_map(|state| state.to_ne_bytes())
-				.collect(),
-		);
-		xdg_surface_data.xdg_surface.configure(SERIAL_COUNTER.inc());
-		self.flush_client();
-	}
-	fn states(&self) -> Vec<u32> {
-		let mut states = vec![1, 5, 6, 7, 8]; // maximized always and tiled
-		let toplevel_state = self.toplevel_state.lock();
-		if toplevel_state.fullscreen {
-			states.push(2);
-		}
-		if toplevel_state.activated {
-			states.push(4);
-		}
-		states
-	}
-
-	pub fn new_popup(
-		&self,
-		panel_item: &PanelItem<XdgBackend>,
-		popup_wl_surface: &WlSurface,
-		data: &PopupData,
-	) {
-		self.popups
-			.lock()
-			.insert(data.uid.clone(), popup_wl_surface.downgrade());
-
-		let Some(geometry) = data.geometry() else {
-			return;
-		};
-		panel_item.new_child(
-			&data.uid,
-			ChildInfo {
-				parent: utils::get_data::<SurfaceID>(&data.parent())
-					.unwrap()
-					.as_ref()
-					.clone(),
-				geometry,
-			},
-		)
-	}
-	pub fn reposition_popup(&self, panel_item: &PanelItem<XdgBackend>, popup_state: &PopupData) {
-		let Some(geometry) = popup_state.geometry() else {
-			return;
-		};
-		panel_item.reposition_child(&popup_state.uid, geometry)
-	}
-	pub fn drop_popup(&self, panel_item: &PanelItem<XdgBackend>, uid: &str) {
-		panel_item.drop_child(uid);
-		let Some(popup) = self.popups.lock().remove(uid) else {
-			return;
-		};
-		let Some(wl_surface) = popup.upgrade().ok() else {
-			return;
-		};
-		self.seat.drop_surface(&wl_surface);
-	}
-
-	fn child_data(&self) -> FxHashMap<String, ChildInfo> {
-		FxHashMap::from_iter(self.popups.lock().iter().filter_map(|(uid, v)| {
-			let wl_surface = v.upgrade().ok()?;
-			let popup_data = utils::get_data::<PopupData>(&wl_surface)?;
-			let parent = utils::get_data::<SurfaceID>(&popup_data.parent())?
-				.as_ref()
-				.clone();
-			let geometry = utils::get_data::<XdgSurfaceData>(&wl_surface)?
-				.geometry
-				.lock()
-				.clone()?;
-			Some((uid.clone(), ChildInfo { parent, geometry }))
-		}))
-	}
-
-	fn flush_client(&self) {
-		let Some(client) = self.toplevel_wl_surface().and_then(|s| s.client()) else {
-			return;
-		};
-		if let Some(client_state) = client.get_data::<ClientState>() {
-			client_state.flush();
-		}
-	}
-}
-impl Drop for XdgBackend {
-	fn drop(&mut self) {
-		debug!("Dropped panel item gracefully");
-	}
-}
-impl Backend for XdgBackend {
-	fn start_data(&self) -> Result<PanelItemInitData> {
-		let toplevel = self.toplevel_wl_surface();
-		let toplevel_data = toplevel.as_ref().and_then(utils::get_data::<ToplevelData>);
-		let toplevel_data = toplevel_data
-			.as_deref()
-			.clone()
-			.ok_or_else(|| eyre!("Could not get toplevel"))?;
-
-		let pointer_grab = self.pointer_grab.lock().clone();
-		let keyboard_grab = self.keyboard_grab.lock().clone();
-
-		Ok(PanelItemInitData {
-			cursor: self.cursor.borrow().as_ref().and_then(|c| c.cursor_data()),
-			toplevel: toplevel_data.into(),
-			children: self.child_data(),
-			pointer_grab,
-			keyboard_grab,
-		})
-	}
-
-	fn apply_surface_material(&self, surface: SurfaceID, model_part: &Arc<ModelPart>) {
-		let Some(wl_surface) = self.wl_surface_from_id(&surface) else {
-			return;
-		};
-		let Some(core_surface) = CoreSurface::from_wl_surface(&wl_surface) else {
-			return;
-		};
-
-		core_surface.apply_material(model_part);
-	}
-
-	fn close_toplevel(&self) {
-		let Ok(xdg_toplevel) = self.toplevel.upgrade() else {
-			return;
-		};
-		xdg_toplevel.close();
-	}
-	fn auto_size_toplevel(&self) {
-		self.configure(Some([0, 0].into()));
-	}
-	fn set_toplevel_size(&self, size: Vector2<u32>) {
-		self.configure(Some(size));
-	}
-	fn set_toplevel_focused_visuals(&self, focused: bool) {
-		self.toplevel_state.lock().activated = focused;
-		self.configure(None);
-	}
-
-	fn pointer_motion(&self, surface: &SurfaceID, position: Vector2<f32>) {
-		let Some(surface) = self.wl_surface_from_id(surface) else {
-			return;
-		};
-		self.seat
-			.pointer_event(&surface, PointerEvent::Motion(position));
-	}
-	fn pointer_button(&self, surface: &SurfaceID, button: u32, pressed: bool) {
-		let Some(surface) = self.wl_surface_from_id(surface) else {
-			return;
-		};
-		self.seat.pointer_event(
-			&surface,
-			PointerEvent::Button {
-				button,
-				state: if pressed { 1 } else { 0 },
-			},
-		)
-	}
-	fn pointer_scroll(
-		&self,
-		surface: &SurfaceID,
-		scroll_distance: Option<Vector2<f32>>,
-		scroll_steps: Option<Vector2<f32>>,
-	) {
-		let Some(surface) = self.wl_surface_from_id(surface) else {
-			return;
-		};
-		self.seat.pointer_event(
-			&surface,
-			PointerEvent::Scroll {
-				axis_continuous: scroll_distance,
-				axis_discrete: scroll_steps,
-			},
-		)
-	}
-
-	fn keyboard_keys(&self, surface: &SurfaceID, keymap_id: &str, keys: Vec<i32>) {
-		let Some(surface) = self.wl_surface_from_id(surface) else {
-			return;
-		};
-		let keymaps = KEYMAPS.lock();
-		let Some(keymap) = keymaps.get(keymap_id).cloned() else {
-			return;
-		};
-		if self.seat.set_keymap(keymap, vec![surface.clone()]).is_err() {
-			return;
-		}
-		for key in keys {
-			self.seat.keyboard_event(
-				&surface,
-				KeyboardEvent::Key {
-					key: key.abs() as u32,
-					state: key > 0,
-				},
-			);
-		}
-	}
-
-	fn touch_down(&self, surface: &SurfaceID, id: u32, position: Vector2<f32>) {
-		let Some(surface) = self.wl_surface_from_id(surface) else {
-			return;
-		};
-		self.seat.touch_down(&surface, id, position)
-	}
-	fn touch_move(&self, id: u32, position: Vector2<f32>) {
-		self.seat.touch_move(id, position)
-	}
-	fn touch_up(&self, id: u32) {
-		self.seat.touch_up(id)
-	}
-	fn reset_touches(&self) {
-		self.seat.reset_touches()
-	}
-}

src/wayland/xdg_shell/mod.rs

@@ -1,69 +0,0 @@
-use self::{backend::XdgBackend, toplevel::ToplevelData};
-use super::state::WaylandState;
-use crate::wayland::{
-	utils::insert_data,
-	xdg_shell::{positioner::PositionerData, surface::XdgSurfaceData},
-};
-use parking_lot::Mutex;
-use smithay::reexports::{
-	wayland_protocols::xdg::shell::server::xdg_wm_base::{self, XdgWmBase},
-	wayland_server::{Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource},
-};
-use tracing::debug;
-
-mod backend;
-mod popup;
-mod positioner;
-mod surface;
-mod toplevel;
-
-impl GlobalDispatch<XdgWmBase, (), WaylandState> for WaylandState {
-	fn bind(
-		_state: &mut WaylandState,
-		_handle: &DisplayHandle,
-		_client: &Client,
-		resource: New<XdgWmBase>,
-		_global_data: &(),
-		data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		data_init.init(resource, ());
-	}
-}
-
-impl Dispatch<XdgWmBase, (), WaylandState> for WaylandState {
-	fn request(
-		_state: &mut WaylandState,
-		_client: &Client,
-		_resource: &XdgWmBase,
-		request: xdg_wm_base::Request,
-		_data: &(),
-		_dhandle: &DisplayHandle,
-		data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		match request {
-			xdg_wm_base::Request::CreatePositioner { id } => {
-				let positioner = data_init.init(id, Mutex::new(PositionerData::default()));
-				debug!(?positioner, "Create XDG positioner");
-			}
-			xdg_wm_base::Request::GetXdgSurface { id, surface } => {
-				let xdg_surface = data_init.init(id, surface.downgrade());
-				debug!(?xdg_surface, "Create XDG surface");
-				insert_data(
-					&surface,
-					XdgSurfaceData {
-						wl_surface: surface.downgrade(),
-						xdg_surface,
-						geometry: Mutex::new(None),
-					},
-				);
-			}
-			xdg_wm_base::Request::Pong { serial } => {
-				debug!(serial, "Client pong");
-			}
-			xdg_wm_base::Request::Destroy => {
-				debug!("Destroy XDG WM base");
-			}
-			_ => unreachable!(),
-		}
-	}
-}

src/wayland/xdg_shell/popup.rs

@@ -1,119 +0,0 @@
-use super::{backend::XdgBackend, positioner::PositionerData};
-use crate::{
-	nodes::items::panel::{Geometry, PanelItem, SurfaceID},
-	wayland::{state::WaylandState, utils::get_data},
-};
-use parking_lot::Mutex;
-use smithay::reexports::{
-	wayland_protocols::xdg::shell::server::{
-		xdg_popup::{self, XdgPopup},
-		xdg_positioner::XdgPositioner,
-	},
-	wayland_server::{
-		protocol::wl_surface::WlSurface, Client, DataInit, Dispatch, DisplayHandle, Resource,
-		Weak as WlWeak,
-	},
-};
-use std::sync::{Arc, Weak};
-use tracing::{debug, error};
-use wayland_backend::server::ClientId;
-
-#[derive(Debug)]
-pub struct PopupData {
-	pub uid: String,
-	grabbed: Mutex<bool>,
-	parent: Mutex<WlWeak<WlSurface>>,
-	panel_item: Weak<PanelItem<XdgBackend>>,
-	positioner: Mutex<XdgPositioner>,
-}
-impl PopupData {
-	pub fn new(
-		uid: impl ToString,
-		parent: WlSurface,
-		panel_item: &Arc<PanelItem<XdgBackend>>,
-		positioner: XdgPositioner,
-	) -> Self {
-		PopupData {
-			uid: uid.to_string(),
-			grabbed: Mutex::new(false),
-			parent: Mutex::new(parent.downgrade()),
-			panel_item: Arc::downgrade(panel_item),
-			positioner: Mutex::new(positioner),
-		}
-	}
-	pub fn geometry(&self) -> Option<Geometry> {
-		let positioner = self.positioner.lock().clone();
-		let positioner_data = positioner.data::<Mutex<PositionerData>>()?.lock();
-		Some(positioner_data.clone().into())
-	}
-	pub fn parent(&self) -> WlSurface {
-		self.parent.lock().upgrade().unwrap()
-	}
-}
-
-impl Dispatch<XdgPopup, WlWeak<WlSurface>, WaylandState> for WaylandState {
-	fn request(
-		_state: &mut WaylandState,
-		_client: &Client,
-		xdg_popup: &XdgPopup,
-		request: xdg_popup::Request,
-		wl_surface_resource: &WlWeak<WlSurface>,
-		_dhandle: &DisplayHandle,
-		_data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		let Ok(wl_surface) = wl_surface_resource.upgrade() else {
-			error!("Couldn't get the wayland surface of the xdg popup");
-			return;
-		};
-		let Some(popup_data) = get_data::<PopupData>(&wl_surface) else {
-			error!("Couldn't get the XdgPopup");
-			return;
-		};
-		let Some(panel_item) = popup_data.panel_item.upgrade() else {
-			error!("Couldn't get the panel item");
-			return;
-		};
-		match request {
-			xdg_popup::Request::Grab { seat, serial } => {
-				*popup_data.grabbed.lock() = true;
-				debug!(?xdg_popup, ?seat, serial, "XDG popup grab");
-				panel_item.grab_keyboard(Some(SurfaceID::Child(popup_data.uid.clone())));
-			}
-			xdg_popup::Request::Reposition { positioner, token } => {
-				debug!(?xdg_popup, ?positioner, token, "XDG popup reposition");
-				*popup_data.positioner.lock() = positioner;
-				panel_item
-					.backend
-					.reposition_popup(&panel_item, &popup_data);
-			}
-			xdg_popup::Request::Destroy => {
-				debug!(?xdg_popup, "Destroy XDG popup");
-				if *popup_data.grabbed.lock() {
-					panel_item.grab_keyboard(None);
-				}
-			}
-			_ => unreachable!(),
-		}
-	}
-
-	fn destroyed(
-		_state: &mut WaylandState,
-		_client: ClientId,
-		_popup: &XdgPopup,
-		data: &WlWeak<WlSurface>,
-	) {
-		let Ok(wl_surface) = data.upgrade() else {
-			error!("Couldn't get the wayland surface of the xdg popup");
-			return;
-		};
-		let Some(popup_data) = get_data::<PopupData>(&wl_surface) else {
-			error!("Couldn't get the XdgPopup");
-			return;
-		};
-		let Some(panel_item) = popup_data.panel_item.upgrade() else {
-			error!("Couldn't get the panel item");
-			return;
-		};
-		panel_item.backend.drop_popup(&panel_item, &popup_data.uid);
-	}
-}

src/wayland/xdg_shell/positioner.rs

@@ -1,226 +0,0 @@
-use crate::{nodes::items::panel::Geometry, wayland::state::WaylandState};
-use mint::Vector2;
-use parking_lot::Mutex;
-use smithay::reexports::{
-	wayland_protocols::xdg::shell::server::xdg_positioner::{
-		self, Anchor, ConstraintAdjustment, Gravity, XdgPositioner,
-	},
-	wayland_server::{Client, DataInit, Dispatch, DisplayHandle, Resource},
-};
-use tracing::{debug, warn};
-use wayland_backend::protocol::WEnum;
-
-#[derive(Debug, Clone, Copy)]
-pub struct PositionerData {
-	size: Vector2<u32>,
-	anchor_rect_pos: Vector2<i32>,
-	anchor_rect_size: Vector2<u32>,
-	anchor: Anchor,
-	gravity: Gravity,
-	constraint_adjustment: ConstraintAdjustment,
-	offset: Vector2<i32>,
-	reactive: bool,
-}
-impl Default for PositionerData {
-	fn default() -> Self {
-		Self {
-			size: Vector2::from([0; 2]),
-			anchor_rect_pos: Vector2::from([0; 2]),
-			anchor_rect_size: Vector2::from([0; 2]),
-			anchor: Anchor::None,
-			gravity: Gravity::None,
-			constraint_adjustment: ConstraintAdjustment::None,
-			offset: Vector2::from([0; 2]),
-			reactive: false,
-		}
-	}
-}
-
-impl PositionerData {
-	fn anchor_has_edge(&self, edge: Anchor) -> bool {
-		match edge {
-			Anchor::Top => {
-				self.anchor == Anchor::Top
-					|| self.anchor == Anchor::TopLeft
-					|| self.anchor == Anchor::TopRight
-			}
-			Anchor::Bottom => {
-				self.anchor == Anchor::Bottom
-					|| self.anchor == Anchor::BottomLeft
-					|| self.anchor == Anchor::BottomRight
-			}
-			Anchor::Left => {
-				self.anchor == Anchor::Left
-					|| self.anchor == Anchor::TopLeft
-					|| self.anchor == Anchor::BottomLeft
-			}
-			Anchor::Right => {
-				self.anchor == Anchor::Right
-					|| self.anchor == Anchor::TopRight
-					|| self.anchor == Anchor::BottomRight
-			}
-			_ => unreachable!(),
-		}
-	}
-
-	fn gravity_has_edge(&self, edge: Gravity) -> bool {
-		match edge {
-			Gravity::Top => {
-				self.gravity == Gravity::Top
-					|| self.gravity == Gravity::TopLeft
-					|| self.gravity == Gravity::TopRight
-			}
-			Gravity::Bottom => {
-				self.gravity == Gravity::Bottom
-					|| self.gravity == Gravity::BottomLeft
-					|| self.gravity == Gravity::BottomRight
-			}
-			Gravity::Left => {
-				self.gravity == Gravity::Left
-					|| self.gravity == Gravity::TopLeft
-					|| self.gravity == Gravity::BottomLeft
-			}
-			Gravity::Right => {
-				self.gravity == Gravity::Right
-					|| self.gravity == Gravity::TopRight
-					|| self.gravity == Gravity::BottomRight
-			}
-			_ => unreachable!(),
-		}
-	}
-
-	pub fn get_pos(&self) -> Vector2<i32> {
-		let mut pos = self.offset;
-
-		if self.anchor_has_edge(Anchor::Top) {
-			pos.y += self.anchor_rect_pos.y;
-		} else if self.anchor_has_edge(Anchor::Bottom) {
-			pos.y += self.anchor_rect_pos.y + self.anchor_rect_size.y as i32;
-		} else {
-			pos.y += self.anchor_rect_pos.y + self.anchor_rect_size.y as i32 / 2;
-		}
-
-		if self.anchor_has_edge(Anchor::Left) {
-			pos.x += self.anchor_rect_pos.x;
-		} else if self.anchor_has_edge(Anchor::Right) {
-			pos.x += self.anchor_rect_pos.x + self.anchor_rect_size.x as i32;
-		} else {
-			pos.x += self.anchor_rect_pos.x + self.anchor_rect_size.x as i32 / 2;
-		}
-
-		if self.gravity_has_edge(Gravity::Top) {
-			pos.y -= self.size.y as i32;
-		} else if !self.gravity_has_edge(Gravity::Bottom) {
-			pos.y -= self.size.y as i32 / 2;
-		}
-
-		if self.gravity_has_edge(Gravity::Left) {
-			pos.x -= self.size.x as i32;
-		} else if !self.gravity_has_edge(Gravity::Right) {
-			pos.x -= self.size.x as i32 / 2;
-		}
-
-		pos
-	}
-}
-impl From<PositionerData> for Geometry {
-	fn from(value: PositionerData) -> Self {
-		Geometry {
-			origin: value.get_pos(),
-			size: value.size,
-		}
-	}
-}
-
-impl Dispatch<XdgPositioner, Mutex<PositionerData>, WaylandState> for WaylandState {
-	fn request(
-		_state: &mut WaylandState,
-		_client: &Client,
-		positioner: &XdgPositioner,
-		request: xdg_positioner::Request,
-		data: &Mutex<PositionerData>,
-		_dhandle: &DisplayHandle,
-		_data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		match request {
-			xdg_positioner::Request::SetSize { width, height } => {
-				debug!(?positioner, width, height, "Set positioner size");
-				data.lock().size = Vector2::from([width as u32, height as u32]);
-			}
-			xdg_positioner::Request::SetAnchorRect {
-				x,
-				y,
-				width,
-				height,
-			} => {
-				if width < 1 || height < 1 {
-					positioner.post_error(
-						xdg_positioner::Error::InvalidInput,
-						"Invalid size for positioner's anchor rectangle.",
-					);
-					warn!(
-						?positioner,
-						width, height, "Invalid size for positioner's anchor rectangle"
-					);
-					return;
-				}
-
-				debug!(
-					?positioner,
-					x, y, width, height, "Set positioner anchor rectangle"
-				);
-				let mut data = data.lock();
-				data.anchor_rect_pos = [x, y].into();
-				data.anchor_rect_size = [width as u32, height as u32].into();
-			}
-			xdg_positioner::Request::SetAnchor { anchor } => {
-				if let WEnum::Value(anchor) = anchor {
-					debug!(?positioner, ?anchor, "Set positioner anchor");
-					data.lock().anchor = anchor;
-				}
-			}
-			xdg_positioner::Request::SetGravity { gravity } => {
-				if let WEnum::Value(gravity) = gravity {
-					debug!(?positioner, ?gravity, "Set positioner gravity");
-					data.lock().gravity = gravity;
-				}
-			}
-			xdg_positioner::Request::SetConstraintAdjustment {
-				constraint_adjustment,
-			} => {
-				debug!(
-					?positioner,
-					constraint_adjustment, "Set positioner constraint adjustment"
-				);
-				let Some(constraint_adjustment) =
-					ConstraintAdjustment::from_bits(constraint_adjustment)
-				else {
-					return;
-				};
-				data.lock().constraint_adjustment = constraint_adjustment;
-			}
-			xdg_positioner::Request::SetOffset { x, y } => {
-				debug!(?positioner, x, y, "Set positioner offset");
-				data.lock().offset = [x, y].into();
-			}
-			xdg_positioner::Request::SetReactive => {
-				debug!(?positioner, "Set positioner reactive");
-				data.lock().reactive = true;
-			}
-			xdg_positioner::Request::SetParentSize {
-				parent_width,
-				parent_height,
-			} => {
-				debug!(
-					?positioner,
-					parent_width, parent_height, "Set positioner parent size"
-				);
-			}
-			xdg_positioner::Request::SetParentConfigure { serial } => {
-				debug!(?positioner, serial, "Set positioner parent size");
-			}
-			xdg_positioner::Request::Destroy => (),
-			_ => unreachable!(),
-		}
-	}
-}

src/wayland/xdg_shell/surface.rs

@@ -1,236 +0,0 @@
-use crate::{
-	nodes::items::panel::{Geometry, PanelItem, SurfaceID},
-	wayland::{
-		seat::handle_cursor,
-		state::{ClientState, WaylandState},
-		surface::CoreSurface,
-		utils,
-		xdg_shell::{popup::PopupData, toplevel::ToplevelData, XdgBackend},
-		SERIAL_COUNTER,
-	},
-};
-use nanoid::nanoid;
-use parking_lot::Mutex;
-use smithay::reexports::{
-	wayland_protocols::xdg::shell::server::{
-		xdg_surface::{self, XdgSurface},
-		xdg_toplevel::{XdgToplevel, EVT_WM_CAPABILITIES_SINCE},
-	},
-	wayland_server::{
-		protocol::wl_surface::WlSurface, Client, DataInit, Dispatch, DisplayHandle, Resource,
-		Weak as WlWeak,
-	},
-};
-use std::sync::{Arc, Weak};
-use tracing::{debug, error};
-
-#[derive(Debug)]
-pub struct XdgSurfaceData {
-	pub wl_surface: WlWeak<WlSurface>,
-	pub xdg_surface: XdgSurface,
-	pub geometry: Mutex<Option<Geometry>>,
-}
-
-impl Dispatch<XdgSurface, WlWeak<WlSurface>, WaylandState> for WaylandState {
-	fn request(
-		state: &mut WaylandState,
-		client: &Client,
-		xdg_surface: &XdgSurface,
-		request: xdg_surface::Request,
-		wl_surface_resource: &WlWeak<WlSurface>,
-		_dhandle: &DisplayHandle,
-		data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		let Ok(wl_surface) = wl_surface_resource.upgrade() else {
-			error!("Couldn't get the wayland surface of the xdg surface");
-			return;
-		};
-		let Some(xdg_surface_data) = utils::get_data::<XdgSurfaceData>(&wl_surface) else {
-			error!("Couldn't get the XdgSurface");
-			return;
-		};
-		match request {
-			xdg_surface::Request::GetToplevel { id } => {
-				let toplevel = data_init.init(id, wl_surface_resource.clone());
-				utils::insert_data(&wl_surface, SurfaceID::Toplevel);
-				utils::insert_data(&wl_surface, toplevel.clone());
-				utils::insert_data(&wl_surface, ToplevelData::new(&wl_surface));
-				debug!(?toplevel, ?xdg_surface, "Create XDG toplevel");
-
-				if toplevel.version() >= EVT_WM_CAPABILITIES_SINCE {
-					toplevel.wm_capabilities(vec![3]);
-				}
-				toplevel.configure(
-					0,
-					0,
-					if toplevel.version() >= 2 {
-						vec![1, 5, 6, 7, 8]
-							.into_iter()
-							.flat_map(u32::to_ne_bytes)
-							.collect()
-					} else {
-						vec![]
-					},
-				);
-				xdg_surface.configure(SERIAL_COUNTER.inc());
-
-				let client_credentials = client.get_credentials(&state.display_handle).ok();
-				let Some(seat_data) = client.get_data::<ClientState>().map(|s| s.seat.clone())
-				else {
-					return;
-				};
-
-				let xdg_surface = xdg_surface.clone();
-				CoreSurface::add_to(
-					state.display_handle.clone(),
-					&wl_surface,
-					{
-						let wl_surface_resource = wl_surface_resource.clone();
-						move || {
-							let wl_surface = wl_surface_resource.upgrade().unwrap();
-
-							let backend = XdgBackend::create(
-								wl_surface.clone(),
-								toplevel.clone(),
-								seat_data.clone(),
-							);
-							let (node, panel_item) = PanelItem::create(
-								Box::new(backend),
-								client_credentials.map(|c| c.pid),
-							);
-							utils::insert_data(&wl_surface, Arc::downgrade(&panel_item));
-							utils::insert_data_raw(&wl_surface, node);
-							handle_cursor(&panel_item, panel_item.backend.cursor.clone());
-						}
-					},
-					{
-						let wl_surface_resource = wl_surface_resource.clone();
-						move |_| {
-							let wl_surface = wl_surface_resource.upgrade().unwrap();
-
-							let Some(panel_item) =
-								utils::get_data::<PanelItem<XdgBackend>>(&wl_surface)
-							else {
-								let Some(toplevel) = utils::get_data::<XdgToplevel>(&wl_surface)
-								else {
-									return;
-								};
-								// if the wayland toplevel isn't mapped, hammer it again with a configure until it cooperates
-								toplevel.configure(
-									0,
-									0,
-									if toplevel.version() >= 2 {
-										vec![5, 6, 7, 8]
-											.into_iter()
-											.flat_map(u32::to_ne_bytes)
-											.collect()
-									} else {
-										vec![]
-									},
-								);
-								xdg_surface.configure(SERIAL_COUNTER.inc());
-								return;
-							};
-							let Some(core_surface) = CoreSurface::from_wl_surface(&wl_surface)
-							else {
-								return;
-							};
-							let Some(size) = core_surface.size() else {
-								return;
-							};
-							panel_item.toplevel_size_changed(size);
-						}
-					},
-				);
-			}
-			xdg_surface::Request::GetPopup {
-				id,
-				parent,
-				positioner,
-			} => {
-				let Some(parent) = parent else { return };
-				let Some(parent_wl_surface) = parent
-					.data::<WlWeak<WlSurface>>()
-					.map(WlWeak::upgrade)
-					.map(Result::ok)
-					.flatten()
-				else {
-					return;
-				};
-				let Some(panel_item) =
-					utils::get_data::<Weak<PanelItem<XdgBackend>>>(&parent_wl_surface)
-						.as_deref()
-						.and_then(Weak::upgrade)
-				else {
-					return;
-				};
-
-				let uid = nanoid!();
-				let popup_data = PopupData::new(
-					uid.clone(),
-					parent_wl_surface.clone(),
-					&panel_item,
-					positioner,
-				);
-				handle_cursor(
-					&panel_item,
-					panel_item.backend.seat.new_surface(&wl_surface),
-				);
-				let xdg_popup = data_init.init(id, wl_surface.downgrade());
-				utils::insert_data(&wl_surface, SurfaceID::Child(uid));
-				utils::insert_data(&wl_surface, Arc::downgrade(&panel_item));
-				utils::insert_data(&wl_surface, popup_data);
-				utils::insert_data(&wl_surface, xdg_popup.clone());
-				debug!(?xdg_popup, ?xdg_surface, "Create XDG popup");
-
-				let xdg_surface = xdg_surface.downgrade();
-				let popup_wl_surface = wl_surface.downgrade();
-				CoreSurface::add_to(
-					state.display_handle.clone(),
-					&wl_surface,
-					move || {
-						let Ok(wl_surface) = popup_wl_surface.upgrade() else {
-							return;
-						};
-						let Some(popup_data) = utils::get_data::<PopupData>(&wl_surface) else {
-							return;
-						};
-						panel_item
-							.backend
-							.new_popup(&panel_item, &wl_surface, &*popup_data);
-					},
-					move |commit_count| {
-						if commit_count == 0 {
-							if let Ok(xdg_surface) = xdg_surface.upgrade() {
-								xdg_surface.configure(SERIAL_COUNTER.inc())
-							}
-						}
-					},
-				);
-			}
-			xdg_surface::Request::SetWindowGeometry {
-				x,
-				y,
-				width,
-				height,
-			} => {
-				debug!(
-					?xdg_surface,
-					x, y, width, height, "Set XDG surface geometry"
-				);
-				let geometry = Geometry {
-					origin: [x, y].into(),
-					size: [width as u32, height as u32].into(),
-				};
-				xdg_surface_data.geometry.lock().replace(geometry);
-			}
-			xdg_surface::Request::AckConfigure { serial } => {
-				debug!(?xdg_surface, serial, "Acknowledge XDG surface configure");
-			}
-			xdg_surface::Request::Destroy => {
-				debug!(?xdg_surface, "Destroy XDG surface");
-			}
-			_ => unreachable!(),
-		}
-	}
-}

src/wayland/xdg_shell/toplevel.rs

@@ -1,239 +0,0 @@
-use super::{backend::XdgBackend, surface::XdgSurfaceData};
-use crate::{
-	nodes::items::panel::{Geometry, PanelItem, ToplevelInfo},
-	wayland::{
-		state::WaylandState,
-		surface::CoreSurface,
-		utils::{self, get_data},
-	},
-};
-use mint::Vector2;
-use once_cell::sync::OnceCell;
-use parking_lot::Mutex;
-use smithay::reexports::{
-	wayland_protocols::xdg::shell::server::xdg_toplevel::{self, ResizeEdge, XdgToplevel},
-	wayland_server::{
-		protocol::wl_surface::WlSurface, Client, DataInit, Dispatch, DisplayHandle, Resource,
-		Weak as WlWeak,
-	},
-};
-use std::sync::Weak;
-use tracing::{debug, error};
-use wayland_backend::protocol::WEnum;
-
-pub struct ToplevelData {
-	panel_item: OnceCell<Weak<PanelItem<XdgBackend>>>,
-	wl_surface: WlWeak<WlSurface>,
-	parent: Mutex<Option<WlWeak<WlSurface>>>,
-	title: Mutex<Option<String>>,
-	app_id: Mutex<Option<String>>,
-	max_size: Mutex<Option<Vector2<u32>>>,
-	min_size: Mutex<Option<Vector2<u32>>>,
-}
-impl ToplevelData {
-	pub fn new(wl_surface: &WlSurface) -> Self {
-		ToplevelData {
-			panel_item: OnceCell::new(),
-			wl_surface: wl_surface.downgrade(),
-			parent: Mutex::new(None),
-			title: Mutex::new(None),
-			app_id: Mutex::new(None),
-			max_size: Mutex::new(None),
-			min_size: Mutex::new(None),
-		}
-	}
-	pub fn parent(&self) -> Option<WlSurface> {
-		self.parent
-			.lock()
-			.as_ref()
-			.map(WlWeak::upgrade)
-			.map(Result::ok)
-			.flatten()
-	}
-}
-impl From<&ToplevelData> for ToplevelInfo {
-	fn from(value: &ToplevelData) -> Self {
-		let wl_surface = value.wl_surface.upgrade().ok();
-		let size = CoreSurface::from_wl_surface(wl_surface.as_ref().unwrap())
-			.unwrap()
-			.size()
-			.unwrap();
-		let logical_rectangle = wl_surface
-			.as_ref()
-			.and_then(utils::get_data::<XdgSurfaceData>)
-			.and_then(|d| d.geometry.lock().clone())
-			.unwrap_or_else(|| Geometry {
-				origin: [0, 0].into(),
-				size,
-			});
-		let parent = value
-			.parent()
-			.as_ref()
-			.and_then(utils::get_data::<Weak<PanelItem<XdgBackend>>>)
-			.as_deref()
-			.and_then(Weak::upgrade)
-			.map(|i| i.uid.clone());
-		ToplevelInfo {
-			parent,
-			title: value.title.lock().clone(),
-			app_id: value.app_id.lock().clone(),
-			size,
-			min_size: value.min_size.lock().clone(),
-			max_size: value.max_size.lock().clone(),
-			logical_rectangle,
-		}
-	}
-}
-impl Drop for ToplevelData {
-	fn drop(&mut self) {
-		// let Some(panel_item) = self.panel_item.get().and_then(Weak::upgrade) else {
-		// return;
-		// };
-		// panel_item.drop_toplevel();
-	}
-}
-
-impl Dispatch<XdgToplevel, WlWeak<WlSurface>, WaylandState> for WaylandState {
-	fn request(
-		_state: &mut WaylandState,
-		_client: &Client,
-		xdg_toplevel: &XdgToplevel,
-		request: xdg_toplevel::Request,
-		wl_surface_resource: &WlWeak<WlSurface>,
-		_dhandle: &DisplayHandle,
-		_data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		let Ok(wl_surface) = wl_surface_resource.upgrade() else {
-			error!("Couldn't get the wayland surface of the xdg toplevel");
-			return;
-		};
-		let Some(toplevel_data) = utils::get_data::<ToplevelData>(&wl_surface) else {
-			error!("Couldn't get the XdgToplevel");
-			return;
-		};
-		match request {
-			xdg_toplevel::Request::SetParent { parent } => {
-				debug!(?xdg_toplevel, ?parent, "Set XDG Toplevel parent");
-				let Some(parent_xdg_toplevel) = parent else {
-					*toplevel_data.parent.lock() = None;
-					return;
-				};
-				let Some(parent_toplevel_data) = parent_xdg_toplevel.data::<ToplevelData>() else {
-					error!("Couldn't get XDG toplevel parent data");
-					return;
-				};
-				let Ok(parent_wl_surface) = parent_toplevel_data.wl_surface.upgrade() else {
-					error!("Couldn't get XDG toplevel parent wl surface");
-					return;
-				};
-				*toplevel_data.parent.lock() = Some(parent_wl_surface.downgrade());
-				let Some(parent_panel_item) = parent_toplevel_data
-					.panel_item
-					.get()
-					.and_then(Weak::upgrade)
-				else {
-					return;
-				};
-				let Some(panel_item) = get_data::<PanelItem<XdgBackend>>(&wl_surface) else {
-					error!("Couldn't get the panel item");
-					return;
-				};
-				panel_item.toplevel_parent_changed(&parent_panel_item.uid);
-			}
-			xdg_toplevel::Request::SetTitle { title } => {
-				debug!(?xdg_toplevel, ?title, "Set XDG Toplevel title");
-				*toplevel_data.title.lock() = (!title.is_empty()).then_some(title.clone());
-				let Some(panel_item) = get_data::<PanelItem<XdgBackend>>(&wl_surface) else {
-					error!("Couldn't get the panel item");
-					return;
-				};
-				panel_item.toplevel_title_changed(&title);
-			}
-			xdg_toplevel::Request::SetAppId { app_id } => {
-				debug!(?xdg_toplevel, ?app_id, "Set XDG Toplevel app ID");
-				*toplevel_data.app_id.lock() = (!app_id.is_empty()).then_some(app_id.clone());
-				let Some(panel_item) = get_data::<PanelItem<XdgBackend>>(&wl_surface) else {
-					error!("Couldn't get the panel item");
-					return;
-				};
-				panel_item.toplevel_app_id_changed(&app_id);
-			}
-			xdg_toplevel::Request::Move { seat, serial } => {
-				debug!(?xdg_toplevel, ?seat, serial, "XDG Toplevel move request");
-				let Some(panel_item) = get_data::<PanelItem<XdgBackend>>(&wl_surface) else {
-					error!("Couldn't get the panel item");
-					return;
-				};
-				panel_item.toplevel_move_request();
-			}
-			xdg_toplevel::Request::Resize {
-				seat,
-				serial,
-				edges,
-			} => {
-				let WEnum::Value(edges) = edges else { return };
-				debug!(
-					?xdg_toplevel,
-					?seat,
-					serial,
-					?edges,
-					"XDG Toplevel resize request"
-				);
-				let (up, down, left, right) = match edges {
-					ResizeEdge::Top => (true, false, false, false),
-					ResizeEdge::Bottom => (false, true, false, false),
-					ResizeEdge::Left => (false, false, true, false),
-					ResizeEdge::TopLeft => (true, false, true, false),
-					ResizeEdge::BottomLeft => (false, true, true, false),
-					ResizeEdge::Right => (false, false, false, true),
-					ResizeEdge::TopRight => (true, false, false, true),
-					ResizeEdge::BottomRight => (false, true, false, true),
-					_ => (false, false, false, false),
-				};
-				let Some(panel_item) = get_data::<PanelItem<XdgBackend>>(&wl_surface) else {
-					error!("Couldn't get the panel item");
-					return;
-				};
-				panel_item.toplevel_resize_request(up, down, left, right)
-			}
-			xdg_toplevel::Request::SetMaxSize { width, height } => {
-				debug!(?xdg_toplevel, width, height, "Set XDG Toplevel max size");
-				*toplevel_data.max_size.lock() = (width > 1 || height > 1)
-					.then_some(Vector2::from([width as u32, height as u32]));
-			}
-			xdg_toplevel::Request::SetMinSize { width, height } => {
-				debug!(?xdg_toplevel, width, height, "Set XDG Toplevel min size");
-				*toplevel_data.min_size.lock() = (width > 1 || height > 1)
-					.then_some(Vector2::from([width as u32, height as u32]));
-			}
-			xdg_toplevel::Request::SetFullscreen { output: _ } => {
-				let Some(panel_item) = get_data::<PanelItem<XdgBackend>>(&wl_surface) else {
-					error!("Couldn't get the panel item");
-					return;
-				};
-				panel_item.backend.toplevel_state.lock().fullscreen = true;
-				panel_item.backend.configure(None);
-				panel_item.toplevel_fullscreen_active(true);
-			}
-			xdg_toplevel::Request::UnsetFullscreen => {
-				let Some(panel_item) = get_data::<PanelItem<XdgBackend>>(&wl_surface) else {
-					error!("Couldn't get the panel item");
-					return;
-				};
-				panel_item.backend.toplevel_state.lock().fullscreen = false;
-				panel_item.backend.configure(None);
-				panel_item.toplevel_fullscreen_active(false);
-			}
-			xdg_toplevel::Request::Destroy => {
-				debug!(?xdg_toplevel, "Destroy XDG Toplevel");
-				let Some(panel_item) = get_data::<PanelItem<XdgBackend>>(&wl_surface) else {
-					error!("Couldn't get the panel item");
-					return;
-				};
-				panel_item.backend.seat.drop_surface(&wl_surface);
-				panel_item.drop_toplevel();
-			}
-			_ => {}
-		}
-	}
-}

src/wayland/xwayland.rs

@@ -1,6 +1,6 @@
 use super::{
 	seat::{KeyboardEvent, PointerEvent, SeatData},
-	X_DISPLAY,
+	state::ClientState,
 };
 use crate::{
 	nodes::{
@@ -32,6 +32,8 @@ use std::{ffi::OsStr, iter::empty, sync::Arc, time::Duration};
 use tokio::sync::oneshot;
 use tracing::debug;
 
+pub static DISPLAY: OnceCell<String> = OnceCell::new();
+
 pub struct XWaylandState {
 	pub display: u32,
 	event_loop_signal: LoopSignal,
@@ -57,14 +59,10 @@ impl XWaylandState {
 							client_fd: _,
 							display: _,
 						} => {
-							handler.seat.client.set(client.id()).unwrap();
+							handler.seat = client.get_data::<ClientState>().map(|s| s.seat.clone());
-							handler
+							handler.wm =
-								.wm
+								X11Wm::start_wm(handle.clone(), dh.clone(), connection, client)
-								.set(
+									.ok();
-									X11Wm::start_wm(handle.clone(), dh.clone(), connection, client)
-										.unwrap(),
-								)
-								.unwrap();
 						}
 						XWaylandEvent::Exited => (),
 					}
@@ -83,15 +81,15 @@ impl XWaylandState {
 				event_loop_signal: event_loop.get_signal(),
 			});
 			let mut handler = XWaylandHandler {
-				wm: OnceCell::new(),
-				seat: SeatData::new(&dh),
 				wayland_display_handle: dh,
+				wm: None,
+				seat: None,
 			};
 			event_loop.run(Duration::from_millis(100), &mut handler, |_| ())
 		});
 
 		let state = rx.blocking_recv()?;
-		let _ = X_DISPLAY.set(state.display);
+		let _ = DISPLAY.set(format!(":{}", state.display));
 
 		Ok(state)
 	}
@@ -104,8 +102,8 @@ impl Drop for XWaylandState {
 
 struct XWaylandHandler {
 	wayland_display_handle: DisplayHandle,
-	wm: OnceCell<X11Wm>,
+	wm: Option<X11Wm>,
-	seat: Arc<SeatData>,
+	seat: Option<Arc<SeatData>>,
 }
 impl XWaylandHandler {
 	fn panel_item(&self, window: &X11Surface) -> Option<Arc<PanelItem<X11Backend>>> {
@@ -117,7 +115,7 @@ impl XWaylandHandler {
 
 impl XwmHandler for XWaylandHandler {
 	fn xwm_state(&mut self, _xwm: XwmId) -> &mut X11Wm {
-		self.wm.get_mut().unwrap()
+		self.wm.as_mut().unwrap()
 	}
 
 	fn new_window(&mut self, _xwm: XwmId, window: X11Surface) {
@@ -138,16 +136,14 @@ impl XwmHandler for XWaylandHandler {
 		let _ = window.set_maximized(true);
 
 		let dh = self.wayland_display_handle.clone();
-		let seat = self.seat.clone();
+		let seat = self.seat.clone().unwrap();
 		CoreSurface::add_to(
 			self.wayland_display_handle.clone(),
 			&window.wl_surface().unwrap(),
 			{
 				let window = window.clone();
 				move || {
-					let Some(wl_surface) = window.wl_surface() else {
+					let Some(wl_surface) = window.wl_surface() else {return};
-						return;
-					};
 					let seat = seat.clone();
 					window.user_data().insert_if_missing_threadsafe(|| {
 						let panel_item = PanelItem::create(
@@ -168,10 +164,7 @@ impl XwmHandler for XWaylandHandler {
 				}
 			},
 			move |_| {
-				let Some(panel_item) = window.user_data().get::<Arc<PanelItem<X11Backend>>>()
+				let Some(panel_item) = window.user_data().get::<Arc<PanelItem<X11Backend>>>() else {return};
-				else {
-					return;
-				};
 				panel_item.toplevel_size_changed(
 					[
 						window.geometry().size.w as u32,
@@ -188,9 +181,6 @@ impl XwmHandler for XWaylandHandler {
 
 	fn unmapped_window(&mut self, _xwm: XwmId, window: X11Surface) {
 		debug!(?window, "Unmap X window");
-		if let Some(panel_item) = window.user_data().get::<Arc<PanelItem<X11Backend>>>() {
-			panel_item.drop_toplevel();
-		}
 	}
 	fn destroyed_window(&mut self, _xwm: XwmId, window: X11Surface) {
 		debug!(?window, "Destroy X window");
@@ -220,9 +210,7 @@ impl XwmHandler for XWaylandHandler {
 	}
 
 	fn move_request(&mut self, _xwm: XwmId, window: X11Surface, button: u32) {
-		let Some(panel_item) = self.panel_item(&window) else {
+		let Some(panel_item) = self.panel_item(&window) else {return};
-			return;
-		};
 		debug!(?window, button, "X window requests move");
 		panel_item.toplevel_move_request();
 	}
@@ -233,9 +221,7 @@ impl XwmHandler for XWaylandHandler {
 		button: u32,
 		resize_edge: ResizeEdge,
 	) {
-		let Some(panel_item) = self.panel_item(&window) else {
+		let Some(panel_item) = self.panel_item(&window) else {return};
-			return;
-		};
 		debug!(?window, button, ?resize_edge, "X window requests resize");
 		let (up, down, left, right) = match resize_edge {
 			ResizeEdge::Top => (true, false, false, false),
@@ -253,16 +239,12 @@ impl XwmHandler for XWaylandHandler {
 
 	fn fullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {
 		let _ = window.set_fullscreen(true);
-		let Some(panel_item) = self.panel_item(&window) else {
+		let Some(panel_item) = self.panel_item(&window) else {return};
-			return;
-		};
 		panel_item.toplevel_fullscreen_active(true);
 	}
 	fn unfullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {
 		let _ = window.set_fullscreen(false);
-		let Some(panel_item) = self.panel_item(&window) else {
+		let Some(panel_item) = self.panel_item(&window) else {return};
-			return;
-		};
 		panel_item.toplevel_fullscreen_active(true);
 	}
 }
@@ -291,6 +273,63 @@ impl X11Backend {
 	// }
 }
 impl Backend for X11Backend {
+	// fn start_data(&self, id: &str) -> Result<Message> {
+	// 	let size = (
+	// 		self.toplevel.geometry().size.w as u32,
+	// 		self.toplevel.geometry().size.h as u32,
+	// 	);
+	// 	let toplevel_state = (
+	// 		None::<String>,
+	// 		self.toplevel.title(),
+	// 		None::<String>,
+	// 		(
+	// 			self.toplevel.geometry().size.w as u32,
+	// 			self.toplevel.geometry().size.h as u32,
+	// 		),
+	// 		self.toplevel.min_size().map(|s| (s.w as u32, s.h as u32)),
+	// 		self.toplevel.max_size().map(|s| (s.w as u32, s.w as u32)),
+	// 		((0_i32, 0_i32), size),
+	// 		vec![0_u32; 0],
+	// 	);
+	// 	let info = (
+	// 		None::<(Vector2<u32>, Vector2<i32>)>,
+	// 		toplevel_state,
+	// 		Vec::<PopupData>::new(),
+	// 		None::<SurfaceID>,
+	// 		None::<SurfaceID>,
+	// 	);
+	// 	Ok(serialize((id, info))?.into())
+	// }
+	// fn serialize_toplevel(&self) -> Result<Message> {
+	// 	let toplevel_state = (
+	// 		None::<String>,
+	// 		self.toplevel.title(),
+	// 		None::<String>,
+	// 		(
+	// 			self.toplevel.geometry().size.w,
+	// 			self.toplevel.geometry().size.h,
+	// 		),
+	// 		self.toplevel.min_size().map(|s| (s.w, s.h)),
+	// 		self.toplevel.max_size().map(|s| (s.w, s.w)),
+	// 	);
+	// 	let data = serialize(&toplevel_state)?;
+	// 	Ok(data.into())
+	// }
+
+	// fn set_toplevel_capabilities(&self, _capabilities: Vec<u8>) {}
+
+	// fn set_toplevel_size(
+	// 	&self,
+	// 	size: Option<Vector2<u32>>,
+	// 	states: Vec<u32>,
+	// 	_bounds: Option<Vector2<u32>>,
+	// ) {
+	// 	let _ = self.toplevel.configure(
+	// 		size.map(|s| Rectangle::from_loc_and_size((0, 0), (s.x as i32, s.y as i32))),
+	// 	);
+	// 	let _ = self.toplevel.set_maximized(states.contains(&1));
+	// }
+
 	fn start_data(&self) -> Result<PanelItemInitData> {
 		Ok(PanelItemInitData {
 			cursor: None,
@@ -325,9 +364,7 @@ impl Backend for X11Backend {
 			keyboard_grab: self._keyboard_grab.lock().clone(),
 		})
 	}
-	fn close_toplevel(&self) {
+	fn close_toplevel(&self) {}
-		let _ = self.toplevel.close();
-	}
 
 	fn auto_size_toplevel(&self) {
 		let _ = self.toplevel.configure(None);
@@ -343,27 +380,19 @@ impl Backend for X11Backend {
 	}
 
 	fn apply_surface_material(&self, surface: SurfaceID, model_part: &Arc<ModelPart>) {
-		let Some(wl_surface) = self.wl_surface_from_id(&surface) else {
+		let Some(wl_surface) = self.wl_surface_from_id(&surface) else {return};
-			return;
+		let Some(core_surface) = CoreSurface::from_wl_surface(&wl_surface) else {return};
-		};
-		let Some(core_surface) = CoreSurface::from_wl_surface(&wl_surface) else {
-			return;
-		};
 
 		core_surface.apply_material(model_part);
 	}
 
 	fn pointer_motion(&self, surface: &SurfaceID, position: Vector2<f32>) {
-		let Some(surface) = self.wl_surface_from_id(surface) else {
+		let Some(surface) = self.wl_surface_from_id(surface) else {return};
-			return;
-		};
 		self.seat
 			.pointer_event(&surface, PointerEvent::Motion(position));
 	}
 	fn pointer_button(&self, surface: &SurfaceID, button: u32, pressed: bool) {
-		let Some(surface) = self.wl_surface_from_id(surface) else {
+		let Some(surface) = self.wl_surface_from_id(surface) else {return};
-			return;
-		};
 		self.seat.pointer_event(
 			&surface,
 			PointerEvent::Button {
@@ -378,9 +407,7 @@ impl Backend for X11Backend {
 		scroll_distance: Option<Vector2<f32>>,
 		scroll_steps: Option<Vector2<f32>>,
 	) {
-		let Some(surface) = self.wl_surface_from_id(surface) else {
+		let Some(surface) = self.wl_surface_from_id(surface) else {return};
-			return;
-		};
 		self.seat.pointer_event(
 			&surface,
 			PointerEvent::Scroll {
@@ -391,13 +418,9 @@ impl Backend for X11Backend {
 	}
 
 	fn keyboard_keys(&self, surface: &SurfaceID, keymap_id: &str, keys: Vec<i32>) {
-		let Some(surface) = self.wl_surface_from_id(surface) else {
+		let Some(surface) = self.wl_surface_from_id(surface) else {return};
-			return;
-		};
 		let keymaps = KEYMAPS.lock();
-		let Some(keymap) = keymaps.get(keymap_id).cloned() else {
+		let Some(keymap) = keymaps.get(keymap_id).cloned() else {return};
-			return;
-		};
 		if self.seat.set_keymap(keymap, vec![surface.clone()]).is_err() {
 			return;
 		}
@@ -406,25 +429,9 @@ impl Backend for X11Backend {
 				&surface,
 				KeyboardEvent::Key {
 					key: key.abs() as u32,
-					state: key < 0,
+					state: if key < 0 { 1 } else { 0 },
 				},
 			);
 		}
 	}
-
-	fn touch_down(&self, surface: &SurfaceID, id: u32, position: Vector2<f32>) {
-		let Some(surface) = self.wl_surface_from_id(surface) else {
-			return;
-		};
-		self.seat.touch_down(&surface, id, position)
-	}
-	fn touch_move(&self, id: u32, position: Vector2<f32>) {
-		self.seat.touch_move(id, position)
-	}
-	fn touch_up(&self, id: u32) {
-		self.seat.touch_up(id)
-	}
-	fn reset_touches(&self) {
-		self.seat.reset_touches()
-	}
 }

src/wayland/xwayland_rootful.rs

@@ -1,267 +0,0 @@
-use crate::core::{client::get_env, task};
-use crate::STOP_NOTIFIER;
-use smithay::reexports::rustix;
-use smithay::reexports::rustix::io::{fcntl_setfd, Errno, FdFlags};
-use smithay::reexports::rustix::net::SocketAddrUnix;
-use std::io::{Read, Write};
-use std::{
-	io::ErrorKind,
-	os::{
-		fd::{AsRawFd, BorrowedFd, RawFd},
-		unix::process::CommandExt,
-	},
-	process::{ChildStdout, Command, Stdio},
-};
-use tokio::net::{UnixListener, UnixStream};
-use tokio::task::AbortHandle;
-use tracing::{debug, info, warn};
-
-use super::X_DISPLAY;
-
-pub fn start_xwayland(wayland_socket: RawFd) -> std::io::Result<X11Lock> {
-	let (mut lock, listener) = bind_socket()?;
-
-	let abort_handle = task::new(|| "X11 Client Acceptor", async move {
-		loop {
-			let Ok((stream, _)) = tokio::select! {
-				_ = STOP_NOTIFIER.notified() => break,
-				e = listener.accept() => e,
-			} else {
-				continue;
-			};
-
-			let Ok((x_wm_x11, _x_wm_me)) = UnixStream::pair() else {
-				continue;
-			};
-			let Ok(env) = stream
-				.peer_cred()
-				.and_then(|c| c.pid().ok_or(ErrorKind::Other.into()))
-				.and_then(get_env)
-			else {
-				continue;
-			};
-
-			let _ = spawn_xwayland(
-				lock.display,
-				wayland_socket,
-				x_wm_x11,
-				stream.as_raw_fd(),
-				env.get("STARDUST_STARTUP_TOKEN").cloned(),
-			);
-		}
-	})
-	.map_err(|_| ErrorKind::Other)?
-	.abort_handle();
-	lock.x_abort_handle.replace(abort_handle);
-	let _ = X_DISPLAY.set(lock.display);
-	Ok(lock)
-}
-
-/// Find a free X11 display slot and setup
-pub(crate) fn bind_socket() -> Result<(X11Lock, UnixListener), std::io::Error> {
-	for d in 0..33 {
-		// if fails, try the next one
-		if let Ok(lock) = X11Lock::grab(d) {
-			// we got a lockfile, try and create the socket
-			match open_x11_socket_for_display(d) {
-				Ok(socket) => return Ok((lock, socket)),
-				Err(err) => warn!(display = d, "Failed to create sockets: {}", err),
-			}
-		}
-	}
-	// If we reach here, all values from 0 to 32 failed
-	// we need to stop trying at some point
-
-	Err(std::io::Error::new(
-		std::io::ErrorKind::AddrInUse,
-		"Could not find a free socket for the XServer.",
-	))
-}
-
-#[derive(Debug)]
-pub(crate) struct X11Lock {
-	display: u32,
-	x_abort_handle: Option<AbortHandle>,
-}
-
-impl X11Lock {
-	/// Try to grab a lockfile for given X display number
-	fn grab(number: u32) -> Result<X11Lock, ()> {
-		debug!(display = number, "Attempting to aquire an X11 display lock");
-		let filename = format!("/tmp/.X{}-lock", number);
-		let lockfile = ::std::fs::OpenOptions::new()
-			.write(true)
-			.create_new(true)
-			.open(&filename);
-		match lockfile {
-			Ok(mut file) => {
-				// we got it, write our PID in it and we're good
-				let ret = file.write_fmt(format_args!(
-					"{:>10}\n",
-					rustix::process::Pid::as_raw(Some(rustix::process::getpid()))
-				));
-				if ret.is_err() {
-					// write to the file failed ? we abandon
-					::std::mem::drop(file);
-					let _ = ::std::fs::remove_file(&filename);
-					Err(())
-				} else {
-					debug!(display = number, "X11 lock acquired");
-					// we got the lockfile and wrote our pid to it, all is good
-					Ok(X11Lock {
-						display: number,
-						x_abort_handle: None,
-					})
-				}
-			}
-			Err(_) => {
-				debug!(display = number, "Failed to acquire lock");
-				// we could not open the file, now we try to read it
-				// and if it contains the pid of a process that no longer
-				// exist (so if a previous x server claimed it and did not
-				// exit gracefully and remove it), we claim it
-				// if we can't open it, give up
-				let mut file = ::std::fs::File::open(&filename).map_err(|_| ())?;
-				let mut spid = [0u8; 11];
-				file.read_exact(&mut spid).map_err(|_| ())?;
-				::std::mem::drop(file);
-				let pid = rustix::process::Pid::from_raw(
-					::std::str::from_utf8(&spid)
-						.map_err(|_| ())?
-						.trim()
-						.parse::<i32>()
-						.map_err(|_| ())?,
-				)
-				.ok_or(())?;
-				if let Err(Errno::SRCH) = rustix::process::test_kill_process(pid) {
-					// no process whose pid equals the contents of the lockfile exists
-					// remove the lockfile and try grabbing it again
-					if let Ok(()) = ::std::fs::remove_file(filename) {
-						debug!(
-							display = number,
-							"Lock was blocked by a defunct X11 server, trying again"
-						);
-						return X11Lock::grab(number);
-					} else {
-						// we could not remove the lockfile, abort
-						return Err(());
-					}
-				}
-				// if we reach here, this lockfile exists and is probably in use, give up
-				Err(())
-			}
-		}
-	}
-
-	pub(crate) fn display(&self) -> u32 {
-		self.display
-	}
-}
-
-impl Drop for X11Lock {
-	fn drop(&mut self) {
-		info!("Cleaning up X11 lock.");
-		// Cleanup all the X11 files
-		if let Err(e) = ::std::fs::remove_file(format!("/tmp/.X11-unix/X{}", self.display)) {
-			warn!(error = ?e, "Failed to remove X11 socket");
-		}
-		if let Err(e) = ::std::fs::remove_file(format!("/tmp/.X{}-lock", self.display)) {
-			warn!(error = ?e, "Failed to remove X11 lockfile");
-		}
-		if let Some(join_handle) = self.x_abort_handle.take() {
-			join_handle.abort();
-		}
-	}
-}
-
-/// Open the two unix sockets an X server listens on
-///
-/// Should only be done after the associated lockfile is acquired!
-fn open_x11_socket_for_display(display: u32) -> rustix::io::Result<UnixListener> {
-	let path = format!("/tmp/.X11-unix/X{}", display);
-	let _ = ::std::fs::remove_file(&path);
-	// We know this path is not too long, these unwrap cannot fail
-	let fs_addr = SocketAddrUnix::new(path.as_bytes()).unwrap();
-	open_socket(fs_addr)
-}
-
-/// Open an unix socket for listening and bind it to given path
-fn open_socket(addr: SocketAddrUnix) -> rustix::io::Result<UnixListener> {
-	// create an unix stream socket
-	let fd = rustix::net::socket_with(
-		rustix::net::AddressFamily::UNIX,
-		rustix::net::SocketType::STREAM,
-		rustix::net::SocketFlags::CLOEXEC,
-		None,
-	)?;
-	// bind it to requested address
-	rustix::net::bind_unix(&fd, &addr)?;
-	rustix::net::listen(&fd, 1)?;
-	Ok(UnixListener::from_std(std::os::unix::net::UnixListener::from(fd)).unwrap())
-}
-
-fn spawn_xwayland(
-	display: u32,
-	wayland_socket: RawFd,
-	wm_socket: UnixStream,
-	listen_socket: RawFd,
-	stardust_startup_token: Option<String>,
-) -> std::io::Result<ChildStdout> {
-	let mut command = Command::new("sh");
-
-	// We use output stream to communicate because FD is easier to handle than exit code.
-	command.stdout(Stdio::piped());
-
-	let mut xwayland_args = format!(":{} -geometry 1920x1080", display);
-	xwayland_args.push_str(&format!(" -listenfd {}", listen_socket));
-
-	// This command let sh to:
-	// * Set up signal handler for USR1
-	// * Launch Xwayland with USR1 ignored so Xwayland will signal us when it is ready (also redirect
-	//   Xwayland's STDOUT to STDERR so its output, if any, won't distract us)
-	// * Print "S" and exit if USR1 is received
-	command.arg("-c").arg(format!(
-		"trap 'echo S' USR1; (trap '' USR1; exec Xwayland {}) 1>&2 & wait",
-		xwayland_args
-	));
-
-	// Setup the environment: clear everything except PATH and XDG_RUNTIME_DIR
-	command.env_clear();
-	for (key, value) in std::env::vars_os() {
-		if key.to_str() == Some("PATH") || key.to_str() == Some("XDG_RUNTIME_DIR") {
-			command.env(key, value);
-			continue;
-		}
-	}
-	command.env("WAYLAND_SOCKET", format!("{}", wayland_socket.as_raw_fd()));
-	command.env(
-		"STARDUST_STARTUP_TOKEN",
-		stardust_startup_token.unwrap_or_default(),
-	);
-
-	unsafe {
-		let wayland_socket_fd = wayland_socket.as_raw_fd();
-		let wm_socket_fd = wm_socket.as_raw_fd();
-		command.pre_exec(move || {
-			// unset the CLOEXEC flag from the sockets we need to pass
-			// to xwayland
-			unset_cloexec(wayland_socket_fd)?;
-			unset_cloexec(wm_socket_fd)?;
-			unset_cloexec(listen_socket)?;
-			Ok(())
-		});
-	}
-
-	let mut child = command.spawn()?;
-	Ok(child.stdout.take().expect("stdout should be piped"))
-}
-
-/// Remove the `O_CLOEXEC` flag from this `Fd`
-///
-/// This means that the `Fd` will *not* be automatically
-/// closed when we `exec()` into XWayland
-unsafe fn unset_cloexec(fd: RawFd) -> std::io::Result<()> {
-	let fd = BorrowedFd::borrow_raw(fd);
-	fcntl_setfd(fd, FdFlags::empty())?;
-	Ok(())
-}