update: stardust-xr core

src/core/scenegraph.rs

@@ -1,19 +1,80 @@
-use crate::core::error::Result;
-use crate::nodes::Node;
-use crate::nodes::alias::get_original;
-use crate::{core::client::Client, nodes::Message};
+use crate::{
+	core::{
+		client::Client,
+		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::scenegraph::ScenegraphError;
-use stardust_xr::schemas::flex::serialize;
-use std::future::Future;
-use std::os::fd::OwnedFd;
-use std::sync::{Arc, OnceLock, Weak};
-use tokio::sync::oneshot;
+use stardust_xr::{
+	messenger::MethodResponse,
+	scenegraph::{self, ScenegraphError},
+	schemas::flex::serialize,
+};
+use std::{
+	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/main.rs

@@ -67,7 +67,7 @@ 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;
@@ -161,15 +161,15 @@ async fn main() -> Result<AppExit, JoinError> {
 
 	let cli_args = CliArgs::parse();
 
-	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");
+	let locked_socket =
+		LockedSocket::get_free().expect("Unable to find a free stardust socket path");
+	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");
 	info!(
-		socket_path = ?socket_path.display(),
+		socket_path = ?locked_socket.socket_path.display(),
 		"Stardust socket created"
 	);
-	let socket =
-		UnixListener::bind(socket_path).expect("Couldn't spawn stardust server at {socket_path}");
+	let socket = UnixListener::bind(locked_socket.socket_path)
+		.expect("Couldn't spawn stardust server at {socket_path}");
 	task::new(|| "client join loop", async move {
 		loop {
 			let Ok((stream, _)) = socket.accept().await else {

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},
@@ -86,7 +88,7 @@ impl Aspect for Alias {
 		_node: Arc<Node>,
 		_method: u64,
 		_message: super::Message,
-		_response: crate::core::scenegraph::MethodResponseSender,
+		_response: MethodResponseSender,
 	) {
 	}
 }

src/nodes/items/camera.rs

@@ -77,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(())?)
 		});
 	}
 

src/nodes/mod.rs

@@ -204,11 +204,11 @@ impl Node {
 	) {
 		if let Ok(alias) = self.get_aspect::<Alias>() {
 			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(
@@ -223,7 +223,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);

src/wayland/core/shm_buffer_backing.rs

@@ -6,7 +6,7 @@ use bevy::{
 };
 use bevy_dmabuf::{
 	dmatex::{Dmatex, DmatexPlane, Resolution},
-	import::{DropCallback, ImportedDmatexs, ImportedTexture, import_texture},
+	import::{DmatexUsage, DropCallback, ImportedDmatexs, ImportedTexture, import_texture},
 };
 use drm_fourcc::DrmFourcc;
 use mint::Vector2;
@@ -176,8 +176,13 @@ impl ShmBufferBacking {
 			flip_y: false,
 			srgb: true,
 		};
-		let imported_dmatex =
-			import_texture(RENDER_DEVICE.wait(), dmatex, DropCallback(None)).unwrap();
+		let imported_dmatex = import_texture(
+			RENDER_DEVICE.wait(),
+			dmatex,
+			DropCallback(None),
+			DmatexUsage::Sampling,
+		)
+		.unwrap();
 		Self {
 			pool,
 			offset,

src/wayland/dmabuf/buffer_backing.rs

@@ -6,7 +6,9 @@ use bevy::{
 };
 use bevy_dmabuf::{
 	dmatex::{Dmatex, Resolution},
-	import::{DropCallback, ImportError, ImportedDmatexs, ImportedTexture, import_texture},
+	import::{
+		DmatexUsage, DropCallback, ImportError, ImportedDmatexs, ImportedTexture, import_texture,
+	},
 };
 use drm_fourcc::DrmFourcc;
 use mint::Vector2;
@@ -45,6 +47,7 @@ impl DmabufBacking {
 				dev,
 				dmatex,
 				DropCallback(None),
+				DmatexUsage::Sampling,
 			)?)),
 		})
 	}