fix: destroy prebound parts on model drop

Signed-off-by: Schmarni <marnistromer@gmail.com>

.github/workflows/build.yml

@@ -1,4 +1,4 @@
-name: Build
+name: CI
 
 on:
   push:
@@ -6,7 +6,7 @@ on:
       - "*"
 
 jobs:
-  build_and_package:
+  check:
     runs-on: ubuntu-latest
 
     steps:
@@ -14,15 +14,13 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Install runtime dependencies
-        run: sudo apt install -y --no-install-recommends libxkbcommon-dev libstdc++6 libopenxr-dev libx11-dev libxfixes-dev libgl1-mesa-dev libegl1-mesa-dev libgbm-dev libfontconfig-dev libjsoncpp-dev  libxcb1-dev libglx-dev libxcb-glx0-dev libdrm-dev libwayland-dev libfreetype-dev libpng-dev
+        run: sudo apt install -y --no-install-recommends libopenxr-dev libwayland-dev libasound2-dev
-
-      - name: Install build dependencies
-        run: sudo apt install -y --no-install-recommends cmake ninja-build libfuse2
 
       - name: Set up Rust
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          toolchain: 1.88.0
+          override: true
 
       - name: Build server
         run: cargo build --release

.zed/debug.json

@@ -0,0 +1,94 @@
+[
+	{
+		"label": "Debug",
+		"adapter": "CodeLLDB",
+		"program": "target/debug/stardust-xr-server",
+		"args": [],
+		"env": {
+			"RUST_LOG": "debug"
+		},
+		"request": "launch",
+		"build": {
+			"command": "cargo",
+			"args": [
+				"build",
+				"--bin=stardust-xr-server",
+				"--package=stardust-xr-server"
+			]
+		}
+	},
+	{
+		"label": "Debug (Overlay)",
+		"adapter": "CodeLLDB",
+		"program": "target/debug/stardust-xr-server",
+		"args": ["-o", "1"],
+		"env": {
+			"RUST_LOG": "debug"
+		},
+		"request": "launch",
+		"build": {
+			"command": "cargo",
+			"args": [
+				"build",
+				"--bin=stardust-xr-server",
+				"--package=stardust-xr-server"
+			]
+		}
+	},
+	{
+		"label": "Debug (Headless)",
+		"adapter": "CodeLLDB",
+		"program": "target/debug/stardust-xr-server",
+		"args": [],
+		"env": {
+			"RUST_LOG": "debug",
+			"DISPLAY": "",
+			"WAYLAND_DISPLAY": ""
+		},
+		"request": "launch",
+		"build": {
+			"command": "cargo",
+			"args": [
+				"build",
+				"--bin=stardust-xr-server",
+				"--package=stardust-xr-server"
+			]
+		}
+	},
+	{
+		"label": "Debug (Flatscreen)",
+		"adapter": "CodeLLDB",
+		"program": "target/debug/stardust-xr-server",
+		"args": ["-f"],
+		"env": {
+			"RUST_LOG": "debug"
+		},
+		"request": "launch",
+		"build": {
+			"command": "cargo",
+			"args": [
+				"build",
+				"--bin=stardust-xr-server",
+				"--package=stardust-xr-server"
+			]
+		}
+	},
+	{
+		"label": "Debug (Flatscreen, Restore Latest)",
+		"adapter": "CodeLLDB",
+		"program": "target/debug/stardust-xr-server",
+		"args": ["-f", "--restore", "latest"],
+		"env": {
+			"RUST_LOG": "debug"
+		},
+		"request": "launch",
+		"build": {
+			"command": "cargo",
+			"args": [
+				"build",
+				"--bin=stardust-xr-server",
+				"--package=stardust-xr-server"
+			]
+		}
+	}
+]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 edition = "2024"
-rust-version = "1.85"
+rust-version = "1.89"
 name = "stardust-xr-server"
 version = "0.45.0"
 authors = ["Nova King <technobaboo@proton.me>"]
@@ -22,93 +22,156 @@ path = "src/main.rs"
 
 [features]
 default = ["wayland"]
-wayland = ["dep:smithay", "dep:wayland-scanner", "dep:wayland-backend"]
+wayland = [
+	"dep:waynest",
+	"dep:waynest-protocols",
+	"dep:waynest-server",
+	"dep:tokio-stream",
+	"dep:memmap2",
+	"dep:drm-fourcc",
+	"dep:memfd",
+	"dep:vulkano",
+	"dep:wgpu-hal",
+	"dep:ash",
+]
 profile_tokio = ["dep:console-subscriber", "tokio/tracing"]
-profile_app = ["dep:tracing-tracy"]
+profile_app = [
-local_deps = ["stereokit-rust/force-local-deps"]
+	"dep:tracing-tracy",
+	"bevy/trace_tracy",
+	"bevy/trace",
+	"dep:tracy-client",
+]
+bevy_debugging = ["bevy/bevy_remote", "bevy/track_location"]
 
 [package.metadata.appimage]
 auto_link = true
-auto_link_exclude_list = [
+auto_link_exclude_list = ["libc*", "libdl*", "libpthread*", "ld-linux*"]
-	"libc*",
+
-	"libdl*",
+
-	"libpthread*",
+[profile.release]
-	"ld-linux*",
+opt-level = "s"
-	"libGL*",
+lto = true
-	"libEGL*",
+codegen-units = 1
-]
+panic = "abort"
+# strip = "symbols"
+debug = true
 
 [profile.dev.package."*"]
 opt-level = 3
-debug = true
-strip = false
-debug-assertions = true
-overflow-checks = true
 
-[profile.release]
+[patch.crates-io]
-opt-level = 3
+bevy_mod_openxr = { git = "https://github.com/awtterpip/bevy_oxr", rev = "9fd0c797" }
-debug = "line-tables-only"
+bevy_mod_xr = { git = "https://github.com/awtterpip/bevy_oxr", rev = "9fd0c797" }
-strip = true
+bevy_gltf = { git = "https://github.com/Schmarni-Dev/bevy", branch = "gltf_backport" }
-debug-assertions = true
+# TODO: figure out how to not need this horrifing patch
-overflow-checks = false
+wgpu = { git = "https://github.com/Schmarni-Dev/wgpu", branch = "bad_dmabuf_workaround" }
-lto = "thin"
+wgpu-types = { git = "https://github.com/Schmarni-Dev/wgpu", branch = "bad_dmabuf_workaround" }
+wgpu-core = { git = "https://github.com/Schmarni-Dev/wgpu", branch = "bad_dmabuf_workaround" }
+naga = { git = "https://github.com/Schmarni-Dev/wgpu", branch = "bad_dmabuf_workaround" }
+wgpu-hal = { git = "https://github.com/Schmarni-Dev/wgpu", branch = "bad_dmabuf_workaround" }
+bevy_pbr = { git = "https://github.com/Schmarni-Dev/bevy", branch = "premul_oit_016" }
+bevy_core_pipeline = { git = "https://github.com/Schmarni-Dev/bevy", branch = "premul_oit_016" }
+bevy_render = { git = "https://github.com/Schmarni-Dev/bevy", branch = "render_thread_init_callback" }
 
 [dependencies]
 # small utility thingys
 nanoid = "0.4.0"
 lazy_static = "1.5.0"
-rand = "0.8.5"
+rand = "0.9.2"
 rustc-hash = "2.0.0"
-send_wrapper = "0.6.0"
 slotmap = "1.0.7"
 global_counter = "=0.2.2"
 parking_lot = "0.12.3"
+dashmap = "6.1.0"
 
 # rust errors/logging
 color-eyre = { version = "0.6.3", default-features = false }
 clap = { version = "4.5.13", features = ["derive"] }
 console-subscriber = { version = "0.4.0", optional = true }
-thiserror = "2.0.9"
+thiserror = "2.0.11"
-tracing = "0.1.40"
+tracing = { version = "0.1.40", features = ["release_max_level_warn"] }
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 tracing-tracy = { version = "0.11.1", optional = true }
+tracy-client = { version = "=0.18.0", optional = true }
 
 # (de)serialization
 serde = { version = "1.0.205", features = ["derive"] }
 serde_repr = "0.1.19"
-toml = "0.8.19"
+toml = "0.9.7"
 
 # mathy stuffs
 glam = { version = "0.29.0", features = ["mint", "serde"] }
 mint = "0.5.9"
 tokio = { version = "1.39.2", features = ["rt-multi-thread", "signal", "time"] }
 
+# bevy
+bevy = { version = "0.16", default-features = false, features = [
+	"bevy_asset",
+	"bevy_audio",
+	"bevy_color",
+	"bevy_core_pipeline",
+	"bevy_gizmos",
+	"bevy_gltf",
+	"bevy_log",
+	"bevy_pbr",
+	"bevy_render",
+	"bevy_window",
+	"bevy_winit",
+	"std",
+	"wayland",
+	"mp3",
+	"wav",
+	"qoi",
+	"png",
+	"hdr",
+	"jpeg",
+	"multi_threaded",
+] }
+bevy_mod_xr = "0.3"
+bevy_mod_openxr = "0.3"
+# bevy_sk.git = "https://github.com/MalekiRe/bevy_sk"
+bevy_sk = { git = "https://github.com/technobaboo/bevy_sk", branch = "stochastic" }
+# bevy-dmabuf = "0.2.0"
+bevy-dmabuf.git = "https://github.com/Schmarni-Dev/bevy-dmabuf"
+bevy-equirect = "0.1.1"
+
+# bevy-mesh-text-3d.git = "https://github.com/terhechte/bevy-mesh-text-3d"
+# use my fork until my pr to use minimal bevy features was merged
+bevy-mesh-text-3d.git = "https://github.com/Schmarni-Dev/bevy-mesh-text-3d"
+
+openxr = "0.19"
+
 # linux stuffs
 input-event-codes = "6.2.0"
-zbus = { version = "5.0.0", default-features = false, features = ["tokio"] }
+zbus = { version = "5.11.0", features = [
-directories = "5.0.1"
+	"blocking-api",
+	"tokio",
+], default-features = false }
+directories = "6.0.0"
 xkbcommon-rs = "0.1.0"
+cosmic-text = "0.14.2"
 
-# wayland
+# Wayland
-wayland-backend = { version = "0.3.7", optional = true, default-features = false }
+waynest = { git = "https://github.com/verdiwm/waynest.git", default-features = false, optional = true }
-wayland-scanner = { version = "0.31.4", optional = true }
+waynest-protocols = { git = "https://github.com/verdiwm/waynest.git", features = [
-dashmap = "6.1.0"
+	"server",
-
+	"stable",
-[dependencies.smithay]
+	"mesa",
-git = "https://github.com/smithay/smithay.git"
+	"tracing",
-default-features = false
+], default-features = false, optional = true }
-features = ["desktop", "backend_drm", "renderer_gl", "wayland_frontend"]
+waynest-server = { git = "https://github.com/verdiwm/waynest.git", default-features = false, optional = true }
-optional = true
+tokio-stream = { version = "0.1.17", optional = true }
-
+memmap2 = { version = "0.9.5", optional = true }
-
+drm-fourcc = { version = "2.2.0", optional = true }
-[dependencies.stereokit-rust]
+memfd = { version = "0.6.4", optional = true }
-git = "https://github.com/mvvvv/StereoKit-rust.git"
+vulkano = { git = "https://github.com/Schmarni-Dev/vulkano", branch = "0_35_dmabuf_fixes", default-features = false, optional = true }
-rev = "73ffaae6f42aa369e599a6ea0391f77840d682d8"
+wgpu-hal = { version = "24", optional = true, features = ["vulkan"] }
-features = ["no-event-loop"]
+ash = { version = "0.38.0", optional = true, default-features = false }
-default-features = false
+rustix = { version = "1.0.8", features = ["time"] }
+pin-project-lite = "0.2.16"
+futures-sink = "0.3.31"
 
 [dependencies.stardust-xr]
 workspace = true
-
 [dependencies.stardust-xr-server-codegen]
 path = "codegen"

codegen/Cargo.toml

@@ -9,8 +9,6 @@ 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"
 
 stardust-xr = { workspace = true }

codegen/src/lib.rs

@@ -1,7 +1,6 @@
 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 {
@@ -64,6 +63,7 @@ fn codegen_protocol(protocol: &'static str) -> proc_macro::TokenStream {
 				description: protocol.description.clone(),
 				inherits: vec![],
 				members: p.members,
+				inherited_aspects: vec![],
 			});
 			quote! {
 				#node_id
@@ -105,7 +105,7 @@ fn codegen_protocol(protocol: &'static str) -> proc_macro::TokenStream {
 	let aspects = protocol
 		.aspects
 		.iter()
-		.map(generate_aspect)
+		.map(|a| generate_aspect(&a.blocking_read()))
 		.reduce(fold_tokens)
 		.unwrap_or_default();
 	quote!(#custom_enums #custom_unions #custom_structs #aspects #interface).into()
@@ -183,14 +183,18 @@ fn generate_custom_struct(custom_struct: &CustomStruct) -> TokenStream {
 
 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_members, server_members) = aspect
+		.members
+		.iter()
+		.partition::<Vec<_>, _>(|m| m.side == Side::Client);
 
 	let client_mod_name = Ident::new(
 		&format!("{}_client", &aspect.name.to_case(Case::Snake)),
 		Span::call_site(),
 	);
 	let client_side_members = client_members
-		.map(|m| generate_member(aspect.id, &aspect.name.to_case(Case::Snake), m))
+		.into_iter()
+		.map(|m| generate_member(aspect.id, &aspect.name.to_case(Case::Pascal), m))
 		.reduce(fold_tokens)
 		.map(|t| {
 			// TODO: properly import all dependencies
@@ -228,6 +232,7 @@ fn generate_aspect(aspect: &Aspect) -> TokenStream {
 	let alias_info = generate_alias_info(aspect);
 
 	let server_side_members = server_members
+		.into_iter()
 		.map(|m| generate_member(aspect.id, &aspect.name.to_case(Case::Pascal), m))
 		.reduce(fold_tokens)
 		.unwrap_or_default();
@@ -281,9 +286,6 @@ fn generate_aspect(aspect: &Aspect) -> TokenStream {
 		}
 		macro_rules! #aspect_macro_name {
 			() => {
-				fn as_any(self: Arc<Self>) -> Arc<dyn std::any::Any + Send + Sync + 'static> {
-					self
-				}
 				#[allow(clippy::all)]
 				fn run_signal(
 					&self,
@@ -304,12 +306,12 @@ fn generate_aspect(aspect: &Aspect) -> TokenStream {
 					_node: std::sync::Arc<crate::nodes::Node>,
 					_method: u64,
 					_message: crate::nodes::Message,
-					_method_response: crate::nodes::MethodResponseSender,
+					_method_response: crate::core::scenegraph::MethodResponseSender,
 				) {
 					match _method {
 						#run_methods
 						_ => {
-							let _ = _method_response.send(Err(stardust_xr::scenegraph::ScenegraphError::MemberNotFound));
+							let _ = _method_response.send_err(stardust_xr::scenegraph::ScenegraphError::MemberNotFound);
 						}
 					}
 				}
@@ -381,6 +383,18 @@ fn generate_member(aspect_id: u64, aspect_name: &str, member: &Member) -> TokenS
 		}
 		Side::Client => quote!(_node: &crate::nodes::Node),
 	};
+
+	let arguments = member
+		.arguments
+		.iter()
+		.map(|a| Ident::new(&a.name.to_case(Case::Snake), Span::call_site()));
+	let argument_debug = member
+		.arguments
+		.iter()
+		.map(|a| Ident::new(&a.name.to_case(Case::Snake), Span::call_site()))
+		.map(|n| quote!(?#n))
+		.reduce(|a, b| quote!(#a, #b))
+		.map(|args| quote!(#args,));
 	let argument_decls = member
 		.arguments
 		.iter()
@@ -405,12 +419,13 @@ fn generate_member(aspect_id: u64, aspect_name: &str, member: &Member) -> TokenS
 			quote! {
 				#[doc = #description]
 				pub fn #name(#argument_decls) -> crate::core::error::Result<()> {
+					let arguments = (#argument_uses);
+					let (#(#arguments),*) = &arguments;
+						::tracing::trace!(#argument_debug "sent signal to client: {}::{}", #aspect_name, #name_str);
+					let result = stardust_xr::schemas::flex::serialize(&arguments).map_err(|e|e.into()).and_then(|serialized|_node.send_remote_signal(#aspect_id, #opcode, serialized));
 
-					let result = stardust_xr::schemas::flex::serialize((#argument_uses)).map_err(|e|e.into()).and_then(|serialized|_node.send_remote_signal(#aspect_id, #opcode, serialized));
 					if let Err(err) = result.as_ref() {
-						::tracing::warn!("failed to send remote signal: {}::{}, error: {}",#aspect_name,#name_str,err);
+						::tracing::warn!(#argument_debug "failed to send signal to client : {}::{}, error: {}",#aspect_name,#name_str,err);
-					} else {
-						::tracing::trace!("sent remote signal: {}::{}",#aspect_name,#name_str);
 					}
 					result
 				}
@@ -420,11 +435,18 @@ fn generate_member(aspect_id: u64, aspect_name: &str, member: &Member) -> TokenS
 			quote! {
 				#[doc = #description]
 				pub async fn #name(#argument_decls) -> crate::core::error::Result<(#return_type, Vec<std::os::fd::OwnedFd>)> {
-					let result = _node.execute_remote_method_typed(#aspect_id, #opcode, &(#argument_uses), vec![]).await;
+					let arguments = (#argument_uses);
-					if let Err(err) = result.as_ref() {
+					let (#(#arguments),*) = &arguments;
-						::tracing::warn!("failed to call remote method: {}::{}, error: {}",#aspect_name,#name_str,err);
+					::tracing::trace!(#argument_debug "called client method: {}::{}",#aspect_name,#name_str);
-					} else {
+					let result = _node.execute_remote_method_typed(#aspect_id, #opcode, &arguments, vec![]).await;
-						::tracing::trace!("called remote method: {}::{}",#aspect_name,#name_str);
+
+					match result.as_ref() {
+						Ok(value) => {
+							::tracing::trace!(?value, "client method returned value: {}::{}",#aspect_name,#name_str);
+						},
+						Err(err) => {
+							::tracing::warn!(#argument_debug "client method returned error: {}::{}, error: {}",#aspect_name,#name_str,err);
+						}
 					}
 					result
 				}
@@ -447,6 +469,8 @@ fn generate_member(aspect_id: u64, aspect_name: &str, member: &Member) -> TokenS
 fn generate_run_member(aspect_name: &Ident, _type: MemberType, member: &Member) -> TokenStream {
 	let opcode = member.opcode;
 	let member_name_ident = Ident::new(&member.name, Span::call_site());
+	let member_name = member_name_ident.to_string();
+	let aspect_name_str = aspect_name.to_string();
 
 	let argument_names = member
 		.arguments
@@ -461,6 +485,13 @@ fn generate_run_member(aspect_name: &Ident, _type: MemberType, member: &Member)
 			generate_argument_type(&_type, a.optional, true)
 		})
 		.reduce(|a, b| quote!(#a, #b));
+	let argument_debug = member
+		.arguments
+		.iter()
+		.map(|a| Ident::new(&a.name.to_case(Case::Snake), Span::call_site()))
+		.map(|n| quote!(?#n))
+		.reduce(|a, b| quote!(#a, #b))
+		.map(|args| quote!(#args,));
 	// dbg!(&argument_types);
 	let deserialize = argument_names
 		.clone()
@@ -483,33 +514,30 @@ fn generate_run_member(aspect_name: &Ident, _type: MemberType, member: &Member)
 		.map(|a| generate_argument_deserialize(&a.name, &a._type, a.optional))
 		.reduce(|a, b| quote!(#a, #b))
 		.unwrap_or_default();
-	let member_name = member_name_ident.to_string();
-	let aspect_name_str = aspect_name.to_string();
 	match _type {
 		MemberType::Signal => quote! {
-			#opcode => { let result = (move || {
+			#opcode => (move || {
 				#deserialize
+				::tracing::trace!(#argument_debug "received local signal: {}::{}",#aspect_name_str,#member_name);
 				<Self as #aspect_name>::#member_name_ident(_node, _calling_client.clone(), #argument_uses)
-			})().map_err(|e: crate::core::error::ServerError| stardust_xr::scenegraph::ScenegraphError::MemberError { error: e.to_string() });
+			})().map_err(|e: crate::core::error::ServerError| stardust_xr::scenegraph::ScenegraphError::MemberError { error: e.to_string() }),
-				if let Err(err) = result.as_ref() {
-					::tracing::warn!("failed to receive local signal: {}::{}, error: {}",#aspect_name_str,#member_name,err);
-				} else {
-					::tracing::trace!("received local signal: {}::{}",#aspect_name_str,#member_name);
-				}
-				result
-			},
 		},
 		MemberType::Method => quote! {
 			#opcode => _method_response.wrap_async(async move {
-					#deserialize
+				#deserialize
-					let result = <Self as #aspect_name>::#member_name_ident(_node, _calling_client.clone(), #argument_uses).await;
+				::tracing::trace!(#argument_debug "called local method: {}::{}",#aspect_name_str,#member_name);
-					if let Err(err) = result.as_ref() {
+				let result = <Self as #aspect_name>::#member_name_ident(_node, _calling_client.clone(), #argument_uses).await;
-						::tracing::warn!("failed to call local method: {}::{}, error: {}",#aspect_name_str,#member_name,err);
+
-					} else {
+				match result.as_ref() {
-						::tracing::trace!("called local method: {}::{}",#aspect_name_str,#member_name);
+					Ok(value) => {
-					};
+						::tracing::trace!(?value, "client method returned value: {}::{}",#aspect_name_str,#member_name);
-					let result = result?;
+					},
-					 Ok((#serialize, Vec::<std::os::fd::OwnedFd>::new()))
+					Err(err) => {
+						::tracing::warn!("client method returned error: {}::{}, error: {}",#aspect_name_str,#member_name,err);
+					}
+				}
+				let result = result?;
+				Ok((#serialize, Vec::<std::os::fd::OwnedFd>::new()))
 			}),
 		},
 	}

flake.lock

@@ -26,11 +26,11 @@
         "nixpkgs-lib": "nixpkgs-lib"
       },
       "locked": {
-        "lastModified": 1722555600,
+        "lastModified": 1754487366,
-        "narHash": "sha256-XOQkdLafnb/p9ij77byFQjDf5m5QYl9b2REiVClC+x4=",
+        "narHash": "sha256-pHYj8gUBapuUzKV/kN/tR3Zvqc7o6gdFB9XKXIp1SQ8=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "8471fe90ad337a8074e957b69ca4d0089218391d",
+        "rev": "af66ad14b28a127c5c0f3bbb298218fc63528a18",
         "type": "github"
       },
       "original": {
@@ -47,11 +47,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1712014858,
+        "lastModified": 1754487366,
-        "narHash": "sha256-sB4SWl2lX95bExY2gMFG5HIzvva5AVMJd4Igm+GpZNw=",
+        "narHash": "sha256-pHYj8gUBapuUzKV/kN/tR3Zvqc7o6gdFB9XKXIp1SQ8=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "9126214d0a59633752a136528f5f3b9aa8565b7d",
+        "rev": "af66ad14b28a127c5c0f3bbb298218fc63528a18",
         "type": "github"
       },
       "original": {
@@ -65,11 +65,11 @@
         "nixpkgs": "nixpkgs"
       },
       "locked": {
-        "lastModified": 1713050562,
+        "lastModified": 1725868201,
-        "narHash": "sha256-m7c6XpmpTM1URuqMG2KqtaWbL2Vt8vJFJtmvq123BmY=",
+        "narHash": "sha256-rDBQ9tXQCCA7emikSYH59ADJELE2IpzB7eoLrpHYzU4=",
         "owner": "StardustXR",
         "repo": "flatland",
-        "rev": "b3b0f29c4ea1b82c96cf9de507837bf15a5e4c0e",
+        "rev": "0914dd3df54a5e6258dfc0a02d65af1c0fc0fc90",
         "type": "github"
       },
       "original": {
@@ -84,11 +84,11 @@
         "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1719226092,
+        "lastModified": 1755233722,
-        "narHash": "sha256-YNkUMcCUCpnULp40g+svYsaH1RbSEj6s4WdZY/SHe38=",
+        "narHash": "sha256-AavrbMltJKcC2Fx0lfJoZfmy7g87ebXU0ddVenhajLA=",
         "owner": "hercules-ci",
         "repo": "hercules-ci-effects",
-        "rev": "11e4b8dc112e2f485d7c97e1cee77f9958f498f5",
+        "rev": "99e03e72e3f7e13506f80ef9ebaedccb929d84d0",
         "type": "github"
       },
       "original": {
@@ -115,23 +115,26 @@
     },
     "nixpkgs-lib": {
       "locked": {
-        "lastModified": 1722555339,
+        "lastModified": 1753579242,
-        "narHash": "sha256-uFf2QeW7eAHlYXuDktm9c25OxOyCoUOQmh5SZ9amE5Q=",
+        "narHash": "sha256-zvaMGVn14/Zz8hnp4VWT9xVnhc8vuL3TStRqwk22biA=",
-        "type": "tarball",
+        "owner": "nix-community",
-        "url": "https://github.com/NixOS/nixpkgs/archive/a5d394176e64ab29c852d03346c1fc9b0b7d33eb.tar.gz"
+        "repo": "nixpkgs.lib",
+        "rev": "0f36c44e01a6129be94e3ade315a5883f0228a6e",
+        "type": "github"
       },
       "original": {
-        "type": "tarball",
+        "owner": "nix-community",
-        "url": "https://github.com/NixOS/nixpkgs/archive/a5d394176e64ab29c852d03346c1fc9b0b7d33eb.tar.gz"
+        "repo": "nixpkgs.lib",
+        "type": "github"
       }
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1713714899,
+        "lastModified": 1755027561,
-        "narHash": "sha256-+z/XjO3QJs5rLE5UOf015gdVauVRQd2vZtsFkaXBq2Y=",
+        "narHash": "sha256-IVft239Bc8p8Dtvf7UAACMG5P3ZV+3/aO28gXpGtMXI=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "6143fc5eeb9c4f00163267708e26191d1e918932",
+        "rev": "005433b926e16227259a1843015b5b2b7f7d1fc3",
         "type": "github"
       },
       "original": {
@@ -143,11 +146,11 @@
     },
     "nixpkgs_3": {
       "locked": {
-        "lastModified": 1723991338,
+        "lastModified": 1755186698,
-        "narHash": "sha256-Grh5PF0+gootJfOJFenTTxDTYPidA3V28dqJ/WV7iis=",
+        "narHash": "sha256-wNO3+Ks2jZJ4nTHMuks+cxAiVBGNuEBXsT29Bz6HASo=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "8a3354191c0d7144db9756a74755672387b702ba",
+        "rev": "fbcf476f790d8a217c3eab4e12033dc4a0f6d23c",
         "type": "github"
       },
       "original": {

flake.nix

@@ -61,14 +61,11 @@
           };
           overlayAttrs = config.packages;
           packages =
-            let
-              sk_gpu = pkgs.callPackage ./nix/sk_gpu.nix { };
-            in
             {
               default = self'.packages.${name};
               gnome-graphical-test = self'.checks.gnome-graphical-test;
               "${name}" = pkgs.callPackage ./nix/stardust-xr-server.nix {
-                inherit name src sk_gpu;
+                inherit name src;
               };
             };
           apps.default = {

nix/gnome-graphical-test.nix

@@ -20,8 +20,8 @@
         # Set a nice desktop background that is pleasing to the eyes :3
         extraGSettingsOverrides = ''
           [org.gnome.desktop.background]
-          picture-uri='file://${pkgs.gnome.gnome-backgrounds}/share/backgrounds/gnome/blobs-l.svg'
+          picture-uri='file://${pkgs.gnome-backgrounds}/share/backgrounds/gnome/blobs-l.svg'
-          picture-uri-dark='file://${pkgs.gnome.gnome-backgrounds}/share/backgrounds/gnome/blobs-l.svg'
+          picture-uri-dark='file://${pkgs.gnome-backgrounds}/share/backgrounds/gnome/blobs-l.svg'
         '';
       };
       displayManager = {
@@ -100,7 +100,7 @@
             # Eval API is now internal so Shell needs to run in unsafe mode.
             # TODO: improve test driver so that it supports openqa-like manipulation
             # that would allow us to drop this mess.
-            "${pkgs.gnome.gnome-shell}/bin/gnome-shell --unsafe-mode"
+            "${pkgs.gnome-shell}/bin/gnome-shell --unsafe-mode"
           ];
         };
       };

nix/stardust-xr-server.nix

@@ -1,25 +1,27 @@
-{ rustPlatform
+{
-, src
+  rustPlatform,
-, name
+  src,
-, libGL
+  name,
-, mesa
+  vulkan-loader,
-, xorg
+  vulkan-headers,
-, fontconfig
+  mesa,
-, libxkbcommon
+  xorg,
-, libclang
+  fontconfig,
+  libxkbcommon,
+  libclang,
 
-, cmake
+  cmake,
-, cpm-cmake
+  pkg-config,
-, pkg-config
+  llvmPackages,
-, llvmPackages
+  fetchFromGitHub,
-, fetchFromGitHub
+  libXau,
-, sk_gpu
-, libXau
 
-, libXdmcp
+  libXdmcp,
-, stdenv
+  stdenv,
-, lib
+  lib,
-, openxr-loader
+  openxr-loader,
+  wayland,
+  alsa-lib,
 }:
 
 rustPlatform.buildRustPackage rec {
@@ -28,50 +30,27 @@ rustPlatform.buildRustPackage rec {
     lockFile = (src + "/Cargo.lock");
     allowBuiltinFetchGit = true;
   };
-  buildFeatures = [ "local_deps" ];
-  FORCE_LOCAL_DEPS = true;
-  CPM_LOCAL_PACKAGES_ONLY = true;
-  CPM_SOURCE_CACHE = "./build";
-  CPM_USE_LOCAL_PACKAGES = true;
-  CPM_DOWNLOAD_ALL = false;
 
-  meshoptimizer = fetchFromGitHub {
+  preBuild = ''
-    owner = "zeux";
+    substituteInPlace /build/cargo-vendor-dir/bevy_gltf-0.16.1/Cargo.toml \
-    repo = "meshoptimizer";
+      --replace-fail '[lints]' "" \
-    rev = "c21d3be6ddf627f8ca852ba4b6db9903b0557858";
+      --replace-fail 'workspace = true' ""
-    sha256 = "sha256-QCxpM2g8WtYSZHkBzLTJNQ/oHb5j/n9rjaVmZJcCZIA=";
-  };
-  basis_universal = fetchFromGitHub {
-    owner = "BinomialLLC";
-    repo = "basis_universal";
-    rev = "900e40fb5d2502927360fe2f31762bdbb624455f";
-    sha256 = "sha256-zBRAXgG5Fi6+5uPQCI/RCGatY6O4ELuYBoKrPNn4K+8=";
-  };
-
-  DEP_MESHOPTIMIZER_SOURCE = "${meshoptimizer}";
-  DEP_BASIS_UNIVERSAL_SOURCE = "${basis_universal}";
-  DEP_SK_GPU_SOURCE = "${sk_gpu}";
-
-  postPatch = let libPath = lib.makeLibraryPath [ stdenv.cc.cc.lib ];
-  in ''
-    sk=$(echo $cargoDepsCopy/stereokit-rust-*/StereoKit)
-    mkdir -p $sk/build/cpm
-
-    # This is not ideal, the original approach was to fetch the exact cmake
-    # file version that was wanted from GitHub directly, but at least this way it comes from Nixpkgs.. so meh
-    cp ${cpm-cmake}/share/cpm/CPM.cmake $sk/build/cpm/CPM_0.38.7.cmake
-    mkdir -p $sk/sk_gpu
-    cp -R ${sk_gpu}/* $sk/sk_gpu
-    chmod -R 755 $sk/sk_gpu/tools/linux_x64/*
-    export DEP_SK_GPU_SOURCE=$sk/sk_gpu
-    export LD_LIBRARY_PATH="${stdenv.cc.cc.lib}/lib";
-                    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
-                      --set-rpath "${libPath}" \
-                    $sk/sk_gpu/tools/linux_x64/skshaderc
   '';
-  nativeBuildInputs = [ cmake pkg-config llvmPackages.libcxxClang ];
+
+  postFixup = ''
+    patchelf $out/bin/stardust-xr-server --add-rpath ${vulkan-loader}/lib
+    patchelf $out/bin/stardust-xr-server --add-rpath ${openxr-loader}/lib
+    patchelf $out/bin/stardust-xr-server --add-rpath ${libxkbcommon}/lib
+  '';
+
+  nativeBuildInputs = [
+    cmake
+    pkg-config
+    llvmPackages.libcxxClang
+  ];
   buildInputs = [
-    libGL
+    vulkan-loader
+    vulkan-headers
     mesa
     xorg.libX11.dev
     xorg.libXft
@@ -81,6 +60,9 @@ rustPlatform.buildRustPackage rec {
     libXau
     libXdmcp
     openxr-loader
+    wayland
+    alsa-lib
   ];
+
   LIBCLANG_PATH = "${libclang.lib}/lib";
 }

src/core/bevy_channel.rs

@@ -0,0 +1,31 @@
+use std::sync::OnceLock;
+
+use bevy::prelude::*;
+use tokio::sync::mpsc::{self, error::TryRecvError};
+
+#[derive(Resource)]
+pub struct BevyChannelReader<T: Send + Sync + 'static>(mpsc::UnboundedReceiver<T>);
+pub struct BevyChannel<T: Send + Sync + 'static>(OnceLock<mpsc::UnboundedSender<T>>);
+impl<T: Send + Sync + 'static> BevyChannel<T> {
+	pub const fn new() -> Self {
+		Self(OnceLock::new())
+	}
+	pub fn init(&self, app: &mut App) {
+		let (tx, rx) = mpsc::unbounded_channel();
+		self.0.set(tx).unwrap();
+		app.insert_resource(BevyChannelReader(rx));
+	}
+	pub fn send(&self, msg: T) -> Option<()> {
+		self.0.get()?.send(msg).ok()
+	}
+}
+
+impl<T: Send + Sync + 'static> BevyChannelReader<T> {
+	pub fn read(&mut self) -> Option<T> {
+		match self.0.try_recv() {
+			Ok(v) => Some(v),
+			Err(TryRecvError::Disconnected) => panic!("bevy channel should never disconnect"),
+			Err(TryRecvError::Empty) => None,
+		}
+	}
+}

src/core/client.rs

@@ -1,6 +1,5 @@
 use super::{
 	client_state::{CLIENT_STATES, ClientStateParsed},
-	destroy_queue,
 	scenegraph::Scenegraph,
 };
 use crate::{
@@ -28,8 +27,9 @@ use std::{
 use tokio::{net::UnixStream, sync::watch, task::JoinHandle};
 use tracing::info;
 
+pub static CLIENTS: OwnedRegistry<Client> = OwnedRegistry::new();
+
 lazy_static! {
-	pub static ref CLIENTS: OwnedRegistry<Client> = OwnedRegistry::new();
 	static ref INTERNAL_CLIENT_MESSAGE_TIMES: (watch::Sender<Instant>, watch::Receiver<Instant>) = watch::channel(Instant::now());
 	pub static ref INTERNAL_CLIENT: Arc<Client> = CLIENTS.add(Client {
 		pid: None,
@@ -86,7 +86,7 @@ impl Client {
 	pub fn from_connection(connection: UnixStream) -> Result<Arc<Self>> {
 		let pid = connection.peer_cred().ok().and_then(|c| c.pid());
 		let env = pid.and_then(|pid| get_env(pid).ok());
-		let exe = pid.and_then(|pid| fs::read_link(format!("/proc/{}/exe", pid)).ok());
+		let exe = pid.and_then(|pid| fs::read_link(format!("/proc/{pid}/exe")).ok());
 		info!(
 			pid,
 			exe = exe
@@ -144,12 +144,7 @@ impl Client {
 			.unwrap_or_else(|| "??".to_string());
 		let _ = client.dispatch_join_handle.get_or_init(|| {
 			task::new(
-				|| {
+				|| format!("Stardust client \"{exe_printable}\" dispatch, pid={pid_printable}"),
-					format!(
-						"client dispatch pid={} exe={}",
-						&pid_printable, &exe_printable,
-					)
-				},
 				{
 					let client = client.clone();
 					async move {
@@ -166,7 +161,7 @@ impl Client {
 		});
 		let _ = client.flush_join_handle.get_or_init(|| {
 			task::new(
-				|| format!("client flush pid={} exe={}", &pid_printable, &exe_printable,),
+				|| format!("Stardust client \"{exe_printable}\" flush, pid={pid_printable}"),
 				{
 					let client = client.clone();
 					async move {
@@ -201,7 +196,9 @@ impl Client {
 		std::fs::read_link(cwd_proc_path).ok()
 	}
 	pub async fn save_state(&self) -> Option<ClientStateParsed> {
+		println!("start save state");
 		let internal = self.root.get()?.save_state().await.ok()?;
+		println!("finished save state");
 		Some(ClientStateParsed::from_deserialized(self, internal))
 	}
 
@@ -229,9 +226,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 {

src/core/client_state.rs

@@ -33,7 +33,8 @@ impl LaunchInfo {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ClientStateParsed {
 	pub launch_info: Option<LaunchInfo>,
-	pub data: Vec<u8>,
+	#[serde(skip)]
+	pub data: Option<Vec<u8>>,
 	pub root: Mat4,
 	pub spatial_anchors: FxHashMap<String, Mat4>,
 }
@@ -41,7 +42,7 @@ impl ClientStateParsed {
 	pub fn from_deserialized(client: &Client, state: ClientState) -> Self {
 		ClientStateParsed {
 			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(),
 			spatial_anchors: state
 				.spatial_anchors
@@ -63,7 +64,9 @@ impl ClientStateParsed {
 	}
 	pub fn from_file(file: &Path) -> Option<Self> {
 		let file_string = std::fs::read_to_string(file).ok()?;
-		toml::from_str(&file_string).ok()
+		let mut client_state: Self = toml::from_str(&file_string).ok()?;
+		client_state.data = std::fs::read(file.with_extension("bin")).ok();
+		Some(client_state)
 	}
 	pub fn to_file(&self, directory: &Path) {
 		let app_name = self
@@ -71,11 +74,14 @@ impl ClientStateParsed {
 			.as_ref()
 			.map(|l| l.cmdline.first().unwrap().split('/').next_back().unwrap())
 			.unwrap_or("unknown");
-		let state_file_path = directory
+		let state_file_prefix = directory.join(format!("{app_name}-{}", nanoid::nanoid!()));
-			.join(format!("{app_name}-{}", nanoid::nanoid!()))
+		let state_metadata_path = state_file_prefix.with_extension("toml");
-			.with_extension("toml");
+		let state_data_path = state_file_prefix.with_extension("bin");
 
-		std::fs::write(state_file_path, toml::to_string(&self).unwrap()).unwrap();
+		std::fs::write(state_metadata_path, toml::to_string(&self).unwrap()).unwrap();
+		if let Some(data) = self.data.as_deref() {
+			std::fs::write(state_data_path, data).unwrap();
+		}
 	}
 
 	pub fn apply_to(&self, client: &Arc<Client>) -> ClientState {
@@ -83,7 +89,7 @@ impl ClientStateParsed {
 			root.set_transform(self.root)
 		}
 		ClientState {
-			data: Some(self.data.clone()),
+			data: self.data.clone(),
 			root: 0,
 			spatial_anchors: self
 				.spatial_anchors
@@ -111,7 +117,7 @@ impl Default for ClientStateParsed {
 	fn default() -> Self {
 		Self {
 			launch_info: None,
-			data: Default::default(),
+			data: None,
 			root: Mat4::IDENTITY,
 			spatial_anchors: Default::default(),
 		}

src/core/color.rs

@@ -0,0 +1,10 @@
+use stardust_xr::values::color::{AlphaColor, Rgb, color_space::LinearRgb};
+
+pub trait ColorConvert {
+	fn to_bevy(&self) -> bevy::color::Color;
+}
+impl ColorConvert for AlphaColor<f32, Rgb<f32, LinearRgb>> {
+	fn to_bevy(&self) -> bevy::color::Color {
+		bevy::color::Color::linear_rgba(self.c.r, self.c.g, self.c.b, self.a)
+	}
+}

src/core/destroy_queue.rs

@@ -1,23 +0,0 @@
-use parking_lot::Mutex;
-use std::{any::Any, sync::LazyLock};
-use tokio::sync::mpsc::{self, unbounded_channel};
-
-type Anything = Box<dyn Any + Send + Sync>;
-
-static MAIN_DESTROY_QUEUE: LazyLock<(
-	mpsc::UnboundedSender<Anything>,
-	Mutex<mpsc::UnboundedReceiver<Anything>>,
-)> = LazyLock::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();
-}
-
-pub fn clear() {
-	while let Ok(thing) = MAIN_DESTROY_QUEUE.1.lock().try_recv() {
-		drop(thing)
-	}
-}

src/core/entity_handle.rs

@@ -0,0 +1,60 @@
+use std::ops::Deref;
+use std::sync::Arc;
+
+use bevy::prelude::*;
+
+use crate::nodes::spatial::SpatialNode;
+
+use super::bevy_channel::{BevyChannel, BevyChannelReader};
+pub struct EntityHandlePlugin;
+
+impl Plugin for EntityHandlePlugin {
+	fn build(&self, app: &mut App) {
+		DESTROY.init(app);
+		app.add_systems(PreUpdate, despawn);
+	}
+}
+
+fn despawn(
+	mut cmds: Commands,
+	mut reader: ResMut<BevyChannelReader<Entity>>,
+	child_query: Query<&Children>,
+	has_spatial: Query<Has<SpatialNode>>,
+) {
+	while let Some(e) = reader.read() {
+		if let Ok(children) = child_query.get(e) {
+			for e in children {
+				if has_spatial.get(*e).unwrap_or_default() {
+					cmds.entity(*e).try_remove::<ChildOf>();
+				}
+			}
+		}
+		cmds.entity(e).despawn();
+	}
+}
+
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone)]
+pub struct EntityHandle(Arc<EntityHandleInner>);
+impl EntityHandle {
+	pub fn get(&self) -> Entity {
+		self.0.0
+	}
+	pub fn new(entity: Entity) -> Self {
+		Self(EntityHandleInner(entity).into())
+	}
+}
+impl Deref for EntityHandle {
+	type Target = Entity;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0.0
+	}
+}
+static DESTROY: BevyChannel<Entity> = BevyChannel::new();
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct EntityHandleInner(Entity);
+impl Drop for EntityHandleInner {
+	fn drop(&mut self) {
+		DESTROY.send(self.0);
+	}
+}

src/core/error.rs

@@ -8,7 +8,6 @@ use stardust_xr::{
 		flexbuffers::{DeserializationError, ReaderError},
 	},
 };
-use stereokit_rust::StereoKitError;
 use thiserror::Error;
 
 pub type Result<T, E = ServerError> = std::result::Result<T, E>;
@@ -29,8 +28,6 @@ pub enum ServerError {
 	DeserializationError(#[from] DeserializationError),
 	#[error("Reader error: {0}")]
 	ReaderError(#[from] ReaderError),
-	#[error("StereoKit error: {0}")]
-	StereoKitError(#[from] StereoKitError),
 	#[error("Aspect {} does not exist for node", 0.to_string())]
 	NoAspect(TypeId),
 	#[error("{0}")]

src/core/mod.rs

@@ -1,7 +1,9 @@
+pub mod bevy_channel;
 pub mod client;
 pub mod client_state;
+pub mod color;
 pub mod delta;
-pub mod destroy_queue;
+pub mod entity_handle;
 pub mod error;
 pub mod registry;
 pub mod resource;

src/core/registry.rs

@@ -36,18 +36,18 @@ impl<T: Send + Sync + ?Sized> Registry<T> {
 
 		for pair in new.0.iter() {
 			let (id, entry) = pair.pair();
-			if let Some(entry) = entry.upgrade() {
+			if let Some(entry) = entry.upgrade()
-				if !old.0.contains_key(id) {
+				&& !old.0.contains_key(id)
-					added.push(entry);
+			{
-				}
+				added.push(entry);
 			}
 		}
 		for pair in old.0.iter() {
 			let (id, entry) = pair.pair();
-			if let Some(entry) = entry.upgrade() {
+			if let Some(entry) = entry.upgrade()
-				if !new.0.contains_key(id) {
+				&& !new.0.contains_key(id)
-					removed.push(entry);
+			{
-				}
+				removed.push(entry);
 			}
 		}
 		(added, removed)
@@ -143,7 +143,7 @@ impl<T: Send + Sync + ?Sized> OwnedRegistry<T> {
 	pub const fn new() -> Self {
 		OwnedRegistry(const_mutex(None))
 	}
-	fn lock(&self) -> MappedMutexGuard<FxHashMap<usize, Arc<T>>> {
+	fn lock(&self) -> MappedMutexGuard<'_, FxHashMap<usize, Arc<T>>> {
 		MutexGuard::map(self.0.lock(), |r| r.get_or_insert_with(FxHashMap::default))
 	}
 	pub fn add(&self, t: T) -> Arc<T>

src/core/scenegraph.rs

@@ -1,19 +1,80 @@
-use crate::core::error::Result;
+use crate::{
-use crate::nodes::Node;
+	core::{
-use crate::nodes::alias::get_original;
+		client::Client,
-use crate::{core::client::Client, nodes::Message};
+		error::{Result, ServerError},
+	},
+	nodes::{Message, Node, alias::get_original},
+};
 use parking_lot::Mutex;
 use rustc_hash::FxHashMap;
 use serde::Serialize;
-use stardust_xr::scenegraph;
+use stardust_xr::{
-use stardust_xr::scenegraph::ScenegraphError;
+	messenger::MethodResponse,
-use stardust_xr::schemas::flex::serialize;
+	scenegraph::{self, ScenegraphError},
-use std::future::Future;
+	schemas::flex::serialize,
-use std::os::fd::OwnedFd;
+};
-use std::sync::{Arc, OnceLock, Weak};
+use std::{
-use tokio::sync::oneshot;
+	os::fd::OwnedFd,
+	sync::{Arc, OnceLock, Weak},
+};
 use tracing::{debug, debug_span};
 
+pub struct MethodResponseSender(pub(crate) MethodResponse);
+impl MethodResponseSender {
+	pub fn send_err(self, error: ScenegraphError) {
+		self.0.send(Err(error));
+	}
+	pub fn send<T: Serialize>(self, result: Result<T, ServerError>) {
+		let data = match result {
+			Ok(d) => d,
+			Err(e) => {
+				self.0.send(Err(ScenegraphError::MemberError {
+					error: e.to_string(),
+				}));
+				return;
+			}
+		};
+		let Ok(serialized) = stardust_xr::schemas::flex::serialize(data) else {
+			self.0.send(Err(ScenegraphError::MemberError {
+				error: "Internal: Failed to serialize".to_string(),
+			}));
+			return;
+		};
+		self.0.send(Ok((&serialized, Vec::<OwnedFd>::new())));
+	}
+	pub fn wrap<T: Serialize, F: FnOnce() -> Result<T>>(self, f: F) {
+		self.send(f())
+	}
+	pub fn wrap_async<T: Serialize>(
+		self,
+		f: impl Future<Output = Result<(T, Vec<OwnedFd>)>> + Send + 'static,
+	) {
+		tokio::task::spawn(async move {
+			let (value, fds) = match f.await {
+				Ok(d) => d,
+				Err(e) => {
+					self.0.send(Err(ScenegraphError::MemberError {
+						error: e.to_string(),
+					}));
+					return;
+				}
+			};
+			let Ok(serialized) = serialize(value) else {
+				self.0.send(Err(ScenegraphError::MemberError {
+					error: "Internal: Failed to serialize".to_string(),
+				}));
+				return;
+			};
+			self.0.send(Ok((&serialized, fds)));
+		});
+	}
+}
+impl std::fmt::Debug for MethodResponseSender {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		f.debug_struct("TypedMethodResponse").finish()
+	}
+}
+
 #[derive(Default)]
 pub struct Scenegraph {
 	pub(super) client: OnceLock<Weak<Client>>,
@@ -45,43 +106,6 @@ impl Scenegraph {
 		self.nodes.lock().remove(&node)
 	}
 }
-
-pub type MethodResponse = Result<(Vec<u8>, Vec<OwnedFd>), ScenegraphError>;
-pub struct MethodResponseSender(oneshot::Sender<MethodResponse>);
-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() -> crate::core::error::Result<Message>>(self, f: F) {
-		self.send(f().map_err(|e| ScenegraphError::MemberError {
-			error: e.to_string(),
-		}))
-	}
-	pub fn wrap_async<T: Serialize>(
-		self,
-		f: impl Future<Output = 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: Result<(T, Vec<OwnedFd>)>,
-) -> Result<(Vec<u8>, Vec<OwnedFd>), ScenegraphError> {
-	let (value, fds) = result.map_err(|e| ScenegraphError::MemberError {
-		error: e.to_string(),
-	})?;
-
-	let serialized_value = serialize(value).map_err(|e| ScenegraphError::MemberError {
-		error: format!("Internal: Serialization failed: {e}"),
-	})?;
-	Ok((serialized_value, fds))
-}
 impl scenegraph::Scenegraph for Scenegraph {
 	fn send_signal(
 		&self,
@@ -115,15 +139,15 @@ impl scenegraph::Scenegraph for Scenegraph {
 		method: u64,
 		data: &[u8],
 		fds: Vec<OwnedFd>,
-		response: oneshot::Sender<Result<(Vec<u8>, Vec<OwnedFd>), ScenegraphError>>,
+		response: MethodResponse,
 	) {
 		let Some(client) = self.get_client() else {
-			let _ = response.send(Err(ScenegraphError::NodeNotFound));
+			response.send(Err(ScenegraphError::NodeNotFound));
 			return;
 		};
 		debug!(aspect_id, node_id, method, "Handle method");
 		let Some(node) = self.get_node(node_id) else {
-			let _ = response.send(Err(ScenegraphError::NodeNotFound));
+			response.send(Err(ScenegraphError::NodeNotFound));
 			return;
 		};
 		node.execute_local_method(

src/core/task.rs

@@ -1,4 +1,3 @@
-use color_eyre::eyre::Result;
 use std::future::Future;
 use tokio::task::JoinHandle;
 
@@ -11,7 +10,7 @@ pub fn new<
 >(
 	name_fn: F,
 	async_future: A,
-) -> Result<JoinHandle<O>> {
+) -> std::io::Result<JoinHandle<O>> {
 	#[cfg(not(feature = "profile_tokio"))]
 	let result = Ok(tokio::task::spawn(async_future));
 	#[cfg(feature = "profile_tokio")]

src/main.rs

@@ -1,49 +1,109 @@
+#![recursion_limit = "256"]
 #![allow(clippy::empty_docs)]
+#![allow(clippy::too_many_arguments)]
+#![allow(clippy::type_complexity)]
 mod core;
 mod nodes;
 mod objects;
 mod session;
+mod spectator_cam;
+pub mod tracking_offset;
 #[cfg(feature = "wayland")]
 mod wayland;
 
-use crate::core::destroy_queue;
+use crate::nodes::drawable::sky::SkyPlugin;
-use crate::nodes::items::camera;
+use crate::nodes::input;
-use crate::nodes::{audio, drawable, input};
+use crate::spectator_cam::SpectatorCameraPlugin;
 
+use bevy::MinimalPlugins;
+use bevy::a11y::AccessibilityPlugin;
+use bevy::app::{App, ScheduleRunnerPlugin, TerminalCtrlCHandlerPlugin};
+use bevy::asset::{AssetMetaCheck, UnapprovedPathMode};
+use bevy::audio::AudioPlugin;
+use bevy::core_pipeline::CorePipelinePlugin;
+use bevy::core_pipeline::oit::OrderIndependentTransparencySettings;
+use bevy::core_pipeline::tonemapping::Tonemapping;
+use bevy::diagnostic::DiagnosticsPlugin;
+use bevy::ecs::schedule::{ExecutorKind, ScheduleLabel};
+use bevy::gizmos::GizmoPlugin;
+use bevy::gltf::GltfPlugin;
+use bevy::input::InputPlugin;
+use bevy::pbr::PbrPlugin;
+use bevy::render::pipelined_rendering::{
+	PipelinedRenderThreadOnCreateCallback, PipelinedRenderingPlugin,
+};
+use bevy::render::settings::{Backends, RenderCreation, WgpuSettings};
+use bevy::render::{RenderDebugFlags, RenderPlugin};
+use bevy::scene::ScenePlugin;
+use bevy::window::{CompositeAlphaMode, PresentMode};
+use bevy::winit::{WakeUp, WinitPlugin};
+use bevy_dmabuf::import::DmabufImportPlugin;
+use bevy_mod_openxr::action_set_attaching::OxrActionAttachingPlugin;
+use bevy_mod_openxr::action_set_syncing::OxrActionSyncingPlugin;
+use bevy_mod_openxr::add_xr_plugins;
+use bevy_mod_openxr::exts::OxrExtensions;
+use bevy_mod_openxr::features::overlay::OxrOverlaySettings;
+use bevy_mod_openxr::graphics::{GraphicsBackend, OxrManualGraphicsConfig};
+use bevy_mod_openxr::init::{OxrInitPlugin, should_run_frame_loop};
+use bevy_mod_openxr::reference_space::OxrReferenceSpacePlugin;
+use bevy_mod_openxr::render::{OxrRenderPlugin, OxrWaitFrameSystem};
+use bevy_mod_openxr::resources::{OxrFrameState, OxrFrameWaiter, OxrSessionConfig};
+use bevy_mod_openxr::types::AppInfo;
+use bevy_mod_xr::camera::XrProjection;
+use bevy_mod_xr::session::{XrFirst, XrHandleEvents, XrSessionPlugin};
 use clap::Parser;
 use core::client::{Client, tick_internal_client};
+use core::entity_handle::EntityHandlePlugin;
 use core::task;
 use directories::ProjectDirs;
-use objects::ServerObjects;
+use nodes::audio::AudioNodePlugin;
+use nodes::drawable::lines::LinesNodePlugin;
+use nodes::drawable::model::ModelNodePlugin;
+use nodes::drawable::text::TextNodePlugin;
+use nodes::fields::FieldDebugGizmoPlugin;
+use nodes::spatial::SpatialNodePlugin;
+use objects::hmd::HmdPlugin;
+use objects::input::mouse_pointer::FlatscreenInputPlugin;
+use objects::input::oxr_controller::ControllerPlugin;
+use objects::input::oxr_hand::HandPlugin;
+use objects::play_space::PlaySpacePlugin;
+use openxr::{EnvironmentBlendMode, ReferenceSpaceType};
 use session::{launch_start, save_session};
 use stardust_xr::schemas::dbus::object_registry::ObjectRegistry;
-use stardust_xr::server;
+use stardust_xr::server::LockedSocket;
+use std::ops::DerefMut as _;
 use std::path::PathBuf;
+use std::str::FromStr;
 use std::sync::{Arc, OnceLock};
-use std::time::Duration;
-use stereokit_rust::material::Material;
-use stereokit_rust::shader::Shader;
-use stereokit_rust::sk::{
-	AppMode, DepthMode, DisplayBlend, OriginMode, QuitReason, SkSettings, sk_quit,
-};
-use stereokit_rust::system::{Handed, Input, LogLevel, Renderer};
-use stereokit_rust::tex::{SHCubemap, Tex, TexFormat, TexType};
-use stereokit_rust::ui::Ui;
-use stereokit_rust::util::{Color128, SphericalHarmonics, Time};
 use tokio::net::UnixListener;
 use tokio::sync::Notify;
+use tokio::task::JoinError;
 use tracing::metadata::LevelFilter;
-use tracing::{debug_span, error, info};
+use tracing::{error, info};
+use tracing_subscriber::filter::Directive;
 use tracing_subscriber::{EnvFilter, fmt, prelude::*};
+use tracking_offset::TrackingOffsetPlugin;
+#[cfg(feature = "wayland")]
+use wayland::{Wayland, WaylandPlugin};
 use zbus::Connection;
 use zbus::fdo::ObjectManager;
 
+use bevy::prelude::*;
+
 #[derive(Debug, Clone, Parser)]
 #[clap(author, version, about, long_about = None)]
 struct CliArgs {
 	/// Force flatscreen mode and use the mouse pointer as a 3D pointer
 	#[clap(short, long, action)]
-	flatscreen: bool,
+	force_flatscreen: bool,
+
+	/// Replaces the flatscreen mode with a first person spectator camera
+	#[clap(short, long, action)]
+	spectator: bool,
+
+	/// Creates a transparent window fot the flatscreen mode
+	#[clap(short, long, action)]
+	transparent_flatscreen: bool,
 
 	/// If monado insists on emulating them, set this flag...we want the raw input
 	#[clap(long)]
@@ -67,17 +127,15 @@ struct CliArgs {
 	/// 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>,
-	/// this should fix nvidia issues, it'll only help on driver 565+
-	/// and only if running under wayland, probably
-	#[clap(long)]
-	nvidia: bool,
 }
 
+pub type BevyMaterial = StandardMaterial;
+
 static STARDUST_INSTANCE: OnceLock<String> = OnceLock::new();
 
 // #[tokio::main(flavor = "current_thread")]
 #[tokio::main]
-async fn main() {
+async fn main() -> Result<AppExit, JoinError> {
 	color_eyre::install().unwrap();
 
 	let registry = tracing_subscriber::registry();
@@ -89,9 +147,7 @@ async fn main() {
 	);
 
 	#[cfg(feature = "profile_tokio")]
-	let (console_layer, _) = console_subscriber::ConsoleLayer::builder().build();
+	let registry = registry.with(console_subscriber::spawn());
-	#[cfg(feature = "profile_tokio")]
-	let registry = registry.with(console_layer);
 
 	let log_layer = fmt::Layer::new()
 		.with_thread_names(true)
@@ -100,36 +156,23 @@ async fn main() {
 		.with_filter(
 			EnvFilter::builder()
 				.with_default_directive(LevelFilter::WARN.into())
-				.from_env_lossy(),
+				.from_env_lossy()
+				.add_directive(Directive::from_str("bevy_mesh_text_3d::text_glyphs=off").unwrap()),
 		);
 	registry.with(log_layer).init();
 
 	let cli_args = CliArgs::parse();
 
-	if cli_args.nvidia && !cli_args.flatscreen {
+	let locked_socket =
-		// Only call this while singlethreaded since it can/will cause raceconditions with other
+		LockedSocket::get_free().expect("Unable to find a free stardust socket path");
-		// functions reading or writing from the env
+	STARDUST_INSTANCE.set(locked_socket.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");
-		unsafe {
-			std::env::set_var("__GLX_VENDOR_LIBRARY_NAME", "mesa");
-			std::env::set_var(
-				"__EGL_VENDOR_LIBRARY_FILENAMES",
-				"/usr/share/glvnd/egl_vendor.d/50_mesa.json",
-			);
-			std::env::set_var("MESA_LOADER_DRIVER_OVERRIDE", "zink");
-			std::env::set_var("GALLIUM_DRIVER", "zink");
-		}
-	}
-
-	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");
 	info!(
-		socket_path = ?socket_path.display(),
+		socket_path = ?locked_socket.socket_path.display(),
 		"Stardust socket created"
 	);
-	let socket =
+	let socket = UnixListener::bind(locked_socket.socket_path)
-		UnixListener::bind(socket_path).expect("Couldn't spawn stardust server at {socket_path}");
+		.expect("Couldn't spawn stardust server at {socket_path}");
-	task::new(|| "client join loop", async move {
+	task::new(|| "Stardust socket accept loop", async move {
 		loop {
 			let Ok((stream, _)) = socket.accept().await else {
 				continue;
@@ -152,6 +195,8 @@ async fn main() {
 	let dbus_connection = Connection::session()
 		.await
 		.expect("Could not open dbus session");
+	// why is this requested here? should there be a specific server bus name that we check
+	// instead?
 	dbus_connection
 		.request_name("org.stardustxr.HMD")
 		.await
@@ -165,19 +210,20 @@ async fn main() {
 		.await
 		.expect("Couldn't add the object manager");
 
-	let object_registry = ObjectRegistry::new(&dbus_connection).await.expect(
+	let object_registry = ObjectRegistry::new(&dbus_connection).await;
-		"Couldn't make the object registry to find all objects with given interfaces in d-bus",
-	);
 
-	let sk_ready_notifier = Arc::new(Notify::new());
+	#[cfg(feature = "wayland")]
-	let stereokit_loop = tokio::task::spawn_blocking({
+	let _wayland = Wayland::new().expect("Couldn't create Wayland instance");
-		let sk_ready_notifier = sk_ready_notifier.clone();
+
+	let ready_notifier = Arc::new(Notify::new());
+	let io_loop = tokio::task::spawn_blocking({
+		let ready_notifier = ready_notifier.clone();
 		let project_dirs = project_dirs.clone();
 		let cli_args = cli_args.clone();
 		let dbus_connection = dbus_connection.clone();
 		move || {
-			stereokit_loop(
+			bevy_loop(
-				sk_ready_notifier,
+				ready_notifier,
 				project_dirs,
 				cli_args,
 				dbus_connection,
@@ -185,16 +231,12 @@ async fn main() {
 			)
 		}
 	});
-	sk_ready_notifier.notified().await;
+	ready_notifier.notified().await;
 	let mut startup_children = project_dirs
 		.as_ref()
 		.map(|project_dirs| launch_start(&cli_args, project_dirs))
 		.unwrap_or_default();
-
+	let return_value = io_loop.await;
-	tokio::select! {
-		_ = stereokit_loop => (),
-		_ = tokio::signal::ctrl_c() => unsafe {sk_quit(QuitReason::SystemClose)},
-	}
 	info!("Stopping...");
 	if let Some(project_dirs) = project_dirs {
 		save_session(&project_dirs).await;
@@ -204,141 +246,280 @@ async fn main() {
 	}
 
 	info!("Cleanly shut down Stardust");
+	return_value
 }
 
-static DEFAULT_SKYTEX: OnceLock<Tex> = OnceLock::new();
+// static DEFAULT_SKYTEX: OnceLock<Tex> = OnceLock::new();
-static DEFAULT_SKYLIGHT: OnceLock<SphericalHarmonics> = OnceLock::new();
+// static DEFAULT_SKYLIGHT: OnceLock<SphericalHarmonics> = OnceLock::new();
 
-fn stereokit_loop(
+#[derive(ScheduleLabel, Hash, Debug, PartialEq, Eq, Clone, Copy)]
-	sk_ready_notifier: Arc<Notify>,
+pub struct PreFrameWait;
-	project_dirs: Option<ProjectDirs>,
+#[derive(Resource, Deref)]
+pub struct ObjectRegistryRes(Arc<ObjectRegistry>);
+#[derive(Resource, Deref)]
+pub struct DbusConnection(Connection);
+
+fn bevy_loop(
+	ready_notifier: Arc<Notify>,
+	_project_dirs: Option<ProjectDirs>,
 	args: CliArgs,
 	dbus_connection: Connection,
-	object_registry: ObjectRegistry,
+	object_registry: Arc<ObjectRegistry>,
-) {
+) -> AppExit {
-	let sk = SkSettings::default()
+	let mut app = App::new();
-		.app_name("Stardust XR")
+	app.insert_resource(DbusConnection(dbus_connection));
-		.blend_preference(DisplayBlend::AnyTransparent)
+	app.insert_resource(OxrManualGraphicsConfig {
-		.mode(if args.flatscreen {
+		fallback_backend: GraphicsBackend::Vulkan(()),
-			AppMode::Simulator
+		vk_instance_exts: Vec::new(),
-		} else {
+		vk_device_exts: bevy_dmabuf::required_device_extensions(),
-			AppMode::XR
+	});
+	app.add_plugins(AssetPlugin {
+		meta_check: AssetMetaCheck::Never,
+		unapproved_path_mode: UnapprovedPathMode::Allow,
+		..default()
+	});
+	let mut plugins = MinimalPlugins
+		.build()
+		.add(DiagnosticsPlugin)
+		.add(TransformPlugin)
+		.add(InputPlugin)
+		.add(AccessibilityPlugin);
+	plugins = plugins
+		.add(TerminalCtrlCHandlerPlugin)
+		// bevy_mod_openxr will replace this, TODO: figure out how to mix this with
+		// bevy-dmabuf
+		.add(RenderPlugin {
+			render_creation: RenderCreation::Automatic(WgpuSettings {
+				backends: Some(Backends::VULKAN),
+				..Default::default()
+			}),
+			..Default::default()
 		})
-		.depth_mode(DepthMode::D32)
+		.add(ImagePlugin::default())
-		.log_filter(match EnvFilter::from_default_env().max_level_hint() {
+		.add(CorePipelinePlugin)
-			Some(LevelFilter::ERROR) => LogLevel::Error,
+		// theoretically we shouldn't need this because of bevy_sk, but everything is tangled in
-			Some(LevelFilter::WARN) => LogLevel::Warning,
+		// there and idk what we actually need to run
-			Some(LevelFilter::INFO) => LogLevel::Inform,
+		.add(PbrPlugin {
-			Some(LevelFilter::DEBUG) => LogLevel::Diagnostic,
+			// this seems to only apply to StandardMaterial, we don't use that
-			Some(LevelFilter::TRACE) => LogLevel::Diagnostic,
+			prepass_enabled: true,
-			Some(LevelFilter::OFF) => LogLevel::None,
+			add_default_deferred_lighting_plugin: false,
-			None => LogLevel::Warning,
+			use_gpu_instance_buffer_builder: true,
+			debug_flags: RenderDebugFlags::default(),
 		})
-		.overlay_app(args.overlay_priority.is_some())
+		// required for gltf
-		.overlay_priority(args.overlay_priority.unwrap_or(u32::MAX))
+		.add(ScenePlugin)
-		.disable_desktop_input_window(true)
+		.add(GltfPlugin::default())
-		.origin(OriginMode::Local)
+		// .add(AnimationPlugin)
-		.init()
+		.add(AudioPlugin::default())
-		.expect("StereoKit failed to initialize");
+		.add(GizmoPlugin)
-	info!("Init StereoKit");
+		.add(WindowPlugin::default());
-
+	#[cfg(feature = "wayland")]
-	Renderer::multisample(0);
-	Material::default().shader(Shader::pbr_clip());
-	Ui::enable_far_interact(false);
-
-	let left_hand_material = Material::find("default/material_hand").unwrap();
-	let mut right_hand_material = left_hand_material.copy();
-	right_hand_material.id("right_hand");
-	Input::hand_material(Handed::Right, Some(Material::find("right_hand").unwrap()));
-
-	Input::hand_visible(Handed::Left, false);
-	Input::hand_visible(Handed::Right, false);
-
-	// Skytex/light stuff
 	{
-		let _ = DEFAULT_SKYTEX.set(Tex::gen_color(
+		plugins = plugins.add(DmabufImportPlugin);
-			Color128::BLACK,
-			1,
-			1,
-			TexType::Cubemap,
-			TexFormat::RGBA32,
-		));
-		let _ = DEFAULT_SKYLIGHT.set(Renderer::get_skylight());
-		if let Some(sky) = project_dirs
-			.as_ref()
-			.map(|dirs| dirs.config_dir().join("skytex.hdr"))
-			.filter(|f| f.exists())
-			.and_then(|p| SHCubemap::from_cubemap(p, true, 100).ok())
-		{
-			sky.render_as_sky();
-		} else {
-			Renderer::skytex(DEFAULT_SKYTEX.get().unwrap());
-		}
 	}
+	let mut task_pool_plugin = TaskPoolPlugin::default();
+	// make tokio work
+	let handle = tokio::runtime::Handle::current();
+	let enter_runtime_context = Arc::new(move || {
+		// TODO: this might be a memory leak
+		std::mem::forget(handle.enter());
+	});
+	task_pool_plugin.task_pool_options.io.on_thread_spawn = Some(enter_runtime_context.clone());
+	task_pool_plugin.task_pool_options.compute.on_thread_spawn =
+		Some(enter_runtime_context.clone());
+	task_pool_plugin
+		.task_pool_options
+		.async_compute
+		.on_thread_spawn = Some(enter_runtime_context.clone());
+	plugins = plugins.set(task_pool_plugin);
+	if std::env::var("DISPLAY").is_ok_and(|s| !s.is_empty())
+		|| std::env::var("WAYLAND_DISPLAY").is_ok_and(|s| !s.is_empty())
+	{
+		let mut plugin = WinitPlugin::<WakeUp>::default();
+		plugin.run_on_any_thread = true;
+		plugins = plugins.add(plugin).disable::<ScheduleRunnerPlugin>();
+		plugins = match args.spectator {
+			true => plugins.add(SpectatorCameraPlugin),
+			false => plugins.add(FlatscreenInputPlugin),
+		};
+	}
+	app.insert_resource(PipelinedRenderThreadOnCreateCallback(
+		enter_runtime_context.clone(),
+	));
+	app.add_plugins(
+		if !args.force_flatscreen {
+			add_xr_plugins(plugins)
+				.set(OxrInitPlugin {
+					app_info: AppInfo {
+						name: "Stardust XR".into(),
+						version: bevy_mod_openxr::types::Version(0, 44, 1),
+					},
+					exts: {
+						// all OpenXR extensions can be requested here
+						let mut exts = OxrExtensions::default();
+						exts.enable_hand_tracking();
+						if args.overlay_priority.is_some() {
+							exts.enable_extx_overlay();
+						}
+						exts.khr_convert_timespec_time = true;
+						exts
+					},
+					..default()
+				})
+				.set(OxrRenderPlugin {
+					default_wait_frame: false,
+					..default()
+				})
+				.set(OxrReferenceSpacePlugin {
+					default_primary_ref_space: ReferenceSpaceType::LOCAL,
+				})
+				// Disable a bunch of unneeded plugins
+				// we don't do any action stuff that needs to integrate with the ecosystem
+				.disable::<OxrActionAttachingPlugin>()
+				.disable::<OxrActionSyncingPlugin>()
+		} else {
+			// enable a event
+			plugins = plugins.add(XrSessionPlugin { auto_handle: false });
+			bevy_dmabuf::wgpu_init::add_dmabuf_init_plugin(plugins)
+		}
+		.set(WindowPlugin {
+			primary_window: Some(Window {
+				transparent: args.transparent_flatscreen,
+				present_mode: PresentMode::AutoNoVsync,
+				composite_alpha_mode: if args.transparent_flatscreen {
+					CompositeAlphaMode::PreMultiplied
+				} else {
+					CompositeAlphaMode::Auto
+				},
+				title: "StardustXR server flatscreen mode".to_string(),
+				..default()
+			}),
+			..default()
+		}),
+	);
+	app.add_plugins(PipelinedRenderingPlugin);
 
+	app.add_plugins(bevy_sk::hand::HandPlugin);
+	app.add_plugins(bevy_equirect::EquirectangularPlugin);
+	// app.add_plugins(HandGizmosPlugin);
+	app.world_mut().resource_mut::<AmbientLight>().brightness = 1000.0;
+	if let Some(priority) = args.overlay_priority {
+		app.insert_resource(OxrOverlaySettings {
+			session_layer_placement: priority,
+			..default()
+		});
+	}
+	app.insert_resource(OxrSessionConfig {
+		blend_mode_preference: vec![
+			EnvironmentBlendMode::ALPHA_BLEND,
+			EnvironmentBlendMode::ADDITIVE,
+			EnvironmentBlendMode::OPAQUE,
+		],
+		..default()
+	});
+	let mut pre_frame_wait = Schedule::new(PreFrameWait);
+	pre_frame_wait.set_executor_kind(ExecutorKind::MultiThreaded);
+	app.add_schedule(pre_frame_wait);
+	app.insert_resource(ClearColor(Color::BLACK.with_alpha(0.0)));
+	app.insert_resource(ObjectRegistryRes(object_registry));
+	#[cfg(feature = "bevy_debugging")]
+	{
+		use bevy::remote::{RemotePlugin, http::RemoteHttpPlugin};
+		app.add_plugins((RemotePlugin::default(), RemoteHttpPlugin::default()));
+	}
+	// the Stardust server plugins
+	// infra plugins
+	app.add_plugins(EntityHandlePlugin);
+	// node plugins
+	app.add_plugins((
+		SpatialNodePlugin,
+		ModelNodePlugin,
+		TextNodePlugin,
+		LinesNodePlugin,
+		AudioNodePlugin,
+		// not really a node ig? at least for now
+		SkyPlugin,
+	));
+	// object plugins
+	app.add_plugins((PlaySpacePlugin, HandPlugin, ControllerPlugin, HmdPlugin));
+	// feature plugins
 	#[cfg(feature = "wayland")]
-	let mut wayland = wayland::Wayland::new().expect("Could not initialize wayland");
+	app.add_plugins(WaylandPlugin);
-	#[cfg(feature = "wayland")]
+	app.add_plugins((TrackingOffsetPlugin, FieldDebugGizmoPlugin));
-	wayland.make_context_current();
+	app.add_systems(PostStartup, move || {
-	sk_ready_notifier.notify_waiters();
+		ready_notifier.notify_waiters();
-	info!("Stardust ready!");
+	});
-
+	app.add_observer(cam_settings);
-	let mut objects = ServerObjects::new(
+	app.add_systems(
-		dbus_connection.clone(),
+		XrFirst,
-		&sk,
+		xr_step
-		[left_hand_material, right_hand_material],
+			.in_set(OxrWaitFrameSystem)
-		args.disable_controllers,
+			.in_set(XrHandleEvents::FrameLoop),
-		args.disable_hands,
 	);
 
-	let mut last_frame_delta = Duration::ZERO;
+	app.run()
-	let mut sleep_duration = Duration::ZERO;
-	while let Some(token) = sk.step() {
-		let _span = debug_span!("StereoKit step");
-		let _span = _span.enter();
-
-		camera::update(token);
-		#[cfg(feature = "wayland")]
-		wayland.frame_event();
-		destroy_queue::clear();
-
-		objects.update(&sk, token, &dbus_connection, &object_registry);
-		input::process_input();
-		nodes::root::Root::send_frame_events(Time::get_step_unscaled());
-		adaptive_sleep(
-			&mut last_frame_delta,
-			&mut sleep_duration,
-			Duration::from_micros(250),
-		);
-
-		tick_internal_client();
-		#[cfg(feature = "wayland")]
-		wayland.update();
-		drawable::draw(token);
-		audio::update();
-	}
-
-	info!("Cleanly shut down StereoKit");
 }
 
-fn adaptive_sleep(
+fn cam_settings(
-	last_frame_delta: &mut Duration,
+	trigger: Trigger<OnAdd, Camera3d>,
-	sleep_duration: &mut Duration,
+	mut query: Query<(Entity, &mut Projection, &mut Msaa, &mut Tonemapping), With<Camera3d>>,
-	sleep_duration_increase: Duration,
+	mut cmds: Commands,
 ) {
-	let frame_delta = Duration::from_secs_f64(Time::get_step_unscaled());
+	let Ok((entity, mut projection, mut msaa, mut tonemapping)) = query.get_mut(trigger.target())
-	if *last_frame_delta < frame_delta {
+	else {
-		if let Some(frame_delta_delta) = frame_delta.checked_sub(*last_frame_delta) {
+		return;
-			if let Some(new_sleep_duration) = sleep_duration.checked_sub(frame_delta_delta) {
+	};
-				*sleep_duration = new_sleep_duration;
+	info!("modifying cam");
+	match projection.deref_mut() {
+		Projection::Perspective(perspective_projection) => perspective_projection.near = 0.003,
+		Projection::Orthographic(orthographic_projection) => orthographic_projection.near = 0.003,
+		Projection::Custom(custom_projection) => {
+			if let Some(xr) = custom_projection.get_mut::<XrProjection>() {
+				xr.near = 0.003
+			} else {
+				error_once!("unknown custom camera projection");
 			}
 		}
-	} else {
+	}
-		*sleep_duration += sleep_duration_increase;
+	*msaa = Msaa::Off;
+	*tonemapping = Tonemapping::None;
+	cmds.entity(entity)
+		.insert(OrderIndependentTransparencySettings::default());
+}
+
+fn xr_step(world: &mut World) {
+	// update things like the Xr input methods
+	world.run_schedule(PreFrameWait);
+	input::process_input();
+	let time = world.resource::<bevy::prelude::Time>().delta_secs_f64();
+	nodes::root::Root::send_frame_events(time);
+
+	let should_wait = world
+		.run_system_cached(should_run_frame_loop)
+		.unwrap_or(false);
+	// we might want to do an adaptive sleep when not OpenXR waiting
+	if should_wait {
+		world.resource_scope::<OxrFrameWaiter, _>(|world, mut waiter| {
+			let state = waiter
+				.wait()
+				.inspect_err(|err| error!("failed to wait OpenXR frame: {err}"))
+				.ok();
+
+			if let Some(state) = state {
+				world.insert_resource(OxrFrameState(state));
+			}
+		});
 	}
 
-	debug_span!("Sleep", ?sleep_duration, ?frame_delta, ?last_frame_delta).in_scope(|| {
+	tick_internal_client();
-		*last_frame_delta = frame_delta;
+}
-		std::thread::sleep(*sleep_duration); // to give clients a chance to even update anything before drawing
+
-	});
+pub fn get_time(pipelined: bool, state: &OxrFrameState) -> openxr::Time {
+	if pipelined {
+		openxr::Time::from_nanos(
+			state.predicted_display_time.as_nanos() + state.predicted_display_period.as_nanos(),
+		)
+	} else {
+		state.predicted_display_time
+	}
 }

src/nodes/alias.rs

@@ -1,5 +1,7 @@
 use super::{Aspect, AspectIdentifier, Node};
-use crate::core::{client::Client, error::Result, registry::Registry};
+use crate::core::{
+	client::Client, error::Result, registry::Registry, scenegraph::MethodResponseSender,
+};
 use std::{
 	ops::Add,
 	sync::{Arc, Weak},
@@ -71,9 +73,6 @@ impl AspectIdentifier for Alias {
 	const ID: u64 = 0;
 }
 impl Aspect for Alias {
-	fn as_any(self: Arc<Self>) -> Arc<dyn std::any::Any + Send + Sync + 'static> {
-		self
-	}
 	fn run_signal(
 		&self,
 		_calling_client: Arc<Client>,
@@ -89,7 +88,7 @@ impl Aspect for Alias {
 		_node: Arc<Node>,
 		_method: u64,
 		_message: super::Message,
-		_response: crate::core::scenegraph::MethodResponseSender,
+		_response: MethodResponseSender,
 	) {
 	}
 }
@@ -122,6 +121,7 @@ impl AliasList {
 	fn add(&self, node: &Arc<Node>) {
 		self.0.add_raw(node);
 	}
+	#[tracing::instrument(level = "trace", skip_all)]
 	pub fn get_from_original_node(&self, original: Weak<Node>) -> Option<Arc<Node>> {
 		self.0
 			.get_valid_contents()
@@ -136,7 +136,7 @@ impl AliasList {
 			let Ok(aspect2) = node.get_aspect::<A>() else {
 				return false;
 			};
-			Arc::as_ptr(&aspect2) == (aspect as *const A)
+			std::ptr::eq(Arc::as_ptr(&aspect2), aspect)
 		})
 	}
 	pub fn get_aliases(&self) -> Vec<Arc<Node>> {
@@ -150,7 +150,7 @@ impl AliasList {
 			let Ok(aspect2) = original.get_aspect::<A>() else {
 				return false;
 			};
-			Arc::as_ptr(&aspect2) != (aspect as *const A)
+			!std::ptr::eq(Arc::as_ptr(&aspect2), aspect)
 		})
 	}
 }

src/nodes/audio.rs

@@ -1,30 +1,102 @@
+use super::spatial::SpatialNode;
 use super::{Aspect, AspectIdentifier, Node};
 use crate::core::client::Client;
-use crate::core::destroy_queue;
+use crate::core::entity_handle::EntityHandle;
 use crate::core::error::Result;
 use crate::core::registry::Registry;
 use crate::core::resource::get_resource_file;
 use crate::nodes::spatial::{SPATIAL_ASPECT_ALIAS_INFO, Spatial, Transform};
+use bevy::audio::{PlaybackMode, Volume};
+use bevy_mod_openxr::session::OxrSession;
+use bevy_mod_xr::session::{XrPreDestroySession, XrSessionCreated};
+use bevy_mod_xr::spaces::XrSpace;
 use color_eyre::eyre::eyre;
-use glam::{Vec4Swizzles, vec3};
 use parking_lot::Mutex;
 use stardust_xr::values::ResourceID;
 
-use std::ops::DerefMut;
+use bevy::prelude::*;
+use bevy::transform::components::Transform as BevyTransform;
 use std::sync::{Arc, OnceLock};
 use std::{ffi::OsStr, path::PathBuf};
-use stereokit_rust::sound::{Sound as SkSound, SoundInst};
+
+pub struct AudioNodePlugin;
+impl Plugin for AudioNodePlugin {
+	fn build(&self, app: &mut App) {
+		app.add_systems(Update, update_sound_event);
+		app.add_systems(XrSessionCreated, spawn_hmd_audio_listener);
+		app.add_systems(XrPreDestroySession, despawn_hmd_audio_listener);
+	}
+}
+
+fn despawn_hmd_audio_listener(mut cmds: Commands, session: Res<OxrSession>, res: Res<HmdListener>) {
+	cmds.remove_resource::<HmdListener>();
+	cmds.entity(res.0).despawn();
+	_ = session.destroy_space(res.1);
+}
+
+fn spawn_hmd_audio_listener(mut cmds: Commands, session: Res<OxrSession>) {
+	let space = session
+		.create_reference_space(openxr::ReferenceSpaceType::VIEW, BevyTransform::IDENTITY)
+		.unwrap();
+	let listener = cmds
+		.spawn((
+			Name::new("HMD audio listener"),
+			space.0,
+			SpatialListener::new(0.2),
+		))
+		.id();
+	cmds.insert_resource(HmdListener(listener, space.0));
+}
+#[derive(Resource)]
+struct HmdListener(Entity, XrSpace);
+fn update_sound_event(
+	mut cmds: Commands,
+	sinks: Query<&SpatialAudioSink>,
+	asset_server: Res<AssetServer>,
+) {
+	for sound in SOUND_REGISTRY.get_valid_contents() {
+		if sound.entity.get().is_none() {
+			let handle = asset_server.load(sound.pending_audio_path.as_path());
+			let entity = cmds
+				.spawn((
+					Name::new("Audio Node"),
+					SpatialNode(Arc::downgrade(&sound.spatial)),
+					AudioPlayer::new(handle),
+					PlaybackSettings {
+						mode: PlaybackMode::Once,
+						volume: Volume::Linear(sound.volume),
+						speed: 1.0,
+						paused: true,
+						muted: false,
+						spatial: true,
+						spatial_scale: None,
+					},
+				))
+				.id();
+			let entity = EntityHandle::new(entity);
+			sound.spatial.set_entity(entity.clone());
+			sound.entity.set(entity).unwrap();
+		}
+		if let Some(sink) = sound.entity.get().and_then(|e| sinks.get(e.get()).ok()) {
+			if sound.play.lock().take().is_some() {
+				sink.play();
+			}
+			if sound.stop.lock().take().is_some() {
+				sink.stop();
+			}
+		}
+	}
+}
 
 static SOUND_REGISTRY: Registry<Sound> = Registry::new();
 
 stardust_xr_server_codegen::codegen_audio_protocol!();
 pub struct Sound {
-	space: Arc<Spatial>,
+	spatial: Arc<Spatial>,
 
 	volume: f32,
 	pending_audio_path: PathBuf,
-	sk_sound: OnceLock<SkSound>,
+	entity: OnceLock<EntityHandle>,
-	instance: Mutex<Option<SoundInst>>,
 	stop: Mutex<Option<()>>,
 	play: Mutex<Option<()>>,
 }
@@ -37,11 +109,10 @@ impl Sound {
 		)
 		.ok_or_else(|| eyre!("Resource not found"))?;
 		let sound = Sound {
-			space: node.get_aspect::<Spatial>().unwrap().clone(),
+			spatial: node.get_aspect::<Spatial>().unwrap().clone(),
 			volume: 1.0,
 			pending_audio_path,
-			sk_sound: OnceLock::new(),
+			entity: OnceLock::new(),
-			instance: Mutex::new(None),
 			stop: Mutex::new(None),
 			play: Mutex::new(None),
 		};
@@ -49,24 +120,6 @@ impl Sound {
 		node.add_aspect_raw(sound_arc.clone());
 		Ok(sound_arc)
 	}
-
-	fn update(&self) {
-		let sound = self
-			.sk_sound
-			.get_or_init(|| SkSound::from_file(self.pending_audio_path.clone()).unwrap());
-		if self.stop.lock().take().is_some() {
-			if let Some(instance) = self.instance.lock().take() {
-				instance.stop();
-			}
-		}
-		if self.instance.lock().is_none() && self.play.lock().take().is_some() {
-			let instance = sound.play(vec3(0.0, 0.0, 0.0), Some(self.volume));
-			self.instance.lock().replace(instance);
-		}
-		if let Some(instance) = self.instance.lock().deref_mut() {
-			instance.position(self.space.global_transform().w_axis.xyz());
-		}
-	}
 }
 impl AspectIdentifier for Sound {
 	impl_aspect_for_sound_aspect_id! {}
@@ -88,22 +141,10 @@ impl SoundAspect for Sound {
 }
 impl Drop for Sound {
 	fn drop(&mut self) {
-		if let Some(instance) = self.instance.lock().take() {
-			instance.stop();
-		}
-		if let Some(sk_sound) = self.sk_sound.take() {
-			destroy_queue::add(sk_sound);
-		}
 		SOUND_REGISTRY.remove(self);
 	}
 }
 
-pub fn update() {
-	for sound in SOUND_REGISTRY.get_valid_contents() {
-		sound.update()
-	}
-}
-
 impl InterfaceAspect for Interface {
 	#[doc = "Create a sound node. WAV and MP3 are supported."]
 	fn create_sound(

src/nodes/drawable/holdout.wgsl

@@ -0,0 +1,5 @@
+fn fragment(
+    in: VertexOutput
+) -> FragmentOutput {
+    return vec4(0.0);
+}

src/nodes/drawable/line.wgsl

@@ -0,0 +1,56 @@
+#import bevy_pbr::{
+    pbr_fragment::pbr_input_from_standard_material,
+    pbr_functions::alpha_discard,
+}
+
+#ifdef PREPASS_PIPELINE
+#import bevy_pbr::{
+    prepass_io::{VertexOutput, FragmentOutput},
+    pbr_deferred_functions::deferred_output,
+}
+#else
+#import bevy_pbr::{
+    forward_io::{VertexOutput, FragmentOutput},
+    pbr_functions::{apply_pbr_lighting, main_pass_post_lighting_processing},
+}
+#endif
+#ifdef OIT_ENABLED
+#import bevy_core_pipeline::oit::oit_draw
+#endif
+
+@fragment
+fn fragment(
+    in: VertexOutput,
+    @builtin(front_facing) is_front: bool,
+) -> FragmentOutput {
+    // generate a PbrInput struct from the StandardMaterial bindings
+    var pbr_input = pbr_input_from_standard_material(in, is_front);
+
+#ifdef VERTEX_COLORS
+    // Multiply emissive color by vertex color
+    pbr_input.material.emissive *= vec4(in.color.rgb, 1.0);
+#endif
+
+    // alpha discard
+    // pbr_input.material.base_color = alpha_discard(pbr_input.material, pbr_input.material.base_color);
+
+#ifdef PREPASS_PIPELINE
+    // in deferred mode we can't modify anything after that, as lighting is run in a separate fullscreen shader.
+    let out = deferred_output(in, pbr_input);
+#else
+    var out: FragmentOutput;
+    // apply lighting
+    out.color = apply_pbr_lighting(pbr_input);
+
+    // apply in-shader post processing (fog, alpha-premultiply, and also tonemapping, debanding if the camera is non-hdr)
+    // note this does not include fullscreen postprocessing effects like bloom.
+    out.color = main_pass_post_lighting_processing(pbr_input, out.color);
+#endif
+
+#ifdef OIT_ENABLED
+    oit_draw(in.position, out.color, false);
+    discard;
+#else 
+    return out;
+#endif
+}

src/nodes/drawable/lines.rs

@@ -1,20 +1,329 @@
 use super::{Line, LinesAspect};
 use crate::{
-	core::{client::Client, error::Result, registry::Registry},
+	BevyMaterial,
-	nodes::{Node, spatial::Spatial},
+	core::{
+		client::Client, color::ColorConvert, entity_handle::EntityHandle, error::Result,
+		registry::Registry,
+	},
+	nodes::{Node, drawable::LinePoint, spatial::Spatial},
 };
-use glam::{FloatExt, Vec3};
+use bevy::{
+	asset::{AssetEvents, RenderAssetUsages, weak_handle},
+	pbr::{ExtendedMaterial, MaterialExtension},
+	prelude::*,
+	render::{
+		mesh::{Indices, PrimitiveTopology, VertexAttributeValues},
+		primitives::Aabb,
+		render_resource::{AsBindGroup, ShaderRef},
+		view::VisibilitySystems,
+	},
+};
+use glam::Vec3;
 use parking_lot::Mutex;
-use std::{collections::VecDeque, sync::Arc};
+use std::sync::{
-use stereokit_rust::{
+	Arc, OnceLock,
-	maths::Bounds, sk::MainThreadToken, system::LinePoint as SkLinePoint, util::Color128,
+	atomic::{AtomicBool, Ordering},
 };
+use tokio::sync::Notify;
+
+type LineMaterial = ExtendedMaterial<BevyMaterial, LineExtension>;
+const LINE_SHADER_HANDLE: Handle<Shader> = weak_handle!("7d28aa5a-3abd-43bb-b0e9-0de8b81b650d");
+// No extra data needed for a simple holdout
+#[derive(Default, Asset, AsBindGroup, TypePath, Debug, Clone)]
+#[data(50, u32, binding_array(101))]
+#[bindless(index_table(range(50..51), binding(100)))]
+pub struct LineExtension {}
+impl From<&LineExtension> for u32 {
+	fn from(_: &LineExtension) -> Self {
+		0
+	}
+}
+impl MaterialExtension for LineExtension {
+	fn fragment_shader() -> ShaderRef {
+		LINE_SHADER_HANDLE.into()
+	}
+
+	fn prepass_fragment_shader() -> ShaderRef {
+		LINE_SHADER_HANDLE.into()
+	}
+
+	fn deferred_fragment_shader() -> ShaderRef {
+		LINE_SHADER_HANDLE.into()
+	}
+
+	fn alpha_mode() -> Option<AlphaMode> {
+		Some(AlphaMode::Blend)
+	}
+}
+
+pub struct LinesNodePlugin;
+impl Plugin for LinesNodePlugin {
+	fn build(&self, app: &mut App) {
+		app.add_systems(
+			PostUpdate,
+			build_line_mesh
+				.after(TransformSystem::TransformPropagate)
+				.before(AssetEvents)
+				.after(VisibilitySystems::VisibilityPropagate)
+				.before(VisibilitySystems::CheckVisibility),
+		);
+		app.world_mut().resource_mut::<Assets<Shader>>().insert(
+			LINE_SHADER_HANDLE.id(),
+			Shader::from_wgsl(
+				include_str!("line.wgsl"),
+				std::path::Path::new(file!())
+					.parent()
+					.unwrap()
+					.join("line.wgsl")
+					.to_string_lossy(),
+			),
+		);
+		app.add_plugins(MaterialPlugin::<LineMaterial>::default());
+	}
+}
+
+fn build_line_mesh(
+	mut cmds: Commands,
+	mut meshes: ResMut<Assets<Mesh>>,
+	mut materials: ResMut<Assets<LineMaterial>>,
+	query: Query<(Ref<GlobalTransform>, &InheritedVisibility)>,
+) {
+	for lines in LINES_REGISTRY.get_valid_contents().into_iter()
+	{
+		let Some((transform, visibil)) = lines.spatial.get_entity().and_then(|e| query.get(e).ok())
+		else {
+			continue;
+		};
+		if !(lines.gen_mesh.load(Ordering::Relaxed) || transform.is_changed()) {
+			continue;
+		}
+		lines.gen_mesh.store(false, Ordering::Relaxed);
+		let mut vertex_positions = Vec::<Vec3>::new();
+		let mut vertex_normals = Vec::<Vec3>::new();
+		let mut vertex_colors = Vec::<[f32; 4]>::new();
+		let mut vertex_indices = Vec::<u32>::new();
+		let lines_data = lines.data.lock();
+		if lines_data.is_empty() {
+			*lines.bounds.lock() = Some(Aabb::default());
+			lines.setup_complete.notify_waiters();
+			match lines.entity.get() {
+				Some(e) => cmds.entity(**e),
+				None => {
+					// if we couldn't get the lines entity then we need to gen the mesh later
+					lines.gen_mesh.store(true, Ordering::Relaxed);
+					continue;
+				}
+			}
+			.remove::<Mesh3d>();
+			continue;
+		}
+
+		let mut indices_set = 0;
+		for line in lines_data.iter() {
+			// yes this alloc is suboptimal, but good enough for now
+			let line_points = line
+				.points
+				.iter()
+				.map(|p: &LinePoint| LinePoint {
+					// point: transform.transform_point(p.point.into()).into(),
+					point: transform.transform_point(p.point.into()).into(),
+					thickness: p.thickness,
+					color: p.color,
+				})
+				.collect::<Vec<_>>();
+
+			let start_set = indices_set;
+			// Create a sliding window of points to process each segment of the line
+			// For cyclic lines: wraps around by connecting last point back to first
+			// For non-cyclic lines: handles endpoints with None values
+			let point_windows = {
+				let mut out = Vec::new();
+				let mut last = line.cyclic.then(|| line_points.last()).flatten();
+				let mut peekable = line_points.iter().peekable();
+				while let Some(curr) = peekable.next() {
+					// Skip this point if it has the same position as the previous point
+					if let Some(prev) = last
+						&& Vec3::from(prev.point) == Vec3::from(curr.point)
+					{
+						last = Some(curr);
+						continue;
+					}
+
+					let mut end = false;
+					// Determine the next point - either the next in sequence or
+					// for cyclic lines, wrap back to first point at the end
+					let next = match peekable.peek() {
+						Some(v) => Some(*v),
+						None => {
+							end = true;
+							line.cyclic.then(|| line_points.first()).flatten()
+						}
+					};
+
+					out.push((last, curr, next, end));
+					last = Some(curr);
+				}
+				out
+			};
+			// if we can't make a full line, don't bother trying
+			if point_windows.len() < 2 {
+				continue;
+			}
+			for (last, curr, next, last_point) in point_windows {
+				let last_quat = last.map(|v| {
+					Quat::from_rotation_arc(
+						Vec3::Y,
+						(Vec3::from(curr.point) - Vec3::from(v.point)).normalize(),
+					)
+				});
+				let next_quat = next.map(|v| {
+					Quat::from_rotation_arc(
+						Vec3::Y,
+						(Vec3::from(v.point) - Vec3::from(curr.point)).normalize(),
+					)
+				});
+				let quat = match (last_quat, next_quat) {
+					(None, None) => {
+						error!("no previous or next point in line");
+						break;
+					}
+					(None, Some(next)) => next,
+					(Some(last), None) => last,
+					(Some(last), Some(next)) => last.lerp(next, 0.5),
+				};
+				if !quat.is_finite() {
+					error!("non finite quat: next: {next:?}, last: {last:?}, curr: {curr:?},");
+					break;
+				}
+				let normals = [
+					Vec3::X,
+					Vec3::new(1., 0., 1.).normalize(),
+					Vec3::Z,
+					Vec3::new(-1., 0., 1.).normalize(),
+					Vec3::NEG_X,
+					Vec3::new(-1., 0., -1.).normalize(),
+					Vec3::NEG_Z,
+					Vec3::new(1., 0., -1.).normalize(),
+				]
+				.map(Vec3::normalize)
+				.map(|v| quat * v);
+				let points = normals.map(|v| (v * curr.thickness) + Vec3::from(curr.point));
+				vertex_normals.extend(normals);
+				vertex_positions.extend(points);
+				vertex_colors.extend([curr.color.to_bevy().to_linear().to_f32_array(); 8]);
+				// Only connect vertices between segments if this isn't the end point
+				if !last_point {
+					vertex_indices.extend(indices(indices_set));
+				}
+				indices_set += 1;
+			}
+			if indices_set > 0 {
+				// Handle the connection between start and end points:
+				// - For cyclic lines: connect last segment back to first
+				// - For non-cyclic lines: add caps at both ends
+				if line.cyclic {
+					vertex_indices.extend(cyclic_indices(start_set, indices_set - 1));
+				} else {
+					vertex_indices.extend(cap_indices(start_set, false));
+					vertex_indices.extend(cap_indices(indices_set - 1, true));
+				}
+			}
+		}
+		let mut mesh = Mesh::new(
+			PrimitiveTopology::TriangleList,
+			RenderAssetUsages::RENDER_WORLD,
+		);
+		mesh.insert_indices(Indices::U32(vertex_indices));
+		mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, vertex_positions);
+		mesh.insert_attribute(Mesh::ATTRIBUTE_NORMAL, vertex_normals);
+		mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, vertex_colors);
+
+		let mut entity = match lines.entity.get() {
+			Some(e) => cmds.entity(**e),
+			None => {
+				let e = cmds.spawn((
+					Name::new("LinesNode"),
+					MeshMaterial3d(materials.add(ExtendedMaterial {
+						base: BevyMaterial {
+							base_color: Color::WHITE,
+							perceptual_roughness: 1.0,
+							alpha_mode: AlphaMode::Premultiplied,
+							emissive: Color::linear_rgba(0.25, 0.25, 0.25, 1.0).into(),
+							..default()
+						},
+						extension: LineExtension {},
+					})),
+				));
+				_ = lines.entity.set(EntityHandle::new(e.id()));
+				e
+			}
+		};
+		if let Some(VertexAttributeValues::Float32x3(values)) =
+			mesh.attribute(Mesh::ATTRIBUTE_POSITION)
+		{
+			let global_to_local = transform.affine().inverse();
+			let local_aabb = Aabb::enclosing(
+				values
+					.iter()
+					.map(|p| global_to_local.transform_point3(Vec3::from_slice(p))),
+			)
+			.unwrap_or_default();
+			let global_aabb =
+				Aabb::enclosing(values.iter().map(|p| Vec3::from_slice(p))).unwrap_or_default();
+			*lines.bounds.lock() = Some(local_aabb);
+			lines.setup_complete.notify_waiters();
+			entity.insert(global_aabb);
+		}
+		entity
+			.insert(Mesh3d(meshes.add(mesh)))
+			.insert(*visibil)
+			.insert(match visibil.get() {
+				true => Visibility::Visible,
+				false => Visibility::Hidden,
+			});
+	}
+}
+
+const END_CAP_INDICES: [u32; 18] = [0, 1, 7, 7, 1, 2, 7, 2, 6, 6, 2, 3, 6, 3, 5, 5, 3, 4];
+fn cap_indices(set: u32, flip: bool) -> [u32; END_CAP_INDICES.len()] {
+	let mut out = END_CAP_INDICES.map(|v| v + (set * 8));
+	if flip {
+		out.reverse();
+	}
+	out
+}
+
+// const BASE: [u16; 6] = [0, 8, 1, 8, 9, 1];
+
+// Defines how vertices are connected between consecutive cross-sections to form the tube
+const INDICES: [u32; 48] = [
+	0, 8, 1, 8, 9, 1, 1, 9, 2, 9, 10, 2, 2, 10, 3, 10, 11, 3, 3, 11, 4, 11, 12, 4, 4, 12, 5, 12,
+	13, 5, 5, 13, 6, 13, 14, 6, 6, 14, 7, 14, 15, 7, 7, 15, 0, 15, 8, 0,
+];
+fn indices(set: u32) -> [u32; INDICES.len()] {
+	INDICES.map(|v| v + (set * 8))
+}
+fn cyclic_indices(start_set: u32, end_set: u32) -> [u32; INDICES.len()] {
+	let mut out = INDICES.map(|v| {
+		if v < 8 {
+			v + ((start_set) * 8)
+		} else {
+			v + ((end_set - 1) * 8)
+		}
+	});
+	out.reverse();
+	out
+}
 
 static LINES_REGISTRY: Registry<Lines> = Registry::new();
 
 pub struct Lines {
-	space: Arc<Spatial>,
+	spatial: Arc<Spatial>,
 	data: Mutex<Vec<Line>>,
+	gen_mesh: AtomicBool,
+	entity: OnceLock<EntityHandle>,
+	bounds: Mutex<Option<Aabb>>,
+	setup_complete: Notify,
 }
 impl Lines {
 	pub fn add_to(node: &Arc<Node>, lines: Vec<Line>) -> Result<Arc<Lines>> {
@@ -23,67 +332,39 @@ impl Lines {
 			.unwrap()
 			.bounding_box_calc
 			.set(|node| {
-				let mut bounds = Bounds::default();
+				Box::pin(async {
-				if let Ok(lines) = node.get_aspect::<Lines>() {
+					let Ok(lines) = node.get_aspect::<Lines>() else {
-					for line in &*lines.data.lock() {
+						return Default::default();
-						for point in &line.points {
+					};
-							bounds.grown_point(Vec3::from(point.point));
+					let bounds = *lines.bounds.lock();
+					match bounds {
+						Some(aabb) => aabb,
+						None => {
+							lines.setup_complete.notified().await;
+							lines.bounds.lock().unwrap_or_default()
 						}
 					}
-				}
+				})
-				bounds
 			});
 
 		let lines = LINES_REGISTRY.add(Lines {
-			space: node.get_aspect::<Spatial>()?.clone(),
+			spatial: node.get_aspect::<Spatial>()?.clone(),
 			data: Mutex::new(lines),
+			gen_mesh: AtomicBool::new(true),
+			entity: OnceLock::new(),
+			bounds: Mutex::new(Some(Aabb::default())),
+			setup_complete: Notify::new(),
 		});
 		node.add_aspect_raw(lines.clone());
 
 		Ok(lines)
 	}
-
-	fn draw(&self, token: &MainThreadToken) {
-		let transform_mat = self.space.global_transform();
-		let data = self.data.lock().clone();
-		for line in &data {
-			let mut points: VecDeque<SkLinePoint> = line
-				.points
-				.iter()
-				.map(|p| SkLinePoint {
-					pt: transform_mat.transform_point3(Vec3::from(p.point)).into(),
-					thickness: p.thickness,
-					color: Color128::new(p.color.c.r, p.color.c.g, p.color.c.b, p.color.a).into(),
-				})
-				.collect();
-			if line.cyclic && !points.is_empty() {
-				let first = line.points.first().unwrap();
-				let last = line.points.last().unwrap();
-
-				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_point3(Vec3::from(first.point).lerp(Vec3::from(last.point), 0.5))
-						.into(),
-					thickness: (first.thickness + last.thickness) * 0.5,
-					color: color.into(),
-				};
-				points.push_front(connect_point);
-				points.push_back(connect_point);
-			}
-			stereokit_rust::system::Lines::add_list(token, points.make_contiguous());
-		}
-	}
 }
 impl LinesAspect for Lines {
 	fn set_lines(node: Arc<Node>, _calling_client: Arc<Client>, lines: Vec<Line>) -> Result<()> {
 		let lines_aspect = node.get_aspect::<Lines>()?;
 		*lines_aspect.data.lock() = lines;
+		lines_aspect.gen_mesh.store(true, Ordering::Relaxed);
 		Ok(())
 	}
 }
@@ -92,13 +373,3 @@ impl Drop for Lines {
 		LINES_REGISTRY.remove(self);
 	}
 }
-
-pub fn draw_all(token: &MainThreadToken) {
-	for lines in LINES_REGISTRY.get_valid_contents() {
-		if let Some(node) = lines.space.node() {
-			if node.enabled() {
-				lines.draw(token);
-			}
-		}
-	}
-}

src/nodes/drawable/mod.rs

@@ -1,6 +1,6 @@
 pub mod lines;
 pub mod model;
-pub mod shaders;
+pub mod sky;
 pub mod text;
 
 use self::{lines::Lines, model::Model, text::Text};
@@ -8,46 +8,13 @@ use super::{
 	Aspect, AspectIdentifier, Node,
 	spatial::{Spatial, Transform},
 };
-use crate::{DEFAULT_SKYLIGHT, nodes::spatial::SPATIAL_ASPECT_ALIAS_INFO};
+use crate::core::{client::Client, error::Result, resource::get_resource_file};
-use crate::{
+use crate::nodes::spatial::SPATIAL_ASPECT_ALIAS_INFO;
-	DEFAULT_SKYTEX,
-	core::{client::Client, error::Result, resource::get_resource_file},
-};
 use color_eyre::eyre::eyre;
 use model::ModelPart;
 use parking_lot::Mutex;
 use stardust_xr::values::ResourceID;
 use std::{ffi::OsStr, path::PathBuf, sync::Arc};
-use stereokit_rust::{sk::MainThreadToken, system::Renderer, tex::SHCubemap};
-
-// #[instrument(level = "debug", skip(sk))]
-pub fn draw(token: &MainThreadToken) {
-	lines::draw_all(token);
-	model::draw_all(token);
-	text::draw_all(token);
-	match QUEUED_SKYTEX.lock().take() {
-		Some(Some(skytex)) => {
-			if let Ok(skytex) = SHCubemap::from_cubemap(skytex, true, 100) {
-				Renderer::skytex(skytex.tex);
-			}
-		}
-		Some(None) => {
-			Renderer::skytex(DEFAULT_SKYTEX.get().unwrap());
-		}
-		None => {}
-	}
-	match QUEUED_SKYLIGHT.lock().take() {
-		Some(Some(skylight)) => {
-			if let Ok(skylight) = SHCubemap::from_cubemap(skylight, true, 100) {
-				Renderer::skylight(skylight.sh);
-			}
-		}
-		Some(None) => {
-			Renderer::skylight(*DEFAULT_SKYLIGHT.get().unwrap());
-		}
-		None => {}
-	}
-}
 
 static QUEUED_SKYLIGHT: Mutex<Option<Option<PathBuf>>> = Mutex::new(None);
 static QUEUED_SKYTEX: Mutex<Option<Option<PathBuf>>> = Mutex::new(None);

src/nodes/drawable/model.rs

@@ -1,314 +1,498 @@
 use super::{MODEL_PART_ASPECT_ALIAS_INFO, MaterialParameter, ModelAspect, ModelPartAspect};
-use crate::bail;
+use crate::core::bevy_channel::{BevyChannel, BevyChannelReader};
 use crate::core::client::Client;
+use crate::core::color::ColorConvert as _;
+use crate::core::entity_handle::EntityHandle;
 use crate::core::error::Result;
 use crate::core::registry::Registry;
 use crate::core::resource::get_resource_file;
 use crate::nodes::Node;
 use crate::nodes::alias::{Alias, AliasList};
-use crate::nodes::spatial::Spatial;
+use crate::nodes::spatial::{Spatial, SpatialNode};
+use crate::{BevyMaterial, bail};
+use bevy::asset::{load_internal_asset, weak_handle};
+use bevy::gltf::GltfLoaderSettings;
+use bevy::pbr::{ExtendedMaterial, MaterialExtension};
+use bevy::prelude::*;
+use bevy::render::primitives::Aabb;
+use bevy::render::render_resource::{AsBindGroup, ShaderRef};
 use color_eyre::eyre::eyre;
-use glam::{Mat4, Vec2, Vec3};
 use parking_lot::Mutex;
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHasher};
 use stardust_xr::values::ResourceID;
 use std::ffi::OsStr;
 use std::hash::{Hash, Hasher};
-use std::sync::{Arc, LazyLock, OnceLock, Weak};
+use std::path::PathBuf;
-use stereokit_rust::material::Transparency;
+use std::sync::atomic::{AtomicBool, Ordering};
-use stereokit_rust::maths::Bounds;
+use std::sync::{Arc, OnceLock, Weak};
-use stereokit_rust::sk::MainThreadToken;
+use tokio::sync::Notify;
-use stereokit_rust::{material::Material, model::Model as SKModel, tex::Tex, util::Color128};
 
-pub struct MaterialWrapper(pub Material);
+static LOAD_MODEL: BevyChannel<(Arc<Model>, PathBuf)> = BevyChannel::new();
-impl Drop for MaterialWrapper {
+
-	fn drop(&mut self) {
+type HoldoutMaterial = ExtendedMaterial<BevyMaterial, HoldoutExtension>;
-		MATERIAL_REGISTRY.remove(self);
+const HOLDOUT_SHADER_HANDLE: Handle<Shader> = weak_handle!("92b481b7-d3da-4188-b252-2335ec814ee2");
+const HOLDOUT_MATERIAL_HANDLE: Handle<HoldoutMaterial> =
+	weak_handle!("d56f1d62-9121-434b-a34f-9f0bbd6b3390");
+
+pub struct ModelNodePlugin;
+#[derive(SystemSet, Hash, Debug, PartialEq, Eq, Clone, Copy)]
+pub struct ModelNodeSystemSet;
+impl Plugin for ModelNodePlugin {
+	fn build(&self, app: &mut App) {
+		LOAD_MODEL.init(app);
+
+		load_internal_asset!(
+			app,
+			HOLDOUT_SHADER_HANDLE,
+			"holdout.wgsl",
+			Shader::from_wgsl
+		);
+		app.add_plugins(MaterialPlugin::<HoldoutMaterial>::default());
+		app.world_mut()
+			.resource_mut::<Assets<HoldoutMaterial>>()
+			.insert(&HOLDOUT_MATERIAL_HANDLE, HoldoutMaterial::default());
+
+		app.init_resource::<MaterialRegistry>();
+		app.add_systems(
+			Update,
+			(load_models, gen_model_parts, apply_materials)
+				.chain()
+				.in_set(ModelNodeSystemSet),
+		);
 	}
 }
 
-impl Hash for MaterialWrapper {
+// No extra data needed for a simple holdout
-	fn hash<H: Hasher>(&self, state: &mut H) {
+#[derive(Default, Asset, AsBindGroup, TypePath, Debug, Clone)]
-		self.0.get_shader().0.as_ptr().hash(state);
+#[data(50, u32, binding_array(101))]
-		for param in self.0.get_all_param_info() {
+#[bindless(index_table(range(50..51), binding(100)))]
-			param.name.hash(state);
+pub struct HoldoutExtension {}
-			param.to_string().hash(state);
+impl From<&HoldoutExtension> for u32 {
-		}
+	fn from(_: &HoldoutExtension) -> Self {
-		self.0.get_chain().map(MaterialWrapper).hash(state)
+		0
 	}
 }
-impl PartialEq for MaterialWrapper {
+impl MaterialExtension for HoldoutExtension {
-	fn eq(&self, other: &Self) -> bool {
+	fn fragment_shader() -> ShaderRef {
-		if self.0.get_shader().0.as_ptr() != other.0.get_shader().0.as_ptr() {
+		HOLDOUT_SHADER_HANDLE.into()
-			return false;
-		}
-		if self.0.get_all_param_info().count() != other.0.get_all_param_info().count() {
-			return false;
-		}
-		for self_param in self.0.get_all_param_info() {
-			let Some(other_param) = other
-				.0
-				.get_all_param_info()
-				.get_data(self_param.get_name(), self_param.get_type())
-			else {
-				return false;
-			};
-			if self_param.to_string() != other_param.to_string() {
-				return false;
-			}
-		}
-		self.0.get_chain().map(MaterialWrapper) == other.0.get_chain().map(MaterialWrapper)
 	}
-}
-impl Eq for MaterialWrapper {}
-unsafe impl Send for MaterialWrapper {}
-unsafe impl Sync for MaterialWrapper {}
 
-#[derive(Default)]
+	fn alpha_mode() -> Option<AlphaMode> {
-struct MaterialRegistry(Mutex<FxHashMap<u64, Weak<MaterialWrapper>>>);
+		Some(AlphaMode::Opaque)
-impl MaterialRegistry {
+	}
-	fn add_or_get(&self, material: Arc<MaterialWrapper>) -> Arc<MaterialWrapper> {
+}
-		let hash = {
+
-			use std::hash::{Hash, Hasher};
+#[derive(Component)]
-			let mut hasher = std::collections::hash_map::DefaultHasher::new();
+struct ModelNode(Weak<Model>);
-			material.hash(&mut hasher);
+
-			hasher.finish()
+fn load_models(
+	asset_server: Res<AssetServer>,
+	mut cmds: Commands,
+	mut mpsc_receiver: ResMut<BevyChannelReader<(Arc<Model>, PathBuf)>>,
+) {
+	while let Some((model, path)) = mpsc_receiver.read() {
+		// idk of the asset label is the correct approach here
+		let handle = asset_server.load_with_settings(
+			GltfAssetLabel::Scene(0).from_asset(path),
+			|settings: &mut GltfLoaderSettings| {
+				settings.load_cameras = false;
+				settings.load_lights = false;
+			},
+		);
+		let entity = cmds
+			.spawn((
+				Name::new("ModelNode"),
+				SceneRoot(handle),
+				ModelNode(Arc::downgrade(&model)),
+				SpatialNode(Arc::downgrade(&model.spatial)),
+				Visibility::Hidden,
+			))
+			.id();
+		model
+			.bevy_scene_entity
+			.set(EntityHandle::new(entity))
+			.unwrap();
+	}
+}
+
+fn apply_materials(
+	mut commands: Commands,
+	mut query: Query<&mut MeshMaterial3d<BevyMaterial>>,
+	mut material_registry: ResMut<MaterialRegistry>,
+	asset_server: Res<AssetServer>,
+	mut materials: ResMut<Assets<BevyMaterial>>,
+) -> bevy::prelude::Result {
+	for model_part in MODEL_REGISTRY
+		.get_valid_contents()
+		.iter()
+		.filter_map(|p| p.parts.get())
+		.flatten()
+	{
+		let entity = **model_part.mesh_entity.get().unwrap();
+		let Ok(mut mesh_mat) = query.get_mut(entity) else {
+			continue;
 		};
-
+		if model_part.holdout.load(Ordering::Relaxed) {
-		let mut lock = self.0.lock();
+			commands
-		if let Some(mat) = lock.get(&hash) {
+				.entity(entity)
-			if let Some(mat) = mat.upgrade() {
+				.remove::<MeshMaterial3d<BevyMaterial>>()
-				return mat;
+				.insert(MeshMaterial3d(HOLDOUT_MATERIAL_HANDLE));
-			}
+			continue;
+		}
+		if let Some(material) = model_part.pending_material_replacement.lock().take()
+			&& let Some(material) = materials.get(&material)
+		{
+			let handle = material_registry.get_handle(material.clone(), &mut materials);
+			mesh_mat.0 = handle;
+		}
+		for (param_name, param) in model_part.pending_material_parameters.lock().drain() {
+			let mut new_mat = materials.get(&mesh_mat.0).unwrap().clone();
+			param.apply_to_material(
+				&model_part.spatial.node().unwrap().get_client().unwrap(),
+				&mut new_mat,
+				&param_name,
+				&asset_server,
+			);
+			let handle = material_registry.get_handle(new_mat, &mut materials);
+			mesh_mat.0 = handle;
 		}
-
-		lock.insert(hash, Arc::downgrade(&material));
-		material
 	}
-	fn remove(&self, material: &MaterialWrapper) {
+
-		let hash = {
+	Ok(())
-			use std::hash::{Hash, Hasher};
+}
-			let mut hasher = std::collections::hash_map::DefaultHasher::new();
+
-			material.hash(&mut hasher);
+fn gen_model_parts(
-			hasher.finish()
+	scenes: Res<Assets<Scene>>,
+	query: Query<(&SceneRoot, &ModelNode, &Children)>,
+	children_query: Query<&Children>,
+	part_query: Query<(&Name, Option<&Children>, &Transform), Without<Mesh3d>>,
+	part_mesh_query: Query<(&Transform, &Aabb), With<Mesh3d>>,
+	has_mesh: Query<Has<Mesh3d>>,
+	mut cmds: Commands,
+) {
+	for (scene_root, model_node, model_children) in query.iter() {
+		let Some(model) = model_node.0.upgrade() else {
+			continue;
 		};
-		let mut lock = self.0.lock();
+		if model.parts.get().is_some() {
-		lock.remove(&hash);
+			continue;
+		}
+		if scenes.get(scene_root.0.id()).is_none() {
+			continue;
+		}
+		let mut parts = Vec::new();
+		for entity in model_children
+			.iter()
+			.filter_map(|e| children_query.get(e).ok())
+			.flat_map(|c| c.iter())
+		{
+			gen_path(
+				entity,
+				&part_query,
+				None,
+				&mut |entity, name, transform, parent, children| {
+					let path = parent
+						.as_ref()
+						.map(|p| format!("{}/{}", &p.path, name.as_str()))
+						.unwrap_or_else(|| name.to_string());
+					let parent_spatial = parent
+						.as_ref()
+						.map(|p| p.spatial.clone())
+						.unwrap_or_else(|| model.spatial.clone());
+					let client = model.spatial.node()?.get_client()?;
+					let (spatial, model_part) =
+						match model.pre_bound_parts.lock().iter().find(|v| v.path == path) {
+							None => {
+								let node =
+									client.scenegraph.add_node(Node::generate(&client, false));
+								let spatial = Spatial::add_to(
+									&node,
+									Some(parent_spatial.clone()),
+									transform.compute_matrix(),
+									false,
+								);
+								let model_part = node.add_aspect(ModelPart {
+									entity: OnceLock::new(),
+									mesh_entity: OnceLock::new(),
+									path,
+									spatial: spatial.clone(),
+									pending_material_parameters: Mutex::default(),
+									pending_material_replacement: Mutex::default(),
+									holdout: AtomicBool::new(false),
+									aliases: AliasList::default(),
+									bounds: OnceLock::new(),
+								});
+								(spatial, model_part)
+							}
+							Some(part) => {
+								part.spatial.set_spatial_parent(&parent_spatial).unwrap();
+								(part.spatial.clone(), part.clone())
+							}
+						};
+					let aabb = Aabb::enclosing(
+						children
+							.iter()
+							.flat_map(|v| v.iter())
+							.filter_map(|e| part_mesh_query.get(e).ok())
+							.flat_map(|(transform, aabb)| {
+								[
+									transform.transform_point(aabb.min().into()),
+									transform.transform_point(aabb.max().into()),
+								]
+							}),
+					)
+					.unwrap_or_default();
+					_ = spatial.bounding_box_calc.set(move |n| {
+						Box::pin(async {
+							n.get_aspect::<ModelPart>()
+								.ok()
+								.and_then(|v| v.bounds.get().copied())
+								.unwrap_or_default()
+						})
+					});
+					let _ = spatial.set_spatial_parent(&parent_spatial);
+					spatial.set_local_transform(transform.compute_matrix());
+					let entity_handle = EntityHandle::new(entity);
+					spatial.set_entity(entity_handle.clone());
+					cmds.entity(entity)
+						.insert(SpatialNode(Arc::downgrade(&spatial)));
+					let mesh_entity = children_query
+						.get(entity)
+						.iter()
+						.flat_map(|v| v.iter())
+						.find(|e| has_mesh.get(*e).unwrap_or(false))?;
+					_ = model_part.bounds.set(aabb);
+					_ = model_part.entity.set(entity_handle);
+					_ = model_part.mesh_entity.set(EntityHandle::new(mesh_entity));
+					parts.push(model_part.clone());
+					Some(model_part)
+				},
+			);
+		}
+		_ = model.parts.set(parts);
+		model.pre_bound_parts.lock().clear();
+		model
+			.spatial
+			.set_entity(model.bevy_scene_entity.get().unwrap().clone());
+		model.setup_complete.store(true, Ordering::Relaxed);
+		model.setup_complete_notify.notify_waiters();
 	}
 }
 
-static MATERIAL_REGISTRY: LazyLock<MaterialRegistry> = LazyLock::new(MaterialRegistry::default);
+fn gen_path(
+	current_entity: Entity,
+	part_query: &Query<(&Name, Option<&Children>, &Transform), Without<Mesh3d>>,
+	parent: Option<Arc<ModelPart>>,
+	func: &mut dyn FnMut(
+		Entity,
+		&Name,
+		&Transform,
+		Option<Arc<ModelPart>>,
+		Option<&Children>,
+	) -> Option<Arc<ModelPart>>,
+) {
+	let Ok((name, children, transform)) = part_query.get(current_entity) else {
+		return;
+	};
+	let Some(parent) = func(current_entity, name, transform, parent, children) else {
+		return;
+	};
+	for e in children.iter().flat_map(|c| c.iter()) {
+		gen_path(e, part_query, Some(parent.clone()), func);
+	}
+}
+
+#[derive(PartialEq, Deref, DerefMut, Clone, Copy, Eq, PartialOrd, Ord, Hash)]
+struct HashedPbrMaterial(u64);
+impl HashedPbrMaterial {
+	fn new(material: &BevyMaterial) -> Self {
+		let mut hasher = FxHasher::default();
+		Self::hash_pbr_mat(material, &mut hasher);
+		Self(hasher.finish())
+	}
+	fn hash_pbr_mat<H: Hasher>(mat: &BevyMaterial, state: &mut H) {
+		hash_color(mat.base_color, state);
+		hash_color(mat.emissive.into(), state);
+		state.write_u32(mat.metallic.to_bits());
+		state.write_u32(mat.perceptual_roughness.to_bits());
+		match mat.alpha_mode {
+			AlphaMode::Opaque => state.write_u8(0),
+			AlphaMode::Mask(v) => {
+				state.write_u8(1);
+				state.write_u32(v.to_bits());
+			}
+			AlphaMode::Blend => state.write_u8(2),
+			AlphaMode::Premultiplied => state.write_u8(3),
+			AlphaMode::AlphaToCoverage => state.write_u8(4),
+			AlphaMode::Add => state.write_u8(5),
+			AlphaMode::Multiply => state.write_u8(6),
+		}
+		state.write_u8(mat.double_sided as u8);
+		mat.base_color_texture.hash(state);
+		mat.emissive_texture.hash(state);
+		mat.metallic_roughness_texture.hash(state);
+		mat.occlusion_texture.hash(state);
+	}
+}
+fn hash_color<H: Hasher>(color: Color, state: &mut H) {
+	match color {
+		Color::Srgba(srgba) => {
+			state.write_u8(0);
+			state.write(&srgba.to_u8_array());
+		}
+		Color::LinearRgba(linear_rgba) => {
+			state.write_u8(1);
+			state.write(&linear_rgba.to_u8_array());
+		}
+		Color::Hsla(hsla) => {
+			state.write_u8(2);
+			hsla.to_f32_array()
+				.iter()
+				.for_each(|v| state.write_u32(v.to_bits()));
+		}
+		Color::Hsva(hsva) => {
+			state.write_u8(3);
+			hsva.to_f32_array()
+				.iter()
+				.for_each(|v| state.write_u32(v.to_bits()));
+		}
+		Color::Hwba(hwba) => {
+			state.write_u8(4);
+			hwba.to_f32_array()
+				.iter()
+				.for_each(|v| state.write_u32(v.to_bits()));
+		}
+		Color::Laba(laba) => {
+			state.write_u8(5);
+			laba.to_f32_array()
+				.iter()
+				.for_each(|v| state.write_u32(v.to_bits()));
+		}
+		Color::Lcha(lcha) => {
+			state.write_u8(6);
+			lcha.to_f32_array()
+				.iter()
+				.for_each(|v| state.write_u32(v.to_bits()));
+		}
+		Color::Oklaba(oklaba) => {
+			state.write_u8(7);
+			oklaba
+				.to_f32_array()
+				.iter()
+				.for_each(|v| state.write_u32(v.to_bits()));
+		}
+		Color::Oklcha(oklcha) => {
+			state.write_u8(8);
+			oklcha
+				.to_f32_array()
+				.iter()
+				.for_each(|v| state.write_u32(v.to_bits()));
+		}
+		Color::Xyza(xyza) => {
+			state.write_u8(9);
+			xyza.to_f32_array()
+				.iter()
+				.for_each(|v| state.write_u32(v.to_bits()));
+		}
+	}
+}
 static MODEL_REGISTRY: Registry<Model> = Registry::new();
-static HOLDOUT_MATERIAL: OnceLock<Arc<MaterialWrapper>> = OnceLock::new();
 
 impl MaterialParameter {
-	fn apply_to_material(&self, client: &Client, material: &Material, parameter_name: &str) {
+	fn apply_to_material(
-		let mut params = material.get_all_param_info();
+		&self,
+		client: &Client,
+		mat: &mut BevyMaterial,
+		parameter_name: &str,
+		asset_server: &AssetServer,
+	) {
 		match self {
-			MaterialParameter::Bool(val) => {
+			MaterialParameter::Bool(val) => match parameter_name {
-				params.set_bool(parameter_name, *val);
+				"double_sided" => mat.double_sided = *val,
+				v => {
+					error!("unknown param_name ({v}) for color")
+				}
+			},
+			MaterialParameter::Int(_val) => {
+				// nothing uses an int
 			}
-			MaterialParameter::Int(val) => {
+			MaterialParameter::UInt(_val) => {
-				params.set_int(parameter_name, &[*val]);
+				// nothing uses an uint
-			}
-			MaterialParameter::UInt(val) => {
-				params.set_uint(parameter_name, &[*val]);
 			}
 			MaterialParameter::Float(val) => {
-				params.set_float(parameter_name, *val);
+				match parameter_name {
+					"metallic" => mat.metallic = *val,
+					"roughness" => mat.perceptual_roughness = *val,
+					// we probably don't want to expose tex_scale
+					// "tex_scale" => mat.tex_scale = *val,
+					v => {
+						error!("unknown param_name ({v}) for float")
+					}
+				}
 			}
-			MaterialParameter::Vec2(val) => {
+			MaterialParameter::Vec2(_val) => {
-				params.set_vec2(parameter_name, Vec2::from(*val));
+				// nothing uses a Vec2
 			}
-			MaterialParameter::Vec3(val) => {
+			MaterialParameter::Vec3(_val) => {
-				params.set_vec3(parameter_name, Vec3::from(*val));
+				// nothing uses a Vec3
-			}
-			MaterialParameter::Color(val) => {
-				params.set_color(
-					parameter_name,
-					Color128::new(val.c.r, val.c.g, val.c.b, val.a),
-				);
 			}
+			MaterialParameter::Color(color) => match parameter_name {
+				"color" => mat.base_color = color.to_bevy(),
+				"emission_factor" => mat.emissive = color.to_bevy().to_linear(),
+				v => {
+					error!("unknown param_name ({v}) for color")
+				}
+			},
 			MaterialParameter::Texture(resource) => {
 				let Some(texture_path) =
 					get_resource_file(resource, client, &[OsStr::new("png"), OsStr::new("jpg")])
 				else {
 					return;
 				};
-				if let Ok(tex) = Tex::from_file(texture_path, true, None) {
+				let handle = asset_server.load(texture_path);
-					params.set_texture(parameter_name, &tex);
+				match parameter_name {
+					"diffuse" => mat.base_color_texture = Some(handle),
+					"emission" => mat.emissive_texture = Some(handle),
+					"metal" => mat.metallic_roughness_texture = Some(handle),
+					"occlusion" => mat.occlusion_texture = Some(handle),
+					v => {
+						error!("unknown param_name ({v}) for texture");
+					}
 				}
+				// mat.alpha_mode = AlphaMode::Blend;
 			}
 		}
 	}
 }
 
 pub struct ModelPart {
-	id: i32,
+	entity: OnceLock<EntityHandle>,
+	mesh_entity: OnceLock<EntityHandle>,
 	path: String,
-	space: Arc<Spatial>,
+	spatial: Arc<Spatial>,
-	model: Weak<Model>,
-	material: Mutex<Option<Arc<MaterialWrapper>>>,
 	pending_material_parameters: Mutex<FxHashMap<String, MaterialParameter>>,
-	pending_material_replacement: Mutex<Option<Arc<MaterialWrapper>>>,
+	pending_material_replacement: Mutex<Option<Handle<BevyMaterial>>>,
+	holdout: AtomicBool,
 	aliases: AliasList,
+	bounds: OnceLock<Aabb>,
 }
 impl ModelPart {
-	fn create_for_model(model: &Arc<Model>, sk_model: &SKModel) {
+	pub fn replace_material(&self, replacement: Handle<BevyMaterial>) {
-		HOLDOUT_MATERIAL.get_or_init(|| {
-			let mut mat = Material::copy(&Material::unlit());
-			mat.transparency(Transparency::None);
-			mat.color_tint(Color128::BLACK_TRANSPARENT);
-			Arc::new(MaterialWrapper(mat))
-		});
-
-		let nodes = sk_model.get_nodes();
-		for part in nodes.all() {
-			ModelPart::create(model, &part);
-		}
-	}
-
-	fn create(model: &Arc<Model>, part: &stereokit_rust::model::ModelNode) -> Option<Arc<Self>> {
-		let mut parts = model.parts.lock();
-		let parent_part = part
-			.get_parent()
-			.and_then(|part| parts.iter().find(|p| p.id == *part.get_id()));
-
-		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 += part.get_name().unwrap();
-
-		let node = client.scenegraph.add_node(Node::generate(&client, false));
-		let spatial_parent = parent_part
-			.map(|n| n.space.clone())
-			.unwrap_or_else(|| model.space.clone());
-
-		let local_transform = unsafe { part.get_local_transform().m };
-		let space = Spatial::add_to(
-			&node,
-			Some(spatial_parent),
-			Mat4::from_cols_array(&local_transform),
-			false,
-		);
-
-		let _ = space.bounding_box_calc.set(|node| {
-			let Ok(model_part) = node.get_aspect::<ModelPart>() 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 model_nodes = sk_model.get_nodes();
-			let Some(model_node) = model_nodes.get_index(model_part.id) else {
-				return Bounds::default();
-			};
-			let Some(sk_mesh) = model_node.get_mesh() else {
-				return Bounds::default();
-			};
-			sk_mesh.get_bounds()
-		});
-
-		let model_part = Arc::new(ModelPart {
-			id: *part.get_id(),
-			path: part_path,
-			space,
-			model: Arc::downgrade(model),
-			pending_material_parameters: Mutex::new(FxHashMap::default()),
-			pending_material_replacement: Mutex::new(None),
-			aliases: AliasList::default(),
-			material: Mutex::new(part.get_material().map(MaterialWrapper).map(Arc::new)),
-		});
-		node.add_aspect_raw(model_part.clone());
-		parts.push(model_part.clone());
-		Some(model_part)
-	}
-
-	pub fn replace_material(&self, replacement: Arc<MaterialWrapper>) {
-		let shared_material = MATERIAL_REGISTRY.add_or_get(replacement);
 		self.pending_material_replacement
 			.lock()
-			.replace(shared_material);
+			.replace(replacement);
 	}
-	/// only to be run on the main thread
+	pub fn set_material_parameter(&self, parameter_name: String, value: MaterialParameter) {
-	pub fn replace_material_now(&self, replacement: &Material) {
+		self.pending_material_parameters
-		let Some(model) = self.model.upgrade() else {
+			.lock()
-			return;
+			.insert(parameter_name, value);
-		};
-		let Some(sk_model) = model.sk_model.get() else {
-			return;
-		};
-		let nodes = sk_model.get_nodes();
-		let Some(mut part) = nodes.get_index(self.id) else {
-			return;
-		};
-		let shared_material =
-			MATERIAL_REGISTRY.add_or_get(Arc::new(MaterialWrapper(replacement.copy())));
-
-		let mut lock = self.material.lock();
-		part.material(&shared_material.0);
-		lock.replace(shared_material);
-	}
-
-	fn update(&self) {
-		let Some(model) = self.model.upgrade() else {
-			return;
-		};
-		let Some(sk_model) = model.sk_model.get() else {
-			return;
-		};
-		let Some(node) = model.space.node() else {
-			return;
-		};
-		let nodes = sk_model.get_nodes();
-		let Some(mut part) = nodes.get_index(self.id) else {
-			return;
-		};
-		part.model_transform(Spatial::space_to_space_matrix(
-			Some(&self.space),
-			Some(&model.space),
-		));
-
-		let Some(client) = node.get_client() else {
-			return;
-		};
-
-		if let Some(material_replacement) = self.pending_material_replacement.lock().take() {
-			let mut lock = self.material.lock();
-			part.material(&material_replacement.0);
-			lock.replace(material_replacement);
-		}
-
-		'mat_params: {
-			let mut material_parameters = self.pending_material_parameters.lock();
-			if !material_parameters.is_empty() {
-				let Some(material) = part.get_material() else {
-					break 'mat_params;
-				};
-				let new_material = material.copy();
-				for (parameter_name, parameter_value) in material_parameters.drain() {
-					parameter_value.apply_to_material(&client, &new_material, &parameter_name);
-				}
-
-				let shared_material =
-					MATERIAL_REGISTRY.add_or_get(Arc::new(MaterialWrapper(new_material)));
-				let mut lock = self.material.lock();
-				part.material(&shared_material.0);
-				lock.replace(shared_material);
-			}
-		}
 	}
 }
 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());
+		model_part.holdout.store(true, Ordering::Relaxed);
 		Ok(())
 	}
 
@@ -320,20 +504,43 @@ impl ModelPartAspect for ModelPart {
 		value: MaterialParameter,
 	) -> Result<()> {
 		let model_part = node.get_aspect::<ModelPart>()?;
-		model_part
+		model_part.set_material_parameter(parameter_name, value);
-			.pending_material_parameters
-			.lock()
-			.insert(parameter_name, value);
-
 		Ok(())
 	}
 }
+#[derive(Default, Resource)]
+pub struct MaterialRegistry(FxHashMap<HashedPbrMaterial, Handle<BevyMaterial>>);
+impl MaterialRegistry {
+	/// returns strong handle for PbrMaterial elminitating duplications
+	pub fn get_handle(
+		&mut self,
+		material: BevyMaterial,
+		materials: &mut ResMut<Assets<BevyMaterial>>,
+	) -> Handle<BevyMaterial> {
+		let hash = HashedPbrMaterial::new(&material);
+		match self
+			.0
+			.get(&hash)
+			.and_then(|v| materials.get_strong_handle(v.id()))
+		{
+			Some(v) => v,
+			None => {
+				let handle = materials.add(material);
+				self.0.insert(hash, handle.clone_weak());
+				handle
+			}
+		}
+	}
+}
 
 pub struct Model {
-	space: Arc<Spatial>,
+	spatial: Arc<Spatial>,
 	_resource_id: ResourceID,
-	sk_model: OnceLock<SKModel>,
+	bevy_scene_entity: OnceLock<EntityHandle>,
-	parts: Mutex<Vec<Arc<ModelPart>>>,
+	parts: OnceLock<Vec<Arc<ModelPart>>>,
+	pre_bound_parts: Mutex<Vec<Arc<ModelPart>>>,
+	setup_complete: AtomicBool,
+	setup_complete_notify: Notify,
 }
 impl Model {
 	pub fn add_to(node: &Arc<Node>, resource_id: ResourceID) -> Result<Arc<Model>> {
@@ -345,44 +552,78 @@ impl Model {
 		.ok_or_else(|| eyre!("Resource not found"))?;
 
 		let model = Arc::new(Model {
-			space: node.get_aspect::<Spatial>().unwrap().clone(),
+			spatial: node.get_aspect::<Spatial>().unwrap().clone(),
 			_resource_id: resource_id,
-			sk_model: OnceLock::new(),
+			bevy_scene_entity: OnceLock::new(),
-			parts: Mutex::new(Vec::default()),
+			pre_bound_parts: Mutex::default(),
+			parts: OnceLock::new(),
+			setup_complete_notify: Notify::new(),
+			setup_complete: AtomicBool::new(false),
 		});
+		_ = model.spatial.bounding_box_calc.set(|n| {
+			Box::pin(async {
+				if let Ok(model) = n.get_aspect::<Model>()
+					&& !model.setup_complete.load(Ordering::Relaxed)
+				{
+					model.setup_complete_notify.notified().await;
+				}
+				Aabb::default()
+			})
+		});
+		LOAD_MODEL
+			.send((model.clone(), pending_model_path))
+			.unwrap();
 		MODEL_REGISTRY.add_raw(&model);
 
-		// technically doing this in anything but the main thread isn't a good idea but dangit we need those model nodes ASAP
-		let sk_model = SKModel::copy(SKModel::from_file(
-			pending_model_path.to_str().unwrap(),
-			None,
-		)?);
-		ModelPart::create_for_model(&model, &sk_model);
-		let _ = model.sk_model.set(sk_model);
 		node.add_aspect_raw(model.clone());
 		Ok(model)
 	}
-
+	pub fn get_model_part(self: &Arc<Self>, part_path: String) -> Result<Arc<ModelPart>> {
-	fn draw(&self, token: &MainThreadToken) {
+		let part = match self
-		let Some(sk_model) = self.sk_model.get() else {
+			.parts
-			return;
+			.get()
-		};
+			.map(|v| v.iter().find(|p| p.path == part_path))
-		let parts = self.parts.lock();
+		{
-		for model_node in &*parts {
+			Some(Some(part)) => part.clone(),
-			model_node.update();
+			Some(None) => {
-		}
+				let paths = self
-		drop(parts);
+					.parts
-
+					.get()
-		if let Some(node) = self.space.node() {
+					.unwrap()
-			if node.enabled() {
+					.iter()
-				sk_model.draw(token, self.space.global_transform(), None, None);
+					.map(|p| &p.path)
+					.collect::<Vec<_>>();
+				bail!(
+					"Couldn't find model part at path {part_path}, all available paths: {paths:?}",
+				);
 			}
-		}
+			None => {
+				let client = self.spatial.node().unwrap().get_client().unwrap();
+				let part_node = client.scenegraph.add_node(Node::generate(&client, false));
+				let spatial = Spatial::add_to(
+					&part_node,
+					Some(self.spatial.clone()),
+					Mat4::IDENTITY,
+					false,
+				);
+				let part = part_node.add_aspect(ModelPart {
+					entity: OnceLock::new(),
+					mesh_entity: OnceLock::new(),
+					path: part_path,
+					spatial,
+					pending_material_parameters: Mutex::default(),
+					pending_material_replacement: Mutex::default(),
+					holdout: AtomicBool::new(false),
+					aliases: AliasList::default(),
+					bounds: OnceLock::new(),
+				});
+				self.pre_bound_parts.lock().push(part.clone());
+				part
+			}
+		};
+		Ok(part)
 	}
 }
-// TODO: proper hread safety in stereokit_rust (probably just bind stereokit directly)
-unsafe impl Send for Model {}
-unsafe impl Sync for Model {}
 impl ModelAspect for Model {
 	#[doc = "Bind a model part to the node with the ID input."]
 	fn bind_model_part(
@@ -392,13 +633,9 @@ impl ModelAspect for Model {
 		part_path: String,
 	) -> Result<()> {
 		let model = node.get_aspect::<Model>()?;
-		let parts = model.parts.lock();
+		let part = model.get_model_part(part_path)?;
-		let Some(part) = parts.iter().find(|p| p.path == part_path) else {
-			let paths = parts.iter().map(|p| &p.path).collect::<Vec<_>>();
-			bail!("Couldn't find model part at path {part_path}, all available paths: {paths:?}",);
-		};
 		Alias::create_with_id(
-			&part.space.node().unwrap(),
+			&part.spatial.node().unwrap(),
 			&calling_client,
 			id,
 			MODEL_PART_ASPECT_ALIAS_INFO.clone(),
@@ -409,12 +646,16 @@ impl ModelAspect for Model {
 }
 impl Drop for Model {
 	fn drop(&mut self) {
+		for p in self.parts.get().iter().flat_map(|v| v.iter()) {
+			if let Some(node) = p.spatial.node() {
+				node.destroy();
+			}
+		}
+		for p in self.pre_bound_parts.lock().iter() {
+			if let Some(node) = p.spatial.node() {
+				node.destroy();
+			}
+		}
 		MODEL_REGISTRY.remove(self);
 	}
 }
-
-pub fn draw_all(token: &MainThreadToken) {
-	for model in MODEL_REGISTRY.get_valid_contents() {
-		model.draw(token);
-	}
-}

src/nodes/drawable/shaders.rs

@@ -1,5 +0,0 @@
-// Simula shader with fancy lanzcos sampling
-pub const UNLIT_SHADER_BYTES: &[u8] = include_bytes!("assets/shaders/shader_unlit_gamma.hlsl.sks");
-
-// Simula shader with fancy lanzcos sampling
-pub const PANEL_SHADER_BYTES: &[u8] = include_bytes!("assets/shaders/shader_unlit_simula.hlsl.sks");

src/nodes/drawable/shaders_src/shader_unlit_gamma.hlsl

@@ -1,39 +0,0 @@
-#include "stereokit.hlsli"
-
-//--name = sk/unlit
-//--diffuse     = white
-//--uv_offset   = 0.0, 0.0
-//--uv_scale    = 1.0, 1.0
-Texture2D    diffuse   : register(t0);
-SamplerState diffuse_s : register(s0);
-float2       uv_scale;
-float2       uv_offset;
-
-struct vsIn {
-	float4 pos  : SV_Position;
-	float3 norm : NORMAL0;
-	float2 uv   : TEXCOORD0;
-};
-struct psIn {
-	float4 pos   : SV_POSITION;
-	float2 uv    : TEXCOORD0;
-	uint view_id : SV_RenderTargetArrayIndex;
-};
-
-psIn vs(vsIn input, uint id : SV_InstanceID) {
-	psIn o;
-	o.view_id = id % sk_view_count;
-	id        = id / sk_view_count;
-
-	float3 world = mul(float4(input.pos.xyz, 1), sk_inst[id].world).xyz;
-	o.pos        = mul(float4(world,         1), sk_viewproj[o.view_id]);
-
-	o.uv    = (input.uv + uv_offset) * uv_scale;
-	return o;
-}
-float4 ps(psIn input) : SV_TARGET {
-	float4 col = diffuse.Sample(diffuse_s, input.uv);
-	col.rgb = pow(col.rgb, float3(2.2));
-
-	return col; 
-}

src/nodes/drawable/shaders_src/shader_unlit_simula.hlsl

@@ -1,119 +0,0 @@
-#include "stereokit.hlsli"
-
-// Port of https://github.com/SimulaVR/Simula/blob/master/addons/godot-haskell-plugin/TextShader.tres to StereoKit and HLSL.
-
-//--name = stardust/text_shader
-//--diffuse     = white
-//--uv_offset   = 0.0, 0.0
-//--uv_scale    = 1.0, 1.0
-//--fcFactor    = 1.0
-//--ripple      = 4.0
-//--alpha_min   = 0.0
-//--alpha_max   = 1.0
-Texture2D    diffuse   : register(t0);
-SamplerState diffuse_s : register(s0);
-float4       diffuse_i;
-float2       uv_scale;
-float2       uv_offset;
-float        fcFactor;
-float        ripple;
-float        alpha_min;
-float        alpha_max;
-
-struct vsIn {
-	float4 pos  : SV_Position;
-	float3 norm : NORMAL0;
-	float2 uv   : TEXCOORD0;
-};
-struct psIn {
-	float4 pos   : SV_POSITION;
-	float2 uv    : TEXCOORD0;
-	uint view_id : SV_RenderTargetArrayIndex;
-};
-
-psIn vs(vsIn input, uint id : SV_InstanceID) {
-	psIn o;
-	o.view_id = id % sk_view_count;
-	id        = id / sk_view_count;
-
-	float3 world = mul(float4(input.pos.xyz, 1), sk_inst[id].world).xyz;
-	o.pos        = mul(float4(world,         1), sk_viewproj[o.view_id]);
-
-	o.uv    = (input.uv + uv_offset) * uv_scale;
-	return o;
-}
-
-float map(float value, float min1, float max1, float min2, float max2) {
-  return min2 + (value - min1) * (max2 - min2) / (max1 - min1);
-}
-
-// float gaussian(float x, float t) {
-// 	float PI = 3.14159265358;
-// 	return exp(-x*x/(2.0 * t*t))/(sqrt(2.0*PI)*t);
-// }
-
-float besselI0(float x) {
-	return 1.0 + pow(x, 2.0) * (0.25 +  pow(x, 2.0) * (0.015625 +  pow(x, 2.0) * (0.000434028 +  pow(x, 2.0) * (6.78168e-6 +  pow(x, 2.0) * (6.78168e-8 +  pow(x, 2.0) * (4.7095e-10 +  pow(x, 2.0) * (2.40281e-12 + pow(x, 2.0) * (9.38597e-15 + pow(x, 2.0) * (2.8969e-17 + 7.24226e-20 * pow(x, 2.0))))))))));
-}
-
-float kaiser(float x, float alpha) {
-	if (x > 1.0) { 
-		return 0.0;
-	}
-	return besselI0(alpha * sqrt(1.0-x*x));
-}
-
-float4 lowpassFilter(Texture2D tex, sampler2D texSampler, float2 uv, float alpha) {
-	float PI = 3.14159265358;
-	
-	float4 q = float4(0.0);
-	
-	float2 dx_uv = ddx(uv);
-	float2 dy_uv = ddy(uv);
-	//float width = sqrt(max(dot(dx_uv, dx_uv), dot(dy_uv, dy_uv)));
-	float2 width = abs(float2(dx_uv.x, dy_uv.y));
-	
-	float2 pixelWidth = floor(width * diffuse_i.xy);
-	float2 aspectRatio = normalize(pixelWidth);
-	
-	float2 xyf = uv * diffuse_i.xy;
-	int2 xy = int2(xyf);
-	
-	pixelWidth = clamp(pixelWidth, float2(1.0), float2(2.0));
-
-	int2 start = xy - int2(pixelWidth);
-	int2 end = xy + int2(pixelWidth);
-	
-	float4 outColor = float4(0.0);
-	
-	float qSum = 0.0;
-	
-	for (int v = start.y; v <= end.y; v++) {
-		for (int u = start.x; u <= end.x; u++) {
-			float kx = fcFactor * (xyf.x - float(u))/pixelWidth.x;
-			float ky = fcFactor * (xyf.y - float(v))/pixelWidth.y;
-			 
-			//float lanczosValue = gaussian(kx, fcx);
-			float lanczosValue = kaiser(sqrt(kx*kx + ky*ky), alpha);
-			
-			q += tex.Sample(texSampler, (float2(u, v)+float2(0.5))/diffuse_i.xy) * lanczosValue;
-			// q += tex.Load(int3(u, v, 0)) * lanczosValue;
-			qSum += lanczosValue;
-		}
-	}
-	
-	return q/qSum;
-}
-
-float4 ps(psIn input) : SV_TARGET {
-	float gamma = 2.2;
-	// float4 col = diffuse.Sample(diffuse_s, input.uv);
-
-	// float4 col = lowpassFilter(diffuse, diffuse_s, diffuse_i.xy, float2(1.0 - input.uv.x, input.uv.y), ripple);
-	float4 col = lowpassFilter(diffuse, diffuse_s, input.uv, ripple);
-	// float4 col = diffuse.Sample(diffuse_s, input.uv);
-	col.rgb = pow(col.rgb, float3(gamma));
-	col.a = map(col.a, 0, 1, alpha_min, alpha_max);
-
-	return col; 
-}

src/nodes/drawable/sky.rs

@@ -0,0 +1,72 @@
+use bevy::{
+	app::{Plugin, Update},
+	color::Color,
+	core_pipeline::{Skybox, core_3d::Camera3d},
+	ecs::{
+		entity::Entity,
+		query::With,
+		system::{Commands, Query, ResMut},
+	},
+	pbr::{AmbientLight, environment_map::EnvironmentMapLight},
+};
+use bevy_equirect::EquirectManager;
+use glam::Quat;
+
+pub struct SkyPlugin;
+
+impl Plugin for SkyPlugin {
+	fn build(&self, app: &mut bevy::app::App) {
+		app.add_systems(Update, apply_sky);
+	}
+}
+
+// TODO: make this work with cameras spawned after setting the sky texture
+fn apply_sky(
+	mut equirect: ResMut<EquirectManager>,
+	cameras: Query<Entity, With<Camera3d>>,
+	mut cmds: Commands,
+) {
+	if let Some(tex) = super::QUEUED_SKYTEX.lock().take() {
+		if let Some(path) = tex {
+			let image_handle = equirect.load_equirect_as_cubemap(path, 1024);
+			for cam in cameras {
+				cmds.entity(cam).insert(Skybox {
+					image: image_handle.clone(),
+					brightness: 1000.0,
+					rotation: Quat::IDENTITY,
+				});
+			}
+		} else {
+			for cam in cameras {
+				cmds.entity(cam).remove::<Skybox>();
+			}
+		}
+	}
+	if let Some(light) = super::QUEUED_SKYLIGHT.lock().take() {
+		if let Some(path) = light {
+			let image_handle = equirect.load_equirect_as_cubemap(path, 1024);
+			for cam in cameras {
+				cmds.entity(cam)
+					.insert(EnvironmentMapLight {
+						diffuse_map: image_handle.clone(),
+						// we might want to use the SkyTex for this?
+						specular_map: image_handle.clone(),
+						intensity: 1000.0,
+						rotation: Quat::IDENTITY,
+						affects_lightmapped_mesh_diffuse: false,
+					})
+					.remove::<AmbientLight>();
+			}
+		} else {
+			for cam in cameras {
+				cmds.entity(cam)
+					.insert(AmbientLight {
+						color: Color::WHITE,
+						brightness: 1000.0,
+						affects_lightmapped_meshes: true,
+					})
+					.remove::<EnvironmentMapLight>();
+			}
+		}
+	}
+}

src/nodes/drawable/text.rs

@@ -1,48 +1,184 @@
 use crate::{
+	BevyMaterial,
 	core::{
-		client::Client, destroy_queue, error::Result, registry::Registry,
+		bevy_channel::{BevyChannel, BevyChannelReader},
+		client::Client,
+		color::ColorConvert,
+		entity_handle::EntityHandle,
+		error::Result,
+		registry::Registry,
 		resource::get_resource_file,
 	},
-	nodes::{Node, spatial::Spatial},
+	nodes::{
+		Node,
+		drawable::{TextFit, XAlign},
+		spatial::{Spatial, SpatialNode},
+	},
+};
+use bevy::{platform::collections::HashMap, prelude::*};
+use bevy_mesh_text_3d::{
+	Align, Attrs, HorizontalAnchorPoint, MeshTextPlugin, Settings as FontSettings, VerticalAlign,
+	VerticalAnchorPoint, generate_meshes,
 };
 use color_eyre::eyre::eyre;
-use glam::{Mat4, Vec2, vec3};
+use core::f32;
 use parking_lot::Mutex;
-use std::{
+use std::{ffi::OsStr, mem, path::PathBuf, sync::Arc};
-	ffi::OsStr,
-	path::PathBuf,
-	sync::{Arc, OnceLock},
-};
-use stereokit_rust::{
-	font::Font,
-	sk::MainThreadToken,
-	system::{TextAlign, TextFit, TextStyle as SkTextStyle},
-	util::{Color32, Color128},
-};
 
-use super::{TextAspect, TextStyle};
+static SPAWN_TEXT: BevyChannel<Arc<Text>> = BevyChannel::new();
 
-static TEXT_REGISTRY: Registry<Text> = Registry::new();
+pub struct TextNodePlugin;
 
-fn convert_align(x_align: super::XAlign, y_align: super::YAlign) -> TextAlign {
+impl Plugin for TextNodePlugin {
-	match (x_align, y_align) {
+	fn build(&self, app: &mut App) {
-		(super::XAlign::Left, super::YAlign::Top) => TextAlign::TopLeft,
+		// Text init stuff
-		(super::XAlign::Left, super::YAlign::Center) => TextAlign::CenterLeft,
+		app.add_plugins(MeshTextPlugin);
-		(super::XAlign::Left, super::YAlign::Bottom) => TextAlign::BottomLeft,
+		app.world_mut()
-		(super::XAlign::Center, super::YAlign::Top) => TextAlign::Center,
+			.resource_mut::<FontSettings>()
-		(super::XAlign::Center, super::YAlign::Center) => TextAlign::Center,
+			.font_system
-		(super::XAlign::Center, super::YAlign::Bottom) => TextAlign::BottomCenter,
+			.db_mut()
-		(super::XAlign::Right, super::YAlign::Top) => TextAlign::TopRight,
+			.load_system_fonts();
-		(super::XAlign::Right, super::YAlign::Center) => TextAlign::CenterRight,
+
-		(super::XAlign::Right, super::YAlign::Bottom) => TextAlign::BottomRight,
+		SPAWN_TEXT.init(app);
+		app.init_resource::<MaterialRegistry>();
+		app.add_systems(Update, spawn_text);
 	}
 }
 
-pub struct Text {
+fn spawn_text(
-	space: Arc<Spatial>,
+	mut mpsc: ResMut<BevyChannelReader<Arc<Text>>>,
-	font_path: Option<PathBuf>,
+	mut cmds: Commands,
-	style: OnceLock<SkTextStyle>,
+	mut font_settings: ResMut<FontSettings>,
+	mut material_registry: ResMut<MaterialRegistry>,
+	mut materials: ResMut<Assets<BevyMaterial>>,
+	mut meshes: ResMut<Assets<Mesh>>,
+	mut font_registry: Local<FontDatabaseRegistry>,
+) {
+	while let Some(text) = mpsc.read() {
+		if let Some(entity) = text.entity.lock().take() {
+			cmds.entity(*entity).despawn();
+		}
+		let style = text.data.lock();
+		let old_db = text.font_path.clone().map(|p| {
+			let db = font_registry.get(p);
+			mem::swap(font_settings.font_system.db_mut(), db);
+			db
+		});
+		let attrs = Attrs::new().weight(cosmic_text::Weight::BOLD);
+		let alignment = Some(match style.text_align_x {
+			super::XAlign::Left => Align::Right,
+			super::XAlign::Center => Align::Center,
+			super::XAlign::Right => Align::Left,
+		});
+		let vertical_alignment = Some(match style.text_align_y {
+			super::YAlign::Top => VerticalAlign::Top,
+			super::YAlign::Center => VerticalAlign::Middle,
+			super::YAlign::Bottom => VerticalAlign::Bottom,
+		});
+		let text_string = text.text.lock().clone();
+		let max_width = style.bounds.as_ref().map(|v| v.bounds.x);
+		let max_height = style.bounds.as_ref().map(|v| v.bounds.y);
+		let horizontal_anchor_point = style
+			.bounds
+			.as_ref()
+			.map(|v| match v.anchor_align_x {
+				XAlign::Left => HorizontalAnchorPoint::Left,
+				XAlign::Center => HorizontalAnchorPoint::Middle,
+				XAlign::Right => HorizontalAnchorPoint::Right,
+			})
+			.unwrap_or(HorizontalAnchorPoint::Middle);
+		let vertical_anchor_point = style
+			.bounds
+			.as_ref()
+			.map(|v| match v.anchor_align_y {
+				YAlign::Top => VerticalAnchorPoint::Top,
+				YAlign::Center => VerticalAnchorPoint::Middle,
+				YAlign::Bottom => VerticalAnchorPoint::Bottom,
+			})
+			.unwrap_or(VerticalAnchorPoint::Middle);
+		let wrap = matches!(style.bounds.as_ref().map(|v| v.fit), Some(TextFit::Wrap));
+		let char_meshes = generate_meshes(
+			bevy_mesh_text_3d::InputText::Simple {
+				text: text_string,
+				material: material_registry.get_handle(
+					BevyMaterial {
+						base_color: style.color.to_bevy(),
+						emissive: Color::WHITE.to_linear(),
+						metallic: 0.0,
+						perceptual_roughness: 1.0,
+						alpha_mode: AlphaMode::Premultiplied,
+						double_sided: false,
+						..default()
+					},
+					&mut materials,
+				),
+				attrs,
+			},
+			&mut font_settings,
+			bevy_mesh_text_3d::Parameters {
+				extrusion_depth: 0.0,
+				font_size: style.character_height,
+				line_height: style.character_height * 1.1,
+				alignment,
+				max_width: wrap.then_some(0).and(max_width),
+				max_height: wrap.then_some(0).and(max_height),
+				vertical_alignment,
+				horizontal_anchor_point,
+				vertical_anchor_point,
+			},
+			&mut meshes,
+		);
+		if let Some(db) = old_db {
+			mem::swap(font_settings.font_system.db_mut(), db);
+		}
+		let Ok((char_meshes, _text_size)) =
+			char_meshes.inspect_err(|err| error!("unable to create text meshes: {err}"))
+		else {
+			continue;
+		};
 
+		let letters = char_meshes
+			.into_iter()
+			.map(|v| {
+				cmds.spawn((Mesh3d(v.mesh), MeshMaterial3d(v.material), v.transform))
+					.id()
+			})
+			.collect::<Vec<_>>();
+		let entity = cmds
+			.spawn((
+				Name::new("TextNode"),
+				SpatialNode(Arc::downgrade(&text.spatial)),
+			))
+			.add_children(&letters)
+			.id();
+		let entity = EntityHandle::new(entity);
+		text.entity.lock().replace(entity.clone());
+		text.spatial.set_entity(entity);
+	}
+}
+
+#[derive(Default)]
+struct FontDatabaseRegistry(HashMap<PathBuf, cosmic_text::fontdb::Database>);
+impl FontDatabaseRegistry {
+	fn get(&mut self, path: PathBuf) -> &mut cosmic_text::fontdb::Database {
+		self.0.entry(path).or_insert_with_key(|path| {
+			let mut db = cosmic_text::fontdb::Database::new();
+			if let Err(err) = db.load_font_file(path) {
+				error!("unable to load font file {} {err}", path.to_string_lossy());
+			};
+			db
+		})
+	}
+}
+
+use super::{TextAspect, TextStyle, YAlign, model::MaterialRegistry};
+
+static TEXT_REGISTRY: Registry<Text> = Registry::new();
+
+pub struct Text {
+	spatial: Arc<Spatial>,
+	font_path: Option<PathBuf>,
+	entity: Mutex<Option<EntityHandle>>,
 	text: Mutex<String>,
 	data: Mutex<TextStyle>,
 }
@@ -50,88 +186,20 @@ impl Text {
 	pub fn add_to(node: &Arc<Node>, text: String, style: TextStyle) -> Result<Arc<Text>> {
 		let client = node.get_client().ok_or_else(|| eyre!("Client not found"))?;
 		let text = TEXT_REGISTRY.add(Text {
-			space: node.get_aspect::<Spatial>().unwrap().clone(),
+			spatial: node.get_aspect::<Spatial>().unwrap().clone(),
 			font_path: style.font.as_ref().and_then(|res| {
 				get_resource_file(res, &client, &[OsStr::new("ttf"), OsStr::new("otf")])
 			}),
-			style: OnceLock::new(),
 
+			entity: Mutex::new(None),
 			text: Mutex::new(text),
 			data: Mutex::new(style),
 		});
 		node.add_aspect_raw(text.clone());
+		_ = SPAWN_TEXT.send(text.clone());
 
 		Ok(text)
 	}
-
-	fn draw(&self, token: &MainThreadToken) {
-		let style = self.style.get_or_init(|| {
-			let font = self
-				.font_path
-				.as_deref()
-				.and_then(|path| Font::from_file(path).ok())
-				.unwrap_or_default();
-			SkTextStyle::from_font(font, 1.0, Color32::WHITE)
-		});
-
-		let text = self.text.lock();
-		let data = self.data.lock();
-		let transform = self.space.global_transform()
-			* Mat4::from_scale(vec3(
-				data.character_height,
-				data.character_height,
-				data.character_height,
-			));
-		if let Some(bounds) = &data.bounds {
-			stereokit_rust::system::Text::add_in(
-				token,
-				&*text,
-				transform,
-				Vec2::from(bounds.bounds) / data.character_height,
-				match bounds.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,
-				},
-				Some(*style),
-				Some(Color128::new(
-					data.color.c.r,
-					data.color.c.g,
-					data.color.c.b,
-					data.color.a,
-				)),
-				data.bounds
-					.as_ref()
-					.map(|b| convert_align(b.anchor_align_x, b.anchor_align_y)),
-				Some(convert_align(data.text_align_x, data.text_align_y)),
-				None,
-				None,
-				None,
-			);
-		} else {
-			stereokit_rust::system::Text::add_at(
-				token,
-				&*text,
-				transform,
-				Some(*style),
-				Some(Color128::new(
-					data.color.c.r,
-					data.color.c.g,
-					data.color.c.b,
-					data.color.a,
-				)),
-				data.bounds
-					.as_ref()
-					.map(|b| convert_align(b.anchor_align_x, b.anchor_align_y)),
-				Some(convert_align(data.text_align_x, data.text_align_y)),
-				None,
-				None,
-				None,
-			);
-		}
-	}
 }
 impl TextAspect for Text {
 	fn set_character_height(
@@ -141,30 +209,19 @@ impl TextAspect for Text {
 	) -> Result<()> {
 		let this_text = node.get_aspect::<Text>()?;
 		this_text.data.lock().character_height = height;
+		_ = SPAWN_TEXT.send(this_text);
 		Ok(())
 	}
 
 	fn set_text(node: Arc<Node>, _calling_client: Arc<Client>, text: String) -> Result<()> {
 		let this_text = node.get_aspect::<Text>()?;
 		*this_text.text.lock() = text;
+		_ = SPAWN_TEXT.send(this_text);
 		Ok(())
 	}
 }
 impl Drop for Text {
 	fn drop(&mut self) {
-		if let Some(style) = self.style.take() {
-			destroy_queue::add(style);
-		}
 		TEXT_REGISTRY.remove(self);
 	}
 }
-
-pub fn draw_all(token: &MainThreadToken) {
-	for text in TEXT_REGISTRY.get_valid_contents() {
-		if let Some(node) = text.space.node() {
-			if node.enabled() {
-				text.draw(token);
-			}
-		}
-	}
-}

src/nodes/fields.rs

@@ -5,17 +5,28 @@ use super::spatial::{
 	Spatial,
 };
 use super::{Aspect, AspectIdentifier, Node};
+use crate::DbusConnection;
 use crate::core::client::Client;
 use crate::core::error::Result;
+use crate::core::registry::Registry;
 use crate::nodes::spatial::SPATIAL_ASPECT_ALIAS_INFO;
 use crate::nodes::spatial::SPATIAL_REF_ASPECT_ALIAS_INFO;
 use crate::nodes::spatial::Transform;
+use bevy::app::{Plugin, Update};
+use bevy::color::Color;
+use bevy::ecs::resource::Resource;
+use bevy::ecs::schedule::IntoScheduleConfigs;
+use bevy::ecs::system::Res;
+use bevy::gizmos::gizmos::Gizmos;
+use bevy::gizmos::primitives::dim3::GizmoPrimitive3d;
+use bevy::math::primitives::{Cylinder, Torus};
 use color_eyre::eyre::OptionExt;
 use glam::{Vec3, Vec3A, Vec3Swizzles, vec2, vec3, vec3a};
 use parking_lot::Mutex;
 use rustc_hash::FxHashMap;
 use stardust_xr::values::Vector3;
-use std::sync::{Arc, LazyLock};
+use std::sync::{Arc, LazyLock, Weak};
+use zbus::interface;
 
 // TODO: get SDFs working properly with non-uniform scale and so on, output distance relative to the spatial it's compared against
 
@@ -32,10 +43,99 @@ pub static FIELD_ALIAS_INFO: LazyLock<AliasInfo> = LazyLock::new(|| AliasInfo {
 	..Default::default()
 });
 
+pub struct FieldDebugGizmoPlugin;
+impl Plugin for FieldDebugGizmoPlugin {
+	fn build(&self, app: &mut bevy::app::App) {
+		let (tx, rx) = tokio::sync::watch::channel(false);
+		let conn = app.world().resource::<DbusConnection>().0.clone();
+		tokio::spawn(async move {
+			_ = conn
+				.object_server()
+				.at("/org/stardustxr/Server", FieldDebugGizmos { state: tx })
+				.await;
+		});
+		app.insert_resource(FieldDebugGizmosEnabled(rx));
+		app.add_systems(
+			Update,
+			draw_field_gizmos.run_if(|res: Res<FieldDebugGizmosEnabled>| *res.0.borrow()),
+		);
+	}
+}
+
+#[derive(Resource)]
+struct FieldDebugGizmosEnabled(tokio::sync::watch::Receiver<bool>);
+
+fn draw_field_gizmos(mut gizmos: Gizmos) {
+	FIELD_REGISTRY_DEBUG_GIZMOS
+		.get_valid_contents()
+		.iter()
+		.for_each(|f| {
+			let transform =
+				bevy::transform::components::Transform::from_matrix(f.spatial.global_transform());
+			let color = Color::srgb_u8(0x04, 0xFD, 0x4C);
+			match f.shape.lock().clone() {
+				Shape::Box(size) => gizmos.cuboid(transform.with_scale(size.into()), color),
+				Shape::Cylinder(CylinderShape { length, radius }) => {
+					gizmos
+						.primitive_3d(
+							&Cylinder {
+								radius,
+								half_height: length * 0.5,
+							},
+							transform.to_isometry(),
+							color,
+						)
+						.resolution(32);
+				}
+				Shape::Sphere(radius) => {
+					gizmos.sphere(transform.to_isometry(), radius, color);
+				}
+				Shape::Torus(TorusShape { radius_a, radius_b }) => {
+					let minor_radius;
+					let major_radius;
+					if radius_a >= radius_b {
+						major_radius = radius_a;
+						minor_radius = radius_b;
+					} else {
+						major_radius = radius_b;
+						minor_radius = radius_a;
+					}
+					gizmos
+						.primitive_3d(
+							&Torus {
+								minor_radius,
+								major_radius,
+							},
+							transform.to_isometry(),
+							color,
+						)
+						.minor_resolution(32)
+						.major_resolution(32);
+				}
+			}
+		});
+}
+
+struct FieldDebugGizmos {
+	state: tokio::sync::watch::Sender<bool>,
+}
+
+#[interface(name = "org.stardustxr.debug.FieldDebugGizmos")]
+impl FieldDebugGizmos {
+	fn enable(&mut self) {
+		_ = self.state.send(true);
+	}
+	fn disable(&mut self) {
+		_ = self.state.send(false);
+	}
+}
+
+static FIELD_REGISTRY_DEBUG_GIZMOS: Registry<Field> = Registry::new();
+
 stardust_xr_server_codegen::codegen_field_protocol!();
 
 lazy_static::lazy_static! {
-	pub static ref EXPORTED_FIELDS: Mutex<FxHashMap<u64, Arc<Node>>> = Mutex::new(FxHashMap::default());
+	pub static ref EXPORTED_FIELDS: Mutex<FxHashMap<u64, Weak<Node>>> = Mutex::new(FxHashMap::default());
 }
 
 pub trait FieldTrait: Send + Sync + 'static {
@@ -145,10 +245,16 @@ impl Field {
 			shape: Mutex::new(shape),
 		};
 		let field = node.add_aspect(field);
+		FIELD_REGISTRY_DEBUG_GIZMOS.add_raw(&field);
 		node.add_aspect(FieldRef);
 		Ok(field)
 	}
 }
+impl Drop for Field {
+	fn drop(&mut self) {
+		FIELD_REGISTRY_DEBUG_GIZMOS.remove(self);
+	}
+}
 impl AspectIdentifier for Field {
 	impl_aspect_for_field_aspect_id! {}
 }
@@ -164,7 +270,7 @@ impl FieldAspect for Field {
 
 	async fn export_field(node: Arc<Node>, _calling_client: Arc<Client>) -> Result<u64> {
 		let id = rand::random();
-		EXPORTED_FIELDS.lock().insert(id, node);
+		EXPORTED_FIELDS.lock().insert(id, Arc::downgrade(&node));
 		Ok(id)
 	}
 }
@@ -265,16 +371,17 @@ impl InterfaceAspect for Interface {
 		Ok(EXPORTED_FIELDS
 			.lock()
 			.get(&uid)
+			.and_then(|s| s.upgrade())
 			.map(|s| {
 				Alias::create(
-					s,
+					&s,
 					&calling_client,
 					FIELD_REF_ASPECT_ALIAS_INFO.clone(),
 					None,
 				)
 				.unwrap()
 			})
-			.ok_or_eyre("Couldn't find spatial with that ID")?)
+			.ok_or_eyre("Couldn't import field with that ID")?)
 	}
 
 	fn create_field(

src/nodes/input/method.rs

@@ -137,6 +137,7 @@ impl InputMethod {
 		self.capture_attempts.remove(handler);
 	}
 
+	#[tracing::instrument(level = "trace", skip(self, handler))]
 	pub(super) fn serialize(&self, alias_id: u64, handler: &Arc<InputHandler>) -> InputData {
 		let mut input = self.data.lock().clone();
 		input.transform(self, handler);

src/nodes/input/mod.rs

@@ -6,8 +6,11 @@ mod method;
 mod pointer;
 mod tip;
 
+use bevy::tasks::ComputeTaskPool;
+use bevy::tasks::ParallelSlice;
 pub use handler::*;
 pub use method::*;
+use tracing::debug_span;
 
 use super::Aspect;
 use super::AspectIdentifier;
@@ -119,51 +122,60 @@ pub fn process_input() {
 			};
 			node.enabled()
 		});
-	for handler in INPUT_HANDLER_REGISTRY.get_valid_contents() {
+	INPUT_HANDLER_REGISTRY
-		for method_alias in handler.method_aliases.get_aliases() {
+		.get_valid_contents()
-			method_alias.set_enabled(false);
+		.into_iter()
-		}
+		.par_splat_map(ComputeTaskPool::get(), None, |_, handlers| {
+			for handler in handlers {
+				let _span = debug_span!("handle input handler").entered();
+				for method_alias in handler.method_aliases.get_aliases() {
+					method_alias.set_enabled(false);
+				}
 
-		let Some(handler_node) = handler.spatial.node() else {
+				let Some(handler_node) = handler.spatial.node() else {
-			continue;
+					continue;
-		};
+				};
-		if !handler_node.enabled() {
+				if !handler_node.enabled() {
-			continue;
+					continue;
-		}
+				}
-		if let Some(handler_field_node) = handler.field.spatial.node() {
+				if let Some(handler_field_node) = handler.field.spatial.node()
-			if !handler_field_node.enabled() {
+					&& !handler_field_node.enabled()
-				continue;
+				{
+					continue;
+				};
+
+				let ser_span = debug_span!("serializing input").entered();
+				let (methods, datas) = methods
+					.clone()
+					// filter out methods without the handler in their handler order
+					.filter(|a| {
+						a.handler_order
+							.lock()
+							.iter()
+							.any(|h| h.ptr_eq(&Arc::downgrade(handler)))
+					})
+					// filter out methods without the proper alias
+					.filter_map(|m| {
+						Some((
+							handler
+								.method_aliases
+								.get_from_original_node(m.spatial.node.clone())?,
+							m,
+						))
+					})
+					// make sure the input method alias is enabled
+					.inspect(|(a, _)| {
+						a.set_enabled(true);
+					})
+					// serialize the data
+					.map(|(a, m)| (a.clone(), m.serialize(a.get_id(), handler)))
+					.unzip::<_, _, Vec<_>, Vec<_>>();
+				drop(ser_span);
+
+				let _span = debug_span!("client input").entered();
+				let _ = input_handler_client::input(&handler_node, &methods, &datas);
 			}
-		};
+		});
-
-		let (methods, datas) = methods
-			.clone()
-			// filter out methods without the handler in their handler order
-			.filter(|a| {
-				a.handler_order
-					.lock()
-					.iter()
-					.any(|h| h.ptr_eq(&Arc::downgrade(&handler)))
-			})
-			// filter out methods without the proper alias
-			.filter_map(|m| {
-				Some((
-					handler
-						.method_aliases
-						.get_from_original_node(m.spatial.node.clone())?,
-					m,
-				))
-			})
-			// make sure the input method alias is enabled
-			.inspect(|(a, _)| {
-				a.set_enabled(true);
-			})
-			// serialize the data
-			.map(|(a, m)| (a.clone(), m.serialize(a.get_id(), &handler)))
-			.unzip::<_, _, Vec<_>, Vec<_>>();
-
-		let _ = input_handler_client::input(&handler_node, &methods, &datas);
-	}
 	for method in methods {
 		method.cull_capture_attempts();
 	}

src/nodes/items/camera.rs

@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 use super::{Item, ItemType, create_item_acceptor_flex, register_item_ui_flex};
 use crate::bail;
 use crate::core::error::Result;
@@ -9,10 +10,7 @@ use crate::{
 	core::{client::Client, registry::Registry, scenegraph::MethodResponseSender},
 	nodes::{
 		Message, Node,
-		drawable::{
+		drawable::model::ModelPart,
-			model::{MaterialWrapper, ModelPart},
-			shaders::UNLIT_SHADER_BYTES,
-		},
 		items::TypeInfo,
 		spatial::{Spatial, Transform},
 	},
@@ -24,19 +22,6 @@ use parking_lot::Mutex;
 
 use stardust_xr::schemas::flex::{deserialize, serialize};
 use std::sync::Arc;
-use std::sync::OnceLock;
-use stereokit_rust::{
-	material::{Material, Transparency},
-	shader::Shader,
-	sk::MainThreadToken,
-	system::Renderer,
-	tex::{Tex, TexFormat, TexType},
-	util::Color128,
-};
-
-pub struct TexWrapper(pub Tex);
-unsafe impl Send for TexWrapper {}
-unsafe impl Sync for TexWrapper {}
 
 stardust_xr_server_codegen::codegen_item_camera_protocol!();
 lazy_static! {
@@ -67,8 +52,6 @@ struct FrameInfo {
 pub struct CameraItem {
 	space: Arc<Spatial>,
 	frame_info: Mutex<FrameInfo>,
-	sk_tex: OnceLock<TexWrapper>,
-	sk_mat: OnceLock<Arc<MaterialWrapper>>,
 	applied_to: Registry<ModelPart>,
 	apply_to: Registry<ModelPart>,
 }
@@ -81,8 +64,6 @@ impl CameraItem {
 				proj_matrix,
 				px_size,
 			}),
-			sk_tex: OnceLock::new(),
-			sk_mat: OnceLock::new(),
 			applied_to: Registry::new(),
 			apply_to: Registry::new(),
 		});
@@ -96,12 +77,12 @@ impl CameraItem {
 		_message: Message,
 		response: MethodResponseSender,
 	) {
-		response.wrap_sync(move || {
+		response.wrap(move || {
 			let ItemType::Camera(_camera) = &node.get_aspect::<Item>().unwrap().specialization
 			else {
 				bail!("Wrong item type?");
 			};
-			Ok(serialize(())?.into())
+			Ok(serialize(())?)
 		});
 	}
 
@@ -127,41 +108,6 @@ impl CameraItem {
 	pub fn send_acceptor_item_created(&self, node: &Node, item: &Arc<Node>) {
 		let _ = camera_item_acceptor_client::capture_item(node, item);
 	}
-
-	pub fn update(&self, token: &MainThreadToken) {
-		let frame_info = self.frame_info.lock();
-		let sk_tex = self.sk_tex.get_or_init(|| {
-			TexWrapper(Tex::gen_color(
-				Color128::default(),
-				frame_info.px_size.x as i32,
-				frame_info.px_size.y as i32,
-				TexType::Rendertarget,
-				TexFormat::RGBA32Linear,
-			))
-		});
-		let sk_mat = self.sk_mat.get_or_init(|| {
-			let shader = Shader::from_memory(UNLIT_SHADER_BYTES).unwrap();
-			let mut mat = Material::new(&shader, None);
-			mat.get_all_param_info().set_texture("diffuse", &sk_tex.0);
-			mat.transparency(Transparency::Blend);
-			Arc::new(MaterialWrapper(mat))
-		});
-		for model_part in self.apply_to.take_valid_contents() {
-			model_part.replace_material(sk_mat.clone())
-		}
-
-		if !self.applied_to.is_empty() {
-			Renderer::render_to(
-				token,
-				&sk_tex.0,
-				self.space.global_transform(),
-				frame_info.proj_matrix,
-				None,
-				None,
-				None,
-			)
-		}
-	}
 }
 impl AspectIdentifier for CameraItem {
 	impl_aspect_for_camera_item_aspect_id! {}
@@ -193,15 +139,6 @@ impl CameraItemAcceptorAspect for CameraItemAcceptor {
 	}
 }
 
-pub fn update(token: &MainThreadToken) {
-	for camera in ITEM_TYPE_INFO_CAMERA.items.get_valid_contents() {
-		let ItemType::Camera(camera) = &camera.specialization else {
-			continue;
-		};
-		camera.update(token);
-	}
-}
-
 impl InterfaceAspect for Interface {
 	#[doc = "Create a camera item at a specific location"]
 	fn create_camera_item(

src/nodes/items/mod.rs

@@ -133,6 +133,7 @@ impl Drop for Item {
 	}
 }
 
+#[cfg_attr(not(feature = "wayland"), allow(dead_code))]
 pub enum ItemType {
 	Camera(Arc<CameraItem>),
 	Panel(Arc<dyn PanelItemTrait>),

src/nodes/items/panel.rs

@@ -1,13 +1,14 @@
 use super::camera::CameraItemAcceptor;
 use super::{create_item_acceptor_flex, register_item_ui_flex};
 use crate::bail;
-use crate::core::error::Result;
+use crate::nodes::{
-use crate::nodes::items::ITEM_ACCEPTOR_ASPECT_ALIAS_INFO;
+	Aspect, AspectIdentifier,
-use crate::nodes::items::ITEM_ASPECT_ALIAS_INFO;
+	items::{ITEM_ACCEPTOR_ASPECT_ALIAS_INFO, ITEM_ASPECT_ALIAS_INFO, ITEM_UI_ASPECT_ALIAS_INFO},
-use crate::nodes::{Aspect, AspectIdentifier};
+};
 use crate::{
 	core::{
 		client::{Client, INTERNAL_CLIENT, get_env, state},
+		error::Result,
 		registry::Registry,
 	},
 	nodes::{
@@ -23,7 +24,7 @@ use mint::Vector2;
 use parking_lot::Mutex;
 use slotmap::{DefaultKey, Key, KeyData, SlotMap};
 use std::sync::{Arc, Weak};
-use tracing::{debug, info};
+use tracing::debug;
 
 stardust_xr_server_codegen::codegen_item_panel_protocol!();
 impl Default for Geometry {
@@ -34,6 +35,7 @@ impl Default for Geometry {
 		}
 	}
 }
+impl Copy for Geometry {}
 
 lazy_static! {
 	pub static ref KEYMAPS: Mutex<SlotMap<DefaultKey, String>> = Mutex::new(SlotMap::default());
@@ -97,11 +99,13 @@ pub trait PanelItemTrait: Send + Sync + 'static {
 	fn send_acceptor_item_created(&self, node: &Node, item: &Arc<Node>);
 }
 
+#[derive(Debug)]
 pub struct PanelItem<B: Backend> {
 	pub node: Weak<Node>,
 	pub backend: Box<B>,
 }
 impl<B: Backend> PanelItem<B> {
+	#[cfg_attr(not(feature = "wayland"), allow(dead_code))]
 	pub fn create(backend: Box<B>, pid: Option<i32>) -> (Arc<Node>, Arc<PanelItem<B>>) {
 		debug!(?pid, "Create panel item");
 
@@ -459,12 +463,6 @@ impl<B: Backend> PanelItemTrait for PanelItem<B> {
 		let _ = panel_item_acceptor_client::capture_item(node, item, init_data);
 	}
 }
-impl<B: Backend> Drop for PanelItem<B> {
-	fn drop(&mut self) {
-		// Dropped panel item, basically just a debug breakpoint place
-		info!("Dropped panel item");
-	}
-}
 
 impl InterfaceAspect for Interface {
 	#[doc = "Register this client to manage the items of a certain type and create default 3D UI for them."]

src/nodes/mod.rs

@@ -126,18 +126,16 @@ impl Node {
 	pub fn enabled(&self) -> bool {
 		self.enabled.load(Ordering::Relaxed)
 			&& if let Ok(spatial) = self.get_aspect::<Spatial>() {
-				spatial
+				spatial.visible()
-					.global_transform()
-					.to_scale_rotation_translation()
-					.0
-					.length_squared()
-					> 0.0
 			} else {
 				true
 			}
 	}
 	pub fn set_enabled(&self, enabled: bool) {
-		self.enabled.store(enabled, Ordering::Relaxed)
+		self.enabled.store(enabled, Ordering::Relaxed);
+		if let Ok(spatial) = self.get_aspect::<Spatial>() {
+			spatial.mark_dirty();
+		}
 	}
 	pub fn destroy(&self) {
 		if let Some(client) = self.get_client() {
@@ -177,7 +175,7 @@ impl Node {
 		message: Message,
 	) -> Result<(), ScenegraphError> {
 		if let Ok(alias) = self.get_aspect::<Alias>() {
-			if !alias.info.server_signals.iter().any(|e| *e == method) {
+			if !alias.info.server_signals.contains(&method) {
 				return Err(ScenegraphError::MemberNotFound);
 			}
 			alias
@@ -208,12 +206,12 @@ impl Node {
 		response: MethodResponseSender,
 	) {
 		if let Ok(alias) = self.get_aspect::<Alias>() {
-			if !alias.info.server_methods.iter().any(|e| *e == method) {
+			if !alias.info.server_methods.contains(&method) {
-				response.send(Err(ScenegraphError::MemberNotFound));
+				response.send_err(ScenegraphError::MemberNotFound);
 				return;
 			}
 			let Some(alias) = alias.original.upgrade() else {
-				response.send(Err(ScenegraphError::BrokenAlias));
+				response.send_err(ScenegraphError::BrokenAlias);
 				return;
 			};
 			alias.execute_local_method(
@@ -228,7 +226,7 @@ impl Node {
 			)
 		} else {
 			let Some(aspect) = self.aspects.0.get(&aspect_id).map(|v| v.clone()) else {
-				response.send(Err(ScenegraphError::AspectNotFound));
+				response.send_err(ScenegraphError::AspectNotFound);
 				return;
 			};
 			aspect.run_method(calling_client, self.clone(), method, message, response);
@@ -303,7 +301,6 @@ pub trait AspectIdentifier: Aspect {
 	const ID: u64;
 }
 pub trait Aspect: Any + Send + Sync + 'static {
-	fn as_any(self: Arc<Self>) -> Arc<dyn Any + Send + Sync + 'static>;
 	fn run_signal(
 		&self,
 		calling_client: Arc<Client>,
@@ -337,7 +334,6 @@ impl Aspects {
 			.get(&A::ID)
 			// .cloned doesn't work for some reason
 			.map(|v| v.clone())
-			.map(|a| a.as_any())
 			.and_then(|a| Arc::downcast(a).ok())
 			.ok_or(ServerError::NoAspect(TypeId::of::<A>()))
 	}

src/nodes/spatial/mod.rs

@@ -6,18 +6,83 @@ use super::fields::{Field, FieldTrait};
 use super::{Aspect, AspectIdentifier};
 use crate::bail;
 use crate::core::client::Client;
+use crate::core::entity_handle::EntityHandle;
 use crate::core::error::Result;
 use crate::core::registry::Registry;
 use crate::nodes::{Node, OWNED_ASPECT_ALIAS_INFO};
+use bevy::ecs::entity::EntityHashMap;
+use bevy::prelude::Transform as BevyTransform;
+use bevy::prelude::*;
+use bevy::render::primitives::Aabb;
 use color_eyre::eyre::OptionExt;
 use glam::{Mat4, Quat, Vec3, vec3a};
 use mint::Vector3;
-use parking_lot::Mutex;
+use parking_lot::{Mutex, RwLock};
 use rustc_hash::FxHashMap;
 use std::fmt::Debug;
+use std::pin::Pin;
+use std::sync::atomic::Ordering;
 use std::sync::{Arc, OnceLock, Weak};
 use std::{f32, ptr};
-use stereokit_rust::maths::Bounds;
+
+pub struct SpatialNodePlugin;
+impl Plugin for SpatialNodePlugin {
+	fn build(&self, app: &mut App) {
+		app.add_systems(
+			PostUpdate,
+			(spawn_spatial_nodes, update_spatial_nodes)
+				.chain()
+				.before(TransformSystem::TransformPropagate),
+		);
+	}
+}
+
+fn spawn_spatial_nodes(mut cmds: Commands) {
+	for spatial in SPATIAL_REGISTRY
+		.get_valid_contents()
+		.into_iter()
+		.filter(|v| v.entity.read().is_none())
+	{
+		let entity = cmds
+			.spawn((SpatialNode(Arc::downgrade(&spatial)), Name::new("Spatial")))
+			.id();
+		spatial.set_entity(EntityHandle::new(entity));
+	}
+}
+
+fn update_spatial_nodes(
+	mut query: Query<(&mut BevyTransform, &mut Visibility, Option<&ChildOf>)>,
+	mut cmds: Commands,
+) {
+	for (entity, (transform, parent_entity)) in UPDATED_SPATIALS_NODES.lock().drain() {
+		let _span = debug_span!("updating spatial node").entered();
+		let Ok((mut bevy_transform, mut vis, parent)) = query.get_mut(entity) else {
+			continue;
+		};
+		// Set visibility based on node enabled state
+		if let Some(transform) = transform {
+			*vis = Visibility::Inherited;
+			*bevy_transform = transform;
+		} else {
+			*vis = Visibility::Hidden;
+		}
+
+		if parent.map(|v| v.0) != parent_entity {
+			match parent_entity {
+				Some(e) => cmds.entity(entity).insert(ChildOf(e)),
+				None => cmds.entity(entity).remove::<ChildOf>(),
+			};
+		}
+	}
+}
+
+static SPATIAL_REGISTRY: Registry<Spatial> = Registry::new();
+
+#[derive(Clone, Component, Debug)]
+#[require(BevyTransform, Visibility)]
+pub struct SpatialNode(pub Weak<Spatial>);
+
+const EPSILON: f32 = 0.00001;
 
 stardust_xr_server_codegen::codegen_spatial_protocol!();
 impl Transform {
@@ -30,9 +95,16 @@ impl Transform {
 			.then_some(self.rotation)
 			.flatten()
 			.unwrap_or_else(|| Quat::IDENTITY.into());
+
+		// Zero scale values break everything
 		let scale = scale
 			.then_some(self.scale)
 			.flatten()
+			.map(|s| Vector3 {
+				x: if s.x == 0.0 { EPSILON } else { s.x },
+				y: if s.y == 0.0 { EPSILON } else { s.y },
+				z: if s.z == 0.0 { EPSILON } else { s.z },
+			})
 			.unwrap_or_else(|| Vector3::from([1.0; 3]));
 
 		Mat4::from_scale_rotation_translation(scale.into(), rotation.into(), position.into())
@@ -46,32 +118,47 @@ impl Aspect for Zone {
 }
 
 lazy_static::lazy_static! {
-	pub static ref EXPORTED_SPATIALS: Mutex<FxHashMap<u64, Arc<Node>>> = Mutex::new(FxHashMap::default());
+	pub static ref EXPORTED_SPATIALS: Mutex<FxHashMap<u64, Weak<Node>>> = Mutex::new(FxHashMap::default());
 }
 
 static ZONEABLE_REGISTRY: Registry<Spatial> = Registry::new();
 
 pub struct Spatial {
 	pub node: Weak<Node>,
-	parent: Mutex<Option<Arc<Spatial>>>,
+	entity: RwLock<Option<EntityHandle>>,
-	old_parent: Mutex<Option<Arc<Spatial>>>,
+	parent: RwLock<Option<Arc<Spatial>>>,
-	transform: Mutex<Mat4>,
+	old_parent: RwLock<Option<Arc<Spatial>>>,
-	zone: Mutex<Weak<Zone>>,
+	transform: RwLock<Mat4>,
+	zone: RwLock<Weak<Zone>>,
 	children: Registry<Spatial>,
-	pub bounding_box_calc: OnceLock<fn(&Node) -> Bounds>,
+	pub bounding_box_calc:
+		OnceLock<for<'a> fn(&'a Node) -> Pin<Box<dyn Future<Output = Aabb> + 'a + Send + Sync>>>,
 }
 
 impl Spatial {
 	pub fn new(node: Weak<Node>, parent: Option<Arc<Spatial>>, transform: Mat4) -> Arc<Self> {
-		Arc::new(Spatial {
+		let spatial = SPATIAL_REGISTRY.add(Spatial {
 			node,
-			parent: Mutex::new(parent),
+			entity: RwLock::new(None),
-			old_parent: Mutex::new(None),
+			parent: RwLock::new(parent),
-			transform: Mutex::new(transform),
+			old_parent: RwLock::new(None),
-			zone: Mutex::new(Weak::new()),
+			transform: RwLock::new(transform),
+			zone: RwLock::new(Weak::new()),
 			children: Registry::new(),
 			bounding_box_calc: OnceLock::default(),
-		})
+		});
+		spatial.mark_dirty();
+		spatial
+	}
+	pub fn set_entity(&self, entity: EntityHandle) {
+		self.entity.write().replace(entity);
+		self.mark_dirty();
+		for child in self.children.get_valid_contents() {
+			child.mark_dirty();
+		}
+	}
+	pub fn get_entity(&self) -> Option<Entity> {
+		self.entity.read().as_ref().map(|v| v.get())
 	}
 	pub fn add_to(
 		node: &Arc<Node>,
@@ -102,23 +189,68 @@ impl Spatial {
 	}
 
 	// the output bounds are probably way bigger than they need to be
-	pub fn get_bounding_box(&self) -> Bounds {
+	pub async fn get_bounding_box(&self) -> Aabb {
 		let Some(node) = self.node() else {
-			return Bounds::default();
+			return Aabb::default();
+		};
+		let mut bounds = match self.bounding_box_calc.get() {
+			Some(f) => f(&node).await,
+			None => Aabb::default(),
 		};
-		let mut bounds = self
-			.bounding_box_calc
-			.get()
-			.map(|b| (b)(&node))
-			.unwrap_or_default();
 		for child in self.children.get_valid_contents() {
-			bounds.grown_box(child.get_bounding_box(), child.local_transform());
+			let mat = child.local_transform();
+			let child_aabb = Box::pin(child.get_bounding_box()).await;
+			bounds = Aabb::enclosing([
+				bounds.min().into(),
+				bounds.max().into(),
+				mat.transform_point3(child_aabb.min().into()),
+				mat.transform_point3(child_aabb.max().into()),
+			])
+			.unwrap();
 		}
 		bounds
 	}
+	pub(super) fn mark_dirty(&self) {
+		let Some(entity) = self.entity.read().as_ref().map(|v| v.get()) else {
+			return;
+		};
+		let enabled = self
+			.node()
+			.is_none_or(|n| n.enabled.load(Ordering::Relaxed))
+			&& self.local_visible();
+		let transform = enabled.then(|| BevyTransform::from_matrix(self.local_transform()));
+		let parent = self
+			.get_parent()
+			.and_then(|v| v.entity.read().as_ref().map(|v| v.get()));
+		UPDATED_SPATIALS_NODES
+			.lock()
+			.insert(entity, (transform, parent));
+	}
 
 	pub fn local_transform(&self) -> Mat4 {
-		*self.transform.lock()
+		*self.transform.read()
+	}
+
+	fn local_visible(&self) -> bool {
+		// Check our own scale by looking at matrix column lengths
+		let mat = self.local_transform();
+		let x_scale = mat.x_axis.length_squared();
+		let y_scale = mat.y_axis.length_squared();
+		let z_scale = mat.z_axis.length_squared();
+
+		x_scale >= EPSILON.powi(2) || y_scale >= EPSILON.powi(2) || z_scale >= EPSILON.powi(2)
+	}
+	/// Check if this node or any ancestor has zero scale (for visibility culling)
+	pub fn visible(&self) -> bool {
+		// Check parent chain
+		if let Some(parent) = self.get_parent()
+			&& !parent.visible()
+		{
+			return false;
+		}
+
+		// Check our own scale by looking at matrix column lengths
+		self.local_visible()
 	}
 	pub fn global_transform(&self) -> Mat4 {
 		let parent_transform = self
@@ -129,7 +261,8 @@ impl Spatial {
 		parent_transform * self.local_transform()
 	}
 	pub fn set_local_transform(&self, transform: Mat4) {
-		*self.transform.lock() = transform;
+		*self.transform.write() = transform;
+		self.mark_dirty();
 	}
 	pub fn set_local_transform_components(
 		&self,
@@ -137,9 +270,7 @@ impl Spatial {
 		transform: Transform,
 	) {
 		if reference_space == Some(self) {
-			self.set_local_transform(
+			self.set_local_transform(transform.to_mat4(true, true, true) * self.local_transform());
-				parse_transform(transform, true, true, true) * self.local_transform(),
-			);
 			return;
 		}
 		let reference_to_parent_transform = reference_space
@@ -190,7 +321,7 @@ impl Spatial {
 	}
 
 	fn get_parent(&self) -> Option<Arc<Spatial>> {
-		self.parent.lock().clone()
+		self.parent.read().clone()
 	}
 	fn set_parent(self: &Arc<Self>, new_parent: &Arc<Spatial>) {
 		if let Some(parent) = self.get_parent() {
@@ -198,7 +329,8 @@ impl Spatial {
 		}
 		new_parent.children.add_raw(self);
 
-		*self.parent.lock() = Some(new_parent.clone());
+		*self.parent.write() = Some(new_parent.clone());
+		self.mark_dirty();
 	}
 
 	pub fn set_spatial_parent(self: &Arc<Self>, parent: &Arc<Spatial>) -> Result<()> {
@@ -222,13 +354,15 @@ impl Spatial {
 
 	pub(self) fn zone_distance(&self) -> f32 {
 		self.zone
-			.lock()
+			.read()
 			.upgrade()
 			.map(|zone| zone.field.clone())
 			.map(|field| field.distance(self, vec3a(0.0, 0.0, 0.0)))
 			.unwrap_or(f32::NEG_INFINITY)
 	}
 }
+static UPDATED_SPATIALS_NODES: Mutex<EntityHashMap<(Option<BevyTransform>, Option<Entity>)>> =
+	Mutex::new(EntityHashMap::new());
 impl AspectIdentifier for Spatial {
 	impl_aspect_for_spatial_aspect_id! {}
 }
@@ -296,7 +430,7 @@ impl SpatialAspect for Spatial {
 	// legit gotta find a way to remove old ones, this just keeps the node alive
 	async fn export_spatial(node: Arc<Node>, _calling_client: Arc<Client>) -> Result<u64> {
 		let id = rand::random();
-		EXPORTED_SPATIALS.lock().insert(id, node);
+		EXPORTED_SPATIALS.lock().insert(id, Arc::downgrade(&node));
 		Ok(id)
 	}
 }
@@ -318,6 +452,7 @@ impl Drop for Spatial {
 	fn drop(&mut self) {
 		zone::release(self);
 		ZONEABLE_REGISTRY.remove(self);
+		SPATIAL_REGISTRY.remove(self);
 	}
 }
 
@@ -334,11 +469,11 @@ impl SpatialRefAspect for SpatialRef {
 		_calling_client: Arc<Client>,
 	) -> Result<BoundingBox> {
 		let this_spatial = node.get_aspect::<Spatial>()?;
-		let bounds = this_spatial.get_bounding_box();
+		let bounds = this_spatial.get_bounding_box().await;
 
 		Ok(BoundingBox {
 			center: Vec3::from(bounds.center).into(),
-			size: Vec3::from(bounds.dimensions).into(),
+			size: Vec3::from(bounds.half_extents * 2.0).into(),
 		})
 	}
 
@@ -349,20 +484,17 @@ impl SpatialRefAspect for SpatialRef {
 	) -> 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))
+		let mat = Spatial::space_to_space_matrix(Some(&this_spatial), Some(&relative_spatial));
-			.transform_point3([0.0; 3].into());
+		let bb = this_spatial.get_bounding_box().await;
-		let mut bounds = Bounds {
+		let bounds = Aabb::enclosing([
-			center: center.into(),
+			mat.transform_point3(bb.min().into()),
-			dimensions: [0.0; 3].into(),
+			mat.transform_point3(bb.max().into()),
-		};
+		])
-		bounds.grown_box(
+		.unwrap();
-			this_spatial.get_bounding_box(),
-			Spatial::space_to_space_matrix(Some(&this_spatial), Some(&relative_spatial)),
-		);
 
 		Ok(BoundingBox {
 			center: Vec3::from(bounds.center).into(),
-			size: Vec3::from(bounds.dimensions).into(),
+			size: Vec3::from(bounds.half_extents * 2.0).into(),
 		})
 	}
 
@@ -388,23 +520,6 @@ impl SpatialRefAspect for SpatialRef {
 	}
 }
 
-pub fn parse_transform(transform: Transform, position: bool, rotation: bool, scale: bool) -> Mat4 {
-	let position = position
-		.then_some(transform.translation)
-		.flatten()
-		.unwrap_or_else(|| Vector3::from([0.0; 3]));
-	let rotation = rotation
-		.then_some(transform.rotation)
-		.flatten()
-		.unwrap_or_else(|| Quat::IDENTITY.into());
-	let scale = scale
-		.then_some(transform.scale)
-		.flatten()
-		.unwrap_or_else(|| Vector3::from([1.0; 3]));
-
-	Mat4::from_scale_rotation_translation(scale.into(), rotation.into(), position.into())
-}
-
 impl InterfaceAspect for Interface {
 	fn create_spatial(
 		_node: Arc<Node>,
@@ -415,7 +530,7 @@ impl InterfaceAspect for Interface {
 		zoneable: bool,
 	) -> Result<()> {
 		let parent = parent.get_aspect::<Spatial>()?;
-		let transform = parse_transform(transform, true, true, true);
+		let transform = transform.to_mat4(true, true, true);
 		let node = Node::from_id(&calling_client, id, true).add_to_scenegraph()?;
 		Spatial::add_to(&node, Some(parent.clone()), transform, zoneable);
 		Ok(())
@@ -429,7 +544,7 @@ impl InterfaceAspect for Interface {
 		field: Arc<Node>,
 	) -> Result<()> {
 		let parent = parent.get_aspect::<Spatial>()?;
-		let transform = parse_transform(transform, true, true, false);
+		let transform = transform.to_mat4(true, true, false);
 		let field = field.get_aspect::<Field>()?;
 
 		let node = Node::from_id(&calling_client, id, true).add_to_scenegraph()?;
@@ -446,9 +561,10 @@ impl InterfaceAspect for Interface {
 		Ok(EXPORTED_SPATIALS
 			.lock()
 			.get(&uid)
+			.and_then(|s| s.upgrade())
 			.map(|s| {
 				Alias::create(
-					s,
+					&s,
 					&calling_client,
 					SPATIAL_REF_ASPECT_ALIAS_INFO.clone(),
 					None,

src/nodes/spatial/zone.rs

@@ -21,8 +21,8 @@ pub fn capture(spatial: &Arc<Spatial>, zone: &Arc<Zone>) {
 	}
 
 	release(spatial);
-	*spatial.old_parent.lock() = spatial.get_parent();
+	*spatial.old_parent.write() = spatial.get_parent();
-	*spatial.zone.lock() = Arc::downgrade(zone);
+	*spatial.zone.write() = Arc::downgrade(zone);
 	let Some(zone_node) = zone.spatial.node.upgrade() else {
 		return;
 	};
@@ -45,11 +45,11 @@ pub fn release(spatial: &Spatial) {
 	};
 	let spatial = spatial_node.get_aspect::<Spatial>().unwrap();
 
-	let Some(old_parent) = spatial.old_parent.lock().take() else {
+	let Some(old_parent) = spatial.old_parent.read().clone() else {
 		return;
 	};
 	let _ = spatial.set_spatial_parent_in_place(&old_parent);
-	let mut spatial_zone = spatial.zone.lock();
+	let mut spatial_zone = spatial.zone.write();
 
 	if let Some(spatial_zone) = spatial_zone.upgrade() {
 		spatial_zone.captured.remove_aspect(spatial.as_ref());

src/objects/hmd.rs

@@ -0,0 +1,109 @@
+use std::sync::Arc;
+
+use bevy::prelude::*;
+use bevy_mod_openxr::{
+	helper_traits::{ToQuat as _, ToVec3 as _},
+	resources::{OxrFrameState, Pipelined},
+	session::OxrSession,
+};
+use bevy_mod_xr::{
+	session::{XrPreDestroySession, XrSessionCreated, session_running},
+	spaces::{XrPrimaryReferenceSpace, XrSpace},
+};
+use openxr::SpaceLocationFlags;
+
+use crate::{DbusConnection, PreFrameWait, get_time, nodes::spatial::Spatial};
+
+use super::{ObjectHandle, SpatialRef, input::mouse_pointer::FlatscreenCam};
+
+pub struct HmdPlugin;
+impl Plugin for HmdPlugin {
+	fn build(&self, app: &mut App) {
+		app.add_systems(XrPreDestroySession, destroy_view_space);
+		app.add_systems(XrSessionCreated, create_view_space);
+		app.add_systems(PreFrameWait, update_xr.run_if(session_running));
+		app.add_systems(PreFrameWait, update_flat.run_if(not(session_running)));
+		app.add_systems(Startup, setup);
+	}
+}
+
+fn setup(connection: Res<DbusConnection>, mut cmds: Commands) {
+	let (spatial, _spatial_handle) = SpatialRef::create(&connection, "/org/stardustxr/HMD");
+	let hmd = Hmd {
+		spatial,
+		_spatial_handle,
+		space: None,
+	};
+	cmds.insert_resource(hmd);
+}
+
+fn create_view_space(session: Res<OxrSession>, mut hmd: ResMut<Hmd>) {
+	let space = session
+		.create_reference_space(openxr::ReferenceSpaceType::VIEW, Transform::IDENTITY)
+		.inspect_err(|err| error!("failed to create View XrSpace"))
+		.ok();
+	hmd.space = space.map(|v| v.0);
+}
+fn destroy_view_space(session: Res<OxrSession>, mut cmds: Commands, mut hmd: ResMut<Hmd>) {
+	let Some(space) = hmd.space.take() else {
+		return;
+	};
+	session.destroy_space(space);
+}
+
+#[derive(Resource)]
+struct Hmd {
+	spatial: Arc<Spatial>,
+	_spatial_handle: ObjectHandle<SpatialRef>,
+	space: Option<XrSpace>,
+}
+
+fn update_flat(cam: Single<&GlobalTransform, With<FlatscreenCam>>, hmd: Res<Hmd>) {
+	// this shouldn't be parented to anything, so global and local spaces should be the same
+	hmd.spatial.set_local_transform(cam.compute_matrix());
+}
+
+fn update_xr(
+	session: Option<Res<OxrSession>>,
+	ref_space: Option<Res<XrPrimaryReferenceSpace>>,
+	hmd: Res<Hmd>,
+	state: Option<Res<OxrFrameState>>,
+	pipelined: Option<Res<Pipelined>>,
+) {
+	let (Some(session), Some(view), Some(ref_space), Some(state)) =
+		(session, hmd.space, ref_space, state)
+	else {
+		// tokio::task::spawn({
+		// 	let handle = hmd.tracked_handle.clone();
+		// 	async move {
+		// 		handle.set_tracked(false);
+		// 	}
+		// });
+		return;
+	};
+	let time = get_time(pipelined.is_some(), &state);
+	let location = session
+		.locate_space(&view, &ref_space, time)
+		.inspect_err(|err| error!("Error while Locating OpenXR Stage Space {err}"));
+	if let Ok(location) = location {
+		let is_tracked = location
+			.location_flags
+			.contains(SpaceLocationFlags::POSITION_VALID | SpaceLocationFlags::POSITION_TRACKED)
+			|| location.location_flags.contains(
+				SpaceLocationFlags::ORIENTATION_VALID | SpaceLocationFlags::ORIENTATION_TRACKED,
+			);
+		// tokio::task::spawn({
+		// 	let handle = play_space.tracked_handle.clone();
+		// 	async move {
+		// 		handle.set_tracked(is_tracked);
+		// 	}
+		// });
+		if is_tracked {
+			hmd.spatial
+				.set_local_transform(Mat4::from_rotation_translation(
+					location.pose.orientation.to_quat(),
+					location.pose.position.to_vec3(),
+				));
+		}
+	}
+}

src/objects/input/eye_pointer.rs

@@ -12,7 +12,6 @@ use glam::{Mat4, vec3};
 use serde::{Deserialize, Serialize};
 use stardust_xr::values::Datamap;
 use std::sync::Arc;
-use stereokit_rust::system::Input;
 
 #[derive(Default, Deserialize, Serialize)]
 pub struct EyeDatamap {
@@ -49,58 +48,4 @@ impl EyePointer {
 			pointer,
 		})
 	}
-	pub fn update(&self) {
-		let ray = Input::get_eyes();
-		self.spatial
-			.set_local_transform(Mat4::from_rotation_translation(
-				ray.orientation.into(),
-				ray.position.into(),
-			));
-		{
-			// Set pointer input datamap
-			*self.pointer.datamap.lock() = Datamap::from_typed(EyeDatamap { eye: 2 }).unwrap();
-		}
-
-		// send input to all the input handlers that are the closest to the ray as possible
-		let rx = INPUT_HANDLER_REGISTRY
-			.get_valid_contents()
-			.into_iter()
-			// filter out all the disabled handlers
-			.filter(|handler| {
-				let Some(node) = handler.spatial.node() else {
-					return false;
-				};
-				node.enabled()
-			})
-			// ray march to all the enabled handlers' fields
-			.map(|handler| {
-				let result = handler.field.ray_march(Ray {
-					origin: vec3(0.0, 0.0, 0.0),
-					direction: vec3(0.0, 0.0, -1.0),
-					space: self.spatial.clone(),
-				});
-				(vec![handler], result)
-			})
-			// make sure the field isn't at the pointer origin and that it's being hit
-			.filter(|(_, result)| result.deepest_point_distance > 0.01 && result.min_distance < 0.0)
-			// .inspect(|(_, result)| {
-			// 	dbg!(result);
-			// })
-			// now collect all handlers that are same distance if they're the closest
-			.reduce(|(mut handlers_a, result_a), (handlers_b, result_b)| {
-				if (result_a.deepest_point_distance - result_b.deepest_point_distance).abs() < 0.001
-				{
-					// distance is basically the same
-					handlers_a.extend(handlers_b);
-					(handlers_a, result_a)
-				} else if result_a.deepest_point_distance < result_b.deepest_point_distance {
-					(handlers_a, result_a)
-				} else {
-					(handlers_b, result_b)
-				}
-			})
-			.map(|(rx, _)| rx)
-			.unwrap_or_default();
-		self.pointer.set_handler_order(rx.iter());
-	}
 }

src/objects/input/mod.rs

@@ -1,7 +1,7 @@
 pub mod eye_pointer;
 pub mod mouse_pointer;
-pub mod sk_controller;
+pub mod oxr_controller;
-pub mod sk_hand;
+pub mod oxr_hand;
 
 use crate::nodes::{
 	fields::{Field, FieldTrait, Ray},
@@ -20,14 +20,13 @@ pub struct CaptureManager {
 }
 impl CaptureManager {
 	pub fn update_capture(&mut self, method: &InputMethod) {
-		if let Some(capture) = &self.capture.upgrade() {
+		if let Some(capture) = &self.capture.upgrade()
-			if !method
+			&& !method
 				.capture_attempts
 				.get_valid_contents()
 				.contains(capture)
-			{
+		{
-				self.capture = Weak::new();
+			self.capture = Weak::new();
-			}
 		}
 	}
 	pub fn set_new_capture(

src/objects/input/mouse_pointer.rs

@@ -1,6 +1,7 @@
 use super::{CaptureManager, DistanceCalculator, get_sorted_handlers};
 use crate::{
-	core::client::INTERNAL_CLIENT,
+	DbusConnection, ObjectRegistryRes,
+	core::{client::INTERNAL_CLIENT, task},
 	nodes::{
 		Node, OwnedNode,
 		fields::{EXPORTED_FIELDS, Field, FieldTrait, Ray},
@@ -8,23 +9,144 @@ use crate::{
 		items::panel::KEYMAPS,
 		spatial::Spatial,
 	},
+	objects::FieldRef,
+};
+use bevy::{
+	input::{
+		ButtonState,
+		keyboard::{KeyboardInput, NativeKey, NativeKeyCode},
+		mouse::{MouseMotion, MouseWheel},
+	},
+	prelude::*,
+	window::PrimaryWindow,
 };
 use color_eyre::eyre::Result;
+use dashmap::DashMap;
 use glam::{Mat4, Vec3, vec3};
 use mint::Vector2;
+use rustc_hash::{FxHashMap, FxHasher};
 use serde::{Deserialize, Serialize};
 use slotmap::{DefaultKey, Key as SlotKey};
 use stardust_xr::{
-	schemas::dbus::{interfaces::FieldRefProxy, object_registry::ObjectRegistry},
+	schemas::dbus::{
+		ObjectInfo,
+		interfaces::FieldRefProxy,
+		list_query::{ListEvent, ObjectListQuery},
+		object_registry::ObjectRegistry,
+		query::{ObjectQuery, QueryContext, QueryEvent},
+	},
 	values::Datamap,
 };
-use std::sync::Arc;
+use std::sync::{Arc, Weak};
-use stereokit_rust::system::{Input, Key};
+use tokio::sync::{Notify, mpsc, watch};
-use tokio::task::JoinSet;
+use tokio::task::{AbortHandle, JoinSet};
 use tokio::time::{Duration, timeout};
 use xkbcommon_rs::{Context, Keymap, KeymapFormat, xkb_keymap::CompileFlags};
 use zbus::{Connection, names::OwnedInterfaceName};
 
+#[derive(Clone)]
+struct HandlerInfo {
+	handler: ObjectInfo,
+	field_ref: Arc<Field>,
+	keyboard_proxy: KeyboardHandlerProxy<'static>,
+}
+
+#[derive(Debug, Clone)]
+struct InputEvent {
+	key: u32,
+	pressed: bool,
+}
+
+pub struct FlatscreenInputPlugin;
+impl Plugin for FlatscreenInputPlugin {
+	fn build(&self, app: &mut App) {
+		app.add_systems(Startup, setup);
+		// yes the input method will be delayed by one frame, its only for debugging anyways
+		app.add_systems(Update, update_pointer);
+	}
+}
+
+#[derive(Component)]
+#[require(Camera3d)]
+pub struct FlatscreenCam;
+
+fn setup(mut cmds: Commands, object_registry: Res<ObjectRegistryRes>) {
+	let Ok(pointer) = MousePointer::new(object_registry.0.clone())
+		.inspect_err(|err| error!("unable to create mouse pointer: {err}"))
+	else {
+		return;
+	};
+	cmds.spawn((FlatscreenCam, Name::new("Flatscreen Camera")));
+	cmds.insert_resource(pointer);
+}
+
+fn update_pointer(
+	window: Single<(&Window), With<PrimaryWindow>>,
+	mut cam: Single<(&Camera, &GlobalTransform, &mut Transform), With<FlatscreenCam>>,
+	mut pointer: ResMut<MousePointer>,
+	connection: Res<DbusConnection>,
+	object_registry: Res<ObjectRegistryRes>,
+	mouse_buttons: Res<ButtonInput<MouseButton>>,
+	keyboard_buttons: Res<ButtonInput<KeyCode>>,
+	mut scroll: EventReader<MouseWheel>,
+	mut motion: EventReader<MouseMotion>,
+	mut keyboard_input_events: EventReader<KeyboardInput>,
+	time: Res<Time>,
+) {
+	let (cam, cam_transform, mut cam_local_transform) = cam.into_inner();
+	if keyboard_buttons.pressed(KeyCode::ShiftLeft) && mouse_buttons.pressed(MouseButton::Right) {
+		let (mut yaw, mut pitch, _) = cam_local_transform.rotation.to_euler(EulerRot::YXZ);
+
+		for e in motion.read() {
+			let scale = -0.003;
+			pitch += e.delta.y * scale;
+			yaw += e.delta.x * scale;
+		}
+
+		cam_local_transform.rotation = Quat::from_rotation_y(yaw) * Quat::from_rotation_x(pitch);
+
+		let mut move_vec = Vec3::ZERO;
+		move_vec.x += keyboard_buttons.pressed(KeyCode::KeyD) as u32 as f32;
+		move_vec.x -= keyboard_buttons.pressed(KeyCode::KeyA) as u32 as f32;
+		move_vec.z += keyboard_buttons.pressed(KeyCode::KeyS) as u32 as f32;
+		move_vec.z -= keyboard_buttons.pressed(KeyCode::KeyW) as u32 as f32;
+		move_vec.y += keyboard_buttons.pressed(KeyCode::KeyE) as u32 as f32;
+		move_vec.y -= keyboard_buttons.pressed(KeyCode::KeyQ) as u32 as f32;
+
+		let move_vec = cam_local_transform.rotation * move_vec.normalize_or_zero();
+		cam_local_transform.translation += move_vec * time.delta_secs() * 3.0;
+
+		return;
+	}
+	let Some(ray) = window
+		.cursor_position()
+		.and_then(|pos| get_viewport_pos(pos, cam))
+		.and_then(|pos| cam.viewport_to_world(cam_transform, pos).ok())
+	else {
+		return;
+	};
+	pointer.update(
+		&connection,
+		&object_registry,
+		ray,
+		&mouse_buttons,
+		&keyboard_buttons,
+		scroll,
+		keyboard_input_events,
+	);
+}
+
+fn get_viewport_pos(logical_pos: Vec2, cam: &Camera) -> Option<Vec2> {
+	if let Some(viewport_rect) = cam.logical_viewport_rect() {
+		if !viewport_rect.contains(logical_pos) {
+			return None;
+		}
+		Some(logical_pos - viewport_rect.min)
+	} else {
+		Some(logical_pos)
+	}
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 struct MouseEvent {
 	select: f32,
@@ -59,7 +181,15 @@ trait KeyboardHandler {
 	async fn reset(&self) -> zbus::Result<()>;
 }
 
-#[allow(unused)]
+// Make KeyboardHandlerProxy queryable
+stardust_xr::schemas::impl_queryable_for_proxy!(KeyboardHandlerProxy);
+
+// Query context for keyboard handlers
+#[derive(Debug, Clone)]
+struct KeyboardQueryContext;
+impl QueryContext for KeyboardQueryContext {}
+
+#[derive(Resource)]
 pub struct MousePointer {
 	node: OwnedNode,
 	keymap: DefaultKey,
@@ -67,9 +197,16 @@ pub struct MousePointer {
 	pointer: Arc<InputMethod>,
 	capture_manager: CaptureManager,
 	mouse_datamap: MouseEvent,
+	// Task management
+	focus_task_abort_handle: AbortHandle,
+	input_delivery_task_abort_handle: AbortHandle,
+	// Channels
+	input_event_tx: mpsc::UnboundedSender<InputEvent>,
+	// Notification for focus recalculation
+	focus_notify: Arc<Notify>,
 }
 impl MousePointer {
-	pub fn new() -> Result<Self> {
+	pub fn new(object_registry: Arc<ObjectRegistry>) -> Result<Self> {
 		let node = Node::generate(&INTERNAL_CLIENT, false).add_to_scenegraph_owned()?;
 		let spatial = Spatial::add_to(&node.0, None, Mat4::IDENTITY, false);
 		let pointer = InputMethod::add_to(
@@ -86,6 +223,39 @@ impl MousePointer {
 				.unwrap(),
 		);
 
+		// Create channels and notification
+		let (focused_handler_tx, focused_handler_rx) = watch::channel::<Option<HandlerInfo>>(None);
+		let (input_event_tx, input_event_rx) = mpsc::unbounded_channel::<InputEvent>();
+		let focus_notify = Arc::new(Notify::new());
+		// Spawn input delivery task
+		info!("Creating input delivery task");
+		let input_delivery_task_abort_handle = task::new(
+			|| "Mouse pointer input delivery task",
+			Self::input_delivery_task(
+				object_registry.get_connection().clone(),
+				focused_handler_rx,
+				input_event_rx,
+				keymap.data().as_ffi(),
+			),
+		)?
+		.abort_handle();
+		info!("Input delivery task created successfully");
+
+		// Spawn focus tracking task
+		info!("Creating focus tracking task");
+		let focus_task_abort_handle = task::new(
+			|| "Mouse pointer focus task",
+			Self::focus_tracking_task(
+				object_registry,
+				focus_notify.clone(),
+				spatial.clone(),
+				pointer.clone(),
+				focused_handler_tx,
+			),
+		)?
+		.abort_handle();
+		info!("Focus tracking task created successfully");
+
 		Ok(MousePointer {
 			node,
 			spatial,
@@ -93,37 +263,86 @@ impl MousePointer {
 			capture_manager: CaptureManager::default(),
 			mouse_datamap: Default::default(),
 			keymap,
+			focus_task_abort_handle,
+			input_delivery_task_abort_handle,
+			input_event_tx,
+			focus_notify,
 		})
 	}
-	pub fn update(&mut self, dbus_connection: &Connection, object_registry: &ObjectRegistry) {
+	pub fn update(
-		let mouse = Input::get_mouse();
+		&mut self,
+		dbus_connection: &Connection,
+		object_registry: &ObjectRegistry,
+		ray: Ray3d,
+		mouse_buttons: &ButtonInput<MouseButton>,
+		keyboard_buttons: &ButtonInput<KeyCode>,
+		mut scroll: EventReader<MouseWheel>,
+		mut keyboard_input_events: EventReader<KeyboardInput>,
+	) {
+		let mut discrete = Vec2::ZERO;
+		let mut continuous = Vec2::ZERO;
+		for e in scroll.read() {
+			match e.unit {
+				bevy::input::mouse::MouseScrollUnit::Line => {
+					discrete.x += e.x;
+					discrete.y += e.y;
+				}
+				bevy::input::mouse::MouseScrollUnit::Pixel => {
+					continuous.x += e.x;
+					continuous.y += e.y;
+				}
+			}
+		}
 
-		let ray = mouse.get_ray();
 		self.spatial.set_local_transform(
-			Mat4::look_to_rh(
+			Mat4::look_to_rh(ray.origin, Vec3::from(ray.direction), Vec3::Y).inverse(),
-				Vec3::from(ray.position),
-				Vec3::from(ray.direction),
-				vec3(0.0, 1.0, 0.0),
-			)
-			.inverse(),
 		);
 		{
 			// Set pointer input datamap
 			self.mouse_datamap = MouseEvent {
-				select: Input::key(Key::MouseLeft).is_active() as u32 as f32,
+				select: mouse_buttons.pressed(MouseButton::Left) as u32 as f32,
-				middle: Input::key(Key::MouseCenter).is_active() as u32 as f32,
+				middle: mouse_buttons.pressed(MouseButton::Middle) as u32 as f32,
-				context: Input::key(Key::MouseRight).is_active() as u32 as f32,
+				context: mouse_buttons.pressed(MouseButton::Right) as u32 as f32,
-				grab: (Input::key(Key::MouseRight).is_active()
+				grab: mouse_buttons.pressed(MouseButton::Right) as u32 as f32, // Was Mouse 5
-					|| (Input::key(Key::Backtick).is_active()
+				scroll_continuous: continuous.into(),
-						&& Input::key(Key::Shift).is_active())) as u32 as f32, // Was Mouse 5
+				scroll_discrete: discrete.into(),
-				scroll_continuous: [0.0, mouse.scroll_change / 120.0].into(),
+				raw_input_events: mouse_buttons
-				scroll_discrete: [0.0, mouse.scroll_change / 120.0].into(),
+					.get_pressed()
-				raw_input_events: vec![],
+					.map(|button| match button {
+						MouseButton::Left => input_event_codes::BTN_LEFT!(),
+						MouseButton::Right => input_event_codes::BTN_RIGHT!(),
+						MouseButton::Middle => input_event_codes::BTN_MIDDLE!(),
+						MouseButton::Back => input_event_codes::BTN_BACK!(),
+						MouseButton::Forward => input_event_codes::BTN_FORWARD!(),
+						MouseButton::Other(b) => *b as u32,
+					})
+					.collect(),
 			};
 			*self.pointer.datamap.lock() = Datamap::from_typed(&self.mouse_datamap).unwrap();
 		}
 		self.target_pointer_input();
-		self.send_keyboard_input(dbus_connection, object_registry);
+
+		// Send keyboard input events via channel
+		for event in keyboard_input_events.read() {
+			if let Some(key) = map_key(event.key_code) {
+				let input_event = InputEvent {
+					key,
+					pressed: matches!(event.state, ButtonState::Pressed),
+				};
+				info!(
+					"Sending keyboard input event: key={}, pressed={}",
+					key, input_event.pressed
+				);
+				if let Err(e) = self.input_event_tx.send(input_event) {
+					error!("Failed to send keyboard input event: {}", e);
+				}
+			} else {
+				warn!("Unable to map key code: {:?}", event.key_code);
+			}
+		}
+
+		// Notify focus tracking task to recalculate focus
+		self.focus_notify.notify_waiters();
 	}
 	fn target_pointer_input(&mut self) {
 		let distance_calculator: DistanceCalculator = |space, data, field| {
@@ -160,158 +379,211 @@ impl MousePointer {
 		);
 	}
 
-	pub fn send_keyboard_input(
+	async fn focus_tracking_task(
-		&mut self,
+		object_registry: Arc<ObjectRegistry>,
-		dbus_connection: &Connection,
+		focus_notify: Arc<Notify>,
-		object_registry: &ObjectRegistry,
+		spatial: Arc<Spatial>,
+		pointer: Arc<InputMethod>,
+		focused_handler_tx: watch::Sender<Option<HandlerInfo>>,
 	) {
-		let keyboard_handlers = object_registry.get_objects("org.stardustxr.XKBv1");
+		info!("Focus tracking task started");
 
-		// Spawn async task to handle keyboard input
+		// Create keyboard handler query inside the task
-		tokio::spawn({
+		let mut keyboard_query = ObjectQuery::<
-			let keyboard_handlers = keyboard_handlers.clone();
+			(FieldRefProxy<'static>, KeyboardHandlerProxy<'static>),
-			let spatial = self.spatial.clone();
+			_,
-			let keymap_id = self.keymap.data().as_ffi();
+		>::new(object_registry.clone(), ());
-			let dbus_connection = dbus_connection.clone();
+		let (keyboard_handlers, mapper) = keyboard_query.to_list_query();
-
+		task::new(
-			async move {
+			|| "Focus tracking mapper",
-				let mut closest_handler = None;
+			mapper.init(async |ev| match ev {
-				let mut closest_distance = f32::MAX;
+				ListEvent::NewMatch((field_ref, keyboard_proxy)) => {
-
+					info!("New keyboard handler found");
-				let mut join_set = JoinSet::new();
+					let uid = timeout(Duration::from_millis(100), field_ref.uid())
-				for handler in &keyboard_handlers {
-					let handler = handler.clone();
-					let dbus_connection = dbus_connection.clone();
-					join_set.spawn(async move {
-						timeout(Duration::from_millis(1), async {
-							let field_ref = handler
-								.to_typed_proxy::<FieldRefProxy>(&dbus_connection)
-								.await
-								.ok()?;
-							let uid = field_ref.uid().await.ok()?;
-							Some((handler, uid))
-						})
 						.await
-						.ok()
+						.ok()?
-						.flatten()
+						.ok()?;
-					});
+					let field_node = EXPORTED_FIELDS.lock().get(&uid)?.upgrade()?;
+					let field = field_node.get_aspect::<Field>();
+					Some((field, keyboard_proxy))
 				}
-				while let Some(Ok(Some((handler, field_ref_id)))) = join_set.join_next().await {
+				ListEvent::Modified((field_ref, keyboard_proxy)) => {
-					let exported_fields = EXPORTED_FIELDS.lock();
+					let uid = timeout(Duration::from_millis(100), field_ref.uid())
-					let Some(field_ref_node) = exported_fields.get(&field_ref_id) else {
+						.await
-						println!("didn't find a thing :(");
+						.ok()?
-						continue;
+						.ok()?;
-					};
+					let field_node = EXPORTED_FIELDS.lock().get(&uid)?.upgrade()?;
-					// println!("still sendin stuff :)");
+					let field = field_node.get_aspect::<Field>();
-					let Ok(field_ref) = field_ref_node.get_aspect::<Field>() else {
+					Some((field, keyboard_proxy))
-						continue;
-					};
-					drop(exported_fields);
-
-					let result = field_ref.ray_march(Ray {
-						origin: vec3(0.0, 0.0, 0.0),
-						direction: vec3(0.0, 0.0, -1.0),
-						space: spatial.clone(),
-					});
-
-					if result.deepest_point_distance > 0.0
-						&& result.min_distance < 0.05
-						&& result.deepest_point_distance < closest_distance
-					{
-						closest_distance = result.deepest_point_distance;
-						closest_handler = Some(handler);
-					}
 				}
+				_ => None,
+			}),
+		);
 
-				let Some(handler) = closest_handler else {
+		// Main focus calculation loop
-					return;
+		loop {
-				};
+			let mut closest_handler = None;
-				let Ok(keyboard_handler) = handler
+			let mut closest_distance = f32::MAX;
-					.to_typed_proxy::<KeyboardHandlerProxy>(&dbus_connection)
+
-					.await
+			// Find closest handler
-				else {
+			for (handler, (field_ref, keyboard_proxy)) in &*keyboard_handlers.iter().await {
-					return;
+				let Ok(field_ref) = field_ref else {
+					continue;
 				};
 
-				// Register keymap first
+				let result = field_ref.ray_march(Ray {
-				let _ = keyboard_handler.keymap(keymap_id).await;
+					origin: vec3(0.0, 0.0, 0.0),
+					direction: vec3(0.0, 0.0, -1.0),
+					space: spatial.clone(),
+				});
 
-				// Send key states
+				if result.deepest_point_distance > 0.0
-				for i in 8_u32..254 {
+					&& result.min_distance < 0.05
-					let key = unsafe { std::mem::transmute::<u32, stereokit_rust::system::Key>(i) };
+					&& result.deepest_point_distance < closest_distance
-					let Some(mapped_key) = map_key(key) else {
+				{
-						continue;
+					closest_distance = result.deepest_point_distance;
-					};
+					closest_handler = Some(HandlerInfo {
-					let input_state = Input::key(key);
+						handler: handler.clone(),
-					if input_state.is_just_active() {
+						field_ref: field_ref.clone(),
-						let _ = keyboard_handler.key_state(mapped_key + 8, true).await;
+						keyboard_proxy: keyboard_proxy.clone(),
-					} else if input_state.is_just_inactive() {
+					});
-						let _ = keyboard_handler.key_state(mapped_key + 8, false).await;
-					}
 				}
 			}
-		});
+
+			// Update focused handler
+			if let Some(ref handler_info) = closest_handler {
+				info!(
+					"Focus tracking task: Focused on handler at distance {}",
+					closest_distance
+				);
+			} else {
+				debug!("Focus tracking task: No handler in focus");
+			}
+			let _ = focused_handler_tx.send(closest_handler);
+
+			// Wait for next frame signal
+			focus_notify.notified().await;
+		}
+	}
+
+	async fn input_delivery_task(
+		dbus_connection: Connection,
+		mut focused_handler_rx: watch::Receiver<Option<HandlerInfo>>,
+		mut input_event_rx: mpsc::UnboundedReceiver<InputEvent>,
+		keymap_id: u64,
+	) {
+		info!("Input delivery task started");
+		loop {
+			// Handle input events
+			while let Some(input_event) = input_event_rx.recv().await {
+				info!(
+					"Input delivery task: Received input event key={}, pressed={}",
+					input_event.key, input_event.pressed
+				);
+				// Get current focused handler
+				let current_handler = focused_handler_rx.borrow().clone();
+				let Some(handler_info) = current_handler else {
+					continue;
+				};
+
+				// Send input to handler using cached proxy
+				info!("Input delivery task: Sending to handler");
+				let keyboard_handler = &handler_info.keyboard_proxy;
+
+				// Register keymap first
+				if let Err(e) = keyboard_handler.keymap(keymap_id).await {
+					warn!("Input delivery task: Failed to register keymap: {}", e);
+				}
+
+				// Send key state
+				if let Err(e) = keyboard_handler
+					.key_state(input_event.key + 8, input_event.pressed)
+					.await
+				{
+					error!("Input delivery task: Failed to send key state: {}", e);
+				} else {
+					info!(
+						"Input delivery task: Successfully sent key {} (pressed={})",
+						input_event.key + 8,
+						input_event.pressed
+					);
+				}
+			}
+		}
 	}
 }
 
-fn map_key(key: Key) -> Option<u32> {
+impl Drop for MousePointer {
+	fn drop(&mut self) {
+		// Abort the persistent tasks when MousePointer is dropped
+		self.focus_task_abort_handle.abort();
+		self.input_delivery_task_abort_handle.abort();
+	}
+}
+
+fn map_key(key: KeyCode) -> Option<u32> {
+	use KeyCode as Key;
 	match key {
+		Key::Unidentified(NativeKeyCode::Xkb(code)) => Some(code),
 		Key::Backspace => Some(input_event_codes::KEY_BACKSPACE!()),
 		Key::Tab => Some(input_event_codes::KEY_TAB!()),
-		Key::Return => Some(input_event_codes::KEY_ENTER!()),
+		Key::Enter => Some(input_event_codes::KEY_ENTER!()),
-		Key::Shift => Some(input_event_codes::KEY_LEFTSHIFT!()),
+		Key::ShiftLeft => Some(input_event_codes::KEY_LEFTSHIFT!()),
-		Key::Ctrl => Some(input_event_codes::KEY_LEFTCTRL!()),
+		Key::ShiftRight => Some(input_event_codes::KEY_RIGHTSHIFT!()),
-		Key::Alt => Some(input_event_codes::KEY_LEFTALT!()),
+		Key::ControlLeft => Some(input_event_codes::KEY_LEFTCTRL!()),
+		Key::ControlRight => Some(input_event_codes::KEY_RIGHTCTRL!()),
+		Key::AltLeft => Some(input_event_codes::KEY_LEFTALT!()),
+		Key::AltRight => Some(input_event_codes::KEY_RIGHTALT!()),
 		Key::CapsLock => Some(input_event_codes::KEY_CAPSLOCK!()),
-		Key::Esc => Some(input_event_codes::KEY_ESC!()),
+		Key::Escape => Some(input_event_codes::KEY_ESC!()),
 		Key::Space => Some(input_event_codes::KEY_SPACE!()),
 		Key::End => Some(input_event_codes::KEY_END!()),
 		Key::Home => Some(input_event_codes::KEY_HOME!()),
-		Key::Left => Some(input_event_codes::KEY_LEFT!()),
+		Key::ArrowLeft => Some(input_event_codes::KEY_LEFT!()),
-		Key::Right => Some(input_event_codes::KEY_RIGHT!()),
+		Key::ArrowRight => Some(input_event_codes::KEY_RIGHT!()),
-		Key::Up => Some(input_event_codes::KEY_UP!()),
+		Key::ArrowUp => Some(input_event_codes::KEY_UP!()),
-		Key::Down => Some(input_event_codes::KEY_DOWN!()),
+		Key::ArrowDown => Some(input_event_codes::KEY_DOWN!()),
 		Key::PageUp => Some(input_event_codes::KEY_PAGEUP!()),
 		Key::PageDown => Some(input_event_codes::KEY_PAGEDOWN!()),
 		Key::PrintScreen => Some(input_event_codes::KEY_PRINT!()),
-		Key::KeyInsert => Some(input_event_codes::KEY_INSERT!()),
+		Key::Insert => Some(input_event_codes::KEY_INSERT!()),
-		Key::Del => Some(input_event_codes::KEY_DELETE!()),
+		Key::Delete => Some(input_event_codes::KEY_DELETE!()),
-		Key::Key0 => Some(input_event_codes::KEY_0!()),
+		Key::Digit0 => Some(input_event_codes::KEY_0!()),
-		Key::Key1 => Some(input_event_codes::KEY_1!()),
+		Key::Digit1 => Some(input_event_codes::KEY_1!()),
-		Key::Key2 => Some(input_event_codes::KEY_2!()),
+		Key::Digit2 => Some(input_event_codes::KEY_2!()),
-		Key::Key3 => Some(input_event_codes::KEY_3!()),
+		Key::Digit3 => Some(input_event_codes::KEY_3!()),
-		Key::Key4 => Some(input_event_codes::KEY_4!()),
+		Key::Digit4 => Some(input_event_codes::KEY_4!()),
-		Key::Key5 => Some(input_event_codes::KEY_5!()),
+		Key::Digit5 => Some(input_event_codes::KEY_5!()),
-		Key::Key6 => Some(input_event_codes::KEY_6!()),
+		Key::Digit6 => Some(input_event_codes::KEY_6!()),
-		Key::Key7 => Some(input_event_codes::KEY_7!()),
+		Key::Digit7 => Some(input_event_codes::KEY_7!()),
-		Key::Key8 => Some(input_event_codes::KEY_8!()),
+		Key::Digit8 => Some(input_event_codes::KEY_8!()),
-		Key::Key9 => Some(input_event_codes::KEY_9!()),
+		Key::Digit9 => Some(input_event_codes::KEY_9!()),
-		Key::A => Some(input_event_codes::KEY_A!()),
+		Key::KeyA => Some(input_event_codes::KEY_A!()),
-		Key::B => Some(input_event_codes::KEY_B!()),
+		Key::KeyB => Some(input_event_codes::KEY_B!()),
-		Key::C => Some(input_event_codes::KEY_C!()),
+		Key::KeyC => Some(input_event_codes::KEY_C!()),
-		Key::D => Some(input_event_codes::KEY_D!()),
+		Key::KeyD => Some(input_event_codes::KEY_D!()),
-		Key::E => Some(input_event_codes::KEY_E!()),
+		Key::KeyE => Some(input_event_codes::KEY_E!()),
-		Key::F => Some(input_event_codes::KEY_F!()),
+		Key::KeyF => Some(input_event_codes::KEY_F!()),
-		Key::G => Some(input_event_codes::KEY_G!()),
+		Key::KeyG => Some(input_event_codes::KEY_G!()),
-		Key::H => Some(input_event_codes::KEY_H!()),
+		Key::KeyH => Some(input_event_codes::KEY_H!()),
-		Key::I => Some(input_event_codes::KEY_I!()),
+		Key::KeyI => Some(input_event_codes::KEY_I!()),
-		Key::J => Some(input_event_codes::KEY_J!()),
+		Key::KeyJ => Some(input_event_codes::KEY_J!()),
-		Key::K => Some(input_event_codes::KEY_K!()),
+		Key::KeyK => Some(input_event_codes::KEY_K!()),
-		Key::L => Some(input_event_codes::KEY_L!()),
+		Key::KeyL => Some(input_event_codes::KEY_L!()),
-		Key::M => Some(input_event_codes::KEY_M!()),
+		Key::KeyM => Some(input_event_codes::KEY_M!()),
-		Key::N => Some(input_event_codes::KEY_N!()),
+		Key::KeyN => Some(input_event_codes::KEY_N!()),
-		Key::O => Some(input_event_codes::KEY_O!()),
+		Key::KeyO => Some(input_event_codes::KEY_O!()),
-		Key::P => Some(input_event_codes::KEY_P!()),
+		Key::KeyP => Some(input_event_codes::KEY_P!()),
-		Key::Q => Some(input_event_codes::KEY_Q!()),
+		Key::KeyQ => Some(input_event_codes::KEY_Q!()),
-		Key::R => Some(input_event_codes::KEY_R!()),
+		Key::KeyR => Some(input_event_codes::KEY_R!()),
-		Key::S => Some(input_event_codes::KEY_S!()),
+		Key::KeyS => Some(input_event_codes::KEY_S!()),
-		Key::T => Some(input_event_codes::KEY_T!()),
+		Key::KeyT => Some(input_event_codes::KEY_T!()),
-		Key::U => Some(input_event_codes::KEY_U!()),
+		Key::KeyU => Some(input_event_codes::KEY_U!()),
-		Key::V => Some(input_event_codes::KEY_V!()),
+		Key::KeyV => Some(input_event_codes::KEY_V!()),
-		Key::W => Some(input_event_codes::KEY_W!()),
+		Key::KeyW => Some(input_event_codes::KEY_W!()),
-		Key::X => Some(input_event_codes::KEY_X!()),
+		Key::KeyX => Some(input_event_codes::KEY_X!()),
-		Key::Y => Some(input_event_codes::KEY_Y!()),
+		Key::KeyY => Some(input_event_codes::KEY_Y!()),
-		Key::Z => Some(input_event_codes::KEY_Z!()),
+		Key::KeyZ => Some(input_event_codes::KEY_Z!()),
 		Key::Numpad0 => Some(input_event_codes::KEY_NUMERIC_0!()),
 		Key::Numpad1 => Some(input_event_codes::KEY_NUMERIC_1!()),
 		Key::Numpad2 => Some(input_event_codes::KEY_NUMERIC_2!()),
@@ -327,31 +599,71 @@ fn map_key(key: Key) -> Option<u32> {
 		Key::F3 => Some(input_event_codes::KEY_F3!()),
 		Key::F4 => Some(input_event_codes::KEY_F4!()),
 		Key::F5 => Some(input_event_codes::KEY_F5!()),
-		// Key::F6 => Some(input_event_codes::KEY_F6!()),
+		Key::F6 => Some(input_event_codes::KEY_F6!()),
-		// Key::F7 => Some(input_event_codes::KEY_F7!()),
+		Key::F7 => Some(input_event_codes::KEY_F7!()),
-		// Key::F8 => Some(input_event_codes::KEY_F8!()),
+		Key::F8 => Some(input_event_codes::KEY_F8!()),
 		Key::F9 => Some(input_event_codes::KEY_F9!()),
 		Key::F10 => Some(input_event_codes::KEY_F10!()),
 		Key::F11 => Some(input_event_codes::KEY_F11!()),
 		Key::F12 => Some(input_event_codes::KEY_F12!()),
+		Key::F13 => Some(input_event_codes::KEY_F13!()),
+		Key::F14 => Some(input_event_codes::KEY_F14!()),
+		Key::F15 => Some(input_event_codes::KEY_F15!()),
+		Key::F16 => Some(input_event_codes::KEY_F16!()),
+		Key::F17 => Some(input_event_codes::KEY_F17!()),
+		Key::F18 => Some(input_event_codes::KEY_F18!()),
+		Key::F19 => Some(input_event_codes::KEY_F19!()),
+		Key::F20 => Some(input_event_codes::KEY_F20!()),
+		Key::F21 => Some(input_event_codes::KEY_F21!()),
+		Key::F22 => Some(input_event_codes::KEY_F22!()),
+		Key::F23 => Some(input_event_codes::KEY_F23!()),
+		Key::F24 => Some(input_event_codes::KEY_F24!()),
 		Key::Comma => Some(input_event_codes::KEY_COMMA!()),
 		Key::Period => Some(input_event_codes::KEY_DOT!()),
-		Key::SlashFwd => Some(input_event_codes::KEY_SLASH!()),
+		Key::Slash => Some(input_event_codes::KEY_SLASH!()),
-		Key::SlashBack => Some(input_event_codes::KEY_BACKSLASH!()),
+		Key::Backslash => Some(input_event_codes::KEY_BACKSLASH!()),
 		Key::Semicolon => Some(input_event_codes::KEY_SEMICOLON!()),
-		Key::Apostrophe => Some(input_event_codes::KEY_APOSTROPHE!()),
+		Key::Quote => Some(input_event_codes::KEY_APOSTROPHE!()),
-		Key::BracketOpen => Some(input_event_codes::KEY_LEFTBRACE!()),
+		Key::BracketLeft => Some(input_event_codes::KEY_LEFTBRACE!()),
-		Key::BracketClose => Some(input_event_codes::KEY_RIGHTBRACE!()),
+		Key::BracketRight => Some(input_event_codes::KEY_RIGHTBRACE!()),
 		Key::Minus => Some(input_event_codes::KEY_MINUS!()),
-		Key::Equals => Some(input_event_codes::KEY_EQUAL!()),
+		Key::Equal => Some(input_event_codes::KEY_EQUAL!()),
-		Key::Backtick => Some(input_event_codes::KEY_GRAVE!()),
+		Key::Backquote => Some(input_event_codes::KEY_GRAVE!()),
-		Key::LCmd => Some(input_event_codes::KEY_LEFTMETA!()),
+		Key::SuperLeft => Some(input_event_codes::KEY_LEFTMETA!()),
-		Key::RCmd => Some(input_event_codes::KEY_RIGHTMETA!()),
+		Key::SuperRight => Some(input_event_codes::KEY_RIGHTMETA!()),
-		Key::Multiply => Some(input_event_codes::KEY_NUMERIC_STAR!()),
+		Key::NumpadMultiply => Some(input_event_codes::KEY_NUMERIC_STAR!()),
-		Key::Add => Some(input_event_codes::KEY_KPPLUS!()),
+		Key::NumpadAdd => Some(input_event_codes::KEY_KPPLUS!()),
-		Key::Subtract => Some(input_event_codes::KEY_MINUS!()),
+		Key::NumpadSubtract => Some(input_event_codes::KEY_MINUS!()),
-		Key::Decimal => Some(input_event_codes::KEY_DOT!()),
+		Key::NumpadDecimal => Some(input_event_codes::KEY_DOT!()),
-		Key::Divide => Some(input_event_codes::KEY_SLASH!()),
+		Key::NumpadDivide => Some(input_event_codes::KEY_SLASH!()),
+		Key::ContextMenu => Some(input_event_codes::KEY_CONTEXT_MENU!()),
+		Key::Help => Some(input_event_codes::KEY_HELP!()),
+		Key::NumLock => Some(input_event_codes::KEY_NUMLOCK!()),
+		Key::NumpadBackspace => Some(input_event_codes::KEY_BACKSPACE!()),
+		Key::NumpadClear => Some(input_event_codes::KEY_CLEAR!()),
+		Key::NumpadClearEntry => Some(input_event_codes::KEY_CLEAR!()),
+		Key::NumpadComma => Some(input_event_codes::KEY_COMMA!()),
+		Key::NumpadEnter => Some(input_event_codes::KEY_ENTER!()),
+		Key::NumpadEqual => Some(input_event_codes::KEY_EQUAL!()),
+		Key::NumpadHash => Some(input_event_codes::KEY_NUMERIC_POUND!()),
+		Key::NumpadStar => Some(input_event_codes::KEY_KPASTERISK!()),
+		Key::Fn => Some(input_event_codes::KEY_FN!()),
+		Key::ScrollLock => Some(input_event_codes::KEY_SCROLLLOCK!()),
+		Key::Pause => Some(input_event_codes::KEY_PAUSE!()),
+		Key::Power => Some(input_event_codes::KEY_POWER!()),
+		Key::Sleep => Some(input_event_codes::KEY_SLEEP!()),
+		Key::Suspend => Some(input_event_codes::KEY_SUSPEND!()),
+		Key::Again => Some(input_event_codes::KEY_AGAIN!()),
+		Key::Copy => Some(input_event_codes::KEY_COPY!()),
+		Key::Cut => Some(input_event_codes::KEY_CUT!()),
+		Key::Find => Some(input_event_codes::KEY_FIND!()),
+		Key::Open => Some(input_event_codes::KEY_OPEN!()),
+		Key::Paste => Some(input_event_codes::KEY_PASTE!()),
+		Key::Props => Some(input_event_codes::KEY_PROPS!()),
+		Key::Select => Some(input_event_codes::KEY_SELECT!()),
+		Key::Undo => Some(input_event_codes::KEY_UNDO!()),
+		Key::Hiragana => Some(input_event_codes::KEY_HIRAGANA!()),
+		Key::Katakana => Some(input_event_codes::KEY_KATAKANA!()),
 		_ => None,
 	}
 }

src/objects/input/oxr_controller.rs

@@ -0,0 +1,417 @@
+use super::{CaptureManager, get_sorted_handlers};
+use crate::{
+	DbusConnection, PreFrameWait,
+	core::client::INTERNAL_CLIENT,
+	get_time,
+	nodes::{
+		Node, OwnedNode,
+		drawable::{
+			MaterialParameter,
+			model::{Model, ModelPart},
+		},
+		fields::{Field, FieldTrait},
+		input::{INPUT_HANDLER_REGISTRY, InputDataType, InputHandler, InputMethod, Tip},
+		spatial::Spatial,
+	},
+	objects::{AsyncTracked, ObjectHandle, SpatialRef, Tracked},
+};
+use bevy::{asset::Handle, ecs::resource::Resource};
+use bevy::{math::Affine3, prelude::*};
+use bevy_mod_openxr::{
+	action_binding::{OxrSendActionBindings, OxrSuggestActionBinding},
+	helper_traits::{ToIsometry3d, ToVec2},
+	resources::{OxrFrameState, OxrInstance, Pipelined},
+	session::OxrSession,
+};
+use bevy_mod_xr::{
+	hands::HandSide,
+	session::{XrPreDestroySession, XrSessionCreated, XrSessionCreatedEvent},
+	spaces::{XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace},
+};
+use color_eyre::eyre::Result;
+use glam::{Affine3A, Mat4, Vec2, Vec3};
+use openxr::{Action, ActiveActionSet, SpaceLocationFlags};
+use serde::{Deserialize, Serialize};
+use stardust_xr::values::{Datamap, ResourceID, color::Rgb};
+use std::{
+	borrow::Cow,
+	fs,
+	path::{Path, PathBuf},
+	str::FromStr,
+	sync::Arc,
+};
+use tracing::instrument;
+use zbus::Connection;
+pub struct ControllerPlugin;
+const CURSOR_MODEL_PATH: &str = "/tmp/stardust_server/models/cursor.glb";
+impl Plugin for ControllerPlugin {
+	fn build(&self, app: &mut App) {
+		let cursor = include_bytes!("cursor.glb");
+		fs::create_dir_all(
+			PathBuf::from_str(CURSOR_MODEL_PATH)
+				.unwrap()
+				.parent()
+				.unwrap(),
+		);
+		fs::write(CURSOR_MODEL_PATH, cursor).expect("can't write tmp cursor model file");
+		app.add_systems(OxrSendActionBindings, suggest_bindings.run_if(run_once));
+		app.add_systems(
+			PostUpdate,
+			create_spaces.run_if(on_event::<XrSessionCreatedEvent>),
+		);
+		app.add_systems(XrPreDestroySession, destroy_spaces);
+		app.add_systems(Startup, setup.run_if(resource_exists::<OxrInstance>));
+		app.add_systems(PreFrameWait, update.run_if(resource_exists::<Controllers>));
+	}
+}
+
+// the api is just slightly nicer when using the bevy_mod_openxr solution okay?
+fn suggest_bindings(
+	instance: Res<OxrInstance>,
+	actions: Res<Actions>,
+	mut suggest: EventWriter<OxrSuggestActionBinding>,
+) {
+	let mut bind_all = |interaction_profile: &'static str,
+	                    bindings: &[(openxr::sys::Action, &[&'static str])]| {
+		for (action, bindings) in bindings {
+			suggest.write(OxrSuggestActionBinding {
+				action: *action,
+				interaction_profile: interaction_profile.into(),
+				bindings: bindings.iter().copied().map(Cow::Borrowed).collect(),
+			});
+		}
+	};
+	bind_all(
+		"/interaction_profiles/oculus/touch_controller",
+		&[
+			(
+				actions.trigger.as_raw(),
+				&[
+					"/user/hand/left/input/trigger/value",
+					"/user/hand/right/input/trigger/value",
+				],
+			),
+			(
+				actions.stick_click.as_raw(),
+				&[
+					"/user/hand/left/input/thumbstick/click",
+					"/user/hand/right/input/thumbstick/click",
+				],
+			),
+			(
+				actions.button.as_raw(),
+				&[
+					"/user/hand/left/input/x/click",
+					"/user/hand/left/input/y/click",
+					"/user/hand/right/input/a/click",
+					"/user/hand/right/input/b/click",
+				],
+			),
+			(
+				actions.grip.as_raw(),
+				&[
+					"/user/hand/left/input/squeeze/value",
+					"/user/hand/right/input/squeeze/value",
+				],
+			),
+			(
+				actions.stick.as_raw(),
+				&[
+					"/user/hand/left/input/thumbstick",
+					"/user/hand/right/input/thumbstick",
+				],
+			),
+			(
+				actions.space.as_raw(),
+				&[
+					"/user/hand/left/input/aim/pose",
+					"/user/hand/right/input/aim/pose",
+				],
+			),
+		],
+	);
+	bind_all(
+		"/interaction_profiles/khr/simple_controller",
+		&[(
+			actions.space.as_raw(),
+			&[
+				"/user/hand/left/input/aim/pose",
+				"/user/hand/right/input/aim/pose",
+			],
+		)],
+	);
+}
+
+fn update(
+	mut controllers: ResMut<Controllers>,
+	actions: Res<Actions>,
+	session: Option<Res<OxrSession>>,
+	ref_space: Option<Res<XrPrimaryReferenceSpace>>,
+	state: Option<Res<OxrFrameState>>,
+	pipelined: Option<Res<Pipelined>>,
+) {
+	let (Some(session), Some(state), Some(ref_space)) = (session, state, ref_space) else {
+		controllers.left.set_enabled(false);
+		controllers.right.set_enabled(false);
+		return;
+	};
+	debug_span!("sync actions").in_scope(|| {
+		session
+			.sync_actions(&[ActiveActionSet::new(&actions.set)])
+			.unwrap();
+	});
+	let time = get_time(pipelined.is_some(), &state);
+	controllers
+		.left
+		.update(&session, &actions, time, ref_space.0);
+	controllers
+		.right
+		.update(&session, &actions, time, ref_space.0);
+}
+
+fn create_spaces(
+	session: Res<OxrSession>,
+	mut controllers: ResMut<Controllers>,
+	actions: Res<Actions>,
+) {
+	// if we ever need more actions than just these we should fully swith to the
+	// bevy_mod_openxr provided stuff
+	session.attach_action_sets(&[&actions.set]);
+	session
+		.sync_actions(&[ActiveActionSet::new(&actions.set)])
+		.unwrap();
+
+	let instance = session.instance();
+	let left = instance.string_to_path("/user/hand/left").unwrap();
+	let right = instance.string_to_path("/user/hand/right").unwrap();
+	let left = session
+		.create_action_space(&actions.space, left, Isometry3d::IDENTITY)
+		.unwrap();
+	let right = session
+		.create_action_space(&actions.space, right, Isometry3d::IDENTITY)
+		.unwrap();
+	controllers.left.space = Some(left);
+	controllers.right.space = Some(right);
+}
+
+fn destroy_spaces(session: Res<OxrSession>, mut controllers: ResMut<Controllers>) {
+	if let Some(space) = controllers.left.space.take() {
+		session.destroy_space(space);
+	}
+	if let Some(space) = controllers.right.space.take() {
+		session.destroy_space(space);
+	}
+}
+
+fn setup(instance: Res<OxrInstance>, connection: Res<DbusConnection>, mut cmds: Commands) {
+	tokio::task::spawn({
+		let connection = connection.clone();
+		async move {
+			connection
+				.request_name("org.stardustxr.Controllers")
+				.await
+				.unwrap();
+		}
+	});
+	let set = instance
+		.create_action_set("input_method_actions", "Input Method Action Source", 0)
+		.unwrap();
+	let paths = &[
+		instance.string_to_path("/user/hand/left").unwrap(),
+		instance.string_to_path("/user/hand/right").unwrap(),
+	];
+	let actions = Actions {
+		trigger: set.create_action("trigger", "Select", paths).unwrap(),
+		stick_click: set.create_action("stick_click", "Middle", paths).unwrap(),
+		button: set.create_action("face_button", "Context", paths).unwrap(),
+		grip: set.create_action("grip", "Grab", paths).unwrap(),
+		stick: set.create_action("stick", "Scroll", paths).unwrap(),
+		space: set.create_action("pose", "Location", paths).unwrap(),
+		set,
+	};
+	let controllers = Controllers {
+		left: OxrControllerInput::new(&connection, HandSide::Left).unwrap(),
+		right: OxrControllerInput::new(&connection, HandSide::Right).unwrap(),
+	};
+	cmds.insert_resource(controllers);
+	cmds.insert_resource(actions);
+}
+
+#[derive(Default, Debug, Deserialize, Serialize)]
+struct ControllerDatamap {
+	select: f32,
+	middle: f32,
+	context: f32,
+	grab: f32,
+	scroll: Vec2,
+}
+#[derive(Resource)]
+struct Actions {
+	set: openxr::ActionSet,
+	trigger: openxr::Action<f32>,
+	stick_click: openxr::Action<f32>,
+	button: openxr::Action<f32>,
+	grip: openxr::Action<f32>,
+	space: openxr::Action<openxr::Posef>,
+	stick: openxr::Action<openxr::Vector2f>,
+}
+#[derive(Resource)]
+struct Controllers {
+	left: OxrControllerInput,
+	right: OxrControllerInput,
+}
+
+pub struct OxrControllerInput {
+	object_handle: ObjectHandle<SpatialRef>,
+	input: Arc<InputMethod>,
+	side: HandSide,
+	model: Arc<Model>,
+	model_part: Arc<ModelPart>,
+	capture_manager: CaptureManager,
+	datamap: ControllerDatamap,
+	tracked: AsyncTracked,
+	space: Option<XrSpace>,
+	_model_node: OwnedNode,
+}
+impl OxrControllerInput {
+	fn new(connection: &Connection, side: HandSide) -> Result<Self> {
+		let path = "/org/stardustxr/Controller/".to_string()
+			+ match side {
+				HandSide::Left => "left",
+				HandSide::Right => "right",
+			};
+		let (spatial, object_handle) = SpatialRef::create(connection, &path);
+		let tracked = AsyncTracked::new(connection, &path);
+		let tip = InputDataType::Tip(Tip::default());
+		let node = spatial.node().unwrap();
+		node.set_enabled(false);
+		let model_node = Arc::new(Node::generate(&INTERNAL_CLIENT, true));
+		let model_spatial = Spatial::add_to(
+			&model_node,
+			Some(spatial.clone()),
+			Mat4::from_scale(Vec3::splat(0.02)),
+			false,
+		);
+		let model =
+			Model::add_to(&model_node, ResourceID::Direct(CURSOR_MODEL_PATH.into())).unwrap();
+		let model_part = model.get_model_part("Cursor".to_string()).unwrap();
+		let input = InputMethod::add_to(
+			&node,
+			tip,
+			Datamap::from_typed(ControllerDatamap::default())?,
+		)?;
+		Ok(OxrControllerInput {
+			object_handle,
+			input,
+			side,
+			model,
+			model_part,
+			capture_manager: CaptureManager::default(),
+			datamap: Default::default(),
+			tracked,
+			space: None,
+			_model_node: OwnedNode(model_node),
+		})
+	}
+	#[instrument(level = "debug", skip(self))]
+	pub fn set_enabled(&self, enabled: bool) {
+		if let Some(node) = self.input.spatial.node() {
+			node.set_enabled(enabled);
+		}
+		self.tracked.set_tracked(enabled);
+	}
+	fn update(
+		&mut self,
+		session: &OxrSession,
+		actions: &Actions,
+		time: openxr::Time,
+		ref_space: XrReferenceSpace,
+	) {
+		let Some(space) = self.space.as_ref() else {
+			return;
+		};
+		let _span = debug_span!("locate space").entered();
+		let Ok(location) = session
+			.locate_space(space, &ref_space, time)
+			.inspect_err(|err| error!("error while locating controller space: {err}"))
+		else {
+			return;
+		};
+		let enabled = location.location_flags.contains(
+			SpaceLocationFlags::POSITION_VALID
+				| SpaceLocationFlags::POSITION_TRACKED
+				| SpaceLocationFlags::ORIENTATION_VALID
+				| SpaceLocationFlags::ORIENTATION_TRACKED,
+		);
+		drop(_span);
+		self.set_enabled(enabled);
+		if enabled {
+			let world_transform = Mat4::from(Affine3A::from(location.pose.to_xr_pose()));
+			self.model_part
+				.set_material_parameter("roughness".to_string(), MaterialParameter::Float(1.0));
+			self.model_part.set_material_parameter(
+				"color".to_string(),
+				MaterialParameter::Color(stardust_xr::values::Color::new(
+					if self.capture_manager.capture.upgrade().is_none() {
+						Rgb::new(1.0, 1.0, 1.0)
+					} else {
+						Rgb::new(0.0, 1.0, 0.75)
+					},
+					1.0,
+				)),
+			);
+			self.input.spatial.set_local_transform(world_transform);
+		}
+		let path = session
+			.instance()
+			.string_to_path(match self.side {
+				HandSide::Left => "/user/hand/left",
+				HandSide::Right => "/user/hand/right",
+			})
+			.unwrap();
+		if let Ok(path) = session.current_interaction_profile(path)
+			&& let Ok(path) = session.instance().path_to_string(path)
+			&& path == "/interaction_profiles/khr/simple_controller"
+		{
+			self.set_enabled(false);
+		}
+
+		fn get<T: openxr::ActionInput + Default>(
+			session: &OxrSession,
+			path: openxr::Path,
+			action: &Action<T>,
+		) -> T {
+			action
+				.state(session, path)
+				.map(|v| v.current_state)
+				.unwrap_or_default()
+		}
+		let _span = debug_span!("apply datamap").entered();
+		self.datamap = ControllerDatamap {
+			select: get(session, path, &actions.trigger),
+			middle: get(session, path, &actions.stick_click) as u32 as f32,
+			context: get(session, path, &actions.button) as u32 as f32,
+			grab: get(session, path, &actions.grip),
+			scroll: get(session, path, &actions.stick).to_vec2(),
+		};
+		*self.input.datamap.lock() = Datamap::from_typed(&self.datamap).unwrap();
+		drop(_span);
+
+		let distance_calculator = |space: &Arc<Spatial>, _data: &InputDataType, field: &Field| {
+			Some(field.distance(space, [0.0; 3].into()).abs())
+		};
+
+		self.capture_manager.update_capture(&self.input);
+		self.capture_manager
+			.set_new_capture(&self.input, distance_calculator);
+		self.capture_manager.apply_capture(&self.input);
+
+		if self.capture_manager.capture.upgrade().is_some() {
+			return;
+		}
+
+		let sorted_handlers = get_sorted_handlers(&self.input, distance_calculator);
+		self.input
+			.set_handler_order(sorted_handlers.iter().map(|(handler, _)| handler));
+	}
+}

src/objects/input/oxr_hand.rs

@@ -0,0 +1,360 @@
+use crate::core::client::INTERNAL_CLIENT;
+use crate::nodes::OwnedNode;
+use crate::nodes::fields::{Field, FieldTrait};
+use crate::nodes::input::{Finger, INPUT_HANDLER_REGISTRY, InputDataType, InputHandler, Thumb};
+use crate::nodes::{
+	Node,
+	input::{Hand, InputMethod, Joint},
+	spatial::Spatial,
+};
+use crate::objects::{AsyncTracked, ObjectHandle, SpatialRef, Tracked};
+use crate::{BevyMaterial, DbusConnection, ObjectRegistryRes, PreFrameWait, get_time};
+use bevy::prelude::Transform as BevyTransform;
+use bevy::prelude::*;
+use bevy_mod_openxr::helper_traits::{ToQuat, ToVec3};
+use bevy_mod_openxr::resources::{OxrFrameState, Pipelined};
+use bevy_mod_openxr::session::OxrSession;
+use bevy_mod_xr::hands::{HandBone, HandSide, XrHandBoneEntities, XrHandBoneRadius};
+use bevy_mod_xr::session::{XrPreDestroySession, XrSessionCreated, session_available};
+use bevy_mod_xr::spaces::{XrPrimaryReferenceSpace, XrSpaceLocationFlags};
+use bevy_sk::hand::GRADIENT_TEXTURE_HANDLE;
+use color_eyre::eyre::Result;
+use glam::{Mat4, Quat, Vec3};
+use openxr::{HandJointLocation, SpaceLocationFlags};
+use serde::{Deserialize, Serialize};
+use stardust_xr::values::Datamap;
+use std::sync::Arc;
+use zbus::Connection;
+
+use super::{CaptureManager, get_sorted_handlers};
+
+pub struct HandPlugin;
+impl Plugin for HandPlugin {
+	fn build(&self, app: &mut App) {
+		app.add_systems(PreFrameWait, update_hands.run_if(resource_exists::<Hands>));
+		app.add_systems(XrSessionCreated, create_trackers);
+		app.add_systems(XrPreDestroySession, destroy_trackers);
+		app.add_systems(
+			PostUpdate,
+			update_hand_material.run_if(resource_exists::<Hands>),
+		);
+		app.add_systems(Startup, setup.run_if(session_available));
+	}
+}
+fn update_hands(
+	mut hands: ResMut<Hands>,
+	session: Option<Res<OxrSession>>,
+	state: Option<Res<OxrFrameState>>,
+	ref_space: Option<Res<XrPrimaryReferenceSpace>>,
+	mut materials: ResMut<Assets<BevyMaterial>>,
+	mut joint_query: Query<(
+		&mut BevyTransform,
+		&mut XrSpaceLocationFlags,
+		&mut XrHandBoneRadius,
+	)>,
+	joints_query: Query<&XrHandBoneEntities>,
+	pipelined: Option<Res<Pipelined>>,
+) {
+	let (Some(session), Some(state), Some(ref_space)) = (session, state, ref_space) else {
+		hands.left.tracked.set_tracked(false);
+		hands.right.tracked.set_tracked(false);
+		return;
+	};
+	let get_joints = |hand: &mut OxrHandInput| -> Option<openxr::HandJointLocations> {
+		let Some(tracker) = hand.tracker.as_ref() else {
+			hand.input.spatial.node().unwrap().set_enabled(false);
+			hand.tracked.set_tracked(false);
+			return None;
+		};
+		let time = get_time(pipelined.is_some(), &state);
+		session
+			.locate_hand_joints(tracker, &ref_space, time)
+			.inspect_err(|err| error!("Error while locating hand joints"))
+			.ok()
+			.flatten()
+	};
+	let joints_left = get_joints(&mut hands.left);
+	let joints_right = get_joints(&mut hands.right);
+	hands.left.update(joints_left.as_ref(), &mut materials);
+	hands.right.update(joints_right.as_ref(), &mut materials);
+}
+
+fn pinch_between(joint_1: &Joint, joint_2: &Joint) -> f32 {
+	const PINCH_MAX: f32 = 0.11;
+	const PINCH_ACTIVACTION_DISTANCE: f32 = 0.01;
+	let combined_radius = joint_1.radius + joint_2.radius;
+	let pinch_dist =
+		Vec3::from(joint_1.position).distance(Vec3::from(joint_2.position)) - combined_radius;
+	(1.0 - ((pinch_dist - PINCH_ACTIVACTION_DISTANCE) / (PINCH_MAX - PINCH_ACTIVACTION_DISTANCE)))
+		.clamp(0.0, 1.0)
+}
+
+fn create_trackers(session: Res<OxrSession>, mut hands: ResMut<Hands>) {
+	hands.left.tracker = session
+		.create_hand_tracker(openxr::HandEXT::LEFT)
+		.inspect_err(|err| error!("failed to create left hand tracker"))
+		.ok();
+	hands.right.tracker = session
+		.create_hand_tracker(openxr::HandEXT::RIGHT)
+		.inspect_err(|err| error!("failed to create right hand tracker"))
+		.ok();
+}
+fn destroy_trackers(mut hands: ResMut<Hands>) {
+	hands.left.tracker.take();
+	hands.right.tracker.take();
+}
+#[derive(Component)]
+struct CorrectHandMaterial;
+fn update_hand_material(
+	query: Query<
+		(Entity, &HandSide),
+		(
+			With<XrHandBoneEntities>,
+			With<MeshMaterial3d<BevyMaterial>>,
+			Without<CorrectHandMaterial>,
+		),
+	>,
+	mut cmds: Commands,
+	hands: Res<Hands>,
+) {
+	for (entity, side) in &query {
+		let handle = match side {
+			HandSide::Left => hands.left.material.clone(),
+			HandSide::Right => hands.right.material.clone(),
+		};
+		cmds.entity(entity)
+			.insert(MeshMaterial3d(handle))
+			.insert(CorrectHandMaterial);
+	}
+}
+
+fn setup(
+	connection: Res<DbusConnection>,
+	mut cmds: Commands,
+	mut materials: ResMut<Assets<BevyMaterial>>,
+) {
+	tokio::task::spawn({
+		let connection = connection.clone();
+		async move {
+			connection
+				.request_name("org.stardustxr.Hands")
+				.await
+				.unwrap();
+		}
+	});
+	cmds.insert_resource(Hands {
+		left: OxrHandInput::new(&connection, HandSide::Left, &mut materials).unwrap(),
+		right: OxrHandInput::new(&connection, HandSide::Right, &mut materials).unwrap(),
+	});
+}
+
+fn convert_joint(joint: HandJointLocation) -> Joint {
+	Joint {
+		position: joint.pose.position.to_vec3().into(),
+		rotation: joint.pose.orientation.to_quat().into(),
+		radius: joint.radius,
+		distance: 0.0,
+	}
+}
+
+#[derive(Resource)]
+struct Hands {
+	left: OxrHandInput,
+	right: OxrHandInput,
+}
+
+#[derive(Default, Deserialize, Serialize)]
+struct HandDatamap {
+	pinch_strength: f32,
+	grab_strength: f32,
+}
+
+pub struct OxrHandInput {
+	_node: OwnedNode,
+	palm_spatial: Arc<Spatial>,
+	palm_object: ObjectHandle<SpatialRef>,
+	side: HandSide,
+	input: Arc<InputMethod>,
+	capture_manager: CaptureManager,
+	datamap: HandDatamap,
+	tracked: AsyncTracked,
+	tracker: Option<openxr::HandTracker>,
+	captured: bool,
+	material: Handle<BevyMaterial>,
+}
+impl OxrHandInput {
+	pub fn new(
+		connection: &Connection,
+		side: HandSide,
+		materials: &mut Assets<BevyMaterial>,
+	) -> Result<Self> {
+		let (palm_spatial, palm_object) = SpatialRef::create(
+			connection,
+			&("/org/stardustxr/Hand/".to_string()
+				+ match side {
+					HandSide::Left => "left",
+					HandSide::Right => "right",
+				} + "/palm"),
+		);
+		let tracked = AsyncTracked::new(
+			connection,
+			&("/org/stardustxr/Hand/".to_string()
+				+ match side {
+					HandSide::Left => "left",
+					HandSide::Right => "right",
+				}),
+		);
+		let node = Node::generate(&INTERNAL_CLIENT, false).add_to_scenegraph_owned()?;
+		Spatial::add_to(&node.0, None, Mat4::IDENTITY, false);
+		let hand = InputDataType::Hand(Hand {
+			right: matches!(side, HandSide::Right),
+			..Default::default()
+		});
+		let datamap = Datamap::from_typed(HandDatamap::default())?;
+		let input = InputMethod::add_to(&node.0, hand, datamap)?;
+
+		let material = materials.add(BevyMaterial {
+			base_color: Srgba::new(1.0, 1.0, 1.0, 1.0).into(),
+			alpha_mode: AlphaMode::Blend,
+			base_color_texture: Some(GRADIENT_TEXTURE_HANDLE),
+			perceptual_roughness: 1.0,
+			..default()
+		});
+		Ok(OxrHandInput {
+			_node: node,
+			palm_spatial,
+			palm_object,
+			side,
+			input,
+			tracked,
+			capture_manager: CaptureManager::default(),
+			datamap: Default::default(),
+			tracker: None,
+			material,
+			captured: false,
+		})
+	}
+	pub fn set_enabled(&self, enabled: bool) {
+		if let Some(node) = self.input.spatial.node() {
+			node.set_enabled(enabled);
+		}
+		self.tracked.set_tracked(enabled);
+	}
+	fn update(
+		&mut self,
+		joints: Option<&openxr::HandJointLocations>,
+		materials: &mut ResMut<Assets<BevyMaterial>>,
+	) {
+		// TODO: use the hand data source ext
+		let real_hand = true;
+		let input_node = self.input.spatial.node().unwrap();
+		let is_tracked = real_hand
+			&& joints.is_some_and(|v| {
+				v.iter().all(|v| {
+					v.location_flags.contains(
+						SpaceLocationFlags::POSITION_VALID | SpaceLocationFlags::POSITION_TRACKED,
+					) || v.location_flags.contains(
+						SpaceLocationFlags::ORIENTATION_VALID
+							| SpaceLocationFlags::ORIENTATION_TRACKED,
+					)
+				})
+			});
+		self.set_enabled(is_tracked);
+		if is_tracked {
+			// cannot ever crash, is_tracked is only true of joints is some
+			let joints = joints.unwrap();
+			let new_hand = Hand {
+				right: matches!(self.side, HandSide::Right),
+				thumb: Thumb {
+					tip: convert_joint(joints[HandBone::ThumbTip as usize]),
+					distal: convert_joint(joints[HandBone::ThumbDistal as usize]),
+					proximal: convert_joint(joints[HandBone::ThumbProximal as usize]),
+					metacarpal: convert_joint(joints[HandBone::ThumbMetacarpal as usize]),
+				},
+				index: Finger {
+					tip: convert_joint(joints[HandBone::IndexTip as usize]),
+					distal: convert_joint(joints[HandBone::IndexDistal as usize]),
+					intermediate: convert_joint(joints[HandBone::IndexIntermediate as usize]),
+					proximal: convert_joint(joints[HandBone::IndexProximal as usize]),
+					metacarpal: convert_joint(joints[HandBone::IndexMetacarpal as usize]),
+				},
+				middle: Finger {
+					tip: convert_joint(joints[HandBone::MiddleTip as usize]),
+					distal: convert_joint(joints[HandBone::MiddleDistal as usize]),
+					intermediate: convert_joint(joints[HandBone::MiddleIntermediate as usize]),
+					proximal: convert_joint(joints[HandBone::MiddleProximal as usize]),
+					metacarpal: convert_joint(joints[HandBone::MiddleMetacarpal as usize]),
+				},
+				ring: Finger {
+					tip: convert_joint(joints[HandBone::RingTip as usize]),
+					distal: convert_joint(joints[HandBone::RingDistal as usize]),
+					intermediate: convert_joint(joints[HandBone::RingIntermediate as usize]),
+					proximal: convert_joint(joints[HandBone::RingProximal as usize]),
+					metacarpal: convert_joint(joints[HandBone::RingMetacarpal as usize]),
+				},
+				little: Finger {
+					tip: convert_joint(joints[HandBone::LittleTip as usize]),
+					distal: convert_joint(joints[HandBone::LittleDistal as usize]),
+					intermediate: convert_joint(joints[HandBone::LittleIntermediate as usize]),
+					proximal: convert_joint(joints[HandBone::LittleProximal as usize]),
+					metacarpal: convert_joint(joints[HandBone::LittleMetacarpal as usize]),
+				},
+				palm: convert_joint(joints[HandBone::Palm as usize]),
+				wrist: convert_joint(joints[HandBone::Wrist as usize]),
+				elbow: None,
+			};
+			self.palm_spatial
+				.set_local_transform(Mat4::from_rotation_translation(
+					new_hand.palm.rotation.into(),
+					new_hand.palm.position.into(),
+				));
+
+			self.datamap.pinch_strength = pinch_between(&new_hand.thumb.tip, &new_hand.index.tip);
+			// this is how stereokit calculates grab
+			self.datamap.grab_strength =
+				pinch_between(&new_hand.ring.tip, &new_hand.ring.metacarpal);
+
+			*self.input.data.lock() = InputDataType::Hand(new_hand);
+			*self.input.datamap.lock() = Datamap::from_typed(&self.datamap).unwrap();
+			let captured = self.capture_manager.capture.upgrade().is_some();
+			if captured && !self.captured {
+				materials.get_mut(&self.material).unwrap().base_color =
+					Srgba::rgb(0., 1., 0.75).into();
+			} else if self.captured && !captured {
+				materials.get_mut(&self.material).unwrap().base_color =
+					Srgba::rgb(1., 1.0, 1.0).into();
+			}
+			self.captured = captured;
+		}
+
+		let distance_calculator = |space: &Arc<Spatial>, data: &InputDataType, field: &Field| {
+			let InputDataType::Hand(hand) = data else {
+				return None;
+			};
+			let thumb_tip_distance = field.distance(space, hand.thumb.tip.position.into());
+			let index_tip_distance = field.distance(space, hand.index.tip.position.into());
+			let middle_tip_distance = field.distance(space, hand.middle.tip.position.into());
+			let ring_tip_distance = field.distance(space, hand.ring.tip.position.into());
+
+			Some(
+				(thumb_tip_distance * 0.3)
+					+ (index_tip_distance * 0.4)
+					+ (middle_tip_distance * 0.15)
+					+ (ring_tip_distance * 0.15),
+			)
+		};
+
+		self.capture_manager.update_capture(&self.input);
+		self.capture_manager
+			.set_new_capture(&self.input, distance_calculator);
+		self.capture_manager.apply_capture(&self.input);
+
+		if self.capture_manager.capture.upgrade().is_some() {
+			return;
+		}
+
+		let sorted_handlers = get_sorted_handlers(&self.input, distance_calculator);
+		self.input
+			.set_handler_order(sorted_handlers.iter().map(|(handler, _)| handler));
+	}
+}

src/objects/input/sk_controller.rs

@@ -1,139 +0,0 @@
-use super::{CaptureManager, get_sorted_handlers};
-use crate::{
-	core::client::INTERNAL_CLIENT,
-	nodes::{
-		Node, OwnedNode,
-		fields::{Field, FieldTrait},
-		input::{INPUT_HANDLER_REGISTRY, InputDataType, InputHandler, InputMethod, Tip},
-		spatial::Spatial,
-	},
-	objects::{ObjectHandle, SpatialRef, Tracked},
-};
-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_rust::{
-	material::Material,
-	model::Model,
-	sk::MainThreadToken,
-	system::{Handed, Input},
-	util::Color128,
-};
-use zbus::Connection;
-
-#[derive(Default, Debug, Deserialize, Serialize)]
-struct ControllerDatamap {
-	select: f32,
-	middle: f32,
-	context: f32,
-	grab: f32,
-	scroll: Vec2,
-}
-
-pub struct SkController {
-	object_handle: ObjectHandle<SpatialRef>,
-	input: Arc<InputMethod>,
-	handed: Handed,
-	model: Model,
-	material: Material,
-	capture_manager: CaptureManager,
-	datamap: ControllerDatamap,
-	tracked: ObjectHandle<Tracked>,
-}
-impl SkController {
-	pub fn new(connection: &Connection, handed: Handed) -> Result<Self> {
-		Input::set_controller_model(handed, Some(Model::new()));
-		let path = "/org/stardustxr/Controller/".to_string()
-			+ match handed {
-				Handed::Left => "left",
-				_ => "right",
-			};
-		let (spatial, object_handle) = SpatialRef::create(connection, &path);
-		let tracked = Tracked::new(connection, &path);
-		let model = Model::copy(&Model::from_memory(
-			"cursor.glb",
-			include_bytes!("cursor.glb"),
-			None,
-		)?);
-		let model_nodes = model.get_nodes();
-		let mut model_node = model_nodes.visuals().next().unwrap();
-		let material = Material::copy(&model_node.get_material().unwrap());
-		model_node.material(&material);
-		let tip = InputDataType::Tip(Tip::default());
-		let input = InputMethod::add_to(
-			&spatial.node().unwrap(),
-			tip,
-			Datamap::from_typed(ControllerDatamap::default())?,
-		)?;
-		Ok(SkController {
-			object_handle,
-			input,
-			handed,
-			model,
-			material,
-			capture_manager: CaptureManager::default(),
-			datamap: Default::default(),
-			tracked,
-		})
-	}
-	pub fn update(&mut self, token: &MainThreadToken) {
-		let controller = Input::controller(self.handed);
-		let input_node = self.input.spatial.node().unwrap();
-		input_node.set_enabled(controller.tracked.is_active());
-		let enabled = input_node.enabled();
-		tokio::spawn({
-			// this is suboptimal since it probably allocates a fresh string every frame
-			let handle = self.tracked.clone();
-			async move {
-				handle.set_tracked(enabled).await;
-			}
-		});
-		if enabled {
-			let world_transform = Mat4::from_rotation_translation(
-				controller.aim.orientation.into(),
-				controller.aim.position.into(),
-			);
-			self.material
-				.color_tint(if self.capture_manager.capture.upgrade().is_none() {
-					Color128::new_rgb(1.0, 1.0, 1.0)
-				} else {
-					Color128::new_rgb(0.0, 1.0, 0.75)
-				});
-			self.model.draw(
-				token,
-				world_transform * Mat4::from_scale(Vec3::ONE * 0.02),
-				None,
-				None,
-			);
-			self.input.spatial.set_local_transform(world_transform);
-		}
-
-		self.datamap = ControllerDatamap {
-			select: controller.trigger,
-			middle: controller.stick_click.is_active() as u32 as f32,
-			context: controller.is_x2_pressed() as u32 as f32,
-			grab: controller.grip,
-			scroll: controller.stick.into(),
-		};
-		*self.input.datamap.lock() = Datamap::from_typed(&self.datamap).unwrap();
-
-		let distance_calculator = |space: &Arc<Spatial>, _data: &InputDataType, field: &Field| {
-			Some(field.distance(space, [0.0; 3].into()).abs())
-		};
-
-		self.capture_manager.update_capture(&self.input);
-		self.capture_manager
-			.set_new_capture(&self.input, distance_calculator);
-		self.capture_manager.apply_capture(&self.input);
-
-		if self.capture_manager.capture.upgrade().is_some() {
-			return;
-		}
-
-		let sorted_handlers = get_sorted_handlers(&self.input, distance_calculator);
-		self.input
-			.set_handler_order(sorted_handlers.iter().map(|(handler, _)| handler));
-	}
-}

src/objects/input/sk_hand.rs

@@ -1,198 +0,0 @@
-use crate::core::client::INTERNAL_CLIENT;
-use crate::nodes::OwnedNode;
-use crate::nodes::fields::{Field, FieldTrait};
-use crate::nodes::input::{INPUT_HANDLER_REGISTRY, InputDataType, InputHandler};
-use crate::nodes::{
-	Node,
-	input::{Hand, InputMethod, Joint},
-	spatial::Spatial,
-};
-use crate::objects::{ObjectHandle, SpatialRef, Tracked};
-use color_eyre::eyre::Result;
-use glam::{Mat4, Quat, Vec3};
-use serde::{Deserialize, Serialize};
-use stardust_xr::values::Datamap;
-use std::sync::Arc;
-use stereokit_rust::material::Material;
-use stereokit_rust::sk::{DisplayMode, MainThreadToken, Sk};
-use stereokit_rust::system::{HandJoint, HandSource, Handed, Input, LinePoint, Lines};
-use stereokit_rust::util::Color128;
-use zbus::Connection;
-
-use super::{CaptureManager, get_sorted_handlers};
-
-fn convert_joint(joint: HandJoint) -> Joint {
-	Joint {
-		position: Vec3::from(joint.position).into(),
-		rotation: Quat::from(joint.orientation).into(),
-		radius: joint.radius,
-		distance: 0.0,
-	}
-}
-
-#[derive(Default, Deserialize, Serialize)]
-struct HandDatamap {
-	pinch_strength: f32,
-	grab_strength: f32,
-}
-
-pub struct SkHand {
-	_node: OwnedNode,
-	palm_spatial: Arc<Spatial>,
-	palm_object: ObjectHandle<SpatialRef>,
-	handed: Handed,
-	input: Arc<InputMethod>,
-	capture_manager: CaptureManager,
-	datamap: HandDatamap,
-	tracked: ObjectHandle<Tracked>,
-}
-impl SkHand {
-	pub fn new(connection: &Connection, handed: Handed) -> Result<Self> {
-		let (palm_spatial, palm_object) = SpatialRef::create(
-			connection,
-			&("/org/stardustxr/Hand/".to_string()
-				+ match handed {
-					Handed::Left => "left",
-					_ => "right",
-				} + "/palm"),
-		);
-		let tracked = Tracked::new(
-			connection,
-			&("/org/stardustxr/Hand/".to_string()
-				+ match handed {
-					Handed::Left => "left",
-					_ => "right",
-				}),
-		);
-		let _node = Node::generate(&INTERNAL_CLIENT, false).add_to_scenegraph_owned()?;
-		Spatial::add_to(&_node.0, None, Mat4::IDENTITY, false);
-		let hand = InputDataType::Hand(Hand {
-			right: handed == Handed::Right,
-			..Default::default()
-		});
-		let datamap = Datamap::from_typed(HandDatamap::default())?;
-		let input = InputMethod::add_to(&_node.0, hand, datamap)?;
-		Input::hand_visible(handed, true);
-
-		Ok(SkHand {
-			_node,
-			palm_spatial,
-			palm_object,
-			handed,
-			input,
-			tracked,
-			capture_manager: CaptureManager::default(),
-			datamap: Default::default(),
-		})
-	}
-	pub fn update(&mut self, sk: &Sk, token: &MainThreadToken, material: &mut Material) {
-		let sk_hand = Input::hand(self.handed);
-		let real_hand = Input::hand_source(self.handed) as u32 == HandSource::Articulated as u32;
-		if let InputDataType::Hand(hand) = &mut *self.input.data.lock() {
-			let input_node = self.input.spatial.node().unwrap();
-			input_node.set_enabled(
-				(real_hand || sk.get_active_display_mode() == DisplayMode::Flatscreen)
-					&& sk_hand.tracked.is_active(),
-			);
-			let enabled = input_node.enabled();
-			tokio::spawn({
-				// this is suboptimal since it probably allocates a fresh string every frame
-				let handle = self.tracked.clone();
-				async move {
-					handle.set_tracked(enabled).await;
-				}
-			});
-			if enabled {
-				hand.thumb.tip = convert_joint(sk_hand.fingers[0][4]);
-				hand.thumb.distal = convert_joint(sk_hand.fingers[0][3]);
-				hand.thumb.proximal = convert_joint(sk_hand.fingers[0][2]);
-				hand.thumb.metacarpal = convert_joint(sk_hand.fingers[0][1]);
-
-				for (finger, mut sk_finger) in [
-					(&mut hand.index, sk_hand.fingers[1]),
-					(&mut hand.middle, sk_hand.fingers[2]),
-					(&mut hand.ring, sk_hand.fingers[3]),
-					(&mut hand.little, sk_hand.fingers[4]),
-				] {
-					sk_finger[4].radius = 0.0;
-					finger.tip = convert_joint(sk_finger[4]);
-					finger.distal = convert_joint(sk_finger[3]);
-					finger.intermediate = convert_joint(sk_finger[2]);
-					finger.proximal = convert_joint(sk_finger[1]);
-					finger.metacarpal = convert_joint(sk_finger[0]);
-				}
-
-				hand.palm.position = Vec3::from(sk_hand.palm.position).into();
-				hand.palm.rotation = Quat::from(sk_hand.palm.orientation).into();
-				hand.palm.radius =
-					(sk_hand.fingers[2][0].radius + sk_hand.fingers[2][1].radius) * 0.5;
-
-				self.palm_spatial
-					.set_local_transform(Mat4::from_rotation_translation(
-						hand.palm.rotation.into(),
-						hand.palm.position.into(),
-					));
-
-				hand.wrist.position = Vec3::from(sk_hand.wrist.position).into();
-				hand.wrist.rotation = Quat::from(sk_hand.wrist.orientation).into();
-				hand.wrist.radius =
-					(sk_hand.fingers[0][0].radius + sk_hand.fingers[4][0].radius) * 0.5;
-
-				hand.elbow = None;
-
-				let hand_color = if self.capture_manager.capture.upgrade().is_none() {
-					Color128::new_rgb(1.0, 1.0, 1.0)
-				} else {
-					Color128::new_rgb(0.0, 1.0, 0.75)
-				};
-				material.color_tint(hand_color);
-			}
-		}
-		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).unwrap();
-
-		let distance_calculator = |space: &Arc<Spatial>, data: &InputDataType, field: &Field| {
-			let InputDataType::Hand(hand) = data else {
-				return None;
-			};
-			let thumb_tip_distance = field.distance(space, hand.thumb.tip.position.into());
-			let index_tip_distance = field.distance(space, hand.index.tip.position.into());
-			let middle_tip_distance = field.distance(space, hand.middle.tip.position.into());
-			let ring_tip_distance = field.distance(space, hand.ring.tip.position.into());
-
-			Some(
-				(thumb_tip_distance * 0.3)
-					+ (index_tip_distance * 0.4)
-					+ (middle_tip_distance * 0.15)
-					+ (ring_tip_distance * 0.15),
-			)
-		};
-
-		self.capture_manager.update_capture(&self.input);
-		self.capture_manager
-			.set_new_capture(&self.input, distance_calculator);
-		self.capture_manager.apply_capture(&self.input);
-
-		if self.capture_manager.capture.upgrade().is_some() {
-			return;
-		}
-
-		let sorted_handlers = get_sorted_handlers(&self.input, distance_calculator);
-		self.input
-			.set_handler_order(sorted_handlers.iter().map(|(handler, _)| handler));
-	}
-}
-impl Drop for SkHand {
-	fn drop(&mut self) {
-		Input::hand_visible(self.handed, false);
-	}
-}
-
-fn joint_to_line_point(joint: &Joint, color: Color128) -> LinePoint {
-	LinePoint {
-		pt: Vec3::from(joint.position).into(),
-		thickness: joint.radius * 2.0,
-		color: color.into(),
-	}
-}

src/objects/mod.rs

@@ -10,195 +10,23 @@ use crate::{
 };
 use glam::{Mat4, vec3};
 use input::{
-	eye_pointer::EyePointer, mouse_pointer::MousePointer, sk_controller::SkController,
+	eye_pointer::EyePointer, mouse_pointer::MousePointer, oxr_controller::OxrControllerInput,
-	sk_hand::SkHand,
+	oxr_hand::OxrHandInput,
 };
+use parking_lot::RwLock;
 use play_space::PlaySpaceBounds;
 use stardust_xr::schemas::dbus::object_registry::ObjectRegistry;
 use std::{
 	marker::PhantomData,
 	sync::{Arc, atomic::Ordering},
 };
-use stereokit_rust::{
+use tokio::{sync::mpsc, task::AbortHandle};
-	material::Material,
-	sk::{DisplayMode, MainThreadToken, Sk},
-	system::{Handed, Input, Key, World},
-	util::Device,
-};
 use zbus::{Connection, interface, object_server::Interface, zvariant::OwnedObjectPath};
 
+pub mod hmd;
 pub mod input;
 pub mod play_space;
 
-enum Inputs {
-	XR {
-		controller_left: SkController,
-		controller_right: SkController,
-		hand_left: SkHand,
-		hand_right: SkHand,
-		eye_pointer: Option<EyePointer>,
-	},
-	MousePointer(MousePointer),
-	// Controllers((SkController, SkController)),
-	Hands {
-		left: SkHand,
-		right: SkHand,
-	},
-}
-
-pub struct ServerObjects {
-	connection: Connection,
-	hmd: (Arc<Spatial>, ObjectHandle<SpatialRef>),
-	play_space: Option<(Arc<Spatial>, ObjectHandle<SpatialRef>)>,
-	hand_materials: [Material; 2],
-	inputs: Inputs,
-	disable_controllers: bool,
-	disable_hands: bool,
-}
-impl ServerObjects {
-	pub fn new(
-		connection: Connection,
-		sk: &Sk,
-		hand_materials: [Material; 2],
-		disable_controllers: bool,
-		disable_hands: bool,
-	) -> ServerObjects {
-		let hmd = SpatialRef::create(&connection, "/org/stardustxr/HMD");
-
-		let play_space = Some(SpatialRef::create(&connection, "/org/stardustxr/PlaySpace"));
-		if play_space.is_some() {
-			let dbus_connection = connection.clone();
-			tokio::task::spawn(async move {
-				PlaySpaceBounds::create(&dbus_connection).await;
-				dbus_connection
-					.request_name("org.stardustxr.PlaySpace")
-					.await
-					.unwrap();
-			});
-		}
-
-		tokio::task::spawn({
-			let connection = connection.clone();
-			async move {
-				connection
-					.request_name("org.stardustxr.Controllers")
-					.await
-					.unwrap();
-				connection
-					.request_name("org.stardustxr.Hands")
-					.await
-					.unwrap();
-			}
-		});
-
-		let inputs = if sk.get_active_display_mode() == DisplayMode::MixedReality {
-			Inputs::XR {
-				controller_left: SkController::new(&connection, Handed::Left).unwrap(),
-				controller_right: SkController::new(&connection, Handed::Right).unwrap(),
-				hand_left: SkHand::new(&connection, Handed::Left).unwrap(),
-				hand_right: SkHand::new(&connection, Handed::Right).unwrap(),
-				eye_pointer: Device::has_eye_gaze()
-					.then(EyePointer::new)
-					.transpose()
-					.unwrap(),
-			}
-		} else {
-			Inputs::MousePointer(MousePointer::new().unwrap())
-		};
-
-		ServerObjects {
-			connection,
-			hmd,
-			play_space,
-			hand_materials,
-			inputs,
-			disable_controllers,
-			disable_hands,
-		}
-	}
-
-	pub fn update(
-		&mut self,
-		sk: &Sk,
-		token: &MainThreadToken,
-		dbus_connection: &Connection,
-		object_registry: &ObjectRegistry,
-	) {
-		let hmd_pose = Input::get_head();
-		self.hmd
-			.0
-			.set_local_transform(Mat4::from_scale_rotation_translation(
-				vec3(1.0, 1.0, 1.0),
-				hmd_pose.orientation.into(),
-				hmd_pose.position.into(),
-			));
-
-		if let Some(play_space) = self.play_space.as_ref() {
-			let pose = World::get_bounds_pose();
-			play_space
-				.0
-				.set_local_transform(Mat4::from_rotation_translation(
-					pose.orientation.into(),
-					pose.position.into(),
-				));
-		}
-
-		#[allow(clippy::collapsible_if)]
-		if sk.get_active_display_mode() != DisplayMode::MixedReality {
-			if Input::key(Key::F6).is_just_inactive() {
-				self.inputs = Inputs::MousePointer(MousePointer::new().unwrap());
-			}
-			// if Input::key(Key::F7).is_just_inactive() {
-			// 	self.inputs = Inputs::Controllers((
-			// 		SkController::new(Handed::Left).unwrap(),
-			// 		SkController::new(Handed::Right).unwrap(),
-			// 	));
-			// }
-			// if Input::key(Key::F8).is_just_inactive() {
-			// 	self.inputs = Inputs::Hands {
-			// 		left: SkHand::new(&self.connection, Handed::Left).unwrap(),
-			// 		right: SkHand::new(&self.connection, Handed::Right).unwrap(),
-			// 	};
-			// }
-		}
-
-		match &mut self.inputs {
-			Inputs::XR {
-				controller_left,
-				controller_right,
-				hand_left,
-				hand_right,
-				eye_pointer,
-			} => {
-				if !self.disable_controllers {
-					controller_left.update(token);
-					controller_right.update(token);
-				}
-				Input::hand_visible(Handed::Left, !self.disable_hands);
-				Input::hand_visible(Handed::Right, !self.disable_hands);
-				if !self.disable_hands {
-					hand_left.update(sk, token, &mut self.hand_materials[0]);
-					hand_right.update(sk, token, &mut self.hand_materials[1]);
-				}
-				if let Some(eye_pointer) = eye_pointer {
-					eye_pointer.update();
-				}
-			}
-			Inputs::MousePointer(mouse_pointer) => {
-				mouse_pointer.update(dbus_connection, object_registry)
-			}
-			// Inputs::Controllers((left, right)) => {
-			// 	left.update(token);
-			// 	right.update(token);
-			// }
-			Inputs::Hands { left, right } => {
-				left.update(sk, token, &mut self.hand_materials[0]);
-				right.update(sk, token, &mut self.hand_materials[1]);
-			}
-		}
-	}
-}
-
 pub struct ObjectHandle<I: Interface>(Connection, OwnedObjectPath, PhantomData<I>);
 
 impl<I: Interface> Clone for ObjectHandle<I> {
@@ -216,13 +44,57 @@ impl<I: Interface> Drop for ObjectHandle<I> {
 	}
 }
 
+/// A wrapper around ObjectHandle<Tracked> that batches async updates
+/// instead of spawning a tokio task for each state change
+pub struct AsyncTracked {
+	pub sender: mpsc::UnboundedSender<bool>,
+	pub _handle: ObjectHandle<Tracked>,
+	pub _abort_handle: AbortHandle,
+}
+
+impl AsyncTracked {
+	pub fn new(connection: &Connection, path: &str) -> Self {
+		let handle = Tracked::new(connection, path);
+		let (sender, mut receiver) = mpsc::unbounded_channel::<bool>();
+
+		// Spawn a single long-running task that processes state updates
+		let task = tokio::task::spawn({
+			let handle = handle.clone();
+			async move {
+				while let Some(is_tracked) = receiver.recv().await {
+					let _ = handle.set_tracked(is_tracked).await;
+				}
+			}
+		});
+
+		Self {
+			sender,
+			_handle: handle,
+			_abort_handle: task.abort_handle(),
+		}
+	}
+
+	pub fn set_tracked(&self, is_tracked: bool) {
+		// Just send over channel instead of spawning a task
+		let _ = self.sender.send(is_tracked);
+	}
+}
+
+impl Drop for AsyncTracked {
+	fn drop(&mut self) {
+		self._abort_handle.abort();
+	}
+}
+
 pub struct SpatialRef(u64, OwnedNode);
 impl SpatialRef {
 	pub fn create(connection: &Connection, path: &str) -> (Arc<Spatial>, ObjectHandle<SpatialRef>) {
 		let node = OwnedNode(Arc::new(Node::generate(&INTERNAL_CLIENT, false)));
 		let spatial = Spatial::add_to(&node.0, None, Mat4::IDENTITY, false);
 		let uid: u64 = rand::random();
-		EXPORTED_SPATIALS.lock().insert(uid, node.0.clone());
+		EXPORTED_SPATIALS
+			.lock()
+			.insert(uid, Arc::downgrade(&node.0));
 
 		tokio::task::spawn({
 			let connection = connection.clone();
@@ -310,7 +182,7 @@ impl FieldRef {
 		Spatial::add_to(&node.0, None, Mat4::IDENTITY, false);
 		let field = Field::add_to(&node.0, shape).unwrap();
 		let uid: u64 = rand::random();
-		EXPORTED_FIELDS.lock().insert(uid, node.0.clone());
+		EXPORTED_FIELDS.lock().insert(uid, Arc::downgrade(&node.0));
 
 		tokio::task::spawn({
 			let connection = connection.clone();

src/objects/play_space.rs

@@ -1,12 +1,145 @@
-use stereokit_rust::system::World;
+use std::sync::Arc;
+
+use bevy::prelude::*;
+use bevy_mod_openxr::{
+	helper_traits::{ToQuat, ToVec3},
+	resources::{OxrFrameState, Pipelined},
+	session::OxrSession,
+};
+use bevy_mod_xr::{
+	session::{XrPreDestroySession, XrSessionCreated},
+	spaces::{XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace},
+};
+use openxr::SpaceLocationFlags;
+use parking_lot::RwLock;
 use zbus::{Connection, ObjectServer, interface};
 
-pub struct PlaySpaceBounds;
+use crate::{DbusConnection, PreFrameWait, get_time, nodes::spatial::Spatial};
+
+use super::{AsyncTracked, ObjectHandle, SpatialRef, Tracked};
+
+pub struct PlaySpacePlugin;
+impl Plugin for PlaySpacePlugin {
+	fn build(&self, app: &mut App) {
+		app.add_systems(XrPreDestroySession, destroy_stage_space);
+		app.add_systems(XrSessionCreated, create_stage_space);
+		app.add_systems(PreFrameWait, update);
+		app.add_systems(Startup, setup);
+	}
+}
+
+fn setup(connection: Res<DbusConnection>, mut cmds: Commands) {
+	let (spatial, spatial_handle) = SpatialRef::create(&connection, "/org/stardustxr/PlaySpace");
+	// the OpenXR session might not exist quite yet
+	let tracked = AsyncTracked::new(&connection, "/org/stardustxr/PlaySpace");
+	let dbus_connection = connection.clone();
+	let play_space_data = Arc::new(RwLock::default());
+	tokio::task::spawn({
+		let data = play_space_data.clone();
+		async move {
+			PlaySpaceBounds::create(&dbus_connection, data).await;
+			dbus_connection
+				.request_name("org.stardustxr.PlaySpace")
+				.await
+				.unwrap();
+		}
+	});
+	cmds.insert_resource(PlaySpace {
+		spatial,
+		_spatial_handle: spatial_handle,
+		tracked_handle: tracked,
+		bounds: play_space_data,
+	});
+}
+
+#[derive(Resource)]
+struct StageSpace(XrSpace);
+fn create_stage_space(session: Res<OxrSession>, mut cmds: Commands) {
+	let space = session
+		.create_reference_space(openxr::ReferenceSpaceType::STAGE, Transform::IDENTITY)
+		.inspect_err(|err| error!("failed to create Stage XrSpace"))
+		.ok();
+	if let Some(space) = space {
+		cmds.insert_resource(StageSpace(space.0));
+	}
+}
+fn destroy_stage_space(session: Res<OxrSession>, mut cmds: Commands, stage: Res<StageSpace>) {
+	session.destroy_space(stage.0);
+	cmds.remove_resource::<StageSpace>();
+}
+
+/// TODO: impl this
+fn update(
+	session: Option<Res<OxrSession>>,
+	stage: Option<Res<StageSpace>>,
+	ref_space: Option<Res<XrPrimaryReferenceSpace>>,
+	play_space: Res<PlaySpace>,
+	state: Option<Res<OxrFrameState>>,
+	pipelined: Option<Res<Pipelined>>,
+) {
+	let (Some(session), Some(stage), Some(ref_space), Some(state)) =
+		(session, stage, ref_space, state)
+	else {
+		play_space.bounds.write().drain(..);
+		play_space.tracked_handle.set_tracked(false);
+
+		play_space
+			.spatial
+			.set_local_transform(Mat4::from_translation(vec3(0.0, -1.65, 0.0)));
+		return;
+	};
+	let time = get_time(pipelined.is_some(), &state);
+	let location = session
+		.locate_space(&stage.0, &ref_space, time)
+		.inspect_err(|err| error!("Error while Locating OpenXR Stage Space {err}"));
+	if let Ok(location) = location {
+		let is_tracked = location.location_flags.contains(
+			SpaceLocationFlags::POSITION_VALID
+				| SpaceLocationFlags::POSITION_TRACKED
+				| SpaceLocationFlags::ORIENTATION_VALID
+				| SpaceLocationFlags::ORIENTATION_TRACKED,
+		);
+		play_space.tracked_handle.set_tracked(is_tracked);
+		if is_tracked {
+			play_space
+				.spatial
+				.set_local_transform(Mat4::from_rotation_translation(
+					location.pose.orientation.to_quat(),
+					location.pose.position.to_vec3(),
+				));
+		}
+	}
+	// session.reference_space_bounds_rect(openxr::ReferenceSpaceType::STAGE);
+
+	// if (World::has_bounds()
+	// 	&& World::get_bounds_size().x != 0.0
+	// 	&& World::get_bounds_size().y != 0.0)
+	// {
+	// 	let bounds = World::get_bounds_size();
+	// 	vec![
+	// 		((bounds.x).into(), (bounds.y).into()),
+	// 		((bounds.x).into(), (-bounds.y).into()),
+	// 		((-bounds.x).into(), (-bounds.y).into()),
+	// 		((-bounds.x).into(), (bounds.y).into()),
+	// 	]
+	// } else {
+	// 	vec![]
+	// }
+}
+
+#[derive(Resource)]
+pub struct PlaySpace {
+	spatial: Arc<Spatial>,
+	_spatial_handle: ObjectHandle<SpatialRef>,
+	tracked_handle: AsyncTracked,
+	bounds: Arc<RwLock<Vec<(f64, f64)>>>,
+}
+pub struct PlaySpaceBounds(Arc<RwLock<Vec<(f64, f64)>>>);
 impl PlaySpaceBounds {
-	pub async fn create(connection: &Connection) {
+	pub async fn create(connection: &Connection, data: Arc<RwLock<Vec<(f64, f64)>>>) {
 		connection
 			.object_server()
-			.at("/org/stardustxr/PlaySpace", Self)
+			.at("/org/stardustxr/PlaySpace", Self(data))
 			.await
 			.unwrap();
 	}
@@ -15,19 +148,6 @@ impl PlaySpaceBounds {
 impl PlaySpaceBounds {
 	#[zbus(property)]
 	fn bounds(&self) -> Vec<(f64, f64)> {
-		if (World::has_bounds()
+		self.0.read().clone()
-			&& World::get_bounds_size().x != 0.0
-			&& World::get_bounds_size().y != 0.0)
-		{
-			let bounds = World::get_bounds_size();
-			vec![
-				((bounds.x).into(), (bounds.y).into()),
-				((bounds.x).into(), (-bounds.y).into()),
-				((-bounds.x).into(), (-bounds.y).into()),
-				((-bounds.x).into(), (bounds.y).into()),
-			]
-		} else {
-			vec![]
-		}
 	}
 }

src/session.rs

@@ -5,6 +5,7 @@ use crate::wayland::WAYLAND_DISPLAY;
 use crate::{CliArgs, STARDUST_INSTANCE};
 use directories::ProjectDirs;
 use rustc_hash::FxHashMap;
+use std::ffi::OsStr;
 use std::os::unix::fs::PermissionsExt;
 use std::path::Path;
 use std::process::{Child, Command, Stdio};
@@ -58,6 +59,7 @@ pub fn restore_session(session_dir: &Path, debug_launched_clients: bool) -> Vec<
 	};
 	clients
 		.filter_map(Result::ok)
+		.filter(|c| c.path().extension() == Some(OsStr::new("toml")))
 		.filter_map(|c| ClientStateParsed::from_file(&c.path()))
 		.filter_map(ClientStateParsed::launch_command)
 		.filter_map(|c| run_client(c, debug_launched_clients))
@@ -86,14 +88,11 @@ pub fn run_client(mut command: Command, debug_launched_clients: bool) -> Option<
 }
 
 pub fn connection_env() -> FxHashMap<String, String> {
-	macro_rules! var_env_insert {
-		($env:ident, $name:ident) => {
-			$env.insert(stringify!($name).to_string(), $name.get().unwrap().clone());
-		};
-	}
-
 	let mut env: FxHashMap<String, String> = FxHashMap::default();
-	var_env_insert!(env, STARDUST_INSTANCE);
+	env.insert(
+		stringify!(STARDUST_INSTANCE).to_string(),
+		STARDUST_INSTANCE.get().unwrap().clone(),
+	);
 
 	if let Some(flat_wayland_display) = std::env::var_os("WAYLAND_DISPLAY") {
 		env.insert(
@@ -103,7 +102,10 @@ pub fn connection_env() -> FxHashMap<String, String> {
 	}
 	#[cfg(feature = "wayland")]
 	{
-		var_env_insert!(env, WAYLAND_DISPLAY);
+		env.insert(
+			stringify!(WAYLAND_DISPLAY).to_string(),
+			WAYLAND_DISPLAY.get().unwrap().to_string_lossy().to_string(),
+		);
 		env.insert("XDG_SESSION_TYPE".to_string(), "wayland".to_string());
 	}
 	env

src/spectator_cam.rs

@@ -0,0 +1,39 @@
+use bevy::{
+	app::Plugin,
+	core_pipeline::core_3d::Camera3d,
+	ecs::{
+		component::Component,
+		system::{Commands, Res},
+	},
+	render::camera::{PerspectiveProjection, Projection},
+	transform::components::Transform,
+};
+use bevy_mod_openxr::session::OxrSession;
+use bevy_mod_xr::session::XrSessionCreated;
+use openxr::ReferenceSpaceType;
+
+pub struct SpectatorCameraPlugin;
+
+impl Plugin for SpectatorCameraPlugin {
+	fn build(&self, app: &mut bevy::app::App) {
+		app.add_systems(XrSessionCreated, create);
+	}
+}
+
+#[derive(Component)]
+#[require(Camera3d)]
+struct SpectatorCam;
+
+fn create(session: Res<OxrSession>, mut cmds: Commands) {
+	cmds.spawn((
+		SpectatorCam,
+		session
+			.create_reference_space(ReferenceSpaceType::VIEW, Transform::IDENTITY)
+			.unwrap()
+			.0,
+		Projection::Perspective(PerspectiveProjection {
+			fov: 100f32.to_radians(),
+			..Default::default()
+		}),
+	));
+}

src/tracking_offset.rs

@@ -0,0 +1,82 @@
+use bevy::{
+	app::{Plugin, Update},
+	ecs::{
+		resource::Resource,
+		schedule::{Condition, IntoScheduleConfigs, common_conditions::resource_exists},
+		system::{Commands, Res, ResMut},
+	},
+	transform::components::Transform,
+};
+use bevy_mod_openxr::{
+	helper_traits::ToTransform as _,
+	poll_events::{OxrEventHandlerExt, OxrEventIn},
+	resources::OxrFrameState,
+	session::OxrSession,
+};
+use bevy_mod_xr::{session::XrSessionCreated, spaces::XrPrimaryReferenceSpace};
+use glam::{Quat, Vec3};
+use openxr::ReferenceSpaceType;
+
+pub struct TrackingOffsetPlugin;
+
+impl Plugin for TrackingOffsetPlugin {
+	fn build(&self, app: &mut bevy::app::App) {
+		app.add_oxr_event_handler(reset_offset);
+		app.add_systems(XrSessionCreated, |mut cmds: Commands| {
+			cmds.insert_resource(OffsetTag);
+		});
+		app.add_systems(
+			Update,
+			offset.run_if(resource_exists::<OffsetTag>.and(resource_exists::<OxrFrameState>)),
+		);
+	}
+}
+
+#[derive(Resource)]
+struct OffsetTag;
+
+fn reset_offset(
+	oxr_event: OxrEventIn,
+	mut ref_space: ResMut<XrPrimaryReferenceSpace>,
+	session: Res<OxrSession>,
+) {
+	if let openxr::Event::ReferenceSpaceChangePending(v) = *oxr_event
+		&& v.reference_space_type() == ReferenceSpaceType::LOCAL
+	{
+		let space = session
+			.create_reference_space(ReferenceSpaceType::LOCAL, Transform::IDENTITY)
+			.unwrap();
+		session.destroy_space(ref_space.0.0).unwrap();
+		ref_space.0 = space;
+	}
+}
+
+fn offset(
+	session: Res<OxrSession>,
+	state: Res<OxrFrameState>,
+	mut primary_ref_space: ResMut<XrPrimaryReferenceSpace>,
+	mut cmds: Commands,
+) {
+	cmds.remove_resource::<OffsetTag>();
+	let local = session
+		.create_reference_space(ReferenceSpaceType::LOCAL, Transform::IDENTITY)
+		.unwrap();
+	let view = session
+		.create_reference_space(ReferenceSpaceType::VIEW, Transform::IDENTITY)
+		.unwrap();
+	let view_pose = session
+		.locate_space(&view, &local, state.predicted_display_time)
+		.unwrap()
+		.pose
+		.to_transform();
+	let offset = view_pose.with_rotation(Quat::from_axis_angle(
+		Vec3::Y,
+		view_pose.rotation.to_euler(glam::EulerRot::XYZ).1,
+	));
+	let offset = Transform::from_matrix(offset.compute_matrix());
+	let local_offset = session
+		.create_reference_space(ReferenceSpaceType::LOCAL, offset)
+		.unwrap();
+	session.destroy_space(primary_ref_space.0.0).unwrap();
+	primary_ref_space.0 = local_offset;
+}

src/wayland/compositor.rs

@@ -1,152 +0,0 @@
-use super::{
-	state::{ClientState, WaylandState},
-	utils::{ChildInfoExt, WlSurfaceExt},
-	xdg_shell::surface_panel_item,
-};
-use crate::{
-	nodes::items::panel::{ChildInfo, Geometry, SurfaceId},
-	wayland::surface::CoreSurface,
-};
-use parking_lot::Mutex;
-use rand::Rng;
-use smithay::{
-	backend::renderer::utils::{RendererSurfaceStateUserData, on_commit_buffer_handler},
-	delegate_compositor,
-	desktop::PopupKind,
-	reexports::wayland_server::{Client, protocol::wl_surface::WlSurface},
-	wayland::compositor::{
-		CompositorClientState, CompositorHandler, CompositorState, add_post_commit_hook,
-	},
-};
-use std::sync::Arc;
-use tracing::{debug, warn};
-
-pub struct ConfiguredSurface;
-
-impl CompositorHandler for WaylandState {
-	fn compositor_state(&mut self) -> &mut CompositorState {
-		&mut self.compositor_state
-	}
-
-	fn commit(&mut self, surface: &WlSurface) {
-		debug!(?surface, "Surface commit");
-
-		on_commit_buffer_handler::<WaylandState>(surface);
-
-		if let Some(toplevel) = self
-			.xdg_shell
-			.toplevel_surfaces()
-			.iter()
-			.find(|s| s.wl_surface() == surface)
-		{
-			if !toplevel.is_initial_configure_sent() {
-				debug!("Sending initial configure for toplevel surface");
-				toplevel.send_configure();
-				surface.insert_data(ConfiguredSurface);
-			}
-		}
-
-		self.popup_manager.commit(surface);
-		if let Some(PopupKind::Xdg(popup)) = self.popup_manager.find_popup(surface) {
-			if surface.insert_data(ConfiguredSurface) {
-				debug!("Configuring popup surface");
-				let _ = popup.send_configure();
-			}
-		}
-	}
-
-	fn client_compositor_state<'a>(&self, client: &'a Client) -> &'a CompositorClientState {
-		&client.get_data::<ClientState>().unwrap().compositor_state
-	}
-
-	fn new_subsurface(&mut self, surface: &WlSurface, parent: &WlSurface) {
-		let id = rand::thread_rng().gen_range(0..u64::MAX);
-		surface.insert_data(SurfaceId::Child(id));
-		CoreSurface::add_to(surface);
-		let Some(parent_surface_id) = parent.get_data::<SurfaceId>() else {
-			warn!("Parent surface has no SurfaceId");
-			return;
-		};
-		surface.insert_data(Mutex::new(ChildInfo {
-			id,
-			parent: parent_surface_id,
-			geometry: Geometry {
-				origin: [0; 2].into(),
-				size: [256; 2].into(),
-			},
-			z_order: 1,
-			receives_input: false,
-		}));
-
-		let Some(panel_item) = surface_panel_item(parent) else {
-			warn!("Parent has no panel item");
-			return;
-		};
-		let panel_item_weak = Arc::downgrade(&panel_item);
-		add_post_commit_hook(surface, move |_: &mut WaylandState, _dh, surf| {
-			if surface_panel_item(surf).is_some() {
-				return;
-			}
-			debug!("Linking surface to panel item");
-			surf.insert_data(panel_item_weak.clone());
-
-			let Some(panel_item) = surface_panel_item(surf) else {
-				warn!("Failed to link surface to panel item");
-				return;
-			};
-
-			surf.with_child_info(|_info| {
-				panel_item.backend.reposition_child(surf);
-			});
-
-			debug!("Adding new child to panel item");
-			panel_item.backend.new_child(surf);
-		});
-
-		add_post_commit_hook(surface, move |_: &mut WaylandState, _dh, surf| {
-			let Some(view) = surf
-				.get_data_raw::<RendererSurfaceStateUserData, _, _>(|s| s.lock().ok()?.view())
-				.flatten()
-			else {
-				debug!("No view data for surface");
-				return;
-			};
-			let mut changed = false;
-			surf.with_child_info(|info| {
-				if info.geometry.origin.x != view.offset.x
-					&& info.geometry.origin.y != view.offset.y
-				{
-					changed = true;
-					debug!("Surface position changed");
-				}
-				if info.geometry.size.x != view.dst.w as u32
-					&& info.geometry.size.y != view.dst.h as u32
-				{
-					changed = true;
-					debug!("Surface size changed");
-				}
-				info.geometry.size = [view.dst.w as u32, view.dst.h as u32].into();
-			});
-
-			let Some(panel_item) = surface_panel_item(surf) else {
-				return;
-			};
-			if changed {
-				debug!("Repositioning child due to geometry change");
-				panel_item.backend.reposition_child(surf);
-			}
-		});
-	}
-
-	fn destroyed(&mut self, surface: &WlSurface) {
-		let Some(panel_item) = surface_panel_item(surface) else {
-			return;
-		};
-		if surface.get_child_info().is_some() {
-			debug!("Dropping destroyed child surface");
-			panel_item.backend.drop_child(surface);
-		}
-	}
-}
-
-delegate_compositor!(WaylandState);

src/wayland/core/buffer.rs

@@ -0,0 +1,112 @@
+use crate::wayland::dmabuf::buffer_backing::DmabufBacking;
+use crate::wayland::{Client, Message, WaylandResult};
+use crate::wayland::{MessageSink, core::shm_buffer_backing::ShmBufferBacking, util::ClientExt};
+use bevy::{
+	asset::{Assets, Handle},
+	image::Image,
+};
+use bevy_dmabuf::import::ImportedDmatexs;
+use mint::Vector2;
+use std::sync::Arc;
+use waynest::ObjectId;
+pub use waynest_protocols::server::core::wayland::wl_buffer::*;
+use waynest_server::{Client as _, RequestDispatcher};
+
+#[derive(Debug)]
+pub struct BufferUsage {
+	pub buffer: Arc<Buffer>,
+	message_sink: MessageSink,
+}
+impl BufferUsage {
+	pub fn new(client: &Client, buffer: &Arc<Buffer>) -> Arc<Self> {
+		Arc::new(Self {
+			buffer: buffer.clone(),
+			message_sink: client.message_sink(),
+		})
+	}
+}
+impl Drop for BufferUsage {
+	fn drop(&mut self) {
+		let _ = self
+			.message_sink
+			.send(Message::ReleaseBuffer(self.buffer.clone()));
+	}
+}
+
+#[derive(Debug)]
+pub enum BufferBacking {
+	Shm(ShmBufferBacking),
+	Dmabuf(DmabufBacking),
+}
+
+#[derive(Debug, RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Buffer {
+	pub id: ObjectId,
+	backing: BufferBacking,
+}
+
+impl Buffer {
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn new(
+		client: &mut Client,
+		id: ObjectId,
+		backing: BufferBacking,
+	) -> WaylandResult<Arc<Self>> {
+		Ok(client.insert(id, Self { id, backing })?)
+	}
+
+	/// Returns the tex if it was updated
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn update_tex(
+		&self,
+		dmatexes: &ImportedDmatexs,
+		images: &mut Assets<Image>,
+	) -> Option<Handle<Image>> {
+		tracing::debug!("Updating texture for buffer {:?}", self.id);
+		match &self.backing {
+			BufferBacking::Shm(backing) => backing.update_tex(dmatexes, images),
+			BufferBacking::Dmabuf(backing) => backing.update_tex(dmatexes, images),
+		}
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn on_commit(&self) {
+		tracing::debug!("running on_commit for buffer {:?}", self.id);
+		match &self.backing {
+			BufferBacking::Shm(backing) => backing.on_commit(),
+			BufferBacking::Dmabuf(_backing) => {}
+		}
+	}
+
+	pub fn is_transparent(&self) -> bool {
+		match &self.backing {
+			BufferBacking::Shm(backing) => backing.is_transparent(),
+			BufferBacking::Dmabuf(backing) => backing.is_transparent(),
+		}
+	}
+
+	pub fn size(&self) -> Vector2<usize> {
+		match &self.backing {
+			BufferBacking::Shm(backing) => backing.size(),
+			BufferBacking::Dmabuf(backing) => backing.size(),
+		}
+	}
+	pub fn uses_buffer_usage(&self) -> bool {
+		matches!(
+			self.backing,
+			BufferBacking::Dmabuf(_) | BufferBacking::Shm(_)
+		)
+	}
+}
+
+impl WlBuffer for Buffer {
+	type Connection = crate::wayland::Client;
+
+	/// https://wayland.app/protocols/wayland#wl_buffer:request:destroy
+	async fn destroy(&self, client: &mut Client, _sender_id: ObjectId) -> WaylandResult<()> {
+		client.remove(self.id);
+		tracing::info!("Destroying buffer {:?}", self.id);
+		Ok(())
+	}
+}

src/wayland/core/callback.rs

@@ -0,0 +1,11 @@
+use waynest::ObjectId;
+pub use waynest_protocols::server::core::wayland::wl_callback::*;
+use waynest_server::RequestDispatcher;
+
+#[derive(Debug, RequestDispatcher, Clone)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Callback(pub ObjectId);
+/// https://wayland.app/protocols/wayland#wl_callback
+impl WlCallback for Callback {
+	type Connection = crate::wayland::Client;
+}

src/wayland/core/compositor.rs

@@ -0,0 +1,86 @@
+use super::surface::WL_SURFACE_REGISTRY;
+use crate::wayland::{WaylandError, WaylandResult};
+use crate::wayland::{core::surface::Surface, util::ClientExt};
+use waynest::ObjectId;
+use waynest_protocols::server::core::wayland::wl_surface::WlSurface;
+pub use waynest_protocols::server::core::wayland::{wl_compositor::*, wl_region::*};
+use waynest_server::{Client as _, RequestDispatcher};
+
+#[derive(Debug, waynest_server::RequestDispatcher, Default)]
+#[waynest(error = WaylandError, connection = crate::wayland::Client)]
+pub struct Compositor;
+impl WlCompositor for Compositor {
+	type Connection = crate::wayland::Client;
+
+	/// https://wayland.app/protocols/wayland#wl_compositor:request:create_surface
+	async fn create_surface(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		id: ObjectId,
+	) -> WaylandResult<()> {
+		let surface = client.insert(id, Surface::new(client, id))?;
+		if let Some(output) = client.display().output.get() {
+			surface.enter(client, id, output.id).await?;
+		}
+		WL_SURFACE_REGISTRY.add_raw(&surface);
+
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_compositor:request:create_region
+	async fn create_region(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		id: ObjectId,
+	) -> WaylandResult<()> {
+		client.insert(id, Region { id })?;
+		Ok(())
+	}
+}
+
+#[derive(Debug, RequestDispatcher)]
+#[waynest(error = WaylandError, connection = crate::wayland::Client)]
+pub struct Region {
+	id: ObjectId,
+}
+impl WlRegion for Region {
+	type Connection = crate::wayland::Client;
+
+	/// https://wayland.app/protocols/wayland#wl_region:request:add
+	async fn add(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_x: i32,
+		_y: i32,
+		_width: i32,
+		_height: i32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_region:request:subtract
+	async fn subtract(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_x: i32,
+		_y: i32,
+		_width: i32,
+		_height: i32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_region:request:destroy
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+}

src/wayland/core/data_device.rs

@@ -0,0 +1,166 @@
+use crate::wayland::{Client, WaylandResult};
+use std::os::fd::OwnedFd;
+use waynest::ObjectId;
+use waynest_protocols::server::core::wayland::{
+	wl_data_device::*, wl_data_device_manager::*, wl_data_offer::WlDataOffer, wl_data_source::*,
+};
+use waynest_server::Client as _;
+
+// TODO: actually implement this
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct DataDeviceManager;
+impl WlDataDeviceManager for DataDeviceManager {
+	type Connection = Client;
+
+	async fn create_data_source(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		id: ObjectId,
+	) -> WaylandResult<()> {
+		client.insert(id, DataSource { id })?;
+		Ok(())
+	}
+
+	async fn get_data_device(
+		&self,
+		client: &mut Client,
+		_sender_id: ObjectId,
+		id: ObjectId,
+		_seat: ObjectId,
+	) -> WaylandResult<()> {
+		client.insert(id, DataDevice)?;
+		Ok(())
+	}
+}
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct DataSource {
+	id: ObjectId,
+}
+impl WlDataSource for DataSource {
+	type Connection = Client;
+
+	async fn offer(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_mime_type: String,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+
+	async fn set_actions(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_dnd_actions: DndAction,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct DataDevice;
+impl WlDataDevice for DataDevice {
+	type Connection = Client;
+
+	async fn start_drag(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_source: Option<ObjectId>,
+		_origin: ObjectId,
+		_icon: Option<ObjectId>,
+		_serial: u32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn set_selection(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_source: Option<ObjectId>,
+		_serial: u32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn release(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct DataOffer {
+	id: ObjectId,
+}
+impl WlDataOffer for DataOffer {
+	type Connection = Client;
+
+	async fn accept(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_serial: u32,
+		_mime_type: Option<String>,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn receive(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_mime_type: String,
+		_fd: OwnedFd,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+
+	async fn finish(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn set_actions(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_dnd_actions: DndAction,
+		_preferred_action: DndAction,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}

src/wayland/core/keyboard.rs

@@ -0,0 +1,258 @@
+use crate::{
+	nodes::items::panel::KEYMAPS,
+	wayland::{Client, WaylandResult, core::surface::Surface, util::ClientExt},
+};
+use dashmap::{DashMap, DashSet};
+use memfd::MemfdOptions;
+use slotmap::{DefaultKey, KeyData};
+use std::{
+	collections::HashSet,
+	io::Write,
+	os::{
+		fd::{AsFd, IntoRawFd},
+		unix::io::{FromRawFd, OwnedFd},
+	},
+	sync::{Arc, Weak},
+};
+use tokio::sync::Mutex;
+use waynest::ObjectId;
+pub use waynest_protocols::server::core::wayland::wl_keyboard::*;
+
+#[derive(Default)]
+struct ModifierState {
+	pressed_keys: HashSet<u32>,
+	mods_depressed: u32,
+	mods_latched: u32,
+	mods_locked: u32,
+	group: u32,
+}
+
+impl ModifierState {
+	fn update_key(&mut self, key: u32, pressed: bool) -> bool {
+		let changed = if pressed {
+			self.pressed_keys.insert(key)
+		} else {
+			self.pressed_keys.remove(&key)
+		};
+
+		if changed {
+			self.update_modifiers();
+		}
+		changed
+	}
+
+	fn update_modifiers(&mut self) {
+		let mut mods = 0;
+
+		// Update modifier state based on currently pressed keys
+		for key in &self.pressed_keys {
+			match *key {
+				input_event_codes::KEY_LEFTSHIFT!() | input_event_codes::KEY_RIGHTSHIFT!() => {
+					mods |= 1
+				}
+				input_event_codes::KEY_LEFTCTRL!() | input_event_codes::KEY_RIGHTCTRL!() => {
+					mods |= 4
+				}
+				input_event_codes::KEY_LEFTALT!() => mods |= 8,
+				input_event_codes::KEY_RIGHTALT!() => mods |= 128,
+				input_event_codes::KEY_LEFTMETA!() | input_event_codes::KEY_RIGHTMETA!() => {
+					mods |= 64
+				}
+				input_event_codes::KEY_CAPSLOCK!() => self.mods_locked ^= 1,
+				_ => {}
+			}
+		}
+
+		self.mods_depressed = mods;
+	}
+}
+
+#[derive(waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Keyboard {
+	pub id: ObjectId,
+	focused_surface: Mutex<Weak<Surface>>,
+	modifier_state: Mutex<ModifierState>,
+	pressed_keys: DashMap<ObjectId, DashSet<u32>>,
+	current_keymap_id: Mutex<u64>,
+}
+
+impl Keyboard {
+	pub fn new(id: ObjectId) -> Self {
+		Self {
+			id,
+			focused_surface: Mutex::new(Weak::new()),
+			modifier_state: Mutex::new(ModifierState::default()),
+			pressed_keys: DashMap::default(),
+			current_keymap_id: Mutex::new(0),
+		}
+	}
+
+	async fn send_keymap(&self, client: &mut Client, keymap: &[u8]) -> WaylandResult<()> {
+		let mut file = MemfdOptions::default()
+			.create("stardust-keymap")?
+			.into_file();
+		file.set_len(keymap.len() as u64)?;
+		file.write_all(keymap)?;
+		file.flush()?;
+
+		let fd = unsafe { OwnedFd::from_raw_fd(file.into_raw_fd()) };
+
+		// Send keymap to client
+		self.keymap(
+			client,
+			self.id,
+			KeymapFormat::XkbV1,
+			fd.as_fd(),
+			keymap.len() as u32,
+		)
+		.await?;
+
+		Ok(())
+	}
+
+	/// has to be the wayland key, so -8 or whatever
+	pub async fn handle_keyboard_key(
+		&self,
+		client: &mut Client,
+		surface: Arc<Surface>,
+		keymap_id: u64,
+		key: u32,
+		pressed: bool,
+	) -> WaylandResult<()> {
+		// KEYMAP UPDATES
+		{
+			let mut old_keymap_id = self.current_keymap_id.lock().await;
+
+			if *old_keymap_id != keymap_id {
+				let keymap_key = DefaultKey::from(KeyData::from_ffi(keymap_id));
+
+				// Get keymap data and drop the lock immediately
+				let keymap_data = {
+					let keymap_lock = KEYMAPS.lock();
+					keymap_lock
+						.get(keymap_key)
+						.map(|s| s.as_bytes().to_vec())
+						.unwrap_or_default()
+				};
+
+				// Now we can safely await
+				self.send_keymap(client, &keymap_data).await?;
+			};
+			*old_keymap_id = keymap_id;
+			drop(old_keymap_id);
+		}
+
+		// PRESSED KEYS UPDATE
+		let pressed_keys = self.pressed_keys.entry(surface.id).or_default();
+		if pressed {
+			pressed_keys.insert(key);
+		} else {
+			pressed_keys.remove(&key);
+		}
+		// println!("pressed keys: {:?}", &*pressed_keys);
+
+		// FOCUS UPDATES
+		let mut focused = self.focused_surface.lock().await;
+		let mut modifier_state = self.modifier_state.lock().await;
+
+		let refocus = focused.as_ptr() != Arc::as_ptr(&surface);
+		// If we're entering a new surface
+		if refocus {
+			// Send leave to old surface if it exists and is still alive
+			if let Some(old_surface) = focused.upgrade() {
+				let serial = client.next_event_serial();
+				self.leave(client, old_surface.id, serial, self.id).await?;
+				// println!("Left surface {}", old_surface.id);
+			}
+
+			// Send enter to new surface
+			let serial = client.next_event_serial();
+			self.enter(
+				client,
+				self.id,
+				serial,
+				surface.id,
+				pressed_keys.iter().flat_map(|k| k.to_ne_bytes()).collect(),
+			)
+			.await?;
+			// println!("Entered new surface {}", surface.id);
+
+			// Update focused surface
+			*focused = Arc::downgrade(&surface);
+		}
+
+		// KEY EVENT SENDING
+		let serial = client.next_event_serial();
+		// println!(
+		// 	"Sent key {key} {}",
+		// 	if pressed { "pressed" } else { "released" }
+		// );
+		self.key(
+			client,
+			self.id,
+			serial,
+			client.display().creation_time.elapsed().as_millis() as u32, // time
+			key,
+			if pressed {
+				KeyState::Pressed
+			} else {
+				KeyState::Released
+			},
+		)
+		.await?;
+
+		// MODIFIER UPDATES
+		// Update modifier state and send modifiers event if changed
+		if refocus || modifier_state.update_key(key, pressed) {
+			// println!("Update modifiers");
+			let serial = client.next_event_serial();
+			self.modifiers(
+				client,
+				self.id,
+				serial,
+				modifier_state.mods_depressed,
+				modifier_state.mods_latched,
+				modifier_state.mods_locked,
+				modifier_state.group,
+			)
+			.await?;
+		}
+
+		Ok(())
+	}
+
+	pub async fn reset(&self, client: &mut Client) -> WaylandResult<()> {
+		let mut modifier_state = self.modifier_state.lock().await;
+		modifier_state.pressed_keys.clear();
+		modifier_state.mods_depressed = 0;
+		modifier_state.mods_latched = 0;
+		modifier_state.mods_locked = 0;
+		modifier_state.group = 0;
+
+		let serial = client.next_event_serial();
+		self.modifiers(
+			client,
+			self.id,
+			serial,
+			modifier_state.mods_depressed,
+			modifier_state.mods_latched,
+			modifier_state.mods_locked,
+			modifier_state.group,
+		)
+		.await
+	}
+}
+
+impl WlKeyboard for Keyboard {
+	type Connection = Client;
+
+	/// https://wayland.app/protocols/wayland#wl_keyboard:request:release
+	async fn release(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}

src/wayland/core/mod.rs

@@ -0,0 +1,13 @@
+pub mod buffer;
+pub mod callback;
+pub mod compositor;
+pub mod data_device;
+pub mod keyboard;
+pub mod output;
+pub mod pointer;
+pub mod seat;
+pub mod shm;
+pub mod shm_buffer_backing;
+pub mod shm_pool;
+pub mod surface;
+pub mod touch;

src/wayland/core/output.rs

@@ -0,0 +1,57 @@
+use crate::wayland::{Client, WaylandResult};
+use waynest::ObjectId;
+pub use waynest_protocols::server::core::wayland::wl_output::*;
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Output {
+	pub id: ObjectId,
+	pub version: u32,
+}
+impl Output {
+	pub async fn advertise_outputs(&self, client: &mut Client) -> WaylandResult<()> {
+		self.geometry(
+			client,
+			self.id,
+			2048,
+			2048,
+			0,
+			0,
+			Subpixel::None,
+			"Stardust Virtual Display".to_string(),
+			"Stardust Virtual Display".to_string(),
+			Transform::Normal,
+		)
+		.await?;
+
+		if self.version >= 4 {
+			self.name(client, self.id, "Stardust Virtual Display".to_string())
+				.await?;
+			self.description(
+				client,
+				self.id,
+				"I needed this to account for dumb clients".to_string(),
+			)
+			.await?;
+		}
+		self.mode(client, self.id, Mode::Current, 2048, 2048, i32::MAX)
+			.await?;
+
+		if self.version >= 2 {
+			self.done(client, self.id).await?;
+		}
+		Ok(())
+	}
+}
+impl WlOutput for Output {
+	type Connection = Client;
+
+	/// https://wayland.app/protocols/wayland#wl_output:request:release
+	async fn release(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}

src/wayland/core/pointer.rs

@@ -0,0 +1,252 @@
+use super::surface::SurfaceRole;
+use crate::nodes::items::panel::Geometry;
+use crate::wayland::core::surface::Surface;
+use crate::wayland::{Client, WaylandResult};
+use mint::Vector2;
+use std::sync::Arc;
+use std::sync::Weak;
+use tokio::sync::Mutex;
+use tracing;
+use waynest::ObjectId;
+use waynest_server::Client as _;
+
+pub use waynest_protocols::server::core::wayland::wl_pointer::*;
+
+#[derive(waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Pointer {
+	pub id: ObjectId,
+	version: u32,
+	focused_surface: Mutex<Weak<Surface>>,
+	cursor_surface: Mutex<Option<Arc<Surface>>>,
+}
+impl Pointer {
+	pub fn new(id: ObjectId, version: u32) -> Self {
+		Self {
+			id,
+			version,
+			focused_surface: Mutex::new(Weak::new()),
+			cursor_surface: Mutex::new(None),
+		}
+	}
+
+	pub async fn handle_pointer_motion(
+		&self,
+		client: &mut Client,
+		surface: Arc<Surface>,
+		position: Vector2<f32>,
+	) -> WaylandResult<()> {
+		tracing::debug!(
+			"Handling pointer motion at ({}, {})",
+			position.x,
+			position.y
+		);
+		let mut focused = self.focused_surface.lock().await;
+
+		// If we're entering a new surface
+		if focused.as_ptr() != Arc::as_ptr(&surface) {
+			tracing::debug!("Surface transition detected");
+			// Send leave to old surface if it exists and is still alive
+			if let Some(old_surface) = focused.upgrade() {
+				let serial = client.next_event_serial();
+				tracing::debug!("Sending leave event with serial {}", serial);
+				self.leave(client, self.id, serial, old_surface.id).await?;
+			}
+
+			// Send enter to new surface
+			let serial = client.next_event_serial();
+			tracing::debug!(
+				"Sending enter event with serial {} to surface {:?}",
+				serial,
+				surface.id
+			);
+			self.enter(
+				client,
+				self.id,
+				serial,
+				surface.id,
+				(position.x as f64).into(),
+				(position.y as f64).into(),
+			)
+			.await?;
+
+			// Update focused surface
+			*focused = Arc::downgrade(&surface);
+		}
+
+		// Send motion event to current surface
+		tracing::debug!("Sending motion event to surface");
+		self.motion(
+			client,
+			self.id,
+			0, // time
+			(position.x as f64).into(),
+			(position.y as f64).into(),
+		)
+		.await?;
+		if self.version >= 5 {
+			self.frame(client, self.id).await?;
+		}
+
+		Ok(())
+	}
+
+	pub async fn handle_pointer_button(
+		&self,
+		client: &mut Client,
+		surface: Arc<Surface>,
+		button: u32,
+		pressed: bool,
+	) -> WaylandResult<()> {
+		tracing::debug!(
+			"Handling pointer button {} {} on surface {:?}",
+			button,
+			if pressed { "pressed" } else { "released" },
+			surface.id
+		);
+		let serial = client.next_event_serial();
+		self.button(
+			client,
+			self.id,
+			serial,
+			0, // time
+			button,
+			if pressed {
+				ButtonState::Pressed
+			} else {
+				ButtonState::Released
+			},
+		)
+		.await?;
+		self.frame(client, self.id).await
+	}
+	pub async fn handle_pointer_scroll(
+		&self,
+		client: &mut Client,
+		_surface: Arc<Surface>,
+		scroll_distance: Option<Vector2<f32>>,
+		scroll_steps: Option<Vector2<f32>>,
+	) -> WaylandResult<()> {
+		tracing::debug!(
+			"Handling pointer scroll: distance={:?}, steps={:?}",
+			scroll_distance,
+			scroll_steps
+		);
+		if let Some(distance) = scroll_distance {
+			self.axis(
+				client,
+				self.id,
+				0, // time
+				Axis::HorizontalScroll,
+				(distance.x as f64).into(),
+			)
+			.await?;
+			self.axis(
+				client,
+				self.id,
+				0, // time
+				Axis::VerticalScroll,
+				(distance.y as f64).into(),
+			)
+			.await?;
+		}
+		if self.version < 8
+			&& self.version >= 5
+			&& let Some(steps) = scroll_steps
+		{
+			self.axis_discrete(client, self.id, Axis::HorizontalScroll, steps.x as i32)
+				.await?;
+			self.axis_discrete(client, self.id, Axis::VerticalScroll, steps.y as i32)
+				.await?;
+		}
+		if self.version >= 8
+			&& let Some(steps) = scroll_steps
+		{
+			self.axis_value120(
+				client,
+				self.id,
+				Axis::HorizontalScroll,
+				(steps.x * 120.) as i32,
+			)
+			.await?;
+			self.axis_value120(
+				client,
+				self.id,
+				Axis::VerticalScroll,
+				(steps.y * 120.) as i32,
+			)
+			.await?;
+		}
+		if self.version >= 5 {
+			self.frame(client, self.id).await?;
+		}
+		Ok(())
+	}
+
+	pub async fn reset(&self, client: &mut Client) -> WaylandResult<()> {
+		let mut focused = self.focused_surface.lock().await;
+		if let Some(old_surface) = focused.upgrade() {
+			let serial = client.next_event_serial();
+			self.leave(client, self.id, serial, old_surface.id).await?;
+			self.frame(client, self.id).await?;
+		}
+		*focused = Weak::new();
+		Ok(())
+	}
+
+	pub async fn cursor_surface(&self) -> Option<Arc<Surface>> {
+		self.cursor_surface.lock().await.clone()
+	}
+}
+
+impl WlPointer for Pointer {
+	type Connection = crate::wayland::Client;
+
+	/// https://wayland.app/protocols/wayland#wl_pointer:request:set_cursor
+	async fn set_cursor(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_serial: u32,
+		surface: Option<ObjectId>,
+		hotspot_x: i32,
+		hotspot_y: i32,
+	) -> WaylandResult<()> {
+		if let Some(focused_surface) = self.focused_surface.lock().await.upgrade()
+			&& let Some(panel_item) = focused_surface.panel_item.lock().upgrade()
+		{
+			panel_item.set_cursor(surface.and_then(|s| client.get::<Surface>(s)).map(|s| {
+				let size = s
+					.current_state()
+					.buffer
+					.map(|b| b.buffer.size())
+					.unwrap_or([16; 2].into());
+				Geometry {
+					origin: [hotspot_x, hotspot_y].into(),
+					size: [size.x as u32, size.y as u32].into(),
+				}
+			}));
+		}
+		let Some(surface) = surface else {
+			return Ok(());
+		};
+		let Some(surface) = client.get::<Surface>(surface) else {
+			return Ok(());
+		};
+
+		surface
+			.try_set_role(SurfaceRole::Cursor, Error::Role)
+			.await?;
+		self.cursor_surface.lock().await.replace(surface);
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_pointer:request:release
+	async fn release(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}

src/wayland/core/seat.rs

@@ -0,0 +1,213 @@
+use crate::wayland::Client;
+use crate::wayland::WaylandResult;
+use crate::wayland::core::{keyboard::Keyboard, pointer::Pointer, surface::Surface, touch::Touch};
+use mint::Vector2;
+use std::sync::Arc;
+use std::sync::OnceLock;
+use waynest::ObjectId;
+pub use waynest_protocols::server::core::wayland::wl_seat::*;
+use waynest_server::Client as _;
+
+#[derive(Debug)]
+pub enum SeatMessage {
+	PointerMotion {
+		surface: Arc<Surface>,
+		position: Vector2<f32>,
+	},
+	PointerButton {
+		surface: Arc<Surface>,
+		button: u32,
+		pressed: bool,
+	},
+	PointerScroll {
+		surface: Arc<Surface>,
+		scroll_distance: Option<Vector2<f32>>,
+		scroll_steps: Option<Vector2<f32>>,
+	},
+	KeyboardKey {
+		surface: Arc<Surface>,
+		keymap_id: u64,
+		key: u32,
+		pressed: bool,
+	},
+	TouchDown {
+		surface: Arc<Surface>,
+		id: u32,
+		position: Vector2<f32>,
+	},
+	TouchMove {
+		id: u32,
+		position: Vector2<f32>,
+	},
+	TouchUp {
+		id: u32,
+	},
+	Reset,
+}
+
+#[derive(Default, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Seat {
+	version: u32,
+	pointer: OnceLock<Arc<Pointer>>,
+	keyboard: OnceLock<Arc<Keyboard>>,
+	touch: OnceLock<Arc<Touch>>,
+}
+
+impl Seat {
+	pub async fn new(client: &mut Client, id: ObjectId, version: u32) -> WaylandResult<Self> {
+		let seat = Self {
+			version,
+			pointer: OnceLock::new(),
+			keyboard: OnceLock::new(),
+			touch: OnceLock::new(),
+		};
+
+		if version >= 2 {
+			seat.name(client, id, "theonlyseat".into()).await?;
+		}
+
+		tracing::debug!("Advertising seat capabilities with id {}", id);
+		let capabilities = Capability::Pointer | Capability::Keyboard | Capability::Touch;
+		WlSeat::capabilities(&seat, client, id, capabilities).await?;
+		tracing::debug!("Capabilities advertised: {:?}", capabilities);
+
+		Ok(seat)
+	}
+
+	pub async fn handle_message(
+		&self,
+		client: &mut Client,
+		message: SeatMessage,
+	) -> WaylandResult<()> {
+		match message {
+			SeatMessage::PointerMotion { surface, position } => {
+				if let Some(pointer) = self.pointer.get() {
+					pointer
+						.handle_pointer_motion(client, surface, position)
+						.await?;
+				}
+			}
+			SeatMessage::PointerButton {
+				surface,
+				button,
+				pressed,
+			} => {
+				if let Some(pointer) = self.pointer.get() {
+					pointer
+						.handle_pointer_button(client, surface, button, pressed)
+						.await?;
+				}
+			}
+			SeatMessage::PointerScroll {
+				surface,
+				scroll_distance,
+				scroll_steps,
+			} => {
+				if let Some(pointer) = self.pointer.get() {
+					pointer
+						.handle_pointer_scroll(client, surface, scroll_distance, scroll_steps)
+						.await?;
+				}
+			}
+			SeatMessage::KeyboardKey {
+				surface,
+				keymap_id,
+				key,
+				pressed,
+			} => {
+				if let Some(keyboard) = self.keyboard.get() {
+					keyboard
+						.handle_keyboard_key(client, surface, keymap_id, key - 8, pressed)
+						.await?;
+				}
+			}
+			SeatMessage::TouchDown {
+				surface,
+				id,
+				position,
+			} => {
+				if let Some(touch) = self.touch.get() {
+					touch
+						.handle_touch_down(client, surface, id, position)
+						.await?;
+				}
+			}
+			SeatMessage::TouchMove { id, position } => {
+				if let Some(touch) = self.touch.get() {
+					touch.handle_touch_move(client, id, position).await?;
+				}
+			}
+			SeatMessage::TouchUp { id } => {
+				if let Some(touch) = self.touch.get() {
+					touch.handle_touch_up(client, id).await?;
+				}
+			}
+			SeatMessage::Reset => {
+				if let Some(pointer) = self.pointer.get() {
+					pointer.reset(client).await?;
+				}
+				if let Some(keyboard) = self.keyboard.get() {
+					keyboard.reset(client).await?;
+				}
+				if let Some(touch) = self.touch.get() {
+					touch.reset(client).await?;
+				}
+			}
+		}
+		Ok(())
+	}
+
+	pub async fn cursor_surface(&self) -> Option<Arc<Surface>> {
+		self.pointer.get()?.cursor_surface().await
+	}
+}
+impl WlSeat for Seat {
+	type Connection = crate::wayland::Client;
+
+	/// https://wayland.app/protocols/wayland#wl_seat:request:get_pointer
+	async fn get_pointer(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		id: ObjectId,
+	) -> WaylandResult<()> {
+		let pointer = client.insert(id, Pointer::new(id, self.version))?;
+		let _ = self.pointer.set(pointer);
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_seat:request:get_keyboard
+	async fn get_keyboard(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		id: ObjectId,
+	) -> WaylandResult<()> {
+		tracing::info!("Getting keyboard");
+		let keyboard = client.insert(id, Keyboard::new(id))?;
+		let _ = self.keyboard.set(keyboard);
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_seat:request:get_touch
+	async fn get_touch(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		id: ObjectId,
+	) -> WaylandResult<()> {
+		let touch = client.insert(id, Touch(id))?;
+		let _ = self.touch.set(touch);
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_seat:request:release
+	async fn release(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}

src/wayland/core/shm.rs

@@ -0,0 +1,47 @@
+use crate::wayland::{Client, WaylandResult, core::shm_pool::ShmPool};
+use std::os::fd::OwnedFd;
+use waynest::ObjectId;
+pub use waynest_protocols::server::core::wayland::wl_shm::*;
+use waynest_server::Client as _;
+
+#[derive(Debug, waynest_server::RequestDispatcher, Default)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Shm;
+impl Shm {
+	pub async fn advertise_formats(
+		&self,
+		client: &mut Client,
+		sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		self.format(client, sender_id, Format::Argb8888).await?;
+		self.format(client, sender_id, Format::Xrgb8888).await?;
+
+		Ok(())
+	}
+}
+impl WlShm for Shm {
+	type Connection = crate::wayland::Client;
+
+	/// https://wayland.app/protocols/wayland#wl_shm:request:create_pool
+	async fn create_pool(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		pool_id: ObjectId,
+		fd: OwnedFd,
+		size: i32,
+	) -> WaylandResult<()> {
+		client.insert(pool_id, ShmPool::new(fd, size, pool_id)?)?;
+
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_shm:request:release
+	async fn release(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}

src/wayland/core/shm_buffer_backing.rs

@@ -0,0 +1,276 @@
+use super::shm_pool::ShmPool;
+use crate::wayland::{RENDER_DEVICE, vulkano_data::VULKANO_CONTEXT};
+use bevy::{
+	asset::{Assets, Handle},
+	image::Image,
+};
+use bevy_dmabuf::{
+	dmatex::{Dmatex, DmatexPlane, Resolution},
+	import::{DmatexUsage, DropCallback, ImportedDmatexs, ImportedTexture, import_texture},
+};
+use drm_fourcc::DrmFourcc;
+use mint::Vector2;
+use parking_lot::Mutex;
+use std::{
+	os::fd::OwnedFd,
+	sync::{Arc, OnceLock},
+};
+use tracing::debug_span;
+use vulkano::{
+	buffer::BufferUsage,
+	command_buffer::{
+		AutoCommandBufferBuilder, CommandBufferUsage, CopyBufferToImageInfo,
+		PrimaryCommandBufferAbstract,
+	},
+	image::{
+		ImageAspect, ImageCreateFlags, ImageCreateInfo, ImageMemory, ImageTiling, ImageUsage,
+		sys::RawImage,
+	},
+	memory::{
+		DedicatedAllocation, DeviceMemory, ExternalMemoryHandleType, MemoryAllocateInfo,
+		ResourceMemory,
+		allocator::{AllocationCreateInfo, MemoryTypeFilter},
+	},
+	sync::GpuFuture,
+};
+use waynest_protocols::server::core::wayland::wl_shm::Format;
+
+/// Parameters for a shared memory buffer
+pub struct ShmBufferBacking {
+	pool: Arc<ShmPool>,
+	offset: usize,
+	stride: usize,
+	size: Vector2<usize>,
+	wl_format: Format,
+	image: Arc<vulkano::image::Image>,
+	tex: OnceLock<Handle<Image>>,
+	pending_imported_dmatex: Mutex<Option<ImportedTexture>>,
+}
+
+impl std::fmt::Debug for ShmBufferBacking {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		f.debug_struct("ShmBufferBacking")
+			.field("pool", &self.pool)
+			.field("offset", &self.offset)
+			.field("stride", &self.stride)
+			.field("size", &self.size)
+			.field("wl_format", &self.wl_format)
+			.field("image", &self.image)
+			.field("tex", &self.tex)
+			.finish()
+	}
+}
+
+impl ShmBufferBacking {
+	pub fn new(
+		pool: Arc<ShmPool>,
+		offset: usize,
+		stride: usize,
+		size: Vector2<usize>,
+		wl_format: Format,
+	) -> Self {
+		let vk = VULKANO_CONTEXT.wait();
+		let format = match wl_format {
+			Format::Argb8888 | Format::Xrgb8888 => vulkano::format::Format::B8G8R8A8_SRGB,
+			_ => unimplemented!(),
+		};
+		let modifiers = vk
+			.phys_dev
+			.format_properties(format)
+			.unwrap()
+			.drm_format_modifier_properties
+			.into_iter()
+			.filter_map(|v| {
+				(v.drm_format_modifier_plane_count == 1).then_some(v.drm_format_modifier)
+			})
+			.collect();
+		let raw_image = RawImage::new(
+			vk.dev.clone(),
+			ImageCreateInfo {
+				flags: ImageCreateFlags::empty(),
+				image_type: vulkano::image::ImageType::Dim2d,
+				format,
+				extent: [size.x as u32, size.y as u32, 1],
+				tiling: ImageTiling::DrmFormatModifier,
+				usage: ImageUsage::TRANSFER_DST,
+				drm_format_modifiers: modifiers,
+				external_memory_handle_types: ExternalMemoryHandleType::DmaBuf.into(),
+				..Default::default()
+			},
+		)
+		.unwrap();
+		let (modifier, num_planes) = raw_image.drm_format_modifier().unwrap();
+
+		let mem_reqs = raw_image.memory_requirements()[0];
+
+		let index = vk
+			.phys_dev
+			.memory_properties()
+			.memory_types
+			.iter()
+			.enumerate()
+			.map(|(i, _v)| i as u32)
+			.find(|i| mem_reqs.memory_type_bits & (1 << i) != 0)
+			.expect("no valid memory type");
+
+		let mem = ResourceMemory::new_dedicated(
+			DeviceMemory::allocate(
+				vk.dev.clone(),
+				MemoryAllocateInfo {
+					allocation_size: mem_reqs.layout.size(),
+					memory_type_index: index,
+					dedicated_allocation: Some(DedicatedAllocation::Image(&raw_image)),
+					export_handle_types: ExternalMemoryHandleType::DmaBuf.into(),
+					..Default::default()
+				},
+			)
+			.unwrap(),
+		);
+		let Ok(image) = raw_image.bind_memory([mem]) else {
+			panic!("unable to bind memory")
+		};
+		let image = Arc::new(image);
+		let ImageMemory::Normal(mem) = image.memory() else {
+			unreachable!()
+		};
+
+		let [mem] = mem.as_slice() else {
+			unreachable!()
+		};
+
+		let fd = OwnedFd::from(
+			mem.device_memory()
+				.export_fd(ExternalMemoryHandleType::DmaBuf)
+				.unwrap(),
+		);
+
+		let planes = (0..num_planes)
+			.filter_map(|i| {
+				Some(match i {
+					0 => ImageAspect::MemoryPlane0,
+					1 => ImageAspect::MemoryPlane1,
+					2 => ImageAspect::MemoryPlane2,
+					3 => ImageAspect::MemoryPlane3,
+					_ => return None,
+				})
+			})
+			.map(|aspect| {
+				let plane_layout = image.subresource_layout(aspect, 0, 0).unwrap();
+
+				DmatexPlane {
+					dmabuf_fd: fd.try_clone().unwrap().into(),
+					modifier,
+					offset: plane_layout.offset as u32,
+					stride: plane_layout.row_pitch as i32,
+				}
+			})
+			.collect::<Vec<_>>();
+
+		let dmatex = Dmatex {
+			planes,
+			res: Resolution {
+				x: size.x as u32,
+				y: size.y as u32,
+			},
+			format: DrmFourcc::Argb8888 as u32,
+			flip_y: false,
+			srgb: true,
+		};
+		let imported_dmatex = import_texture(
+			RENDER_DEVICE.wait(),
+			dmatex,
+			DropCallback(None),
+			DmatexUsage::Sampling,
+		)
+		.unwrap();
+		Self {
+			pool,
+			offset,
+			stride,
+			size,
+			wl_format,
+			image,
+			pending_imported_dmatex: Mutex::new(Some(imported_dmatex)),
+			tex: OnceLock::new(),
+		}
+	}
+	pub fn on_commit(&self) {
+		let vk = VULKANO_CONTEXT.wait();
+		let data_len = self.size.x * self.size.y * 4;
+		let gpu_buffer = vulkano::buffer::Buffer::new_slice::<u8>(
+			vk.alloc.clone(),
+			vulkano::buffer::BufferCreateInfo {
+				usage: BufferUsage::TRANSFER_SRC,
+				..Default::default()
+			},
+			AllocationCreateInfo {
+				memory_type_filter: MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+				..Default::default()
+			},
+			data_len as u64,
+		)
+		.unwrap();
+		{
+			let _span = debug_span!("copy to gpu buffer").entered();
+			let shm_data_lock = self.pool.data_lock();
+			let mut gpu_slice = gpu_buffer.write().unwrap();
+			for (shm_offset, gpu_offset) in
+				(0..self.size.y).map(|v| (self.offset + (v * self.stride), (v * (self.size.x * 4))))
+			{
+				let line_slice = &shm_data_lock[shm_offset..(shm_offset + (self.size.x * 4))];
+				let gpu_subslice = &mut gpu_slice[gpu_offset..(gpu_offset + (self.size.x * 4))];
+				gpu_subslice.copy_from_slice(line_slice);
+			}
+		}
+		let mut command_buffer = AutoCommandBufferBuilder::primary(
+			vk.command_buffer_alloc.clone(),
+			vk.queue.queue_family_index(),
+			CommandBufferUsage::OneTimeSubmit,
+		)
+		.unwrap();
+
+		command_buffer
+			.copy_buffer_to_image(CopyBufferToImageInfo::buffer_image(
+				gpu_buffer.clone(),
+				self.image.clone(),
+			))
+			.unwrap();
+
+		let command_buffer = command_buffer.build().unwrap();
+		command_buffer
+			.execute(vk.queue.clone())
+			.unwrap()
+			.then_signal_fence_and_flush()
+			.unwrap()
+			.wait(None)
+			.unwrap();
+	}
+
+	#[tracing::instrument("debug", skip_all)]
+	pub fn update_tex(
+		&self,
+		dmatexes: &ImportedDmatexs,
+		images: &mut Assets<Image>,
+	) -> Option<Handle<Image>> {
+		self.pending_imported_dmatex
+			.lock()
+			.take()
+			.map(|tex| dmatexes.insert_imported_dmatex(images, tex))
+			.inspect(|handle| {
+				_ = self.tex.set(handle.clone());
+			});
+		self.tex.get().cloned()
+	}
+
+	pub fn is_transparent(&self) -> bool {
+		match self.wl_format {
+			Format::Xrgb8888 => false,
+			Format::Argb8888 => true,
+			_ => true,
+		}
+	}
+
+	pub fn size(&self) -> Vector2<usize> {
+		self.size
+	}
+}

src/wayland/core/shm_pool.rs

@@ -0,0 +1,93 @@
+use super::shm_buffer_backing::ShmBufferBacking;
+use crate::wayland::{
+	Client, WaylandResult,
+	core::buffer::{Buffer, BufferBacking},
+};
+use memmap2::{MmapOptions, RemapOptions};
+use parking_lot::{Mutex, MutexGuard, RawMutex, lock_api::MappedMutexGuard};
+use std::os::fd::{AsRawFd, OwnedFd};
+use waynest::ObjectId;
+use waynest_protocols::server::core::wayland::wl_shm::Format;
+pub use waynest_protocols::server::core::wayland::wl_shm_pool::*;
+use waynest_server::Client as _;
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct ShmPool {
+	inner: Mutex<memmap2::MmapMut>,
+	id: ObjectId,
+}
+
+impl ShmPool {
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn new(fd: OwnedFd, size: i32, id: ObjectId) -> WaylandResult<Self> {
+		let map = unsafe {
+			MmapOptions::new()
+				.len(size as usize)
+				.map_mut(fd.as_raw_fd())?
+		};
+
+		Ok(Self {
+			inner: Mutex::new(map),
+			id,
+		})
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn data_lock(&self) -> MappedMutexGuard<'_, RawMutex, [u8]> {
+		MutexGuard::map(self.inner.lock(), |i| i.as_mut())
+	}
+}
+
+impl WlShmPool for ShmPool {
+	type Connection = Client;
+
+	/// https://wayland.app/protocols/wayland#wl_shm_pool:request:create_buffer
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn create_buffer(
+		&self,
+		client: &mut Self::Connection,
+		sender_id: ObjectId,
+		id: ObjectId,
+		offset: i32,
+		width: i32,
+		height: i32,
+		stride: i32,
+		format: Format,
+	) -> WaylandResult<()> {
+		let params = ShmBufferBacking::new(
+			client.get::<ShmPool>(sender_id).unwrap(),
+			offset as usize,
+			stride as usize,
+			[width as usize, height as usize].into(),
+			format,
+		);
+
+		Buffer::new(client, id, BufferBacking::Shm(params))?;
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_shm_pool:request:resize
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn resize(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		size: i32,
+	) -> WaylandResult<()> {
+		let mut inner = self.inner.lock();
+		unsafe { inner.remap(size as usize, RemapOptions::new().may_move(true))? };
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_shm_pool:request:destroy
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+}

src/wayland/core/surface.rs

@@ -0,0 +1,501 @@
+use super::{buffer::Buffer, callback::Callback};
+use crate::{
+	BevyMaterial,
+	core::registry::Registry,
+	nodes::{
+		drawable::model::ModelPart,
+		items::panel::{Geometry, PanelItem, SurfaceId},
+	},
+	wayland::{
+		Client, Message, MessageSink, WaylandError, WaylandResult,
+		core::buffer::BufferUsage,
+		presentation::{MonotonicTimestamp, PresentationFeedback},
+		util::{ClientExt, DoubleBuffer},
+		xdg::backend::XdgBackend,
+	},
+};
+use bevy::{
+	asset::{Assets, Handle},
+	image::Image,
+	render::alpha::AlphaMode,
+};
+use bevy_dmabuf::import::ImportedDmatexs;
+use mint::Vector2;
+use parking_lot::Mutex;
+use std::{
+	fmt::Display,
+	sync::{Arc, OnceLock, Weak},
+};
+use waynest::ObjectId;
+use waynest_protocols::server::{
+	core::wayland::{wl_output::Transform, wl_surface::*},
+	stable::presentation_time::wp_presentation_feedback::{Kind, WpPresentationFeedback},
+};
+use waynest_server::Client as _;
+
+pub static WL_SURFACE_REGISTRY: Registry<Surface> = Registry::new();
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SurfaceRole {
+	Cursor,
+	Subsurface,
+	XdgToplevel,
+	XdgPopup,
+}
+impl Display for SurfaceRole {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			SurfaceRole::Cursor => f.write_str("SurfaceRole::Cursor"),
+			SurfaceRole::Subsurface => f.write_str("SurfaceRole::Subsurface"),
+			SurfaceRole::XdgToplevel => f.write_str("SurfaceRole::XdgToplevel"),
+			SurfaceRole::XdgPopup => f.write_str("SurfaceRole::XdgPopup"),
+		}
+	}
+}
+
+#[derive(Debug, Clone)]
+pub struct BufferState {
+	pub buffer: Arc<Buffer>,
+	pub usage: Option<Arc<BufferUsage>>,
+}
+
+#[derive(Debug, Clone)]
+pub struct SurfaceState {
+	pub buffer: Option<BufferState>,
+	pub density: f32,
+	pub geometry: Option<Geometry>,
+	pub min_size: Option<Vector2<u32>>,
+	pub max_size: Option<Vector2<u32>>,
+	frame_callbacks: Vec<Arc<Callback>>,
+}
+impl Default for SurfaceState {
+	fn default() -> Self {
+		Self {
+			buffer: Default::default(),
+			density: 1.0,
+			geometry: None,
+			min_size: None,
+			max_size: None,
+			frame_callbacks: Vec::new(),
+		}
+	}
+}
+impl SurfaceState {
+	pub fn has_valid_buffer(&self) -> bool {
+		self.buffer
+			.as_ref()
+			.is_some_and(|b| b.buffer.size().x > 0 && b.buffer.size().y > 0)
+	}
+}
+
+// if returning false, don't run this callback again... just remove it
+pub type OnCommitCallback = Box<dyn FnMut(&Surface, &SurfaceState) -> bool + Send + Sync>;
+#[derive(waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Surface {
+	pub id: ObjectId,
+	pub surface_id: OnceLock<SurfaceId>,
+	state: Mutex<DoubleBuffer<SurfaceState>>,
+	pub message_sink: MessageSink,
+	pub role: OnceLock<SurfaceRole>,
+	pub panel_item: Mutex<Weak<PanelItem<XdgBackend>>>,
+	on_commit_handlers: Mutex<Vec<OnCommitCallback>>,
+	frame_callbacks: Mutex<Vec<Arc<Callback>>>,
+	material: OnceLock<Handle<BevyMaterial>>,
+	pending_material_applications: Registry<ModelPart>,
+	presentation_feedback: Mutex<Vec<Arc<PresentationFeedback>>>,
+}
+impl std::fmt::Debug for Surface {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		f.debug_struct("Surface")
+			.field("id", &self.id)
+			.field("surface_id", &self.surface_id)
+			.field("state", &self.state)
+			.field("message_sink", &self.message_sink)
+			.field("role", &self.role)
+			.field(
+				"on_commit_handlers",
+				&format!("<{} handlers>", self.on_commit_handlers.lock().len()),
+			)
+			.field("material", &self.material)
+			.field("presentation_feedback", &self.presentation_feedback)
+			.finish()
+	}
+}
+impl Surface {
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn new(client: &Client, id: ObjectId) -> Self {
+		Surface {
+			id,
+			surface_id: OnceLock::new(),
+			state: Default::default(),
+			message_sink: client.message_sink(),
+			role: OnceLock::new(),
+			panel_item: Mutex::new(Weak::default()),
+			on_commit_handlers: Mutex::new(Vec::new()),
+			frame_callbacks: Mutex::new(Vec::new()),
+			material: OnceLock::new(),
+			pending_material_applications: Registry::new(),
+			presentation_feedback: Mutex::default(),
+		}
+	}
+
+	pub async fn try_set_role(
+		&self,
+		role: SurfaceRole,
+		role_error: impl Into<u32>,
+	) -> WaylandResult<()> {
+		match self.role.get().cloned() {
+			Some(current_role) => {
+				if current_role == role {
+					Ok(())
+				} else {
+					Err(WaylandError::Fatal {
+						object_id: self.id,
+						code: role_error.into(),
+						message: "Surface has an incomparible role",
+					})
+				}
+			}
+			None => {
+				let _ = self.role.set(role);
+				Ok(())
+			}
+		}
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn state_lock(&self) -> parking_lot::MutexGuard<'_, DoubleBuffer<SurfaceState>> {
+		self.state.lock()
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn add_commit_handler<F: FnMut(&Surface, &SurfaceState) -> bool + Send + Sync + 'static>(
+		&self,
+		handler: F,
+	) {
+		let mut handlers = self.on_commit_handlers.lock();
+		handlers.push(Box::new(handler));
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn update_graphics(
+		&self,
+		dmatexes: &ImportedDmatexs,
+		materials: &mut Assets<BevyMaterial>,
+		images: &mut Assets<Image>,
+	) {
+		let Some(buffer) = self.state.lock().current().buffer.clone() else {
+			return;
+		};
+
+		let material = self.material.get_or_init(|| {
+			// // Set default shader parameters
+			// let mut params = mat_wrapper.0.get_all_param_info();
+			// params.set_vec2("uv_scale", stereokit_rust::maths::Vec2::new(1.0, 1.0));
+			// params.set_vec2("uv_offset", stereokit_rust::maths::Vec2::new(0.0, 0.0));
+			// params.set_float("fcFactor", 1.0);
+			// params.set_float("ripple", 4.0);
+			// params.set_float("alpha_min", 0.0);
+			// params.set_float("alpha_max", 1.0);
+
+			materials.add(BevyMaterial {
+				unlit: true,
+				..Default::default()
+			})
+		});
+
+		if let Some(new_tex) = buffer.buffer.update_tex(dmatexes, images) {
+			let material = materials.get_mut(material).unwrap();
+			material.base_color_texture.replace(new_tex);
+			material.alpha_mode = if buffer.buffer.is_transparent() {
+				AlphaMode::Premultiplied
+			} else {
+				AlphaMode::Opaque
+			};
+		}
+
+		self.apply_surface_materials();
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn apply_material(&self, model_part: &Arc<ModelPart>) {
+		// tracing::info!("uwu applying material");
+		self.pending_material_applications.add_raw(model_part)
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	fn apply_surface_materials(&self) {
+		let Some(mat) = self.material.get() else {
+			return;
+		};
+
+		for model_node in self.pending_material_applications.get_valid_contents() {
+			model_node.replace_material(mat.clone());
+		}
+		self.pending_material_applications.clear();
+	}
+	#[tracing::instrument("debug", skip_all)]
+	pub fn current_state(&self) -> SurfaceState {
+		self.state.lock().current().clone()
+	}
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn frame_event(&self) {
+		let callbacks = std::mem::take(&mut *self.frame_callbacks.lock());
+		if !callbacks.is_empty() {
+			let _ = self.message_sink.send(Message::Frame(callbacks));
+		}
+	}
+	// pub fn size(&self) -> Option<Vector2<u32>> {
+	// 	self.state
+	// 		.lock()
+	// 		.current()
+	// 		.buffer
+	// 		.as_ref()
+	// 		.map(|b| [b.size.x as u32, b.size.y as u32].into())
+	// }
+
+	// pub async fn release_old_buffer(&self, client: &mut Self::Connection) -> Result<()> {
+	// 	let (old_buffer, object) = {
+	// 		let lock = self.state.lock();
+
+	// 		let Some(old_buffer) = lock.current().buffer.clone() else {
+	// 			return Ok(());
+	// 		};
+	// 		let new_buffer = lock.pending.buffer.as_ref();
+	// 		if new_buffer.map(Arc::as_ptr) == Some(Arc::as_ptr(&old_buffer)) {
+	// 			return Ok(());
+	// 		}
+	// 		drop(lock);
+
+	// 		(old_buffer.clone(), old_buffer.id)
+	// 	};
+	// 	old_buffer.release(client, object).await?;
+
+	// 	Ok(())
+	// }
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn add_presentation_feedback(&self, feedback: Arc<PresentationFeedback>) {
+		self.presentation_feedback.lock().push(feedback);
+	}
+
+	pub fn submit_presentation_feedback(
+		self: &Arc<Self>,
+		display_timestamp: MonotonicTimestamp,
+		refresh_cycle: u64,
+	) {
+		let _ = self.message_sink.send(Message::SendPresentationFeedback {
+			surface: self.clone(),
+			display_timestamp,
+			refresh_cycle,
+		});
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub async fn send_presentation_feedback(
+		&self,
+		client: &mut Client,
+		display_timestamp: MonotonicTimestamp,
+		refresh_cycle: u64,
+	) -> WaylandResult<()> {
+		let feedbacks = self
+			.presentation_feedback
+			.lock()
+			.drain(..)
+			.collect::<Vec<_>>();
+		for feedback in feedbacks {
+			if let Some(display_id) = client.display().output.get().map(|display| display.id) {
+				feedback.sync_output(client, feedback.0, display_id).await?;
+			}
+			let cycle_lo = refresh_cycle as u32;
+			let cycle_hi = (refresh_cycle >> 32) as u32;
+			feedback
+				.presented(
+					client,
+					feedback.0,
+					display_timestamp.secs_hi(),
+					display_timestamp.secs_lo(),
+					display_timestamp.subsec_nanos(),
+					0,
+					cycle_hi,
+					cycle_lo,
+					Kind::empty(),
+				)
+				.await?;
+		}
+		Ok(())
+	}
+}
+impl WlSurface for Surface {
+	type Connection = crate::wayland::Client;
+
+	/// https://wayland.app/protocols/wayland#wl_surface:request:attach
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn attach(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		buffer: Option<ObjectId>,
+		_x: i32,
+		_y: i32,
+	) -> WaylandResult<()> {
+		self.state.lock().pending.buffer = buffer.and_then(|b| {
+			let buffer = client.get::<Buffer>(b)?;
+			let mut usage = Some(BufferUsage::new(client, &buffer));
+			Some(BufferState {
+				usage: usage.take_if(|_| buffer.uses_buffer_usage()),
+				buffer,
+			})
+		});
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_surface:request:damage
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn damage(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_x: i32,
+		_y: i32,
+		_width: i32,
+		_height: i32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_surface:request:frame
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn frame(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		callback_id: ObjectId,
+	) -> WaylandResult<()> {
+		let callback = client.insert(callback_id, Callback(callback_id))?;
+		self.state.lock().pending.frame_callbacks.push(callback);
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_surface:request:set_opaque_region
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn set_opaque_region(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_region: Option<ObjectId>,
+	) -> WaylandResult<()> {
+		// nothing we can really do to repaint behind this so ignore it
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_surface:request:set_input_region
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn set_input_region(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_region: Option<ObjectId>,
+	) -> WaylandResult<()> {
+		// too complicated to implement this for now so who the hell cares
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_surface:request:commit
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn commit(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		// we want the upload to complete before we give the image to bevy
+		let buffer_option = self
+			.state_lock()
+			.pending
+			.buffer
+			.as_ref()
+			.map(|b| b.buffer.clone());
+		if let Some(buffer) = buffer_option {
+			tokio::task::spawn_blocking(move || buffer.on_commit())
+				.await
+				.unwrap();
+		}
+		self.state.lock().apply();
+
+		self.state.lock().pending.frame_callbacks.clear();
+		let current_state = self.current_state();
+		self.frame_callbacks
+			.lock()
+			.extend(current_state.frame_callbacks.iter().cloned());
+		let mut handlers = self.on_commit_handlers.lock();
+		handlers.retain_mut(|f| (f)(self, &current_state));
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_surface:request:set_buffer_transform
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn set_buffer_transform(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_transform: Transform,
+	) -> WaylandResult<()> {
+		// we just don't have the output transform or fullscreen at all so this optimization is never needed
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_surface:request:set_buffer_scale
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn set_buffer_scale(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		scale: i32,
+	) -> WaylandResult<()> {
+		self.state.lock().pending.density = scale as f32;
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_surface:request:damage_buffer
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn damage_buffer(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_x: i32,
+		_y: i32,
+		_width: i32,
+		_height: i32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_surface:request:offset
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn offset(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_x: i32,
+		_y: i32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_surface:request:destroy
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+}
+impl Drop for Surface {
+	fn drop(&mut self) {
+		self.role.take();
+	}
+}

src/wayland/core/touch.rs

@@ -0,0 +1,73 @@
+use crate::wayland::{Client, WaylandResult, core::surface::Surface};
+use mint::Vector2;
+use std::sync::Arc;
+use waynest::ObjectId;
+pub use waynest_protocols::server::core::wayland::wl_touch::*;
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Touch(pub ObjectId);
+impl Touch {
+	pub async fn handle_touch_down(
+		&self,
+		client: &mut Client,
+		surface: Arc<Surface>,
+		id: u32,
+		position: Vector2<f32>,
+	) -> WaylandResult<()> {
+		let serial = client.next_event_serial();
+		self.down(
+			client,
+			self.0,
+			serial,
+			0,
+			surface.id,
+			id as i32,
+			(position.x as f64).into(),
+			(position.y as f64).into(),
+		)
+		.await?;
+		self.frame(client, self.0).await
+	}
+
+	pub async fn handle_touch_move(
+		&self,
+		client: &mut Client,
+		id: u32,
+		position: Vector2<f32>,
+	) -> WaylandResult<()> {
+		self.motion(
+			client,
+			self.0,
+			0,
+			id as i32,
+			(position.x as f64).into(),
+			(position.y as f64).into(),
+		)
+		.await?;
+		self.frame(client, self.0).await
+	}
+
+	pub async fn handle_touch_up(&self, client: &mut Client, id: u32) -> WaylandResult<()> {
+		let serial = client.next_event_serial();
+		self.up(client, self.0, serial, 0, id as i32).await?;
+		self.frame(client, self.0).await
+	}
+
+	pub async fn reset(&self, client: &mut Client) -> WaylandResult<()> {
+		self.frame(client, self.0).await
+	}
+}
+
+impl WlTouch for Touch {
+	type Connection = crate::wayland::Client;
+
+	/// https://wayland.app/protocols/wayland#wl_touch:request:release
+	async fn release(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}

src/wayland/data_device.rs

@@ -1,100 +0,0 @@
-use smithay::reexports::wayland_server::{
-	Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
-	protocol::{
-		wl_data_device::{
-			Request::{Release, SetSelection, StartDrag},
-			WlDataDevice,
-		},
-		wl_data_device_manager::{
-			Request::{CreateDataSource, GetDataDevice},
-			WlDataDeviceManager,
-		},
-		wl_data_source::{
-			Request::{Destroy, Offer, SetActions},
-			WlDataSource,
-		},
-	},
-};
-
-use super::state::WaylandState;
-
-impl GlobalDispatch<WlDataDeviceManager, (), WaylandState> for WaylandState {
-	fn bind(
-		_state: &mut WaylandState,
-		_handle: &DisplayHandle,
-		_client: &Client,
-		resource: New<WlDataDeviceManager>,
-		_global_data: &(),
-		data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		let _resource = data_init.init(resource, ());
-	}
-}
-
-impl Dispatch<WlDataDeviceManager, (), WaylandState> for WaylandState {
-	fn request(
-		_state: &mut WaylandState,
-		_client: &Client,
-		_resource: &WlDataDeviceManager,
-		request: <WlDataDeviceManager as Resource>::Request,
-		_data: &(),
-		_dhandle: &DisplayHandle,
-		data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		match request {
-			CreateDataSource { id } => {
-				data_init.init(id, ());
-			}
-			GetDataDevice { id, seat: _ } => {
-				data_init.init(id, ());
-			}
-			_ => unreachable!(),
-		}
-	}
-}
-
-impl Dispatch<WlDataSource, (), WaylandState> for WaylandState {
-	fn request(
-		_state: &mut WaylandState,
-		_client: &Client,
-		_resource: &WlDataSource,
-		request: <WlDataSource as Resource>::Request,
-		_data: &(),
-		_dhandle: &DisplayHandle,
-		_data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		match request {
-			Offer { mime_type: _ } => {}
-			Destroy => {}
-			SetActions { dnd_actions: _ } => {}
-			_ => unreachable!(),
-		}
-	}
-}
-
-impl Dispatch<WlDataDevice, (), WaylandState> for WaylandState {
-	fn request(
-		_state: &mut WaylandState,
-		_client: &Client,
-		_resource: &WlDataDevice,
-		request: <WlDataDevice as Resource>::Request,
-		_data: &(),
-		_dhandle: &DisplayHandle,
-		_data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		match request {
-			StartDrag {
-				source: _,
-				origin: _,
-				icon: _,
-				serial: _,
-			} => {}
-			SetSelection {
-				source: _,
-				serial: _,
-			} => {}
-			Release => {}
-			_ => unreachable!(),
-		}
-	}
-}

src/wayland/decoration.rs

@@ -1,97 +0,0 @@
-use super::state::WaylandState;
-use smithay::{
-	delegate_kde_decoration,
-	reexports::{
-		wayland_protocols::xdg::{
-			decoration::zv1::server::{
-				zxdg_decoration_manager_v1::{self, ZxdgDecorationManagerV1},
-				zxdg_toplevel_decoration_v1::{self, Mode, ZxdgToplevelDecorationV1},
-			},
-			shell::server::xdg_toplevel::XdgToplevel,
-		},
-		wayland_protocols_misc::server_decoration::server::org_kde_kwin_server_decoration::{
-			Mode as KdeMode, OrgKdeKwinServerDecoration,
-		},
-		wayland_server::{
-			Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource, WEnum, Weak,
-			protocol::wl_surface::WlSurface,
-		},
-	},
-	wayland::shell::{self, kde::decoration::KdeDecorationHandler},
-};
-
-impl GlobalDispatch<ZxdgDecorationManagerV1, (), WaylandState> for WaylandState {
-	fn bind(
-		_state: &mut WaylandState,
-		_handle: &DisplayHandle,
-		_client: &Client,
-		resource: New<ZxdgDecorationManagerV1>,
-		_global_data: &(),
-		data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		data_init.init(resource, ());
-	}
-}
-
-impl Dispatch<ZxdgDecorationManagerV1, (), WaylandState> for WaylandState {
-	fn request(
-		_state: &mut WaylandState,
-		_client: &Client,
-		_resource: &ZxdgDecorationManagerV1,
-		request: zxdg_decoration_manager_v1::Request,
-		_data: &(),
-		_dhandle: &DisplayHandle,
-		data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		match request {
-			zxdg_decoration_manager_v1::Request::Destroy => (),
-			zxdg_decoration_manager_v1::Request::GetToplevelDecoration { id, toplevel } => {
-				data_init.init(id, toplevel.downgrade());
-			}
-			_ => unreachable!(),
-		}
-	}
-}
-impl Dispatch<ZxdgToplevelDecorationV1, Weak<XdgToplevel>, WaylandState> for WaylandState {
-	fn request(
-		_state: &mut WaylandState,
-		_client: &Client,
-		resource: &ZxdgToplevelDecorationV1,
-		request: zxdg_toplevel_decoration_v1::Request,
-		_data: &Weak<XdgToplevel>,
-		_dhandle: &DisplayHandle,
-		_data_init: &mut DataInit<'_, WaylandState>,
-	) {
-		match request {
-			zxdg_toplevel_decoration_v1::Request::SetMode { mode: _ } => {
-				resource.configure(Mode::ServerSide);
-			}
-			zxdg_toplevel_decoration_v1::Request::UnsetMode => {
-				resource.configure(Mode::ServerSide);
-			}
-			zxdg_toplevel_decoration_v1::Request::Destroy => (),
-			_ => unreachable!(),
-		}
-	}
-}
-
-impl KdeDecorationHandler for WaylandState {
-	fn kde_decoration_state(&self) -> &shell::kde::decoration::KdeDecorationState {
-		&self.kde_decoration_state
-	}
-
-	fn new_decoration(&mut self, _surface: &WlSurface, decoration: &OrgKdeKwinServerDecoration) {
-		decoration.mode(KdeMode::Server);
-	}
-
-	fn request_mode(
-		&mut self,
-		_surface: &WlSurface,
-		decoration: &OrgKdeKwinServerDecoration,
-		mode: WEnum<KdeMode>,
-	) {
-		let Ok(mode) = mode.into_result() else { return };
-		decoration.mode(mode);
-	}
-}
-delegate_kde_decoration!(WaylandState);

src/wayland/display.rs

@@ -0,0 +1,79 @@
+#![allow(unused)]
+
+use crate::wayland::{
+	MessageSink, WaylandResult,
+	core::{
+		callback::{Callback, WlCallback},
+		output::Output,
+		seat::Seat,
+	},
+	registry::Registry,
+};
+use global_counter::primitive::exact::CounterU32;
+use std::{
+	sync::{Arc, OnceLock},
+	time::Instant,
+};
+use waynest::ObjectId;
+pub use waynest_protocols::server::core::wayland::wl_display::*;
+use waynest_server::Client as _;
+
+#[derive(waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Display {
+	pub message_sink: MessageSink,
+	pub pid: Option<i32>,
+	pub seat: OnceLock<Arc<Seat>>,
+	pub output: OnceLock<Arc<Output>>,
+	id_counter: CounterU32,
+	pub creation_time: Instant,
+}
+impl Display {
+	pub fn new(message_sink: MessageSink, pid: Option<i32>) -> Self {
+		Self {
+			message_sink,
+			pid,
+			seat: OnceLock::new(),
+			output: OnceLock::new(),
+			id_counter: CounterU32::new(0xff000000), // Start at 0xff000000 to avoid conflicts with client-generated IDs
+			creation_time: Instant::now(),
+		}
+	}
+	pub fn next_server_id(&self) -> ObjectId {
+		unsafe { ObjectId::from_raw(self.id_counter.inc()) }
+	}
+}
+impl WlDisplay for Display {
+	type Connection = crate::wayland::Client;
+
+	/// https://wayland.app/protocols/wayland#wl_display:request:sync
+	async fn sync(
+		&self,
+		client: &mut Self::Connection,
+		sender_id: ObjectId,
+		callback_id: ObjectId,
+	) -> WaylandResult<()> {
+		let serial = client.next_event_serial();
+		Callback(callback_id)
+			.done(client, callback_id, serial)
+			.await?;
+
+		self.delete_id(client, sender_id, callback_id.as_raw())
+			.await?;
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/wayland#wl_display:request:get_registry
+	async fn get_registry(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		registry_id: ObjectId,
+	) -> WaylandResult<()> {
+		let registry = client.insert(registry_id, Registry)?;
+
+		registry.advertise_globals(client, registry_id).await?;
+
+		Ok(())
+	}
+}

src/wayland/dmabuf/buffer_backing.rs

@@ -0,0 +1,122 @@
+use super::buffer_params::BufferParams;
+use crate::wayland::RENDER_DEVICE;
+use bevy::{
+	asset::{Assets, Handle},
+	image::Image,
+};
+use bevy_dmabuf::{
+	dmatex::{Dmatex, Resolution},
+	import::{
+		DmatexUsage, DropCallback, ImportError, ImportedDmatexs, ImportedTexture, import_texture,
+	},
+};
+use drm_fourcc::DrmFourcc;
+use mint::Vector2;
+use parking_lot::Mutex;
+use std::sync::{Arc, OnceLock};
+use waynest_protocols::server::stable::linux_dmabuf_v1::zwp_linux_buffer_params_v1::Flags;
+
+/// Parameters for a shared memory buffer
+pub struct DmabufBacking {
+	size: Vector2<u32>,
+	format: DrmFourcc,
+	tex: OnceLock<Handle<Image>>,
+	pending_imported_dmatex: Mutex<Option<ImportedTexture>>,
+}
+
+impl std::fmt::Debug for DmabufBacking {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		f.debug_struct("DmabufBacking")
+			.field("size", &self.size)
+			.field("format", &self.format)
+			.field("tex", &self.tex)
+			.finish()
+	}
+}
+
+impl DmabufBacking {
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn new(dmatex: Dmatex) -> Result<Self, ImportError> {
+		let dev = RENDER_DEVICE.wait();
+
+		Ok(Self {
+			size: [dmatex.res.x, dmatex.res.y].into(),
+			format: DrmFourcc::try_from(dmatex.format).unwrap(),
+			tex: OnceLock::new(),
+			pending_imported_dmatex: Mutex::new(Some(import_texture(
+				dev,
+				dmatex,
+				DropCallback(None),
+				DmatexUsage::Sampling,
+			)?)),
+		})
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn from_params(
+		params: Arc<BufferParams>,
+		size: Vector2<u32>,
+		format: DrmFourcc,
+		flags: Flags,
+	) -> Result<Self, ImportError> {
+		tracing::info!("Creating new DmabufBacking");
+		let mut planes = Vec::from_iter(std::mem::take(&mut *params.planes.lock()));
+		planes.sort_by_key(|(index, _)| *index);
+		let planes = planes.into_iter().map(|(_, tex)| tex).collect::<Vec<_>>();
+		let dmatex = Dmatex {
+			planes,
+			res: Resolution {
+				x: size.x,
+				y: size.y,
+			},
+			format: format as u32,
+			// TODO: impl this in bevy-dmabuf
+			flip_y: flags.contains(Flags::YInvert),
+			srgb: true,
+		};
+
+		DmabufBacking::new(dmatex)
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn update_tex(
+		&self,
+		dmatexes: &ImportedDmatexs,
+		images: &mut Assets<Image>,
+	) -> Option<Handle<Image>> {
+		self.pending_imported_dmatex
+			.lock()
+			.take()
+			.map(|tex| dmatexes.insert_imported_dmatex(images, tex))
+			.inspect(|handle| {
+				_ = self.tex.set(handle.clone());
+			});
+		self.tex.get().cloned()
+	}
+
+	pub fn is_transparent(&self) -> bool {
+		matches!(
+			self.format,
+			DrmFourcc::Abgr1555
+				| DrmFourcc::Abgr16161616f
+				| DrmFourcc::Abgr2101010
+				| DrmFourcc::Abgr4444
+				| DrmFourcc::Abgr8888
+				| DrmFourcc::Argb1555
+				| DrmFourcc::Argb16161616f
+				| DrmFourcc::Argb2101010
+				| DrmFourcc::Argb4444
+				| DrmFourcc::Argb8888
+				| DrmFourcc::Axbxgxrx106106106106
+				| DrmFourcc::Ayuv
+				| DrmFourcc::Rgba1010102
+				| DrmFourcc::Rgba4444
+				| DrmFourcc::Rgba5551
+				| DrmFourcc::Rgba8888
+		)
+	}
+
+	pub fn size(&self) -> Vector2<usize> {
+		[self.size.x as usize, self.size.y as usize].into()
+	}
+}

src/wayland/dmabuf/buffer_params.rs

@@ -0,0 +1,181 @@
+use super::buffer_backing::DmabufBacking;
+use crate::wayland::{
+	Client, WaylandError, WaylandResult,
+	core::buffer::{Buffer, BufferBacking},
+	util::ClientExt,
+};
+use bevy_dmabuf::dmatex::DmatexPlane;
+use drm_fourcc::DrmFourcc;
+use parking_lot::Mutex;
+use rustc_hash::FxHashMap;
+use std::os::fd::{AsRawFd, OwnedFd};
+use waynest::ObjectId;
+use waynest_protocols::server::stable::linux_dmabuf_v1::zwp_linux_buffer_params_v1::{
+	Error, Flags, ZwpLinuxBufferParamsV1,
+};
+use waynest_server::Client as _;
+
+/// Parameters for creating a DMA-BUF-based wl_buffer
+///
+/// This is a temporary object that collects dmabufs and other parameters
+/// that together form a single logical buffer. The object may eventually
+/// create one wl_buffer unless cancelled by destroying it.
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct BufferParams {
+	pub id: ObjectId,
+	pub(super) planes: Mutex<FxHashMap<u32, DmatexPlane>>,
+}
+
+impl BufferParams {
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub fn new(id: ObjectId) -> Self {
+		tracing::info!("Creating new BufferParams with id {:?}", id);
+		Self {
+			id,
+			planes: Mutex::new(FxHashMap::default()),
+		}
+	}
+}
+
+impl ZwpLinuxBufferParamsV1 for BufferParams {
+	type Connection = Client;
+
+	async fn destroy(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		tracing::info!("Destroying BufferParams {:?}", self.id);
+		Ok(())
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn add(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		fd: OwnedFd,
+		plane_idx: u32,
+		offset: u32,
+		stride: u32,
+		modifier_hi: u32,
+		modifier_lo: u32,
+	) -> WaylandResult<()> {
+		let fd_num = fd.as_raw_fd();
+		tracing::info!(
+			"Adding plane {} with fd {} to BufferParams {:?}",
+			plane_idx,
+			fd_num,
+			self.id
+		);
+
+		let mut planes = self.planes.lock();
+
+		// Check if plane index is already set
+		if planes.contains_key(&plane_idx) {
+			tracing::error!(
+				"Plane {} already exists in BufferParams {:?}",
+				plane_idx,
+				self.id
+			);
+			return Err(crate::wayland::WaylandError::MissingObject(self.id));
+		}
+
+		// Create plane with the provided parameters
+		let plane = DmatexPlane {
+			dmabuf_fd: fd.into(),
+			offset,
+			stride: stride as i32,
+			modifier: ((modifier_hi as u64) << 32) | (modifier_lo as u64),
+		};
+
+		// Store the plane
+		planes.insert(plane_idx, plane);
+		Ok(())
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn create(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		width: i32,
+		height: i32,
+		format: u32,
+		flags: Flags,
+	) -> WaylandResult<()> {
+		tracing::info!("Creating buffer from BufferParams {:?}", self.id);
+		// Create the buffer with DMA-BUF backing using self as the backing
+		let size = [width as u32, height as u32].into();
+		let buffer = DmabufBacking::from_params(
+			client.get::<Self>(self.id).unwrap(),
+			size,
+			DrmFourcc::try_from(format).unwrap(),
+			flags,
+		)
+		.inspect_err(|e| tracing::error!("Failed to import dmabuf because {e}"))
+		.map(|backing| {
+			let id = client.display().next_server_id();
+			Buffer::new(client, id, BufferBacking::Dmabuf(backing))
+		});
+
+		match buffer {
+			Ok(buffer) => self.created(client, self.id, buffer?.id).await,
+			Err(_) => {
+				client.remove(self.id);
+				self.failed(client, self.id).await
+			}
+		}
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	async fn create_immed(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		buffer_id: ObjectId,
+		width: i32,
+		height: i32,
+		format: u32,
+		flags: Flags,
+	) -> WaylandResult<()> {
+		// TODO: terminate client on fail, or send a fail event or something
+		// Create the buffer with DMA-BUF backing using self as the backing
+		match DmabufBacking::from_params(
+			client.get::<Self>(self.id).unwrap(),
+			[width as u32, height as u32].into(),
+			DrmFourcc::try_from(format).unwrap(),
+			flags,
+		) {
+			Ok(backing) => {
+				Buffer::new(client, buffer_id, BufferBacking::Dmabuf(backing))?;
+			}
+			Err(e) => {
+				tracing::error!("Failed to import dmabuf because {e}");
+				return Err(WaylandError::Fatal {
+					object_id: buffer_id,
+					code: Error::Incomplete as u32,
+					message: "Failed to import dmabuf",
+				});
+			}
+		}
+		Ok(())
+	}
+}
+
+impl Drop for BufferParams {
+	#[tracing::instrument(level = "debug", skip_all)]
+	fn drop(&mut self) {
+		let planes = self.planes.get_mut();
+		tracing::info!("BufferParams being dropped with {} planes", planes.len());
+		for (idx, plane) in planes.iter() {
+			tracing::info!(
+				"Dropping plane {} with fd {}",
+				idx,
+				plane.dmabuf_fd.as_raw_fd()
+			);
+		}
+		planes.clear();
+	}
+}

src/wayland/dmabuf/feedback.rs

@@ -0,0 +1,101 @@
+use super::Dmabuf;
+use crate::wayland::{Client, WaylandResult, vulkano_data::VULKANO_CONTEXT};
+use memfd::MemfdOptions;
+use std::{
+	io::Write,
+	os::fd::{AsFd as _, FromRawFd, IntoRawFd, OwnedFd},
+	sync::Arc,
+};
+use waynest::ObjectId;
+use waynest_protocols::server::stable::linux_dmabuf_v1::zwp_linux_dmabuf_feedback_v1::{
+	TrancheFlags, ZwpLinuxDmabufFeedbackV1,
+};
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct DmabufFeedback(pub Arc<Dmabuf>);
+impl DmabufFeedback {
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub async fn send_params(&self, client: &mut Client, sender_id: ObjectId) -> WaylandResult<()> {
+		let num_formats = self.0.formats.len();
+		// Send format table first
+		self.send_format_table(client, sender_id).await?;
+
+		// Get the device information from Vulkan properties
+		let props = VULKANO_CONTEXT.get().unwrap().phys_dev.properties();
+
+		// Create dev_t from the primary node major/minor numbers
+		let primary_dev_id = {
+			let major = props.primary_major.unwrap() as u64;
+			let minor = props.primary_minor.unwrap() as u64;
+			// On Linux, dev_t is created with makedev(major, minor)
+			// which is ((major & 0xfffff000) << 32) | ((major & 0xfff) << 8) | (minor & 0xff)
+			((major & 0xfffff000) << 32) | ((major & 0xfff) << 8) | (minor & 0xff)
+		};
+		let dev_id = primary_dev_id.to_ne_bytes().to_vec();
+
+		// Send main device
+		self.main_device(client, sender_id, dev_id.clone()).await?;
+
+		// Send tranche with same device since we only support the main GPU
+		self.tranche_target_device(client, sender_id, dev_id)
+			.await?;
+
+		let indices = (0..num_formats)
+			.flat_map(|i| (i as u16).to_ne_bytes())
+			.collect();
+		self.tranche_formats(client, sender_id, indices).await?;
+
+		// No special flags needed for simple EGL texture usage
+		self.tranche_flags(client, sender_id, TrancheFlags::empty())
+			.await?;
+
+		// Mark tranche complete
+		self.tranche_done(client, sender_id).await?;
+
+		// Mark overall feedback complete
+		self.done(client, sender_id).await?;
+		Ok(())
+	}
+
+	#[tracing::instrument(level = "debug", skip_all)]
+	pub async fn send_format_table(
+		&self,
+		client: &mut Client,
+		sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		// Format + modifier pair (16 bytes):
+		// - format: u32
+		// - padding: 4 bytes
+		// - modifier: u64
+		let size = self.0.formats.len() as u32 * 16u32;
+		// Create a temporary file for the format table
+		let mfd = MemfdOptions::default().create("stardustxr-format-table")?;
+
+		mfd.as_file().set_len(size as u64)?;
+
+		for (format, modifier) in self.0.formats.iter() {
+			let format = *format as u32;
+			// Write the format+modifier pair
+			mfd.as_file().write_all(&format.to_ne_bytes())?;
+			mfd.as_file().write_all(&0_u32.to_ne_bytes())?;
+			mfd.as_file().write_all(&modifier.to_ne_bytes())?;
+		}
+		let fd = unsafe { OwnedFd::from_raw_fd(mfd.into_raw_fd()) };
+		self.format_table(client, sender_id, fd.as_fd(), size)
+			.await?;
+		Ok(())
+	}
+}
+
+impl ZwpLinuxDmabufFeedbackV1 for DmabufFeedback {
+	type Connection = crate::wayland::Client;
+
+	async fn destroy(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}

src/wayland/dmabuf/mod.rs

@@ -0,0 +1,287 @@
+pub mod buffer_backing;
+pub mod buffer_params;
+pub mod feedback;
+
+use super::vulkano_data::VULKANO_CONTEXT;
+use crate::{
+	core::registry::Registry,
+	wayland::{Client, WaylandError, WaylandResult},
+};
+use bevy_dmabuf::{
+	format_mapping::{drm_fourcc_to_vk_format, vk_format_to_srgb},
+	wgpu_init::vulkan_to_wgpu,
+};
+use buffer_params::BufferParams;
+use drm_fourcc::DrmFourcc;
+use feedback::DmabufFeedback;
+use rustc_hash::FxHashSet;
+use std::sync::LazyLock;
+use vulkano::format::FormatFeatures;
+use waynest::ObjectId;
+use waynest_protocols::server::stable::linux_dmabuf_v1::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1;
+use waynest_server::Client as _;
+
+pub static DMABUF_FORMATS: LazyLock<Vec<(DrmFourcc, u64)>> = LazyLock::new(|| {
+	let vk = VULKANO_CONTEXT.wait();
+
+	let format_modifier_pairs = ALL_DRM_FOURCCS
+		.iter()
+		.copied()
+		.filter_map(|f| Some((f, drm_fourcc_to_vk_format(f)?)))
+		.filter(|(_, vk_format)| vulkan_to_wgpu(*vk_format).is_some())
+		.filter(|(_, vk_format)| vk_format_to_srgb(*vk_format).is_some())
+		.filter_map(|(f, vk_format)| {
+			Some((
+				f,
+				vk.phys_dev
+					.format_properties(vk_format.try_into().unwrap())
+					.ok()?
+					.drm_format_modifier_properties
+					.into_iter()
+					.filter(|v| {
+						v.drm_format_modifier_tiling_features
+							.contains(FormatFeatures::SAMPLED_IMAGE)
+					})
+					.map(|v| v.drm_format_modifier)
+					.collect::<Vec<_>>(),
+			))
+		})
+		.flat_map(|(f, mods)| mods.into_iter().map(move |modifier| (f, modifier)))
+		.collect::<FxHashSet<_>>();
+
+	let mut format_modifier_pairs = format_modifier_pairs.into_iter().collect::<Vec<_>>();
+	format_modifier_pairs.sort_by(|(f1, m1), (f2, m2)| {
+		// Prioritize LINEAR modifier
+		let linear1 = *m1 == 0;
+		let linear2 = *m2 == 0;
+		linear2
+			.cmp(&linear1) // true = 1, false = 0
+			.then_with(|| (*f1 as u32).cmp(&(*f2 as u32))) // Sort by format numerically
+			.then_with(|| m1.cmp(m2)) // Then by modifier
+	});
+	format_modifier_pairs
+});
+
+/// Main DMA-BUF interface implementation
+///
+/// This interface allows clients to create wl_buffers from DMA-BUFs.
+/// It handles:
+/// - Format/modifier advertisement
+/// - Buffer parameter creation
+/// - Default/surface-specific feedback
+///
+/// The implementation ensures:
+/// - Coherency for read access in dmabuf data
+/// - Proper lifetime management of dmabuf file descriptors
+/// - Safe handling of buffer attachments
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Dmabuf {
+	// Track supported formats and modifiers
+	// formats: Mutex<FxHashSet<DrmFormat>>,
+	// Track active buffer parameters objects by their ID
+	active_params: Registry<BufferParams>,
+	pub(self) version: u32,
+	pub(self) formats: Vec<(DrmFourcc, u64)>,
+}
+
+impl Dmabuf {
+	/// Create a new DMA-BUF interface instance
+	pub async fn new(client: &mut Client, id: ObjectId, version: u32) -> WaylandResult<Self> {
+		let dmabuf = Self {
+			active_params: Registry::new(),
+			version,
+			formats: DMABUF_FORMATS.clone(),
+		};
+
+		if version < 3 {
+			for (format, _) in &dmabuf.formats {
+				dmabuf.format(client, id, *format as u32).await?;
+			}
+		}
+		// `modifier` is deprecated in version 4
+		if version == 3 {
+			for (format, modifier) in &dmabuf.formats {
+				let format = *format as u32;
+				let modifier_hi = (*modifier >> 32) as u32;
+				let modifier_lo = *modifier as u32;
+				dmabuf
+					.modifier(client, id, format, modifier_hi, modifier_lo)
+					.await?;
+			}
+		}
+
+		Ok(dmabuf)
+	}
+
+	/// Remove a buffer parameters object from tracking
+	pub(crate) fn remove_params(&self, params_id: ObjectId) {
+		self.active_params.retain(|params| params.id != params_id);
+	}
+}
+
+impl ZwpLinuxDmabufV1 for Dmabuf {
+	type Connection = crate::wayland::Client;
+
+	async fn destroy(
+		&self,
+		_client: &mut Self::Connection,
+		sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		self.remove_params(sender_id);
+		Ok(())
+	}
+
+	async fn create_params(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		params_id: ObjectId,
+	) -> WaylandResult<()> {
+		// Create new buffer parameters object
+		let params = client.insert(params_id, BufferParams::new(params_id))?;
+		self.active_params.add_raw(&params);
+		Ok(())
+	}
+
+	async fn get_default_feedback(
+		&self,
+		client: &mut Self::Connection,
+		sender_id: ObjectId,
+		id: ObjectId,
+	) -> WaylandResult<()> {
+		if self.version < 3 {
+			return Err(WaylandError::Fatal {
+				object_id: id,
+				code: 71,
+				message: "Can't call get_default_feedback on version < 4 of dmabuf",
+			});
+		}
+		// Create feedback object for default (non-surface-specific) settings
+		let feedback =
+			client.insert(id, DmabufFeedback(client.get::<Dmabuf>(sender_id).unwrap()))?;
+		feedback.send_params(client, id).await?;
+		Ok(())
+	}
+
+	async fn get_surface_feedback(
+		&self,
+		client: &mut Self::Connection,
+		sender_id: ObjectId,
+		id: ObjectId,
+		_surface: ObjectId,
+	) -> WaylandResult<()> {
+		// Create feedback object for surface-specific settings
+		// Note: Surface-specific feedback could be optimized based on the surface's
+		// requirements, but for now we use the same feedback as default
+		self.get_default_feedback(client, sender_id, id).await
+	}
+}
+
+pub const ALL_DRM_FOURCCS: [DrmFourcc; 105] = [
+	DrmFourcc::Abgr1555,
+	DrmFourcc::Abgr16161616f,
+	DrmFourcc::Abgr2101010,
+	DrmFourcc::Abgr4444,
+	DrmFourcc::Abgr8888,
+	DrmFourcc::Argb1555,
+	DrmFourcc::Argb16161616f,
+	DrmFourcc::Argb2101010,
+	DrmFourcc::Argb4444,
+	DrmFourcc::Argb8888,
+	DrmFourcc::Axbxgxrx106106106106,
+	DrmFourcc::Ayuv,
+	DrmFourcc::Bgr233,
+	DrmFourcc::Bgr565,
+	DrmFourcc::Bgr565_a8,
+	DrmFourcc::Bgr888,
+	DrmFourcc::Bgr888_a8,
+	DrmFourcc::Bgra1010102,
+	DrmFourcc::Bgra4444,
+	DrmFourcc::Bgra5551,
+	DrmFourcc::Bgra8888,
+	DrmFourcc::Bgrx1010102,
+	DrmFourcc::Bgrx4444,
+	DrmFourcc::Bgrx5551,
+	DrmFourcc::Bgrx8888,
+	DrmFourcc::Bgrx8888_a8,
+	DrmFourcc::Big_endian,
+	DrmFourcc::C8,
+	DrmFourcc::Gr1616,
+	DrmFourcc::Gr88,
+	DrmFourcc::Nv12,
+	DrmFourcc::Nv15,
+	DrmFourcc::Nv16,
+	DrmFourcc::Nv21,
+	DrmFourcc::Nv24,
+	DrmFourcc::Nv42,
+	DrmFourcc::Nv61,
+	DrmFourcc::P010,
+	DrmFourcc::P012,
+	DrmFourcc::P016,
+	DrmFourcc::P210,
+	DrmFourcc::Q401,
+	DrmFourcc::Q410,
+	DrmFourcc::R16,
+	DrmFourcc::R8,
+	DrmFourcc::Rg1616,
+	DrmFourcc::Rg88,
+	DrmFourcc::Rgb332,
+	DrmFourcc::Rgb565,
+	DrmFourcc::Rgb565_a8,
+	DrmFourcc::Rgb888,
+	DrmFourcc::Rgb888_a8,
+	DrmFourcc::Rgba1010102,
+	DrmFourcc::Rgba4444,
+	DrmFourcc::Rgba5551,
+	DrmFourcc::Rgba8888,
+	DrmFourcc::Rgbx1010102,
+	DrmFourcc::Rgbx4444,
+	DrmFourcc::Rgbx5551,
+	DrmFourcc::Rgbx8888,
+	DrmFourcc::Rgbx8888_a8,
+	DrmFourcc::Uyvy,
+	DrmFourcc::Vuy101010,
+	DrmFourcc::Vuy888,
+	DrmFourcc::Vyuy,
+	DrmFourcc::X0l0,
+	DrmFourcc::X0l2,
+	DrmFourcc::Xbgr1555,
+	DrmFourcc::Xbgr16161616f,
+	DrmFourcc::Xbgr2101010,
+	DrmFourcc::Xbgr4444,
+	DrmFourcc::Xbgr8888,
+	DrmFourcc::Xbgr8888_a8,
+	DrmFourcc::Xrgb1555,
+	DrmFourcc::Xrgb16161616f,
+	DrmFourcc::Xrgb2101010,
+	DrmFourcc::Xrgb4444,
+	DrmFourcc::Xrgb8888,
+	DrmFourcc::Xrgb8888_a8,
+	DrmFourcc::Xvyu12_16161616,
+	DrmFourcc::Xvyu16161616,
+	DrmFourcc::Xvyu2101010,
+	DrmFourcc::Xyuv8888,
+	DrmFourcc::Y0l0,
+	DrmFourcc::Y0l2,
+	DrmFourcc::Y210,
+	DrmFourcc::Y212,
+	DrmFourcc::Y216,
+	DrmFourcc::Y410,
+	DrmFourcc::Y412,
+	DrmFourcc::Y416,
+	DrmFourcc::Yuv410,
+	DrmFourcc::Yuv411,
+	DrmFourcc::Yuv420,
+	DrmFourcc::Yuv420_10bit,
+	DrmFourcc::Yuv420_8bit,
+	DrmFourcc::Yuv422,
+	DrmFourcc::Yuv444,
+	DrmFourcc::Yuyv,
+	DrmFourcc::Yvu410,
+	DrmFourcc::Yvu411,
+	DrmFourcc::Yvu420,
+	DrmFourcc::Yvu422,
+	DrmFourcc::Yvu444,
+	DrmFourcc::Yvyu,
+];

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::{
-		Fourcc, Modifier,
-		dmabuf::{Dmabuf, DmabufFlags},
-	},
-	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/mesa_drm.rs

@@ -0,0 +1,133 @@
+use crate::wayland::{
+	Client, WaylandResult,
+	core::buffer::{Buffer, BufferBacking},
+	dmabuf::{DMABUF_FORMATS, buffer_backing::DmabufBacking},
+	vulkano_data::VULKANO_CONTEXT,
+};
+use bevy_dmabuf::dmatex::{Dmatex, DmatexPlane, Resolution};
+use rustc_hash::FxHashSet;
+use std::os::fd::OwnedFd;
+use waynest::ObjectId;
+use waynest_protocols::server::mesa::drm::wl_drm::*;
+
+#[derive(Debug, waynest_server::RequestDispatcher, Default)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct MesaDrm {
+	version: u32,
+}
+impl MesaDrm {
+	pub async fn new(client: &mut Client, id: ObjectId, version: u32) -> WaylandResult<MesaDrm> {
+		let drm = MesaDrm { version };
+
+		let path = {
+			// Get the device information from Vulkan properties
+			let props = VULKANO_CONTEXT.get().unwrap().phys_dev.properties();
+			let minor_version = props.render_minor.unwrap();
+			format!("/dev/dri/renderD{minor_version}")
+		};
+		drm.device(client, id, path).await?;
+
+		// this is basically just enabling ancient dmabufs lel
+		if drm.version >= 2 {
+			drm.capabilities(client, id, Capability::Prime as u32)
+				.await?;
+		}
+
+		// DRM fomrats check
+		let formats = DMABUF_FORMATS
+			.iter()
+			.map(|(fourcc, _)| fourcc)
+			.collect::<FxHashSet<_>>();
+		for format in formats {
+			drm.format(client, id, *format as u32).await?;
+		}
+
+		Ok(drm)
+	}
+}
+impl WlDrm for MesaDrm {
+	type Connection = Client;
+
+	async fn authenticate(
+		&self,
+		client: &mut Self::Connection,
+		sender_id: ObjectId,
+		_id: u32,
+	) -> WaylandResult<()> {
+		self.authenticated(client, sender_id).await
+	}
+
+	async fn create_buffer(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_id: ObjectId,
+		_name: u32,
+		_width: i32,
+		_height: i32,
+		_stride: u32,
+		_format: u32,
+	) -> WaylandResult<()> {
+		tracing::error!("Tried to create non-prime wl_drm buffer!");
+		Ok(())
+	}
+
+	async fn create_planar_buffer(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_id: ObjectId,
+		_name: u32,
+		_width: i32,
+		_height: i32,
+		_format: u32,
+		_offset0: i32,
+		_stride0: i32,
+		_offset1: i32,
+		_stride1: i32,
+		_offset2: i32,
+		_stride2: i32,
+	) -> WaylandResult<()> {
+		tracing::error!("Tried to create non-prime wl_drm buffer!");
+		Ok(())
+	}
+
+	async fn create_prime_buffer(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		buffer_id: ObjectId,
+		name: OwnedFd,
+		width: i32,
+		height: i32,
+		format: u32,
+		offset0: i32,
+		stride0: i32,
+		_offset1: i32,
+		_stride1: i32,
+		_offset2: i32,
+		_stride2: i32,
+	) -> WaylandResult<()> {
+		// TODO: actual error checking
+
+		let _ = DmabufBacking::new(Dmatex {
+			planes: vec![DmatexPlane {
+				dmabuf_fd: name.into(),
+				modifier: 72057594037927935, // because drmfourcc is so broken it doesn't actually export this, this is Invalid btw
+				offset: offset0 as u32,
+				stride: stride0,
+			}],
+			res: Resolution {
+				x: width as u32,
+				y: height as u32,
+			},
+			format,
+			flip_y: false,
+			srgb: true,
+		})
+		.inspect_err(|e| tracing::error!("Failed to import dmabuf because {e}"))
+		.map(|backing| Buffer::new(client, buffer_id, BufferBacking::Dmabuf(backing)));
+
+		Ok(())
+	}
+}

src/wayland/mod.rs

@@ -1,209 +1,525 @@
-mod compositor;
+mod core;
-mod data_device;
+mod display;
-mod decoration;
+mod dmabuf;
-mod seat;
+mod mesa_drm;
-mod state;
+mod presentation;
-mod surface;
+mod registry;
-// mod xdg_activation;
+mod util;
-mod drm;
+mod viewporter;
-mod utils;
+mod vulkano_data;
-mod xdg_shell;
+mod xdg;
 
-use self::{state::WaylandState, surface::CORE_SURFACES};
+use crate::core::error::ServerError;
-use crate::{core::task, wayland::state::ClientState};
+use crate::core::registry::OwnedRegistry;
-use color_eyre::eyre::{Result, ensure};
+use crate::get_time;
-use parking_lot::Mutex;
+use crate::nodes::drawable::model::ModelNodeSystemSet;
-use smithay::{
+use crate::wayland::core::seat::SeatMessage;
-	backend::{
+use crate::wayland::core::surface::Surface;
-		allocator::dmabuf::Dmabuf,
+use crate::wayland::presentation::MonotonicTimestamp;
-		egl::EGLContext,
+use crate::wayland::util::ClientExt;
-		renderer::{ImportDma, Renderer, gles::GlesRenderer},
+use crate::{BevyMaterial, core::task};
-	},
+use bevy::app::{App, Plugin, Update};
-	output::Output,
+use bevy::ecs::schedule::IntoScheduleConfigs;
-	reexports::wayland_server::{Display, DisplayHandle, ListeningSocket},
+use bevy::ecs::system::{Local, Res, ResMut};
-	wayland::dmabuf,
+use bevy::prelude::{Deref, DerefMut};
-};
+use bevy::render::renderer::RenderDevice;
+use bevy::render::{Render, RenderApp};
+use bevy::{asset::Assets, ecs::resource::Resource, image::Image};
+use bevy_dmabuf::import::ImportedDmatexs;
+use bevy_mod_openxr::render::end_frame;
+use bevy_mod_openxr::resources::{OxrFrameState, OxrInstance, Pipelined};
+use bevy_mod_xr::session::XrRenderSet;
+use core::buffer::BufferUsage;
+use core::{buffer::Buffer, callback::Callback, surface::WL_SURFACE_REGISTRY};
+use display::Display;
+use mint::Vector2;
+use pin_project_lite::pin_project;
+use std::fs::File;
+use std::io::ErrorKind;
+use std::mem::MaybeUninit;
+use std::time::Duration;
 use std::{
-	ffi::{OsStr, c_void},
+	io,
-	os::fd::AsFd,
+	path::PathBuf,
 	sync::{Arc, OnceLock},
 };
-use stereokit_rust::system::{Backend, BackendGraphics};
+use tokio::{net::UnixStream, sync::mpsc, task::AbortHandle};
-use tokio::{
+use tokio_stream::{Stream, StreamExt};
-	io::unix::AsyncFd,
+use tracing::{debug_span, instrument};
-	sync::{
+use vulkano_data::setup_vulkano_context;
-		Notify,
+use waynest::{Connection, Socket};
-		mpsc::{self, UnboundedReceiver},
+use waynest::{ObjectId, ProtocolError};
+use waynest_protocols::server::core::wayland::wl_display::WlDisplay;
+use waynest_server::{Client as _, Listener, Store, StoreError};
+use xdg::toplevel::Toplevel;
+
+pub static WAYLAND_DISPLAY: OnceLock<PathBuf> = OnceLock::new();
+
+#[derive(thiserror::Error, Debug)]
+pub enum WaylandError {
+	// #[error("Listener error: {0}")]
+	// Listener(#[from] waynest_server::ListenerError),
+	#[error("I/O error: {0}")]
+	Io(#[from] io::Error),
+	#[error("Decode error: {0}")]
+	DecodeError(#[from] waynest::ProtocolError),
+	#[error("Client requested unknown global: {0}")]
+	UnknownGlobal(u32),
+	#[error("No object found with ID {0}")]
+	MissingObject(ObjectId),
+	#[error("Fatal error on object {object_id} with code {code}: {message}")]
+	Fatal {
+		object_id: ObjectId,
+		code: u32,
+		message: &'static str,
 	},
-	task::AbortHandle,
+	#[error("Memfd error: {0}")]
-};
+	MemfdError(#[from] memfd::Error),
-use tracing::{debug_span, info, instrument};
+	#[error("Dmabuf import error: {0}")]
-
+	DmabufImport(#[from] bevy_dmabuf::import::ImportError),
-pub static WAYLAND_DISPLAY: OnceLock<String> = OnceLock::new();
+	#[error("Server error: {0}")]
-
+	Server(#[from] ServerError),
-struct EGLRawHandles {
+	#[error("Failed to Insert Object")]
-	display: *const c_void,
+	FailedToInsertObject,
-	config: *const c_void,
-	context: *const c_void,
 }
-fn get_sk_egl() -> Result<EGLRawHandles> {
+impl<T: Clone> From<StoreError<T>> for WaylandError {
-	ensure!(
+	fn from(_value: StoreError<T>) -> Self {
-		Backend::graphics() == BackendGraphics::OpenGLESEGL,
+		Self::FailedToInsertObject
-		"StereoKit is not running using EGL!"
+	}
-	);
-
-	Ok(unsafe {
-		EGLRawHandles {
-			display: stereokit_rust::system::backend_opengl_egl_get_display() as *const c_void,
-			config: stereokit_rust::system::backend_opengl_egl_get_config() as *const c_void,
-			context: stereokit_rust::system::backend_opengl_egl_get_context() as *const c_void,
-		}
-	})
 }
 
-pub struct Wayland {
+pin_project! {
-	flush_notify: Arc<Notify>,
+	pub struct Client {
-	client_listener: AbortHandle,
+		store: Store<Client, WaylandError>,
-	client_dispatcher: AbortHandle,
+		#[pin]
-	renderer: GlesRenderer,
+		connection: Socket,
-	output: Output,
+		next_event_serial: u32,
-	dmabuf_rx: UnboundedReceiver<(Dmabuf, Option<dmabuf::ImportNotifier>)>,
+	}
 }
-impl Wayland {
+impl Connection for Client {
-	pub fn new() -> Result<Self> {
+	type Error = WaylandError;
-		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()?;
+	fn fd(&mut self) -> Result<std::os::unix::prelude::OwnedFd, <Self as Connection>::Error> {
-		let display_handle = display.handle();
+		Ok(self.connection.fd()?)
+	}
+}
+impl Stream for Client {
+	type Item = <Socket as Stream>::Item;
 
-		let (dmabuf_tx, dmabuf_rx) = mpsc::unbounded_channel();
+	fn poll_next(
+		self: std::pin::Pin<&mut Self>,
+		cx: &mut std::task::Context<'_>,
+	) -> std::task::Poll<Option<Self::Item>> {
+		// <Socket as Stream>::poll_next(self.project().connection, cx)
+		self.project().connection.poll_next(cx)
+	}
+}
+impl futures_sink::Sink<waynest::Message> for Client {
+	type Error = ProtocolError;
 
-		let wayland_state = WaylandState::new(display_handle.clone(), &renderer, dmabuf_tx);
+	fn poll_ready(
-		let output = wayland_state.lock().output.clone();
+		self: std::pin::Pin<&mut Self>,
+		cx: &mut std::task::Context<'_>,
+	) -> std::task::Poll<Result<(), Self::Error>> {
+		self.project().connection.poll_ready(cx)
+	}
 
-		let socket = ListeningSocket::bind_auto("wayland", 0..33)?;
+	fn start_send(
-		let socket_name = socket
+		self: std::pin::Pin<&mut Self>,
-			.socket_name()
+		item: waynest::Message,
-			.and_then(OsStr::to_str)
+	) -> Result<(), Self::Error> {
-			.map(ToString::to_string);
+		self.project().connection.start_send(item)
-		if let Some(socket_name) = &socket_name {
+	}
-			let _ = WAYLAND_DISPLAY.set(socket_name.clone());
-		}
-		info!(socket_name, "Wayland active");
 
-		let flush_notify = Arc::new(Notify::new());
+	fn poll_flush(
-		let client_listener = task::new(
+		self: std::pin::Pin<&mut Self>,
-			|| "Wayland client listener loop",
+		cx: &mut std::task::Context<'_>,
-			Wayland::client_listener_loop(display_handle, socket, wayland_state.clone()),
+	) -> std::task::Poll<Result<(), Self::Error>> {
-		)?
+		self.project().connection.poll_flush(cx)
-		.abort_handle();
+	}
-		let client_dispatcher = task::new(
-			|| "Wayland dispatch client loop",
-			Wayland::dispatch_client_loop(display, flush_notify.clone(), wayland_state),
-		)?
-		.abort_handle();
 
-		Ok(Wayland {
+	fn poll_close(
-			flush_notify,
+		self: std::pin::Pin<&mut Self>,
-			client_listener,
+		cx: &mut std::task::Context<'_>,
-			client_dispatcher,
+	) -> std::task::Poll<Result<(), Self::Error>> {
-			renderer,
+		self.project().connection.poll_close(cx)
-			output,
+	}
-			dmabuf_rx,
+}
+impl Client {
+	fn new(unix_stream: UnixStream) -> tokio::io::Result<Self> {
+		Ok(Self {
+			store: Store::new(),
+			connection: Socket::new(unix_stream.into_std()?)?,
+			next_event_serial: 0,
 		})
 	}
+	pub fn next_event_serial(&mut self) -> u32 {
+		let prev = self.next_event_serial;
+		self.next_event_serial = self.next_event_serial.wrapping_add(1);
+		prev
+	}
+}
 
-	async fn client_listener_loop(
+impl waynest_server::Client for Client {
-		mut display_handle: DisplayHandle,
+	type Store = Store<Client, WaylandError>;
-		socket: ListeningSocket,
-		state: Arc<Mutex<WaylandState>>,
-	) -> Result<()> {
-		let async_fd = AsyncFd::new(socket.as_fd())?;
-		loop {
-			let mut guard = async_fd.readable().await?;
-			let Ok(Some(stream)) = socket.accept() else {
-				guard.clear_ready();
-				continue;
-			};
 
-			let stream = tokio::net::UnixStream::from_std(stream)?;
+	fn store(&self) -> &Self::Store {
-			let pid = stream.peer_cred().ok().and_then(|c| c.pid());
+		&self.store
-
-			// New client connected
-			let client_state = Arc::new(ClientState {
-				pid,
-				id: OnceLock::new(),
-				compositor_state: Default::default(),
-				seat: state.lock().seat.clone(),
-			});
-			let _client = display_handle.insert_client(stream.into_std()?, client_state.clone())?;
-		}
 	}
 
-	async fn dispatch_client_loop(
+	fn store_mut(&mut self) -> &mut Self::Store {
-		mut display: Display<WaylandState>,
+		&mut self.store
-		flush_notify: Arc<Notify>,
+	}
-		state: Arc<Mutex<WaylandState>>,
+}
-	) -> std::io::Result<()> {
+
+pub fn get_free_wayland_socket_path() -> Option<(PathBuf, File)> {
+	// Use XDG runtime directory for secure, user-specific sockets
+	let base_dirs = directories::BaseDirs::new()?;
+	let runtime_dir = base_dirs.runtime_dir()?;
+
+	// Iterate through conventional display numbers (matches X11 behavior)
+	for display in 0..=32 {
+		let socket_path = runtime_dir.join(format!("wayland-{display}"));
+		let socket_lock_path = runtime_dir.join(format!("wayland-{display}.lock"));
+
+		let Ok(lock) = File::create(&socket_lock_path) else {
+			continue;
+		};
+
+		if lock.try_lock().is_err() {
+			continue;
+		};
+
+		// Check for zombie sockets (file exists but nothing listening)
+		if socket_path.exists() {
+			match std::os::unix::net::UnixStream::connect(&socket_path) {
+				Ok(_) => continue, // Active compositor found - skip
+				Err(e) if e.kind() == ErrorKind::ConnectionRefused => {
+					// Stale socket - safe to remove since we hold the lock
+					let _ = std::fs::remove_file(&socket_path);
+				}
+				Err(_) => continue, // Transient error - conservative skip
+			}
+		}
+
+		// Found viable candidate: lock held, socket cleared/available
+		return Some((socket_path, lock));
+	}
+
+	None // Exhausted all conventional display numbers
+}
+
+pub type WaylandResult<T, E = WaylandError> = std::result::Result<T, E>;
+
+pub enum Message {
+	Frame(Vec<Arc<Callback>>),
+	ReleaseBuffer(Arc<Buffer>),
+	CloseToplevel(Arc<Toplevel>),
+	ResizeToplevel {
+		toplevel: Arc<Toplevel>,
+		size: Option<Vector2<u32>>,
+	},
+	ReconfigureToplevel(Arc<Toplevel>),
+	SetToplevelVisualActive {
+		toplevel: Arc<Toplevel>,
+		active: bool,
+	},
+	Seat(SeatMessage),
+	SendPresentationFeedback {
+		surface: Arc<Surface>,
+		display_timestamp: MonotonicTimestamp,
+		refresh_cycle: u64,
+	},
+}
+
+pub type MessageSink = mpsc::UnboundedSender<Message>;
+
+#[derive(Debug)]
+struct WaylandClient {
+	abort_handle: AbortHandle,
+}
+impl WaylandClient {
+	pub fn from_stream(socket: UnixStream) -> WaylandResult<Self> {
+		let pid = socket.peer_cred().ok().and_then(|c| c.pid());
+		let exe = pid.and_then(|pid| std::fs::read_link(format!("/proc/{pid}/exe")).ok());
+
+		let mut client = Client::new(socket)?;
+		let (message_sink, message_source) = mpsc::unbounded_channel();
+
+		client.insert(ObjectId::DISPLAY, Display::new(message_sink, pid))?;
+
+		let pid_printable = pid
+			.map(|pid| pid.to_string())
+			.unwrap_or_else(|| "??".to_string());
+		let exe_printable = exe
+			.and_then(|exe| {
+				exe.file_name()
+					.and_then(|exe| exe.to_str())
+					.map(|exe| exe.to_string())
+			})
+			.unwrap_or_else(|| "??".to_string());
+		let abort_handle = task::new(
+			|| format!("Wayland client \"{exe_printable}\" dispatch, pid={pid_printable}"),
+			Self::dispatch_loop(client, message_source),
+		)?
+		.abort_handle();
+
+		Ok(WaylandClient { abort_handle })
+	}
+
+	async fn dispatch_loop(
+		mut client: Client,
+		mut render_message_rx: mpsc::UnboundedReceiver<Message>,
+	) -> WaylandResult<()> {
 		loop {
-			let poll_fd = display.backend().poll_fd();
-			let async_fd = AsyncFd::new(poll_fd)?;
 			tokio::select! {
 				biased;
-				_ = async_fd.readable() => {
+				// send all queued up messages
-					drop(async_fd);
+				msg = render_message_rx.recv() => {
-					let _span = debug_span!("Dispatch wayland event");
+					let Some(msg) = msg else {
-					let _span = _span.enter();
+						// Render message channel closed, end the dispatch loop
-					let _ = display.dispatch_clients(&mut *state.lock());
+						return Ok(());
-					let _ = display.flush_clients();
+					};
+					Self::handle_render_message(&mut client, msg).await?;
 				}
-				_ = flush_notify.notified() => {
+				// handle the next message
-					drop(async_fd);
+				msg = client.try_next() => {
-					let _ = display.flush_clients();
+					let Some(mut msg) = msg? else {
-				},
+						// Client disconnected, end the dispatch loop
-			}
+						return Ok(());
+					};
+					if let Err(e) = client
+						.get_raw(msg.object_id())
+						.ok_or(WaylandError::MissingObject(msg.object_id()))?
+						.dispatch_request(&mut client, msg.object_id(), &mut msg)
+						.await
+					{
+						if let WaylandError::Fatal { object_id, code, message } = e {
+							client.display().error(&mut client, ObjectId::DISPLAY, object_id, code, message.to_string()).await?;
+						}
+						tracing::error!("Wayland: {e}");
+						return Err(e);
+					}
+				}
+			};
 		}
 	}
 
-	#[instrument(level = "debug", name = "Wayland frame", skip(self))]
+	async fn handle_render_message(client: &mut Client, message: Message) -> WaylandResult<()> {
-	pub fn update(&mut self) {
+		use waynest_protocols::server::core::wayland::wl_buffer::WlBuffer;
-		while let Ok((dmabuf, notifier)) = self.dmabuf_rx.try_recv() {
+		use waynest_protocols::server::core::wayland::wl_callback::WlCallback;
-			if self.renderer.import_dmabuf(&dmabuf, None).is_err() {
+		use waynest_protocols::server::core::wayland::wl_display::WlDisplay;
-				if let Some(notifier) = notifier {
+		use waynest_protocols::server::stable::xdg_shell::xdg_toplevel::XdgToplevel;
-					notifier.failed();
+
+		match message {
+			Message::Frame(callbacks) => {
+				let now = rustix::time::clock_gettime(rustix::time::ClockId::Monotonic);
+				let now = Duration::new(now.tv_sec as u64, now.tv_nsec as u32);
+				let ms = (now.as_millis() % (u32::MAX as u128)) as u32;
+				for callback in callbacks {
+					callback.done(client, callback.0, ms).await?;
+					client
+						.get::<Display>(ObjectId::DISPLAY)
+						.unwrap()
+						.delete_id(client, ObjectId::DISPLAY, callback.0.as_raw())
+						.await?;
+					client.remove(callback.0);
 				}
 			}
+			Message::ReleaseBuffer(buffer) => {
+				buffer.release(client, buffer.id).await?;
+			}
+			Message::CloseToplevel(toplevel) => {
+				toplevel.close(client, toplevel.id).await?;
+			}
+			Message::ResizeToplevel { toplevel, size } => {
+				toplevel.set_size(size);
+				toplevel.reconfigure(client).await?;
+			}
+			Message::ReconfigureToplevel(toplevel) => {
+				toplevel.reconfigure(client).await?;
+			}
+			Message::SetToplevelVisualActive { toplevel, active } => {
+				toplevel.set_activated(active);
+				toplevel.reconfigure(client).await?;
+			}
+			Message::Seat(seat_message) => {
+				if let Some(seat) = client.get::<Display>(ObjectId::DISPLAY).unwrap().seat.get() {
+					seat.handle_message(client, seat_message).await?;
+				}
+			}
+			Message::SendPresentationFeedback {
+				surface,
+				display_timestamp,
+				refresh_cycle,
+			} => {
+				surface
+					.send_presentation_feedback(client, display_timestamp, refresh_cycle)
+					.await?;
+			}
 		}
-		for core_surface in CORE_SURFACES.get_valid_contents() {
+		Ok(())
-			core_surface.process(&mut self.renderer);
-		}
-		let _ = self.renderer.cleanup_texture_cache();
-
-		self.flush_notify.notify_waiters();
 	}
-
+}
-	pub fn frame_event(&self) {
+impl Drop for WaylandClient {
-		for core_surface in CORE_SURFACES.get_valid_contents() {
+	fn drop(&mut self) {
-			core_surface.frame(self.output.clone());
+		self.abort_handle.abort();
-		}
 	}
+}
 
-	pub fn make_context_current(&self) {
+#[derive(Debug, Resource)]
-		unsafe {
+pub struct Wayland {
-			let _ = self.renderer.egl_context().make_current();
+	_lockfile: File,
+	abort_handle: AbortHandle,
+}
+impl Wayland {
+	pub fn new() -> color_eyre::eyre::Result<Self> {
+		let (socket_path, _lockfile) = get_free_wayland_socket_path().ok_or(WaylandError::Io(
+			std::io::ErrorKind::AddrNotAvailable.into(),
+		))?;
+
+		let _ = WAYLAND_DISPLAY.set(socket_path.clone());
+
+		let listener = waynest_server::Listener::new_with_path(&socket_path)?;
+		let _ = WAYLAND_DISPLAY.set(listener.socket_path().to_path_buf());
+
+		let abort_handle = task::new(
+			|| "Wayland socket accept loop",
+			Self::handle_wayland_loop(listener),
+		)?
+		.abort_handle();
+
+		Ok(Self {
+			_lockfile,
+			abort_handle,
+		})
+	}
+	async fn handle_wayland_loop(mut listener: Listener) -> WaylandResult<()> {
+		let mut clients = Vec::new();
+		loop {
+			if let Ok(Some(stream)) = listener.try_next().await {
+				debug_span!("Accept wayland client").in_scope(|| {
+					if let Ok(client) = WaylandClient::from_stream(stream) {
+						clients.push(client);
+					}
+				});
+			}
+			clients.retain(|client| !client.abort_handle.is_finished());
 		}
+
+		#[allow(unreachable_code)]
+		Ok(())
 	}
 }
 impl Drop for Wayland {
 	fn drop(&mut self) {
-		self.client_listener.abort();
+		self.abort_handle.abort();
-		self.client_dispatcher.abort();
+	}
+}
+
+static RENDER_DEVICE: OnceLock<RenderDevice> = OnceLock::new();
+
+pub struct WaylandPlugin;
+impl Plugin for WaylandPlugin {
+	fn build(&self, app: &mut App) {
+		app.add_systems(Update, update_graphics.before(ModelNodeSystemSet));
+		app.init_resource::<UsedBuffers>();
+		app.sub_app_mut(RenderApp)
+			.init_resource::<UsedBuffers>()
+			.add_systems(
+				Render,
+				init_render_device.run_if(|| RENDER_DEVICE.get().is_none()),
+			);
+	}
+	fn finish(&self, app: &mut App) {
+		app.sub_app_mut(RenderApp)
+			.add_systems(Render, setup_vulkano_context)
+			.add_systems(Render, before_render.in_set(XrRenderSet::PreRender))
+			.add_systems(Render, after_render.in_set(XrRenderSet::PostRender))
+			.add_systems(
+				Render,
+				submit_frame_timings
+					.in_set(XrRenderSet::PostRender)
+					.after(end_frame),
+			);
+	}
+}
+
+fn init_render_device(dev: Res<RenderDevice>) {
+	_ = RENDER_DEVICE.set(dev.clone());
+}
+
+#[derive(Resource, Deref, DerefMut)]
+struct UsedBuffers(OwnedRegistry<BufferUsage>);
+impl Default for UsedBuffers {
+	fn default() -> Self {
+		Self(OwnedRegistry::new())
+	}
+}
+
+fn before_render(buffers: Res<UsedBuffers>) {
+	for buf in WL_SURFACE_REGISTRY
+		.get_valid_contents()
+		.into_iter()
+		.filter_map(|surface| surface.current_state().buffer)
+		.filter_map(|buffer| buffer.usage)
+	{
+		buffers.add_raw(buf);
+	}
+	for surface in WL_SURFACE_REGISTRY.get_valid_contents() {
+		surface.frame_event();
+	}
+}
+
+fn after_render(buffers: Res<UsedBuffers>) {
+	buffers.clear();
+}
+
+#[instrument(level = "debug", name = "Wayland frame", skip_all)]
+fn update_graphics(
+	dmatexes: Res<ImportedDmatexs>,
+	mut materials: ResMut<Assets<BevyMaterial>>,
+	mut images: ResMut<Assets<Image>>,
+) {
+	for surface in WL_SURFACE_REGISTRY.get_valid_contents() {
+		surface.update_graphics(&dmatexes, &mut materials, &mut images);
+	}
+}
+
+#[instrument(level = "debug", name = "Wayland frame", skip_all)]
+fn submit_frame_timings(
+	mut frame_count: Local<u64>,
+	instance: Option<Res<OxrInstance>>,
+	frame_state: Option<Res<OxrFrameState>>,
+	pipelined: Option<Res<Pipelined>>,
+) {
+	*frame_count += 1;
+	let display_timestamp = frame_state
+		.and_then(|state| Some((state, instance?)))
+		.and_then(|(state, instance)| {
+			instance
+				.exts()
+				.khr_convert_timespec_time
+				.and_then(|v| unsafe {
+					let mut out = MaybeUninit::uninit();
+					let result = (v.convert_time_to_timespec_time)(
+						instance.as_raw(),
+						get_time(pipelined.is_some(), &state),
+						out.as_mut_ptr(),
+					);
+					if result != openxr::sys::Result::SUCCESS {
+						return None;
+					}
+					let v = out.assume_init();
+					Some(rustix::time::Timespec {
+						tv_sec: v.tv_sec,
+						tv_nsec: v.tv_nsec,
+					})
+				})
+		})
+		.unwrap_or_else(|| rustix::time::clock_gettime(rustix::time::ClockId::Monotonic))
+		.into();
+	for surface in WL_SURFACE_REGISTRY.get_valid_contents() {
+		surface.submit_presentation_feedback(display_timestamp, *frame_count);
 	}
 }

src/wayland/presentation.rs

@@ -0,0 +1,81 @@
+use crate::wayland::WaylandResult;
+use crate::wayland::core::surface::Surface;
+use rustix::fs::Timespec;
+use waynest::ObjectId;
+use waynest_protocols::server::stable::presentation_time::{
+	wp_presentation::*, wp_presentation_feedback::*,
+};
+use waynest_server::Client as _;
+
+#[derive(Clone, Copy, Debug)]
+pub struct MonotonicTimestamp {
+	secs: u64,
+	subsec_nanos: u32,
+}
+
+impl MonotonicTimestamp {
+	pub fn secs_lo(&self) -> u32 {
+		self.secs as u32
+	}
+	pub fn secs_hi(&self) -> u32 {
+		(self.secs >> 16) as u32
+	}
+	pub fn subsec_nanos(&self) -> u32 {
+		self.subsec_nanos
+	}
+}
+impl From<Timespec> for MonotonicTimestamp {
+	fn from(value: Timespec) -> Self {
+		Self {
+			secs: value.tv_sec as u64,
+			subsec_nanos: value.tv_nsec as u32,
+		}
+	}
+}
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Presentation {
+	id: ObjectId,
+}
+impl Presentation {
+	pub fn new(id: ObjectId) -> Self {
+		Self { id }
+	}
+}
+impl WpPresentation for Presentation {
+	type Connection = crate::wayland::Client;
+
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+
+	async fn feedback(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		surface: ObjectId,
+		id: ObjectId,
+	) -> WaylandResult<()> {
+		let Some(surface) = client.get::<Surface>(surface) else {
+			tracing::error!("unable to get surface#{surface}");
+			return Ok(());
+		};
+		let feedback = client.insert(id, PresentationFeedback(id))?;
+		surface.add_presentation_feedback(feedback);
+
+		Ok(())
+	}
+}
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct PresentationFeedback(pub ObjectId);
+impl WpPresentationFeedback for PresentationFeedback {
+	type Connection = crate::wayland::Client;
+}

src/wayland/registry.rs

@@ -0,0 +1,229 @@
+use crate::wayland::{Client, WaylandResult};
+use crate::wayland::{
+	WaylandError,
+	core::{
+		compositor::{Compositor, WlCompositor},
+		data_device::DataDeviceManager,
+		output::{Output, WlOutput},
+		seat::{Seat, WlSeat},
+		shm::{Shm, WlShm},
+	},
+	dmabuf::Dmabuf,
+	mesa_drm::MesaDrm,
+	presentation::Presentation,
+	util::ClientExt,
+	viewporter::Viewporter,
+	xdg::wm_base::{WmBase, XdgWmBase},
+};
+use waynest::{NewId, ObjectId};
+use waynest_protocols::server::{
+	core::wayland::{wl_data_device_manager::WlDataDeviceManager, wl_registry::*},
+	mesa::drm::wl_drm::WlDrm,
+	stable::{
+		linux_dmabuf_v1::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1,
+		presentation_time::wp_presentation::WpPresentation,
+		viewporter::wp_viewporter::WpViewporter,
+	},
+};
+use waynest_server::Client as _;
+
+struct RegistryGlobals;
+impl RegistryGlobals {
+	pub const COMPOSITOR: u32 = 0;
+	pub const SHM: u32 = 1;
+	pub const WM_BASE: u32 = 2;
+	pub const SEAT: u32 = 3;
+	pub const DATA_DEVICE_MANAGER: u32 = 4;
+	pub const OUTPUT: u32 = 5;
+	pub const DMABUF: u32 = 6;
+	pub const WL_DRM: u32 = 7;
+	pub const PRESENTATION: u32 = 8;
+	pub const VIEWPORTER: u32 = 9;
+}
+
+#[derive(Debug, waynest_server::RequestDispatcher, Default)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Registry;
+
+impl Registry {
+	pub async fn advertise_globals(
+		&self,
+		client: &mut Client,
+		sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		self.global(
+			client,
+			sender_id,
+			RegistryGlobals::COMPOSITOR,
+			Compositor::INTERFACE.to_string(),
+			Compositor::VERSION,
+		)
+		.await?;
+
+		self.global(
+			client,
+			sender_id,
+			RegistryGlobals::SHM,
+			Shm::INTERFACE.to_string(),
+			Shm::VERSION,
+		)
+		.await?;
+
+		self.global(
+			client,
+			sender_id,
+			RegistryGlobals::WM_BASE,
+			WmBase::INTERFACE.to_string(),
+			WmBase::VERSION,
+		)
+		.await?;
+
+		self.global(
+			client,
+			sender_id,
+			RegistryGlobals::SEAT,
+			Seat::INTERFACE.to_string(),
+			Seat::VERSION,
+		)
+		.await?;
+
+		self.global(
+			client,
+			sender_id,
+			RegistryGlobals::DATA_DEVICE_MANAGER,
+			DataDeviceManager::INTERFACE.to_string(),
+			DataDeviceManager::VERSION,
+		)
+		.await?;
+
+		self.global(
+			client,
+			sender_id,
+			RegistryGlobals::OUTPUT,
+			Output::INTERFACE.to_string(),
+			Output::VERSION,
+		)
+		.await?;
+
+		self.global(
+			client,
+			sender_id,
+			RegistryGlobals::DMABUF,
+			crate::wayland::dmabuf::Dmabuf::INTERFACE.to_string(),
+			Dmabuf::VERSION,
+		)
+		.await?;
+
+		self.global(
+			client,
+			sender_id,
+			RegistryGlobals::WL_DRM,
+			crate::wayland::mesa_drm::MesaDrm::INTERFACE.to_string(),
+			MesaDrm::VERSION,
+		)
+		.await?;
+
+		self.global(
+			client,
+			sender_id,
+			RegistryGlobals::PRESENTATION,
+			Presentation::INTERFACE.to_string(),
+			Presentation::VERSION,
+		)
+		.await?;
+
+		self.global(
+			client,
+			sender_id,
+			RegistryGlobals::VIEWPORTER,
+			Viewporter::INTERFACE.to_string(),
+			Viewporter::VERSION,
+		)
+		.await?;
+
+		Ok(())
+	}
+}
+
+impl WlRegistry for Registry {
+	type Connection = crate::wayland::Client;
+
+	async fn bind(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		name: u32,
+		new_id: NewId,
+	) -> WaylandResult<()> {
+		match name {
+			RegistryGlobals::COMPOSITOR => {
+				tracing::info!("Binding compositor");
+				client.insert(new_id.object_id, Compositor)?;
+			}
+			RegistryGlobals::SHM => {
+				tracing::info!("Binding SHM");
+				let shm = client.insert(new_id.object_id, Shm)?;
+				shm.advertise_formats(client, new_id.object_id).await?;
+			}
+			RegistryGlobals::WM_BASE => {
+				tracing::info!("Binding WM_BASE");
+				client.insert(
+					new_id.object_id,
+					WmBase::new(new_id.object_id, new_id.version),
+				)?;
+			}
+			RegistryGlobals::SEAT => {
+				tracing::info!("Binding seat with id {}", new_id.object_id);
+				let seat = Seat::new(client, new_id.object_id, new_id.version).await?;
+				let seat = client.insert(new_id.object_id, seat)?;
+				let _ = client.display().seat.set(seat.clone());
+
+				tracing::info!("Seat capabilities advertised");
+			}
+			RegistryGlobals::DATA_DEVICE_MANAGER => {
+				tracing::info!("Binding data device manager");
+				client.insert(new_id.object_id, DataDeviceManager)?;
+			}
+			RegistryGlobals::OUTPUT => {
+				tracing::info!("Binding output");
+				let output = client.insert(
+					new_id.object_id,
+					Output {
+						id: new_id.object_id,
+						version: new_id.version,
+					},
+				)?;
+				let _ = client.display().output.set(output.clone());
+				output.advertise_outputs(client).await?;
+			}
+			RegistryGlobals::DMABUF => {
+				tracing::info!("Binding dmabuf");
+
+				let dmabuf = Dmabuf::new(client, new_id.object_id, new_id.version).await?;
+				client.insert(new_id.object_id, dmabuf)?;
+			}
+			RegistryGlobals::WL_DRM => {
+				tracing::info!("Binding wl_drm");
+
+				let drm = MesaDrm::new(client, new_id.object_id, new_id.version).await?;
+				client.insert(new_id.object_id, drm)?;
+			}
+			RegistryGlobals::PRESENTATION => {
+				tracing::info!("Binding wp_presentation");
+
+				client.insert(new_id.object_id, Presentation::new(new_id.object_id))?;
+			}
+			RegistryGlobals::VIEWPORTER => {
+				tracing::info!("Binding wp_viewporter");
+
+				client.insert(new_id.object_id, Viewporter::new(new_id.object_id))?;
+			}
+			id => {
+				tracing::error!(id, "Wayland: failed to bind to registry global");
+				return Err(WaylandError::UnknownGlobal(name));
+			}
+		}
+
+		Ok(())
+	}
+}

src/wayland/seat.rs

@@ -1,313 +0,0 @@
-use super::{state::WaylandState, surface::CoreSurface, utils::WlSurfaceExt};
-use crate::{
-	core::task,
-	nodes::items::panel::{Backend, Geometry, KEYMAPS, PanelItem},
-};
-use mint::Vector2;
-use parking_lot::Mutex;
-use rustc_hash::FxHashMap;
-use slotmap::KeyData;
-use smithay::{
-	backend::input::{AxisRelativeDirection, ButtonState, KeyState},
-	delegate_seat,
-	input::{
-		Seat, SeatHandler,
-		keyboard::{FilterResult, LedState},
-		pointer::{AxisFrame, ButtonEvent, CursorImageStatus, CursorImageSurfaceData, MotionEvent},
-		touch::{self, DownEvent, UpEvent},
-	},
-	reexports::wayland_server::{Resource, Weak as WlWeak, protocol::wl_surface::WlSurface},
-	utils::SERIAL_COUNTER,
-	wayland::compositor,
-};
-use std::sync::{Arc, Weak};
-use tokio::sync::watch;
-
-impl SeatHandler for WaylandState {
-	type PointerFocus = WlSurface;
-	type KeyboardFocus = WlSurface;
-	type TouchFocus = WlSurface;
-
-	fn seat_state(&mut self) -> &mut smithay::input::SeatState<Self> {
-		&mut self.seat_state
-	}
-	fn focus_changed(&mut self, _seat: &Seat<Self>, _focused: Option<&Self::KeyboardFocus>) {}
-	fn cursor_image(&mut self, _seat: &Seat<Self>, image: CursorImageStatus) {
-		self.seat.cursor_info_tx.send_modify(|c| match image {
-			CursorImageStatus::Hidden => c.surface = None,
-			CursorImageStatus::Surface(surface) => {
-				CoreSurface::add_to(&surface);
-				compositor::with_states(&surface, |data| {
-					if let Some(cursor_attributes) = data.data_map.get::<CursorImageSurfaceData>() {
-						let hotspot = cursor_attributes.lock().unwrap().hotspot;
-						c.hotspot_x = hotspot.x;
-						c.hotspot_y = hotspot.y;
-					}
-					if let Some(core_surface) = data.data_map.get::<Arc<CoreSurface>>() {
-						core_surface.set_material_offset(1);
-					}
-				});
-				c.surface = Some(surface.downgrade())
-			}
-			_ => (),
-		});
-	}
-	fn led_state_changed(&mut self, _seat: &Seat<Self>, _led_state: LedState) {}
-}
-delegate_seat!(WaylandState);
-
-pub fn handle_cursor<B: Backend>(
-	panel_item: &Arc<PanelItem<B>>,
-	mut cursor: watch::Receiver<CursorInfo>,
-) {
-	let panel_item_weak = Arc::downgrade(panel_item);
-	let _ = task::new(|| "cursor handler", async move {
-		while cursor.changed().await.is_ok() {
-			let Some(panel_item) = panel_item_weak.upgrade() else {
-				continue;
-			};
-			let cursor_info = cursor.borrow();
-			panel_item.set_cursor(cursor_info.cursor_data());
-		}
-	});
-}
-pub struct CursorInfo {
-	pub surface: Option<WlWeak<WlSurface>>,
-	pub hotspot_x: i32,
-	pub hotspot_y: i32,
-}
-impl CursorInfo {
-	pub fn cursor_data(&self) -> Option<Geometry> {
-		let cursor_size = self.surface.as_ref()?.upgrade().ok()?.get_size()?;
-		Some(Geometry {
-			origin: [self.hotspot_x, self.hotspot_y].into(),
-			size: cursor_size,
-		})
-	}
-}
-
-pub struct SeatWrapper {
-	wayland_state: Weak<Mutex<WaylandState>>,
-	cursor_info_tx: watch::Sender<CursorInfo>,
-	pub cursor_info_rx: watch::Receiver<CursorInfo>,
-	seat: Seat<WaylandState>,
-	touches: Mutex<FxHashMap<u32, WlWeak<WlSurface>>>,
-}
-impl SeatWrapper {
-	pub fn new(wayland_state: Weak<Mutex<WaylandState>>, seat: Seat<WaylandState>) -> Self {
-		let (cursor_info_tx, cursor_info_rx) = watch::channel(CursorInfo {
-			surface: None,
-			hotspot_x: 0,
-			hotspot_y: 0,
-		});
-		SeatWrapper {
-			wayland_state,
-			cursor_info_tx,
-			cursor_info_rx,
-			seat,
-			touches: Mutex::new(FxHashMap::default()),
-		}
-	}
-	pub fn unfocus_internal_state(&self, surface: &WlSurface) {
-		let Some(state) = self.wayland_state.upgrade() else {
-			return;
-		};
-		self.unfocus(surface, &mut state.lock());
-	}
-	pub fn unfocus(&self, surface: &WlSurface, state: &mut WaylandState) {
-		let pointer = self.seat.get_pointer().unwrap();
-		if pointer.current_focus() == Some(surface.clone()) {
-			pointer.motion(
-				state,
-				None,
-				&MotionEvent {
-					location: (0.0, 0.0).into(),
-					serial: SERIAL_COUNTER.next_serial(),
-					time: 0,
-				},
-			)
-		}
-		let keyboard = self.seat.get_keyboard().unwrap();
-		if keyboard.current_focus() == Some(surface.clone()) {
-			keyboard.set_focus(state, None, SERIAL_COUNTER.next_serial());
-		}
-		for (id, touch_surface) in self.touches.lock().iter() {
-			if touch_surface.id() == surface.id() {
-				self.touch_up(*id);
-			}
-		}
-	}
-
-	pub fn pointer_motion(&self, surface: WlSurface, position: Vector2<f32>) {
-		let Some(state) = self.wayland_state.upgrade() else {
-			return;
-		};
-		let mut state = state.lock();
-		let Some(pointer) = self.seat.get_pointer() else {
-			return;
-		};
-		pointer.motion(
-			&mut state,
-			Some((surface, (0.0, 0.0).into())),
-			&MotionEvent {
-				location: (position.x as f64, position.y as f64).into(),
-				serial: SERIAL_COUNTER.next_serial(),
-				time: 0,
-			},
-		);
-		pointer.frame(&mut state);
-	}
-	pub fn pointer_button(&self, button: u32, pressed: bool) {
-		let Some(state) = self.wayland_state.upgrade() else {
-			return;
-		};
-		let mut state = state.lock();
-		let Some(pointer) = self.seat.get_pointer() else {
-			return;
-		};
-		pointer.button(
-			&mut state,
-			&ButtonEvent {
-				button,
-				state: if pressed {
-					ButtonState::Pressed
-				} else {
-					ButtonState::Released
-				},
-				serial: SERIAL_COUNTER.next_serial(),
-				time: 0,
-			},
-		);
-		pointer.frame(&mut state);
-	}
-	pub fn pointer_scroll(
-		&self,
-		scroll_distance: Option<Vector2<f32>>,
-		scroll_steps: Option<Vector2<f32>>,
-	) {
-		let Some(state) = self.wayland_state.upgrade() else {
-			return;
-		};
-		let mut state = state.lock();
-		let Some(pointer) = self.seat.get_pointer() else {
-			return;
-		};
-		pointer.axis(
-			&mut state,
-			AxisFrame {
-				source: None,
-				relative_direction: (
-					AxisRelativeDirection::Identical,
-					AxisRelativeDirection::Identical,
-				),
-				time: 0,
-				axis: scroll_distance
-					.map(|d| (d.x as f64, d.y as f64))
-					.unwrap_or((0.0, 0.0)),
-				v120: scroll_steps.map(|d| ((d.x * 120.0) as i32, (d.y * 120.0) as i32)),
-				stop: (false, false),
-			},
-		);
-		pointer.frame(&mut state);
-	}
-
-	pub fn keyboard_key(&self, surface: WlSurface, keymap_id: u64, key: u32, pressed: bool) {
-		let Some(state) = self.wayland_state.upgrade() else {
-			return;
-		};
-		let Some(keyboard) = self.seat.get_keyboard() else {
-			return;
-		};
-		let keymaps = KEYMAPS.lock();
-		let Some(keymap) = keymaps.get(KeyData::from_ffi(keymap_id).into()).cloned() else {
-			return;
-		};
-
-		keyboard.set_focus(
-			&mut state.lock(),
-			Some(surface),
-			SERIAL_COUNTER.next_serial(),
-		);
-		if keyboard
-			.set_keymap_from_string(&mut state.lock(), keymap)
-			.is_err()
-		{
-			return;
-		}
-		keyboard.input(
-			&mut state.lock(),
-			key.into(),
-			if pressed {
-				KeyState::Pressed
-			} else {
-				KeyState::Released
-			},
-			SERIAL_COUNTER.next_serial(),
-			0,
-			|_, _, _| FilterResult::Forward::<()>,
-		);
-	}
-
-	pub fn touch_down(&self, surface: WlSurface, id: u32, position: Vector2<f32>) {
-		let Some(state) = self.wayland_state.upgrade() else {
-			return;
-		};
-		let Some(touch) = self.seat.get_touch() else {
-			return;
-		};
-		touch.down(
-			&mut state.lock(),
-			Some((surface, (0.0, 0.0).into())),
-			&DownEvent {
-				slot: Some(id).into(),
-				location: (position.x as f64, position.y as f64).into(),
-				serial: SERIAL_COUNTER.next_serial(),
-				time: 0,
-			},
-		);
-		touch.frame(&mut state.lock());
-	}
-	pub fn touch_move(&self, id: u32, position: Vector2<f32>) {
-		let Some(state) = self.wayland_state.upgrade() else {
-			return;
-		};
-		let Some(surface) = self.touches.lock().get(&id).and_then(|c| c.upgrade().ok()) else {
-			return;
-		};
-		let Some(touch) = self.seat.get_touch() else {
-			return;
-		};
-		touch.motion(
-			&mut state.lock(),
-			Some((surface, (0.0, 0.0).into())),
-			&touch::MotionEvent {
-				slot: Some(id).into(),
-				location: (position.x as f64, position.y as f64).into(),
-				time: 0,
-			},
-		);
-		touch.frame(&mut state.lock());
-	}
-	pub fn touch_up(&self, id: u32) {
-		let Some(state) = self.wayland_state.upgrade() else {
-			return;
-		};
-		let Some(touch) = self.seat.get_touch() else {
-			return;
-		};
-		touch.up(
-			&mut state.lock(),
-			&UpEvent {
-				slot: Some(id).into(),
-				serial: SERIAL_COUNTER.next_serial(),
-				time: 0,
-			},
-		);
-		touch.frame(&mut state.lock());
-	}
-	pub fn reset_input(&self) {
-		for id in self.touches.lock().keys() {
-			self.touch_up(*id)
-		}
-	}
-}

src/wayland/state.rs

@@ -1,230 +0,0 @@
-use super::seat::SeatWrapper;
-use crate::wayland::drm::wl_drm::WlDrm;
-use parking_lot::Mutex;
-use smithay::{
-	backend::{
-		allocator::{Fourcc, dmabuf::Dmabuf},
-		egl::EGLDevice,
-		renderer::gles::GlesRenderer,
-	},
-	delegate_dmabuf, delegate_output, delegate_shm, delegate_viewporter,
-	desktop::PopupManager,
-	input::{SeatState, keyboard::XkbConfig},
-	output::{Mode, Output, Scale, Subpixel},
-	reexports::{
-		wayland_protocols::xdg::{
-			decoration::zv1::server::zxdg_decoration_manager_v1::ZxdgDecorationManagerV1,
-			shell::server::xdg_toplevel::WmCapabilities,
-		},
-		wayland_protocols_misc::server_decoration::server::org_kde_kwin_server_decoration_manager::Mode as DecorationMode,
-		wayland_server::{
-			DisplayHandle,
-			backend::{ClientData, ClientId, DisconnectReason},
-			protocol::{
-				wl_buffer::WlBuffer, wl_data_device_manager::WlDataDeviceManager,
-				wl_output::WlOutput,
-			},
-		},
-	},
-	utils::{Size, Transform},
-	wayland::{
-		buffer::BufferHandler,
-		compositor::{CompositorClientState, CompositorState},
-		dmabuf::{
-			self, DmabufFeedback, DmabufFeedbackBuilder, DmabufGlobal, DmabufHandler, DmabufState,
-		},
-		output::OutputHandler,
-		shell::{
-			kde::decoration::KdeDecorationState,
-			xdg::{WmCapabilitySet, XdgShellState},
-		},
-		shm::{ShmHandler, ShmState},
-		viewporter::ViewporterState,
-	},
-};
-use std::sync::{Arc, OnceLock};
-use tokio::sync::mpsc::UnboundedSender;
-use tracing::{info, warn};
-
-pub struct ClientState {
-	pub pid: Option<i32>,
-	pub id: OnceLock<ClientId>,
-	pub compositor_state: CompositorClientState,
-	pub seat: Arc<SeatWrapper>,
-}
-impl ClientData for ClientState {
-	fn initialized(&self, client_id: ClientId) {
-		info!("Wayland client {:?} connected", client_id);
-		let _ = self.id.set(client_id);
-	}
-
-	fn disconnected(&self, client_id: ClientId, reason: DisconnectReason) {
-		info!(
-			"Wayland client {:?} disconnected because {:#?}",
-			client_id, reason
-		);
-	}
-}
-
-pub struct WaylandState {
-	pub compositor_state: CompositorState,
-	// pub xdg_activation_state: XdgActivationState,
-	pub kde_decoration_state: KdeDecorationState,
-	pub shm_state: ShmState,
-	dmabuf_state: (DmabufState, DmabufGlobal, Option<DmabufFeedback>),
-	pub _viewporter_state: ViewporterState,
-	pub drm_formats: Vec<Fourcc>,
-	pub dmabuf_tx: UnboundedSender<(Dmabuf, Option<dmabuf::ImportNotifier>)>,
-	pub seat_state: SeatState<Self>,
-	pub seat: Arc<SeatWrapper>,
-	pub xdg_shell: XdgShellState,
-	pub popup_manager: PopupManager,
-	pub output: Output,
-}
-
-impl WaylandState {
-	pub fn new(
-		display_handle: DisplayHandle,
-		renderer: &GlesRenderer,
-		dmabuf_tx: UnboundedSender<(Dmabuf, Option<dmabuf::ImportNotifier>)>,
-	) -> Arc<Mutex<Self>> {
-		let compositor_state = CompositorState::new::<Self>(&display_handle);
-		// let xdg_activation_state = XdgActivationState::new::<Self, _>(&display_handle);
-		let kde_decoration_state =
-			KdeDecorationState::new::<Self>(&display_handle, DecorationMode::Server);
-		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()
-				.ok(),
-			Ok(None) => {
-				warn!("failed to query render node, dmabuf will use v3");
-				None
-			}
-			Err(err) => {
-				warn!(?err, "failed to egl device for display, dmabuf will use v3");
-				None
-			}
-		};
-		// if we failed to build dmabuf feedback we fall back to dmabuf v3
-		// Note: egl on Mesa requires either v4 or wl_drm (initialized with bind_wl_display)
-		let dmabuf_state = if let Some(default_feedback) = dmabuf_default_feedback {
-			let mut dmabuf_state = DmabufState::new();
-			let dmabuf_global = dmabuf_state.create_global_with_default_feedback::<WaylandState>(
-				&display_handle,
-				&default_feedback,
-			);
-			(dmabuf_state, dmabuf_global, Some(default_feedback))
-		} else {
-			let mut dmabuf_state = DmabufState::new();
-			let dmabuf_global =
-				dmabuf_state.create_global::<WaylandState>(&display_handle, dmabuf_formats.clone());
-			(dmabuf_state, dmabuf_global, None)
-		};
-
-		let mut seat_state = SeatState::new();
-		let mut seat = seat_state.new_wl_seat(&display_handle, "seat0");
-		seat.add_pointer();
-		seat.add_keyboard(XkbConfig::default(), 200, 25).unwrap();
-		seat.add_touch();
-
-		let output = Output::new(
-			"1x".to_owned(),
-			smithay::output::PhysicalProperties {
-				size: Size::default(),
-				subpixel: Subpixel::None,
-				make: "Virtual XR Display".to_owned(),
-				model: "Your Headset Name Here".to_owned(),
-			},
-		);
-		let _output_global = output.create_global::<Self>(&display_handle);
-		let mode = Mode {
-			size: (1024, 1024).into(),
-			refresh: 60000,
-		};
-		output.change_current_state(
-			Some(mode),
-			Some(Transform::Normal),
-			Some(Scale::Integer(2)),
-			None,
-		);
-		output.set_preferred(mode);
-
-		let mut xdg_shell = XdgShellState::new::<Self>(&display_handle);
-		let _viewporter_state = ViewporterState::new::<Self>(&display_handle);
-		let popup_manager = PopupManager::default();
-		let mut capabilities = WmCapabilitySet::default();
-		capabilities.set(WmCapabilities::Maximize);
-		capabilities.set(WmCapabilities::Fullscreen);
-		capabilities.unset(WmCapabilities::Minimize);
-		capabilities.unset(WmCapabilities::WindowMenu);
-		xdg_shell.replace_capabilities(capabilities);
-		display_handle.create_global::<Self, WlDataDeviceManager, _>(3, ());
-		display_handle.create_global::<Self, ZxdgDecorationManagerV1, _>(1, ());
-		display_handle.create_global::<Self, WlDrm, _>(2, ());
-
-		info!("Init Wayland compositor");
-
-		Arc::new_cyclic(|weak| {
-			Mutex::new(WaylandState {
-				compositor_state,
-				// xdg_activation_state,
-				kde_decoration_state,
-				shm_state,
-				drm_formats,
-				dmabuf_state,
-				dmabuf_tx,
-				seat_state,
-				seat: Arc::new(SeatWrapper::new(weak.clone(), seat)),
-				xdg_shell,
-				popup_manager,
-				output,
-				_viewporter_state,
-			})
-		})
-	}
-}
-impl Drop for WaylandState {
-	fn drop(&mut self) {
-		info!("Cleanly shut down the Wayland compositor");
-	}
-}
-impl BufferHandler for WaylandState {
-	fn buffer_destroyed(&mut self, _buffer: &WlBuffer) {}
-}
-impl ShmHandler for WaylandState {
-	fn shm_state(&self) -> &ShmState {
-		&self.shm_state
-	}
-}
-impl DmabufHandler for WaylandState {
-	fn dmabuf_state(&mut self) -> &mut DmabufState {
-		&mut self.dmabuf_state.0
-	}
-
-	fn dmabuf_imported(
-		&mut self,
-		_global: &DmabufGlobal,
-		dmabuf: Dmabuf,
-		notifier: dmabuf::ImportNotifier,
-	) {
-		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);
-delegate_viewporter!(WaylandState);

src/wayland/surface.rs

@@ -1,198 +0,0 @@
-use super::utils::WlSurfaceExt;
-use crate::{
-	core::{delta::Delta, destroy_queue, registry::Registry},
-	nodes::{
-		drawable::{
-			model::{MaterialWrapper, ModelPart},
-			shaders::PANEL_SHADER_BYTES,
-		},
-		items::camera::TexWrapper,
-	},
-};
-use parking_lot::Mutex;
-use send_wrapper::SendWrapper;
-use smithay::{
-	backend::renderer::{
-		Renderer, Texture,
-		gles::{GlesRenderer, GlesTexture},
-		utils::{RendererSurfaceStateUserData, import_surface_tree},
-	},
-	desktop::utils::send_frames_surface_tree,
-	output::Output,
-	reexports::wayland_server::{self, Resource, protocol::wl_surface::WlSurface},
-};
-use std::{
-	ffi::c_void,
-	sync::{Arc, OnceLock},
-	time::Duration,
-};
-use stereokit_rust::{
-	material::{Material, Transparency},
-	shader::Shader,
-	tex::{Tex, TexAddress, TexFormat, TexSample, TexType},
-	util::Time,
-};
-
-pub static CORE_SURFACES: Registry<CoreSurface> = Registry::new();
-
-pub struct CoreSurfaceData {
-	wl_tex: Option<SendWrapper<GlesTexture>>,
-}
-impl Drop for CoreSurfaceData {
-	fn drop(&mut self) {
-		destroy_queue::add(self.wl_tex.take());
-	}
-}
-
-pub struct CoreSurface {
-	pub weak_surface: wayland_server::Weak<WlSurface>,
-	mapped_data: Mutex<Option<CoreSurfaceData>>,
-	sk_tex: OnceLock<Mutex<TexWrapper>>,
-	sk_mat: OnceLock<Mutex<MaterialWrapper>>,
-	material_offset: Mutex<Delta<u32>>,
-	pub pending_material_applications: Registry<ModelPart>,
-}
-
-impl CoreSurface {
-	pub fn add_to(surface: &WlSurface) {
-		let core_surface = CORE_SURFACES.add(CoreSurface {
-			weak_surface: surface.downgrade(),
-			mapped_data: Mutex::new(None),
-			sk_tex: OnceLock::new(),
-			sk_mat: OnceLock::new(),
-			material_offset: Mutex::new(Delta::new(0)),
-			pending_material_applications: Registry::new(),
-		});
-		surface.insert_data(core_surface);
-	}
-
-	pub fn from_wl_surface(surf: &WlSurface) -> Option<Arc<CoreSurface>> {
-		surf.get_data()
-	}
-
-	pub fn process(&self, renderer: &mut GlesRenderer) {
-		let Some(wl_surface) = self.wl_surface() else {
-			return;
-		};
-
-		let sk_tex = self.sk_tex.get_or_init(|| {
-			Mutex::new(TexWrapper(Tex::new(
-				TexType::ImageNomips,
-				TexFormat::RGBA32Linear,
-				nanoid::nanoid!(),
-			)))
-		});
-		self.sk_mat.get_or_init(|| {
-			let shader = Shader::from_memory(PANEL_SHADER_BYTES).unwrap();
-			// let _ = renderer.with_context(|c| unsafe {
-			// 	shader_inject(c, &mut shader, SIMULA_VERT_STR, SIMULA_FRAG_STR)
-			// });
-
-			let mut mat = Material::new(shader, None);
-			mat.diffuse_tex(&sk_tex.lock().0);
-			mat.transparency(Transparency::Blend);
-			Mutex::new(MaterialWrapper(mat))
-		});
-
-		// Import all surface buffers into textures
-		if let Err(err) = import_surface_tree(renderer, &wl_surface) {
-			tracing::error!("Failed to import surface tree for surface {}: {}", wl_surface.id(), err);
-			return;
-		}
-
-		self.update_textures(renderer);
-		self.apply_surface_materials();
-	}
-
-	pub fn update_textures(&self, renderer: &mut GlesRenderer) {
-		let Some(wl_surface) = self.wl_surface() else {
-			return;
-		};
-
-		let Some(smithay_tex) = wl_surface
-			.get_data_raw::<RendererSurfaceStateUserData, _, _>(|surface_states| {
-				let locked = surface_states.lock().unwrap();
-				locked.texture::<GlesRenderer>(renderer.id()).cloned()
-			})
-			.flatten()
-		else {
-			return;
-		};
-
-		let Some(sk_tex) = self.sk_tex.get() else {
-			tracing::error!("No sk_tex found for surface");
-			return;
-		};
-		let Some(sk_mat) = self.sk_mat.get() else {
-			tracing::error!("No sk_mat found for surface");
-			return;
-		};
-		sk_tex
-			.lock()
-			.0
-			.set_native_surface(
-				smithay_tex.tex_id() as usize as *mut c_void,
-				TexType::ImageNomips,
-				smithay::backend::renderer::gles::ffi::RGBA8.into(),
-				smithay_tex.width() as i32,
-				smithay_tex.height() as i32,
-				1,
-				false,
-			)
-			.sample_mode(TexSample::Point)
-			.address_mode(TexAddress::Clamp);
-
-		if let Some(material_offset) = self.material_offset.lock().delta() {
-			sk_mat.lock().0.queue_offset(*material_offset as i32);
-		}
-
-		let new_mapped_data = CoreSurfaceData {
-			wl_tex: Some(SendWrapper::new(smithay_tex)),
-		};
-		*self.mapped_data.lock() = Some(new_mapped_data);
-	}
-
-	pub fn frame(&self, output: Output) {
-		let Some(wl_surface) = self.wl_surface() else {
-			return;
-		};
-
-		send_frames_surface_tree(
-			&wl_surface,
-			&output,
-			Duration::from_secs_f64(Time::get_total_unscaled()),
-			None,
-			|_, _| Some(output.clone()),
-		);
-	}
-
-	pub fn set_material_offset(&self, material_offset: u32) {
-		*self.material_offset.lock().value_mut() = material_offset;
-	}
-
-	pub fn apply_material(&self, model_part: &Arc<ModelPart>) {
-		self.pending_material_applications.add_raw(model_part)
-	}
-
-	fn apply_surface_materials(&self) {
-		if let Some(sk_mat) = self.sk_mat.get() {
-			let sk_mat = sk_mat.lock();
-			for model_node in self.pending_material_applications.get_valid_contents() {
-				model_node.replace_material_now(&sk_mat.0);
-			}
-			self.pending_material_applications.clear();
-		}
-	}
-
-	pub fn wl_surface(&self) -> Option<WlSurface> {
-		self.weak_surface.upgrade().ok()
-	}
-}
-impl Drop for CoreSurface {
-	fn drop(&mut self) {
-		CORE_SURFACES.remove(self);
-
-		destroy_queue::add(self.sk_tex.take());
-		destroy_queue::add(self.sk_mat.take());
-	}
-}

src/wayland/util.rs

@@ -0,0 +1,50 @@
+#![allow(unused)]
+
+use super::{Message, MessageSink, display::Display};
+use crate::wayland::{Client, WaylandError, WaylandResult};
+use std::{fmt::Debug, sync::Arc};
+use waynest::ObjectId;
+use waynest_protocols::server::core::wayland::wl_display::WlDisplay;
+use waynest_server::{Client as _, RequestDispatcher};
+
+pub trait ClientExt {
+	fn message_sink(&self) -> MessageSink;
+	fn display(&self) -> Arc<Display>;
+	fn try_get<D: RequestDispatcher>(&self, id: ObjectId) -> WaylandResult<Arc<D>>;
+}
+impl ClientExt for Client {
+	fn message_sink(&self) -> MessageSink {
+		self.get::<Display>(ObjectId::DISPLAY)
+			.unwrap()
+			.message_sink
+			.clone()
+	}
+
+	fn display(&self) -> Arc<Display> {
+		self.get::<Display>(ObjectId::DISPLAY).unwrap()
+	}
+
+	fn try_get<D: RequestDispatcher>(&self, id: ObjectId) -> WaylandResult<Arc<D>> {
+		self.get::<D>(id).ok_or(WaylandError::MissingObject(id))
+	}
+}
+
+#[derive(Debug, Default)]
+pub struct DoubleBuffer<State: Debug + Clone> {
+	pub current: State,
+	pub pending: State,
+}
+impl<State: Debug + Clone> DoubleBuffer<State> {
+	pub fn new(initial_state: State) -> Self {
+		DoubleBuffer {
+			current: initial_state.clone(),
+			pending: initial_state,
+		}
+	}
+	pub fn apply(&mut self) {
+		self.current = self.pending.clone();
+	}
+	pub fn current(&self) -> &State {
+		&self.current
+	}
+}

src/wayland/utils.rs

@@ -1,121 +0,0 @@
-use mint::Vector2;
-use parking_lot::Mutex;
-use smithay::{
-	backend::renderer::utils::RendererSurfaceStateUserData,
-	reexports::wayland_server::protocol::wl_surface::WlSurface,
-	wayland::{
-		compositor,
-		shell::xdg::{SurfaceCachedState, XdgToplevelSurfaceData},
-	},
-};
-
-use crate::nodes::items::panel::{ChildInfo, Geometry, ToplevelInfo};
-
-use super::xdg_shell::surface_panel_item;
-pub trait WlSurfaceExt {
-	fn insert_data<T: Send + Sync + 'static>(&self, data: T) -> bool;
-	fn get_data<T: Send + Sync + Clone + 'static>(&self) -> Option<T>;
-	fn get_data_raw<T: Send + Sync + 'static, O, F: FnOnce(&T) -> O>(&self, f: F) -> Option<O>;
-	fn get_current_surface_state(&self) -> SurfaceCachedState;
-	fn get_pending_surface_state(&self) -> SurfaceCachedState;
-	fn get_size(&self) -> Option<Vector2<u32>>;
-	fn get_geometry(&self) -> Option<Geometry>;
-}
-impl WlSurfaceExt for WlSurface {
-	fn insert_data<T: Send + Sync + 'static>(&self, data: T) -> bool {
-		compositor::with_states(self, |d| {
-			d.data_map.insert_if_missing_threadsafe(move || data)
-		})
-	}
-	fn get_data<T: Send + Sync + Clone + 'static>(&self) -> Option<T> {
-		compositor::with_states(self, |d| d.data_map.get::<T>().cloned())
-	}
-	fn get_data_raw<T: Send + Sync + 'static, O, F: FnOnce(&T) -> O>(&self, f: F) -> Option<O> {
-		compositor::with_states(self, |d| Some((f)(d.data_map.get::<T>()?)))
-	}
-	fn get_current_surface_state(&self) -> SurfaceCachedState {
-		compositor::with_states(self, |states| {
-			*states.cached_state.get::<SurfaceCachedState>().current()
-		})
-	}
-	fn get_pending_surface_state(&self) -> SurfaceCachedState {
-		compositor::with_states(self, |states| {
-			*states.cached_state.get::<SurfaceCachedState>().pending()
-		})
-	}
-	fn get_size(&self) -> Option<Vector2<u32>> {
-		self.get_data_raw::<RendererSurfaceStateUserData, _, _>(|surface_states| {
-			surface_states.lock().unwrap().surface_size()
-		})
-		.flatten()
-		.map(|size| Vector2::from([size.w as u32, size.h as u32]))
-	}
-	fn get_geometry(&self) -> Option<Geometry> {
-		self.get_current_surface_state().geometry.map(|r| r.into())
-	}
-}
-
-pub trait ToplevelInfoExt {
-	fn get_toplevel_info(&self) -> Option<ToplevelInfo>;
-	fn with_toplevel_info<O, F: FnOnce(&mut ToplevelInfo) -> O>(&self, f: F) -> Option<O>;
-
-	fn get_parent(&self) -> Option<u64>;
-	fn get_app_id(&self) -> Option<String>;
-	fn get_title(&self) -> Option<String>;
-	fn min_size(&self) -> Option<Vector2<u32>>;
-	fn max_size(&self) -> Option<Vector2<u32>>;
-}
-impl ToplevelInfoExt for WlSurface {
-	fn get_toplevel_info(&self) -> Option<ToplevelInfo> {
-		self.get_data_raw::<Mutex<ToplevelInfo>, _, _>(|c| c.lock().clone())
-	}
-	fn with_toplevel_info<O, F: FnOnce(&mut ToplevelInfo) -> O>(&self, f: F) -> Option<O> {
-		self.get_data_raw::<Mutex<ToplevelInfo>, _, _>(|r| (f)(&mut r.lock()))
-	}
-
-	fn get_parent(&self) -> Option<u64> {
-		self.get_data_raw::<XdgToplevelSurfaceData, _, _>(|d| d.lock().unwrap().parent.clone())
-			.flatten()
-			.and_then(|p| surface_panel_item(&p))
-			.and_then(|p| p.node.upgrade())
-			.map(|p| p.get_id())
-	}
-	fn get_app_id(&self) -> Option<String> {
-		self.get_data_raw::<XdgToplevelSurfaceData, _, _>(|d| d.lock().ok()?.app_id.clone())
-			.flatten()
-	}
-	fn get_title(&self) -> Option<String> {
-		self.get_data_raw::<XdgToplevelSurfaceData, _, _>(|d| d.lock().ok()?.title.clone())
-			.flatten()
-	}
-	fn min_size(&self) -> Option<Vector2<u32>> {
-		let state = self.get_pending_surface_state();
-		let size = state.min_size;
-		if size.w == 0 && size.h == 0 {
-			None
-		} else {
-			Some(Vector2::from([size.w as u32, size.h as u32]))
-		}
-	}
-	fn max_size(&self) -> Option<Vector2<u32>> {
-		let state = self.get_pending_surface_state();
-		let size = state.max_size;
-		if size.w == 0 && size.h == 0 {
-			None
-		} else {
-			Some(Vector2::from([size.w as u32, size.h as u32]))
-		}
-	}
-}
-pub trait ChildInfoExt {
-	fn get_child_info(&self) -> Option<ChildInfo>;
-	fn with_child_info<O, F: FnOnce(&mut ChildInfo) -> O>(&self, f: F) -> Option<O>;
-}
-impl ChildInfoExt for WlSurface {
-	fn get_child_info(&self) -> Option<ChildInfo> {
-		self.get_data_raw::<Mutex<ChildInfo>, _, _>(|c| c.lock().clone())
-	}
-	fn with_child_info<O, F: FnOnce(&mut ChildInfo) -> O>(&self, f: F) -> Option<O> {
-		self.get_data_raw::<Mutex<ChildInfo>, _, _>(|r| (f)(&mut r.lock()))
-	}
-}

src/wayland/viewporter.rs

@@ -0,0 +1,96 @@
+use crate::wayland::WaylandResult;
+use waynest::Fixed;
+use waynest::ObjectId;
+pub use waynest_protocols::server::stable::viewporter::wp_viewport::*;
+pub use waynest_protocols::server::stable::viewporter::wp_viewporter::*;
+use waynest_server::Client as _;
+
+// This is a barebones/stub no-op implementation of wp_viewporter to make xwayland apps work
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Viewporter {
+	id: ObjectId,
+}
+
+impl Viewporter {
+	pub fn new(id: ObjectId) -> Self {
+		Self { id }
+	}
+}
+
+impl WpViewporter for Viewporter {
+	type Connection = crate::wayland::Client;
+
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+
+	async fn get_viewport(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		id: ObjectId,
+		surface_id: ObjectId,
+	) -> WaylandResult<()> {
+		let viewport = Viewport::new(id, surface_id);
+		client.insert(id, viewport)?;
+		Ok(())
+	}
+}
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Viewport {
+	id: ObjectId,
+	_surface_id: ObjectId,
+}
+
+impl Viewport {
+	pub fn new(id: ObjectId, surface_id: ObjectId) -> Self {
+		Self {
+			id,
+			_surface_id: surface_id,
+		}
+	}
+}
+
+impl WpViewport for Viewport {
+	type Connection = crate::wayland::Client;
+
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+
+	async fn set_source(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_x: Fixed,
+		_y: Fixed,
+		_width: Fixed,
+		_height: Fixed,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn set_destination(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_width: i32,
+		_height: i32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}

src/wayland/vulkano_data.rs

@@ -0,0 +1,145 @@
+use std::sync::{Arc, OnceLock};
+
+use bevy::{
+	ecs::system::Res,
+	render::renderer::{RenderAdapter, RenderDevice, RenderInstance},
+};
+use vulkano::{
+	VulkanLibrary,
+	command_buffer::allocator::{
+		CommandBufferAllocator, StandardCommandBufferAllocator,
+		StandardCommandBufferAllocatorCreateInfo,
+	},
+	device::{DeviceCreateInfo, QueueCreateInfo},
+	instance::InstanceCreateFlags,
+	memory::allocator::{MemoryAllocator, StandardMemoryAllocator},
+};
+use wgpu_hal::vulkan::Api as VulkanHal;
+
+pub static VULKANO_CONTEXT: OnceLock<VulkanoContext> = OnceLock::new();
+
+#[expect(dead_code)]
+pub struct VulkanoContext {
+	pub instance: Arc<vulkano::instance::Instance>,
+	pub phys_dev: Arc<vulkano::device::physical::PhysicalDevice>,
+	pub dev: Arc<vulkano::device::Device>,
+	pub queue: Arc<vulkano::device::Queue>,
+	pub alloc: Arc<dyn MemoryAllocator>,
+	pub command_buffer_alloc: Arc<dyn CommandBufferAllocator>,
+}
+
+pub fn setup_vulkano_context(
+	dev: Res<RenderDevice>,
+	instance: Res<RenderInstance>,
+	adapter: Res<RenderAdapter>,
+) {
+	if VULKANO_CONTEXT.get().is_some() {
+		return;
+	}
+	let hal_instance = unsafe { instance.as_hal::<VulkanHal>() }
+		.unwrap()
+		.shared_instance();
+
+	let ash_instance = hal_instance.raw_instance();
+	let vulkan_lib =
+		VulkanLibrary::with_loader(AshEntryVulkanoLoader(hal_instance.entry().clone())).unwrap();
+
+	let vulkano_instance = unsafe {
+		vulkano::instance::Instance::from_handle(
+			vulkan_lib,
+			ash_instance.handle(),
+			vulkano::instance::InstanceCreateInfo {
+				flags: InstanceCreateFlags::empty(),
+				// TODO: make vulkan init reasonable and remove this hardcoded value from
+				// bevy_mod_openxr
+				max_api_version: Some(vulkano::Version::V1_2),
+				enabled_extensions: vulkano::instance::InstanceExtensions::from_iter(
+					hal_instance
+						.extensions()
+						.iter()
+						.map(|s| s.to_str().unwrap()),
+				),
+				..Default::default()
+			},
+		)
+	};
+
+	let ash_phys_dev_handle = unsafe {
+		adapter.as_hal::<VulkanHal, _, _>(|adapter| adapter.unwrap().raw_physical_device())
+	};
+
+	let vulkano_phys_dev = unsafe {
+		vulkano::device::physical::PhysicalDevice::from_handle(
+			vulkano_instance.clone(),
+			ash_phys_dev_handle,
+		)
+	}
+	.unwrap();
+	let (ash_dev_handle, dev_create_info) = unsafe {
+		dev.wgpu_device().as_hal::<VulkanHal, _, _>(|dev| {
+			let dev = dev.unwrap();
+			(
+				dev.raw_device().handle(),
+				DeviceCreateInfo {
+					queue_create_infos: vec![QueueCreateInfo {
+						queue_family_index: dev.queue_family_index(),
+						..Default::default()
+					}],
+					enabled_extensions: vulkano::device::DeviceExtensions::from_iter(
+						dev.enabled_device_extensions()
+							.iter()
+							// TODO: remove this hack by telling wgpu about the actual exts used in
+							// bevy_mod_openxr
+							.chain(bevy_dmabuf::required_device_extensions().iter())
+							.map(|v| v.to_str().unwrap()),
+					),
+					// this is def wrong, lets hope it doesn't cause issues....
+					enabled_features: vulkano::device::DeviceFeatures::empty(),
+
+					..Default::default()
+				},
+			)
+		})
+	};
+	let (vulkano_dev, mut queues) = unsafe {
+		vulkano::device::Device::from_handle(
+			vulkano_phys_dev.clone(),
+			ash_dev_handle,
+			dev_create_info,
+		)
+	};
+
+	let alloc = Arc::new(StandardMemoryAllocator::new_default(vulkano_dev.clone()));
+
+	let command_buffer_alloc = Arc::new(StandardCommandBufferAllocator::new(
+		vulkano_dev.clone(),
+		StandardCommandBufferAllocatorCreateInfo::default(),
+	));
+	_ = VULKANO_CONTEXT.set(VulkanoContext {
+		instance: vulkano_instance,
+		phys_dev: vulkano_phys_dev,
+		dev: vulkano_dev,
+		queue: queues.next().unwrap(),
+		alloc,
+		command_buffer_alloc,
+	});
+}
+
+// ensures that we don't destroy the vulkan handles wgpu/bevy use
+// TODO: remove once we don't use bevys wgpu instance/device/physical_device
+impl Drop for VulkanoContext {
+	fn drop(&mut self) {
+		panic!("the vulkano context shall never be dropped");
+	}
+}
+
+struct AshEntryVulkanoLoader(ash::Entry);
+unsafe impl vulkano::library::Loader for AshEntryVulkanoLoader {
+	unsafe fn get_instance_proc_addr(
+		&self,
+		instance: ash::vk::Instance,
+		name: *const std::os::raw::c_char,
+	) -> ash::vk::PFN_vkVoidFunction {
+		unsafe { self.0.get_instance_proc_addr(instance, name) }
+	}
+}

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/backend.rs

@@ -0,0 +1,311 @@
+use super::toplevel::Toplevel;
+use crate::{
+	core::{error::Result, task},
+	nodes::{
+		drawable::model::ModelPart,
+		items::panel::{
+			Backend, ChildInfo, Geometry, PanelItem, PanelItemInitData, SurfaceId, ToplevelInfo,
+		},
+	},
+	wayland::{
+		Message,
+		core::{
+			seat::{Seat, SeatMessage},
+			surface::Surface,
+		},
+	},
+};
+use dashmap::DashMap;
+use mint::Vector2;
+use std::sync::Arc;
+use std::sync::Weak;
+use tracing;
+
+#[derive(Debug)]
+pub struct XdgBackend {
+	seat: Weak<Seat>,
+	toplevel: Weak<Toplevel>,
+	children: DashMap<u64, (Weak<Surface>, ChildInfo)>,
+}
+
+impl XdgBackend {
+	pub fn new(seat: &Arc<Seat>, toplevel: &Arc<Toplevel>) -> Self {
+		Self {
+			seat: Arc::downgrade(seat),
+			toplevel: Arc::downgrade(toplevel),
+			children: DashMap::new(),
+		}
+	}
+
+	// Since XdgBackend is created and owned by Mapped which is owned by Toplevel,
+	// we can safely assume the Toplevel reference will always be valid
+	fn toplevel(&self) -> Arc<Toplevel> {
+		self.toplevel
+			.upgrade()
+			.expect("Toplevel should always be valid while XdgBackend exists")
+	}
+
+	pub fn panel_item(&self) -> Option<Arc<PanelItem<XdgBackend>>> {
+		self.toplevel().wl_surface().panel_item.lock().upgrade()
+	}
+
+	fn surface_from_id(&self, id: &SurfaceId) -> Option<Arc<Surface>> {
+		match id {
+			SurfaceId::Toplevel(_) => Some(self.toplevel().wl_surface().clone()),
+			SurfaceId::Child(id) => self.children.get(id).as_deref().and_then(|c| c.0.upgrade()),
+		}
+	}
+
+	pub fn add_child(&self, surface: &Arc<Surface>, info: ChildInfo) {
+		let Some(SurfaceId::Child(id)) = surface.surface_id.get().cloned() else {
+			return;
+		};
+		self.children
+			.insert(id, (Arc::downgrade(surface), info.clone()));
+
+		let Some(panel_item) = self.panel_item() else {
+			tracing::error!("Couldn't find panel item in add_child");
+			return;
+		};
+		panel_item.create_child(id, &info);
+	}
+
+	pub fn reposition_child(&self, surface: &Arc<Surface>, geometry: Geometry) {
+		let Some(SurfaceId::Child(id)) = surface.surface_id.get() else {
+			return;
+		};
+
+		if let Some(mut child) = self.children.get_mut(id) {
+			child.1.geometry = geometry;
+		}
+		let Some(panel_item) = self.panel_item() else {
+			tracing::error!("Couldn't find panel item in reposition_child");
+			return;
+		};
+		panel_item.reposition_child(*id, &geometry);
+	}
+
+	pub fn remove_child(&self, surface: &Surface) {
+		let Some(SurfaceId::Child(id)) = surface.surface_id.get() else {
+			return;
+		};
+		self.children.remove(id);
+
+		let Some(panel_item) = self.panel_item() else {
+			tracing::error!("Couldn't find panel item in remove_child");
+			return;
+		};
+		panel_item.destroy_child(*id);
+	}
+}
+impl Backend for XdgBackend {
+	fn start_data(&self) -> Result<PanelItemInitData> {
+		let surface_state = self.toplevel().wl_surface().current_state();
+
+		let size = surface_state
+			.buffer
+			.map(|b| [b.buffer.size().x as u32, b.buffer.size().y as u32].into())
+			.unwrap_or([0; 2].into());
+		let toplevel = ToplevelInfo {
+			parent: self.toplevel().parent(),
+			title: self.toplevel().title(),
+			app_id: self.toplevel().app_id(),
+			size,
+			min_size: surface_state
+				.min_size
+				.map(|v| [v.x as f32, v.y as f32].into()),
+			max_size: surface_state
+				.max_size
+				.map(|v| [v.x as f32, v.y as f32].into()),
+			logical_rectangle: surface_state.geometry.unwrap_or(Geometry {
+				origin: [0; 2].into(),
+				size,
+			}),
+		};
+
+		Ok(PanelItemInitData {
+			cursor: None,
+			toplevel,
+			children: vec![],
+			pointer_grab: None,
+			keyboard_grab: None,
+		})
+	}
+
+	fn apply_cursor_material(&self, model_part: &Arc<ModelPart>) {
+		let model_part = model_part.clone();
+		let Some(seat) = self.seat.upgrade() else {
+			return;
+		};
+		let _ = task::new(|| "Apply cursor material", async move {
+			let Some(cursor) = seat.cursor_surface().await else {
+				return;
+			};
+			cursor.apply_material(&model_part);
+		});
+	}
+	fn apply_surface_material(&self, surface: SurfaceId, model_part: &Arc<ModelPart>) {
+		if let Some(surface) = self.surface_from_id(&surface) {
+			surface.apply_material(model_part);
+		}
+	}
+
+	fn close_toplevel(&self) {
+		let _ = self
+			.toplevel()
+			.wl_surface()
+			.message_sink
+			.send(Message::CloseToplevel(self.toplevel().clone()));
+	}
+
+	fn auto_size_toplevel(&self) {
+		let _ = self
+			.toplevel()
+			.wl_surface()
+			.message_sink
+			.send(Message::ResizeToplevel {
+				toplevel: self.toplevel().clone(),
+				size: None,
+			});
+	}
+
+	fn set_toplevel_size(&self, size: Vector2<u32>) {
+		let _ = self
+			.toplevel()
+			.wl_surface()
+			.message_sink
+			.send(Message::ResizeToplevel {
+				toplevel: self.toplevel().clone(),
+				size: Some(size),
+			});
+	}
+
+	fn set_toplevel_focused_visuals(&self, focused: bool) {
+		let _ = self
+			.toplevel()
+			.wl_surface()
+			.message_sink
+			.send(Message::SetToplevelVisualActive {
+				toplevel: self.toplevel().clone(),
+				active: focused,
+			});
+	}
+
+	fn pointer_motion(&self, surface: &SurfaceId, position: Vector2<f32>) {
+		if let Some(surface) = self.surface_from_id(surface) {
+			let _ = self
+				.toplevel()
+				.wl_surface()
+				.message_sink
+				.send(Message::Seat(SeatMessage::PointerMotion {
+					surface,
+					position,
+				}));
+		}
+	}
+
+	fn pointer_button(&self, surface: &SurfaceId, button: u32, pressed: bool) {
+		if let Some(surface) = self.surface_from_id(surface) {
+			let _ = self
+				.toplevel()
+				.wl_surface()
+				.message_sink
+				.send(Message::Seat(SeatMessage::PointerButton {
+					surface,
+					button,
+					pressed,
+				}));
+		}
+	}
+
+	fn pointer_scroll(
+		&self,
+		surface: &SurfaceId,
+		scroll_distance: Option<Vector2<f32>>,
+		scroll_steps: Option<Vector2<f32>>,
+	) {
+		if let Some(surface) = self.surface_from_id(surface) {
+			let _ = self
+				.toplevel()
+				.wl_surface()
+				.message_sink
+				.send(Message::Seat(SeatMessage::PointerScroll {
+					surface,
+					scroll_distance,
+					scroll_steps,
+				}));
+		}
+	}
+
+	fn keyboard_key(&self, surface: &SurfaceId, keymap_id: u64, key: u32, pressed: bool) {
+		tracing::debug!(
+			"Backend: Keyboard key {} {}",
+			key,
+			if pressed { "pressed" } else { "released" }
+		);
+		if let Some(surface) = self.surface_from_id(surface) {
+			let _ = self
+				.toplevel()
+				.wl_surface()
+				.message_sink
+				.send(Message::Seat(SeatMessage::KeyboardKey {
+					surface,
+					keymap_id,
+					key,
+					pressed,
+				}));
+		}
+	}
+
+	fn touch_down(&self, surface: &SurfaceId, id: u32, position: Vector2<f32>) {
+		tracing::debug!(
+			"Backend: Touch down {} at ({}, {})",
+			id,
+			position.x,
+			position.y
+		);
+		if let Some(surface) = self.surface_from_id(surface) {
+			let _ = self
+				.toplevel()
+				.wl_surface()
+				.message_sink
+				.send(Message::Seat(SeatMessage::TouchDown {
+					surface,
+					id,
+					position,
+				}));
+		}
+	}
+
+	fn touch_move(&self, id: u32, position: Vector2<f32>) {
+		tracing::debug!(
+			"Backend: Touch move {} to ({}, {})",
+			id,
+			position.x,
+			position.y
+		);
+		let toplevel = self.toplevel();
+		let _ = toplevel
+			.wl_surface()
+			.message_sink
+			.send(Message::Seat(SeatMessage::TouchMove { id, position }));
+	}
+
+	fn touch_up(&self, id: u32) {
+		tracing::debug!("Backend: Touch up {}", id);
+		let toplevel = self.toplevel();
+		let _ = toplevel
+			.wl_surface()
+			.message_sink
+			.send(Message::Seat(SeatMessage::TouchUp { id }));
+	}
+
+	fn reset_input(&self) {
+		tracing::debug!("Backend: Reset input");
+		let toplevel = self.toplevel();
+		let _ = toplevel
+			.wl_surface()
+			.message_sink
+			.send(Message::Seat(SeatMessage::Reset));
+	}
+}

src/wayland/xdg/mod.rs

@@ -0,0 +1,6 @@
+pub mod backend;
+pub mod popup;
+pub mod positioner;
+pub mod surface;
+pub mod toplevel;
+pub mod wm_base;

src/wayland/xdg/popup.rs

@@ -0,0 +1,104 @@
+use super::{
+	positioner::{Positioner, PositionerData},
+	surface::Surface,
+};
+use crate::nodes::items::panel::SurfaceId;
+use crate::wayland::WaylandResult;
+use parking_lot::Mutex;
+use rand::Rng;
+use std::sync::Arc;
+use waynest::ObjectId;
+use waynest_protocols::server::stable::xdg_shell::xdg_popup::XdgPopup;
+use waynest_server::Client as _;
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Popup {
+	version: u32,
+	pub surface: Arc<Surface>,
+	positioner_data: Mutex<PositionerData>,
+	id: ObjectId,
+}
+impl Popup {
+	pub fn new(version: u32, surface: Arc<Surface>, positioner: &Positioner, id: ObjectId) -> Self {
+		let _ = surface
+			.wl_surface
+			.surface_id
+			.set(SurfaceId::Child(rand::rng().random()));
+
+		let positioner_data = positioner.data();
+		Self {
+			version,
+			surface,
+			positioner_data: Mutex::new(positioner_data),
+			id,
+		}
+	}
+}
+impl XdgPopup for Popup {
+	type Connection = crate::wayland::Client;
+
+	/// https://wayland.app/protocols/xdg-shell#xdg_popup:request:grab
+	async fn grab(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_seat: ObjectId,
+		_serial: u32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/xdg-shell#xdg_popup:request:reposition
+	async fn reposition(
+		&self,
+		client: &mut Self::Connection,
+		sender_id: ObjectId,
+		positioner: ObjectId,
+		token: u32,
+	) -> WaylandResult<()> {
+		let positioner = client.get::<Positioner>(positioner).unwrap();
+		let positioner_data = positioner.data();
+		*self.positioner_data.lock() = positioner_data;
+		if self.version >= 5 {
+			self.repositioned(client, sender_id, token).await?;
+		}
+		let geometry = positioner_data.infinite_geometry();
+		self.configure(
+			client,
+			sender_id,
+			geometry.origin.x,
+			geometry.origin.y,
+			geometry.size.x as i32,
+			geometry.size.y as i32,
+		)
+		.await?;
+		self.surface.reconfigure(client).await?;
+
+		let Some(panel_item) = self.surface.wl_surface.panel_item.lock().upgrade() else {
+			return Ok(());
+		};
+		panel_item
+			.backend
+			.reposition_child(&self.surface.wl_surface, geometry);
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/xdg-shell#xdg_popup:request:destroy
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+}
+impl Drop for Popup {
+	fn drop(&mut self) {
+		let Some(panel_item) = self.surface.wl_surface.panel_item.lock().upgrade() else {
+			return;
+		};
+		panel_item.backend.remove_child(&self.surface.wl_surface);
+	}
+}

src/wayland/xdg/positioner.rs

@@ -0,0 +1,265 @@
+use crate::{nodes::items::panel::Geometry, wayland::WaylandResult};
+use mint::Vector2;
+use parking_lot::Mutex;
+use waynest::ObjectId;
+use waynest_protocols::server::stable::xdg_shell::xdg_positioner::*;
+use waynest_server::Client as _;
+
+#[derive(Debug, Clone, Copy)]
+pub struct PositionerData {
+	pub size: Vector2<u32>,
+	pub anchor_rect: Geometry,
+	pub offset: Vector2<i32>,
+	pub anchor: Anchor,
+	pub gravity: Gravity,
+	pub constraint_adjustment: ConstraintAdjustment,
+	pub reactive: bool,
+	pub parent_size: Vector2<u32>,
+}
+impl PositionerData {
+	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 infinite_geometry(&self) -> Geometry {
+		let anchor_point = match self.anchor {
+			Anchor::TopLeft => self.anchor_rect.origin,
+			Anchor::Top => [
+				self.anchor_rect.origin.x + (self.anchor_rect.size.x / 2) as i32,
+				self.anchor_rect.origin.y,
+			]
+			.into(),
+			Anchor::TopRight => [
+				self.anchor_rect.origin.x + self.anchor_rect.size.x as i32,
+				self.anchor_rect.origin.y,
+			]
+			.into(),
+			Anchor::Left => [
+				self.anchor_rect.origin.x,
+				self.anchor_rect.origin.y + (self.anchor_rect.size.y / 2) as i32,
+			]
+			.into(),
+			Anchor::Right => [
+				self.anchor_rect.origin.x + self.anchor_rect.size.x as i32,
+				self.anchor_rect.origin.y + (self.anchor_rect.size.y / 2) as i32,
+			]
+			.into(),
+			Anchor::BottomLeft => [
+				self.anchor_rect.origin.x,
+				self.anchor_rect.origin.y + self.anchor_rect.size.y as i32,
+			]
+			.into(),
+			Anchor::Bottom => [
+				self.anchor_rect.origin.x + (self.anchor_rect.size.x / 2) as i32,
+				self.anchor_rect.origin.y + self.anchor_rect.size.y as i32,
+			]
+			.into(),
+			Anchor::BottomRight => [
+				self.anchor_rect.origin.x + self.anchor_rect.size.x as i32,
+				self.anchor_rect.origin.y + self.anchor_rect.size.y as i32,
+			]
+			.into(),
+			_ => [
+				self.anchor_rect.origin.x + (self.anchor_rect.size.x / 2) as i32,
+				self.anchor_rect.origin.y + (self.anchor_rect.size.y / 2) as i32,
+			]
+			.into(),
+		};
+
+		let mut geometry = Geometry {
+			origin: [
+				anchor_point.x + self.offset.x,
+				anchor_point.y + self.offset.y,
+			]
+			.into(),
+			size: self.size,
+		};
+
+		// apply gravity
+		if self.gravity_has_edge(Gravity::Top) {
+			geometry.origin.y -= geometry.size.y as i32;
+		} else if !self.gravity_has_edge(Gravity::Bottom) {
+			geometry.origin.y -= (geometry.size.y / 2) as i32;
+		}
+
+		if self.gravity_has_edge(Gravity::Left) {
+			geometry.origin.x -= geometry.size.x as i32;
+		} else if !self.gravity_has_edge(Gravity::Right) {
+			geometry.origin.x -= (geometry.size.x / 2) as i32;
+		}
+
+		geometry
+	}
+}
+impl Default for PositionerData {
+	fn default() -> Self {
+		Self {
+			size: [0; 2].into(),
+			anchor_rect: Default::default(),
+			offset: [0, 0].into(),
+			anchor: Anchor::TopLeft,
+			gravity: Gravity::TopLeft,
+			constraint_adjustment: ConstraintAdjustment::empty(),
+			reactive: false,
+			parent_size: [0; 2].into(),
+		}
+	}
+}
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Positioner {
+	data: Mutex<PositionerData>,
+	id: ObjectId,
+}
+impl Positioner {
+	pub fn new(id: ObjectId) -> Self {
+		Self {
+			data: Mutex::new(PositionerData::default()),
+			id,
+		}
+	}
+}
+impl Positioner {
+	pub fn data(&self) -> PositionerData {
+		*self.data.lock()
+	}
+}
+impl XdgPositioner for Positioner {
+	type Connection = crate::wayland::Client;
+
+	async fn set_size(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_width: i32,
+		_height: i32,
+	) -> WaylandResult<()> {
+		let mut data = self.data.lock();
+		data.size = [_width.max(0) as u32, _height.max(0) as u32].into();
+		data.reactive = true;
+		Ok(())
+	}
+
+	async fn set_anchor_rect(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_x: i32,
+		_y: i32,
+		_width: i32,
+		_height: i32,
+	) -> WaylandResult<()> {
+		let mut data = self.data.lock();
+		data.anchor_rect.origin = [_x, _y].into();
+		data.anchor_rect.size = [_width.max(0) as u32, _height.max(0) as u32].into();
+		data.offset = [0, 0].into();
+		Ok(())
+	}
+
+	async fn set_anchor(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_anchor: Anchor,
+	) -> WaylandResult<()> {
+		let mut data = self.data.lock();
+		data.anchor = _anchor;
+		Ok(())
+	}
+
+	async fn set_gravity(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		gravity: Gravity,
+	) -> WaylandResult<()> {
+		let mut data = self.data.lock();
+		data.gravity = gravity;
+		Ok(())
+	}
+
+	async fn set_constraint_adjustment(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_constraint_adjustment: ConstraintAdjustment,
+	) -> WaylandResult<()> {
+		let mut data = self.data.lock();
+		data.constraint_adjustment = _constraint_adjustment;
+		Ok(())
+	}
+
+	async fn set_offset(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_x: i32,
+		_y: i32,
+	) -> WaylandResult<()> {
+		let mut data = self.data.lock();
+		data.offset.x += _x;
+		data.offset.y += _y;
+		Ok(())
+	}
+
+	async fn set_reactive(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn set_parent_size(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_parent_width: i32,
+		_parent_height: i32,
+	) -> WaylandResult<()> {
+		let mut data = self.data.lock();
+		data.parent_size.x = _parent_width.max(0) as u32;
+		data.parent_size.y = _parent_height.max(0) as u32;
+		Ok(())
+	}
+
+	async fn set_parent_configure(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_serial: u32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+}

src/wayland/xdg/surface.rs

@@ -0,0 +1,223 @@
+use super::{popup::Popup, positioner::Positioner, toplevel::MappedInner};
+use crate::nodes::items::panel::{ChildInfo, SurfaceId};
+use crate::wayland::{Client, WaylandError};
+use crate::wayland::{
+	Message, WaylandResult, core::surface::SurfaceRole, display::Display, util::ClientExt,
+	xdg::toplevel::Toplevel,
+};
+use std::sync::Arc;
+use waynest::ObjectId;
+use waynest_protocols::server::stable::xdg_shell::xdg_popup::XdgPopup;
+pub use waynest_protocols::server::stable::xdg_shell::xdg_surface::*;
+use waynest_server::Client as _;
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Surface {
+	id: ObjectId,
+	version: u32,
+	pub wl_surface: Arc<crate::wayland::core::surface::Surface>,
+	configured: Arc<std::sync::atomic::AtomicBool>,
+}
+impl Surface {
+	pub fn new(
+		id: ObjectId,
+		version: u32,
+		wl_surface: Arc<crate::wayland::core::surface::Surface>,
+	) -> Self {
+		Self {
+			id,
+			version,
+			wl_surface,
+			configured: Arc::new(std::sync::atomic::AtomicBool::new(false)),
+		}
+	}
+
+	pub async fn reconfigure(&self, client: &mut Client) -> WaylandResult<()> {
+		let serial = client.next_event_serial();
+		self.configure(client, self.id, serial).await
+	}
+}
+
+impl XdgSurface for Surface {
+	type Connection = crate::wayland::Client;
+
+	/// https://wayland.app/protocols/xdg-shell#xdg_surface:request:destroy
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/xdg-shell#xdg_surface:request:get_toplevel
+	async fn get_toplevel(
+		&self,
+		client: &mut Self::Connection,
+		sender_id: ObjectId,
+		toplevel_id: ObjectId,
+	) -> WaylandResult<()> {
+		let toplevel = client.insert(
+			toplevel_id,
+			Toplevel::new(
+				toplevel_id,
+				self.wl_surface.clone(),
+				client.get::<Self>(sender_id).unwrap(),
+			),
+		)?;
+
+		self.wl_surface
+			.try_set_role(SurfaceRole::XdgToplevel, Error::AlreadyConstructed)
+			.await?;
+
+		let toplevel_weak = Arc::downgrade(&toplevel);
+		let display = client.get::<Display>(ObjectId::DISPLAY).unwrap();
+		let seat = Arc::downgrade(display.seat.get().unwrap());
+		let pid = display.pid;
+		let configured = self.configured.clone();
+		let mut first_commit = true;
+		let message_tx = client.message_sink().clone();
+		self.wl_surface.add_commit_handler(move |surface, state| {
+			let Some(toplevel) = toplevel_weak.upgrade() else {
+				return true;
+			};
+
+			if first_commit {
+				let _ = message_tx.send(Message::ReconfigureToplevel(toplevel.clone()));
+				first_commit = false;
+			}
+
+			let mut mapped_lock = toplevel.mapped.lock();
+			if mapped_lock.is_none()
+				&& configured.load(std::sync::atomic::Ordering::SeqCst)
+				&& state.has_valid_buffer()
+			{
+				let mapped_inner = MappedInner::create(&seat.upgrade().unwrap(), &toplevel, pid);
+				*surface.panel_item.lock() = Arc::downgrade(&mapped_inner.panel_item);
+				mapped_lock.replace(mapped_inner);
+				return false;
+			}
+			true
+		});
+
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/xdg-shell#xdg_surface:request:get_popup
+	async fn get_popup(
+		&self,
+		client: &mut Self::Connection,
+		sender_id: ObjectId,
+		popup_id: ObjectId,
+		parent: Option<ObjectId>,
+		positioner: ObjectId,
+	) -> WaylandResult<()> {
+		self.wl_surface
+			.try_set_role(SurfaceRole::XdgPopup, Error::AlreadyConstructed)
+			.await?;
+
+		let Some(parent) = parent else {
+			return Err(WaylandError::Fatal {
+				object_id: popup_id,
+				code: 3,
+				message: "Parent surface does not have an XDG role",
+			});
+		};
+		let Some(parent) = client.get::<Surface>(parent) else {
+			return Err(WaylandError::Fatal {
+				object_id: popup_id,
+				code: 3,
+				message: "Parent surface does not exist",
+			});
+		};
+		*self.wl_surface.panel_item.lock() = parent.wl_surface.panel_item.lock().clone();
+		let positioner = client.get::<Positioner>(positioner).unwrap();
+
+		let surface = client.get::<Surface>(self.id).unwrap();
+
+		let popup = client.insert(
+			popup_id,
+			Popup::new(self.version, surface, &positioner, popup_id),
+		)?;
+
+		let positioner_geometry = positioner.data().infinite_geometry();
+
+		popup
+			.configure(
+				client,
+				popup_id,
+				positioner_geometry.origin.x,
+				positioner_geometry.origin.y,
+				positioner_geometry.size.x as i32,
+				positioner_geometry.size.y as i32,
+			)
+			.await?;
+		let serial = client.next_event_serial();
+		self.configure(client, sender_id, serial).await?;
+
+		let Some(SurfaceId::Child(id)) = self.wl_surface.surface_id.get() else {
+			return Ok(());
+		};
+		let Some(parent_id) = parent.wl_surface.surface_id.get() else {
+			return Ok(());
+		};
+
+		let child_info = ChildInfo {
+			id: *id,
+			parent: parent_id.clone(),
+			geometry: positioner.data().infinite_geometry(),
+			z_order: 1,
+			receives_input: true,
+		};
+
+		let popup_weak = Arc::downgrade(&popup);
+		let configured = self.configured.clone();
+		self.wl_surface.add_commit_handler(move |surface, state| {
+			let Some(popup) = popup_weak.upgrade() else {
+				return true;
+			};
+			let Some(panel_item) = surface.panel_item.lock().upgrade() else {
+				return true;
+			};
+
+			if configured.load(std::sync::atomic::Ordering::SeqCst) && state.has_valid_buffer() {
+				panel_item
+					.backend
+					.add_child(&popup.surface.wl_surface, child_info.clone());
+				return false;
+			}
+			true
+		});
+
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/xdg-shell#xdg_surface:request:set_window_geometry
+	async fn set_window_geometry(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_x: i32,
+		_y: i32,
+		_width: i32,
+		_height: i32,
+	) -> WaylandResult<()> {
+		// we're gonna delegate literally all the window management
+		// to 3D stuff sooo we don't care, maximized is the floating state
+		Ok(())
+	}
+
+	/// https://wayland.app/protocols/xdg-shell#xdg_surface:request:ack_configure
+	async fn ack_configure(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_serial: u32,
+	) -> WaylandResult<()> {
+		self.configured
+			.store(true, std::sync::atomic::Ordering::SeqCst);
+		Ok(())
+	}
+}

src/wayland/xdg/toplevel.rs

@@ -0,0 +1,331 @@
+use super::backend::XdgBackend;
+use crate::{
+	nodes::{
+		Node,
+		items::panel::{PanelItem, SurfaceId},
+	},
+	wayland::{
+		Client, WaylandResult,
+		core::{seat::Seat, surface::Surface},
+	},
+};
+use mint::Vector2;
+use parking_lot::Mutex;
+use std::sync::Arc;
+use waynest::ObjectId;
+pub use waynest_protocols::server::stable::xdg_shell::xdg_toplevel::*;
+use waynest_server::Client as _;
+
+#[derive(Debug)]
+pub struct MappedInner {
+	pub panel_item_node: Arc<Node>,
+	pub panel_item: Arc<PanelItem<XdgBackend>>,
+}
+impl MappedInner {
+	pub fn create(seat: &Arc<Seat>, toplevel: &Arc<Toplevel>, pid: Option<i32>) -> Self {
+		let (panel_item_node, panel_item) =
+			PanelItem::create(Box::new(XdgBackend::new(seat, toplevel)), pid);
+
+		Self {
+			panel_item_node,
+			panel_item,
+		}
+	}
+}
+
+#[derive(Debug, Clone)]
+struct ToplevelData {
+	parent: Option<u64>,
+	app_id: Option<String>,
+	title: Option<String>,
+	activated: bool,
+	fullscreen: bool,
+	pub size: Option<Vector2<u32>>,
+}
+impl Default for ToplevelData {
+	fn default() -> Self {
+		Self {
+			parent: None,
+			app_id: None,
+			title: None,
+			activated: true,
+			fullscreen: false,
+			size: None,
+		}
+	}
+}
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct Toplevel {
+	pub id: ObjectId,
+	xdg_surface: Arc<super::surface::Surface>,
+	pub mapped: Mutex<Option<MappedInner>>,
+	data: Mutex<ToplevelData>,
+}
+impl Toplevel {
+	pub fn new(
+		object_id: ObjectId,
+		wl_surface: Arc<Surface>,
+		xdg_surface: Arc<super::surface::Surface>,
+	) -> Self {
+		let _ = wl_surface.surface_id.set(SurfaceId::Toplevel(()));
+
+		Toplevel {
+			id: object_id,
+			xdg_surface,
+			mapped: Mutex::new(None),
+			data: Mutex::new(ToplevelData::default()),
+		}
+	}
+
+	pub fn wl_surface(&self) -> &Arc<Surface> {
+		&self.xdg_surface.wl_surface
+	}
+
+	pub fn title(&self) -> Option<String> {
+		self.data.lock().title.clone()
+	}
+	pub fn app_id(&self) -> Option<String> {
+		self.data.lock().app_id.clone()
+	}
+	pub fn parent(&self) -> Option<u64> {
+		self.data.lock().parent
+	}
+
+	pub fn set_size(&self, size: Option<Vector2<u32>>) {
+		self.data.lock().size = size;
+	}
+
+	pub fn set_activated(&self, activated: bool) {
+		self.data.lock().activated = activated;
+	}
+
+	// Helper to clamp size against constraints
+	fn clamp_size(&self, size: Vector2<u32>) -> Vector2<u32> {
+		let state = self.wl_surface().current_state();
+		let mut clamped = size;
+
+		if let Some(min_size) = state.min_size {
+			clamped.x = clamped.x.max(min_size.x);
+			clamped.y = clamped.y.max(min_size.y);
+		}
+		if let Some(max_size) = state.max_size {
+			clamped.x = clamped.x.min(max_size.x);
+			clamped.y = clamped.y.min(max_size.y);
+		}
+		clamped
+	}
+
+	pub async fn reconfigure(&self, client: &mut Client) -> WaylandResult<()> {
+		let data = self.data.lock().clone();
+
+		// Use the explicitly set size, applying constraints
+		let size = data.size.map(|s| self.clamp_size(s));
+
+		let mut states = vec![
+			State::TiledTop,
+			State::TiledLeft,
+			State::TiledRight,
+			State::TiledBottom,
+			if data.fullscreen {
+				State::Fullscreen
+			} else {
+				State::Maximized
+			},
+		];
+		if data.activated {
+			states.push(State::Activated);
+		}
+
+		self.configure(
+			client,
+			self.id,
+			size.map(|v| v.x as i32).unwrap_or(0),
+			size.map(|v| v.y as i32).unwrap_or(0),
+			states
+				.into_iter()
+				.flat_map(|x| (x as u32).to_ne_bytes())
+				.collect(),
+		)
+		.await?;
+		self.xdg_surface.reconfigure(client).await?;
+		Ok(())
+	}
+}
+impl XdgToplevel for Toplevel {
+	type Connection = crate::wayland::Client;
+
+	async fn set_parent(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		parent: Option<ObjectId>,
+	) -> WaylandResult<()> {
+		// Handle case where parent is specified
+		if let Some(parent) = parent {
+			// Per spec: parent must be another xdg_toplevel surface
+			if let Some(parent_toplevel) = client.get::<Toplevel>(parent) {
+				let Some(mapped) = &*parent_toplevel.mapped.lock() else {
+					// Per spec: parent surfaces must be mapped before being used as a parent
+					// Setting an unmapped window as parent should raise a protocol error
+					// For now we just unset the parent as a fallback
+					self.data.lock().parent.take();
+					return Ok(());
+				};
+
+				// Per spec: store parent to ensure this surface is stacked above parent
+				// and other ancestor surfaces. Used for proper window stacking order.
+				self.data
+					.lock()
+					.parent
+					.replace(mapped.panel_item_node.get_id());
+			}
+		} else {
+			// Per spec: null parent unsets the parent, making this a top-level window
+			// This allows converting child windows back to independent top-level windows
+			self.data.lock().parent.take();
+		}
+
+		Ok(())
+	}
+
+	async fn set_title(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		title: String,
+	) -> WaylandResult<()> {
+		self.data.lock().title.replace(title);
+		Ok(())
+	}
+
+	async fn set_app_id(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		app_id: String,
+	) -> WaylandResult<()> {
+		self.data.lock().app_id.replace(app_id);
+		Ok(())
+	}
+
+	async fn show_window_menu(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_seat: ObjectId,
+		_serial: u32,
+		_x: i32,
+		_y: i32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn r#move(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_seat: ObjectId,
+		_serial: u32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn resize(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_seat: ObjectId,
+		_serial: u32,
+		_edges: ResizeEdge,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn set_max_size(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		width: i32,
+		height: i32,
+	) -> WaylandResult<()> {
+		self.wl_surface().state_lock().pending.max_size = if width == 0 && height == 0 {
+			None
+		} else {
+			Some([width as u32, height as u32].into())
+		};
+		Ok(())
+	}
+
+	async fn set_min_size(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		width: i32,
+		height: i32,
+	) -> WaylandResult<()> {
+		self.xdg_surface.wl_surface.state_lock().pending.min_size = if width == 0 && height == 0 {
+			None
+		} else {
+			Some([width as u32, height as u32].into())
+		};
+		Ok(())
+	}
+
+	async fn set_maximized(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn unset_maximized(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn set_fullscreen(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_output: Option<ObjectId>,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn unset_fullscreen(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn set_minimized(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		self.mapped.lock().take();
+		Ok(())
+	}
+}
+impl Drop for Toplevel {
+	fn drop(&mut self) {
+		self.mapped.lock().take();
+	}
+}

src/wayland/xdg/wm_base.rs

@@ -0,0 +1,73 @@
+use super::positioner::Positioner;
+use crate::wayland::{WaylandError, WaylandResult, util::ClientExt, xdg::surface::Surface};
+
+use waynest::ObjectId;
+pub use waynest_protocols::server::stable::xdg_shell::xdg_wm_base::*;
+use waynest_server::Client as _;
+
+#[derive(Debug, waynest_server::RequestDispatcher)]
+#[waynest(error = crate::wayland::WaylandError, connection = crate::wayland::Client)]
+pub struct WmBase {
+	version: u32,
+	id: ObjectId,
+}
+impl WmBase {
+	pub fn new(id: ObjectId, version: u32) -> Self {
+		Self { version, id }
+	}
+}
+impl XdgWmBase for WmBase {
+	type Connection = crate::wayland::Client;
+
+	async fn destroy(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+	) -> WaylandResult<()> {
+		client.remove(self.id);
+		Ok(())
+	}
+
+	async fn create_positioner(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		id: ObjectId,
+	) -> WaylandResult<()> {
+		client.insert(id, Positioner::new(id))?;
+		Ok(())
+	}
+
+	async fn get_xdg_surface(
+		&self,
+		client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		xdg_surface_id: ObjectId,
+		wl_surface_id: ObjectId,
+	) -> WaylandResult<()> {
+		let wl_surface = client.try_get::<crate::wayland::core::surface::Surface>(wl_surface_id)?;
+		match wl_surface.role.get() {
+			None => (),
+			Some(_) => {
+				return Err(WaylandError::Fatal {
+					object_id: wl_surface_id,
+					code: Error::Role as u32,
+					message: "Wayland surface has role",
+				});
+			}
+		};
+		let xdg_surface = Surface::new(xdg_surface_id, self.version, wl_surface);
+		client.insert(xdg_surface_id, xdg_surface)?;
+
+		Ok(())
+	}
+
+	async fn pong(
+		&self,
+		_client: &mut Self::Connection,
+		_sender_id: ObjectId,
+		_serial: u32,
+	) -> WaylandResult<()> {
+		Ok(())
+	}
+}