From 6f4da69e363145483d73a1dbb5c5bdd13441b176 Mon Sep 17 00:00:00 2001 From: Nova Date: Sat, 2 Sep 2023 19:49:53 -0400 Subject: [PATCH] feat: async methods --- Cargo.lock | 20 +--- Cargo.toml | 8 +- src/core/scenegraph.rs | 48 +++++--- src/nodes/fields/mod.rs | 125 +++++++++++--------- src/nodes/items/camera.rs | 26 ++-- src/nodes/items/environment.rs | 10 +- src/nodes/mod.rs | 73 +++++------- src/nodes/spatial/mod.rs | 209 ++++++++++++++++++--------------- src/nodes/startup.rs | 56 +++++---- 9 files changed, 305 insertions(+), 270 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3b5a79d..617e0ce 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -138,17 +138,6 @@ dependencies = [ "num-traits", ] -[[package]] -name = "async-recursion" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e97ce7de6cf12de5d7226c73f5ba9811622f4db3a5b91b55c53e987e5f91cba" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.28", -] - [[package]] name = "async-trait" version = "0.1.73" @@ -2034,9 +2023,10 @@ dependencies = [ [[package]] name = "stardust-xr" -version = "0.13.0" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "996e151a9271144684a8ccb1d23d2949c5590bc37c4a12119d4f72f64462307e" dependencies = [ - "async-trait", "cluFlock", "color-rs", "dirs", @@ -2054,6 +2044,8 @@ dependencies = [ [[package]] name = "stardust-xr-schemas" version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd65a40d6e6e8dc993ea9832666cf4cdc09c1a329f38b48ec9704af26cba229b" dependencies = [ "flatbuffers", "flexbuffers", @@ -2070,8 +2062,6 @@ dependencies = [ name = "stardust-xr-server" version = "0.42.1" dependencies = [ - "async-recursion", - "async-trait", "atty", "clap", "color-eyre", diff --git a/Cargo.toml b/Cargo.toml index 051b23d..7480e55 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -52,7 +52,7 @@ tokio = { version = "1.27.0", features = ["rt-multi-thread", "signal"] } send_wrapper = "0.6.0" prisma = "0.1.1" xkbcommon = { version = "0.5.0", default-features = false, optional = true } -stardust-xr = "0.13.0" +stardust-xr = "0.14.0" directories = "5.0.0" serde = { version = "1.0.160", features = ["derive"] } tracing = "0.1.37" @@ -60,8 +60,6 @@ tracing-subscriber = { version = "0.3.17", features = ["env-filter"] } global_counter = "0.2.2" rand = "0.8.5" atty = "0.2.14" -async-trait = "0.1.73" -async-recursion = "1.0.4" [dependencies.stereokit] default-features = false @@ -89,7 +87,7 @@ optional = true # path = "../stereokit-rs" # [patch.crates-io.stereokit-sys] # path = "../stereokit-sys" -[patch.crates-io.stardust-xr] -path = "../core/core" +# [patch.crates-io.stardust-xr] +# path = "../core/core" # [patch.crates-io.stardust-xr-schemas] # path = "../core/schemas" diff --git a/src/core/scenegraph.rs b/src/core/scenegraph.rs index 3fc7b33..230a99c 100644 --- a/src/core/scenegraph.rs +++ b/src/core/scenegraph.rs @@ -1,12 +1,12 @@ use crate::nodes::Node; use crate::{core::client::Client, nodes::Message}; -use async_trait::async_trait; use color_eyre::eyre::Result; use once_cell::sync::OnceCell; use stardust_xr::scenegraph; use stardust_xr::scenegraph::ScenegraphError; use std::os::fd::OwnedFd; use std::sync::{Arc, Weak}; +use tokio::sync::oneshot; use tracing::{debug, debug_span, instrument}; use core::hash::BuildHasherDefault; @@ -51,7 +51,17 @@ impl Scenegraph { } } -#[async_trait] +pub struct MethodResponseSender(oneshot::Sender, Vec), ScenegraphError>>); +impl MethodResponseSender { + pub fn send(self, t: Result) { + let _ = self.0.send(t.map(|m| (m.data, m.fds))); + } + pub fn wrap_sync color_eyre::eyre::Result>(self, f: F) { + self.send(f().map_err(|e| ScenegraphError::MethodError { + error: e.to_string(), + })) + } +} impl scenegraph::Scenegraph for Scenegraph { fn send_signal( &self, @@ -76,29 +86,31 @@ impl scenegraph::Scenegraph for Scenegraph { ) }) } - async fn execute_method( + fn execute_method( &self, path: &str, method: &str, data: &[u8], fds: Vec, - ) -> Result<(Vec, Vec), ScenegraphError> { + response: oneshot::Sender, Vec), ScenegraphError>>, + ) { let Some(client) = self.get_client() else { - return Err(ScenegraphError::MethodNotFound); + let _ = response.send(Err(ScenegraphError::MethodNotFound)); + return; }; debug!(path, method, "Handle method"); - let message = self - .get_node(path) - .ok_or(ScenegraphError::NodeNotFound)? - .execute_local_method( - client, - method, - Message { - data: data.to_vec(), - fds, - }, - ) - .await?; - Ok((message.data, message.fds)) + let Some(node) = self.get_node(path) else { + let _ = response.send(Err(ScenegraphError::NodeNotFound)); + return; + }; + node.execute_local_method( + client, + method, + Message { + data: data.to_vec(), + fds, + }, + MethodResponseSender(response), + ); } } diff --git a/src/nodes/fields/mod.rs b/src/nodes/fields/mod.rs index 14e3bcc..6e55e7d 100644 --- a/src/nodes/fields/mod.rs +++ b/src/nodes/fields/mod.rs @@ -12,6 +12,7 @@ use super::alias::AliasInfo; use super::spatial::Spatial; use super::{Message, Node}; use crate::core::client::Client; +use crate::core::scenegraph::MethodResponseSender; use crate::nodes::spatial::find_reference_space; use color_eyre::eyre::Result; use glam::{vec2, vec3a, Vec3, Vec3A}; @@ -137,82 +138,94 @@ fn field_distance_flex( node: &Node, calling_client: Arc, message: Message, -) -> Result { - #[derive(Deserialize)] - struct FieldInfoArgs<'a> { - reference_space_path: &'a str, - point: Vector3, - } - let args: FieldInfoArgs = deserialize(message.as_ref())?; - let reference_space = find_reference_space(&calling_client, args.reference_space_path)?; + response: MethodResponseSender, +) { + response.wrap_sync(move || { + #[derive(Deserialize)] + struct FieldInfoArgs<'a> { + reference_space_path: &'a str, + point: Vector3, + } + let args: FieldInfoArgs = deserialize(message.as_ref())?; + let reference_space = find_reference_space(&calling_client, args.reference_space_path)?; - let distance = node - .field - .get() - .unwrap() - .distance(reference_space.as_ref(), args.point.into()); - Ok(serialize(distance)?.into()) + let distance = node + .field + .get() + .unwrap() + .distance(reference_space.as_ref(), args.point.into()); + Ok(serialize(distance)?.into()) + }); } fn field_normal_flex( node: &Node, calling_client: Arc, message: Message, -) -> Result { - #[derive(Deserialize)] - struct FieldInfoArgs<'a> { - reference_space_path: &'a str, - point: Vector3, - } - let args: FieldInfoArgs = deserialize(message.as_ref())?; - let reference_space = find_reference_space(&calling_client, args.reference_space_path)?; + response: MethodResponseSender, +) { + response.wrap_sync(move || { + #[derive(Deserialize)] + struct FieldInfoArgs<'a> { + reference_space_path: &'a str, + point: Vector3, + } + let args: FieldInfoArgs = deserialize(message.as_ref())?; + let reference_space = find_reference_space(&calling_client, args.reference_space_path)?; - let normal = node.field.get().as_ref().unwrap().normal( - reference_space.as_ref(), - args.point.into(), - 0.001, - ); - Ok(serialize(mint::Vector3::from(normal))?.into()) + let normal = node.field.get().as_ref().unwrap().normal( + reference_space.as_ref(), + args.point.into(), + 0.001, + ); + Ok(serialize(mint::Vector3::from(normal))?.into()) + }); } fn field_closest_point_flex( node: &Node, calling_client: Arc, message: Message, -) -> Result { - #[derive(Deserialize)] - struct FieldInfoArgs<'a> { - reference_space_path: &'a str, - point: Vector3, - } - let args: FieldInfoArgs = deserialize(message.as_ref())?; - let reference_space = find_reference_space(&calling_client, args.reference_space_path)?; + response: MethodResponseSender, +) { + response.wrap_sync(move || { + #[derive(Deserialize)] + struct FieldInfoArgs<'a> { + reference_space_path: &'a str, + point: Vector3, + } + let args: FieldInfoArgs = deserialize(message.as_ref())?; + let reference_space = find_reference_space(&calling_client, args.reference_space_path)?; - let closest_point = node.field.get().as_ref().unwrap().closest_point( - reference_space.as_ref(), - args.point.into(), - 0.001, - ); - Ok(serialize(mint::Vector3::from(closest_point))?.into()) + let closest_point = node.field.get().as_ref().unwrap().closest_point( + reference_space.as_ref(), + args.point.into(), + 0.001, + ); + Ok(serialize(mint::Vector3::from(closest_point))?.into()) + }); } fn field_ray_march_flex( node: &Node, calling_client: Arc, message: Message, -) -> Result { - #[derive(Deserialize)] - struct FieldInfoArgs<'a> { - reference_space_path: &'a str, - ray_origin: Vector3, - ray_direction: Vector3, - } - let args: FieldInfoArgs = deserialize(message.as_ref())?; - let reference_space = find_reference_space(&calling_client, args.reference_space_path)?; + response: MethodResponseSender, +) { + response.wrap_sync(move || { + #[derive(Deserialize)] + struct FieldInfoArgs<'a> { + reference_space_path: &'a str, + ray_origin: Vector3, + ray_direction: Vector3, + } + let args: FieldInfoArgs = deserialize(message.as_ref())?; + let reference_space = find_reference_space(&calling_client, args.reference_space_path)?; - let ray_march_result = node.field.get().unwrap().ray_march(Ray { - origin: args.ray_origin.into(), - direction: args.ray_direction.into(), - space: reference_space, + let ray_march_result = node.field.get().unwrap().ray_march(Ray { + origin: args.ray_origin.into(), + direction: args.ray_direction.into(), + space: reference_space, + }); + Ok(serialize(ray_march_result)?.into()) }); - Ok(serialize(ray_march_result)?.into()) } pub enum Field { diff --git a/src/nodes/items/camera.rs b/src/nodes/items/camera.rs index 71aaf2d..0eb9b76 100644 --- a/src/nodes/items/camera.rs +++ b/src/nodes/items/camera.rs @@ -3,6 +3,7 @@ use crate::{ core::{ client::{Client, INTERNAL_CLIENT}, registry::Registry, + scenegraph::MethodResponseSender, }, nodes::{ drawable::{model::ModelPart, shaders::UNLIT_SHADER_BYTES, Drawable}, @@ -11,7 +12,7 @@ use crate::{ Message, Node, }, }; -use color_eyre::eyre::{bail, Result}; +use color_eyre::eyre::{bail, eyre, Result}; use glam::Mat4; use lazy_static::lazy_static; use mint::{RowMatrix4, Vector2}; @@ -31,7 +32,7 @@ use stereokit::{ lazy_static! { pub(super) static ref ITEM_TYPE_INFO_CAMERA: TypeInfo = TypeInfo { type_name: "camera", - aliased_local_signals: vec!["frame"], + aliased_local_signals: vec!["apply_preview_material", "frame"], aliased_local_methods: vec![], aliased_remote_signals: vec![], ui: Default::default(), @@ -71,19 +72,26 @@ impl CameraItem { apply_to: Registry::new(), }), ); - // node.add_local_method("frame", CameraItem::frame_flex); + node.add_local_method("frame", CameraItem::frame_flex); node.add_local_signal( "apply_preview_material", CameraItem::apply_preview_material_flex, ); } - // fn frame_flex(node: &Node, _calling_client: Arc, message: Message) -> Result { - // let ItemType::Camera(camera) = &node.item.get().unwrap().specialization else { - // return Err(eyre!("Wrong item type?")) - // }; - // Ok(serialize(())?.into()) - // } + fn frame_flex( + node: &Node, + _calling_client: Arc, + _message: Message, + response: MethodResponseSender, + ) { + response.wrap_sync(move || { + let ItemType::Camera(_camera) = &node.item.get().unwrap().specialization else { + return Err(eyre!("Wrong item type?")) + }; + Ok(serialize(())?.into()) + }); + } fn apply_preview_material_flex( node: &Node, diff --git a/src/nodes/items/environment.rs b/src/nodes/items/environment.rs index 6fa411d..c2566cb 100644 --- a/src/nodes/items/environment.rs +++ b/src/nodes/items/environment.rs @@ -3,6 +3,7 @@ use crate::{ core::{ client::{Client, INTERNAL_CLIENT}, registry::Registry, + scenegraph::MethodResponseSender, }, nodes::{ items::TypeInfo, @@ -50,11 +51,14 @@ impl EnvironmentItem { node: &Node, _calling_client: Arc, _message: Message, - ) -> Result { - let ItemType::Environment(environment_item) = &node.item.get().unwrap().specialization else { + response: MethodResponseSender, + ) { + response.wrap_sync(move || { + let ItemType::Environment(environment_item) = &node.item.get().unwrap().specialization else { return Err(eyre!("Wrong item type?")) }; - Ok(serialize(environment_item.path.as_str())?.into()) + Ok(serialize(environment_item.path.as_str())?.into()) + }); } pub fn serialize_start_data(&self, id: &str) -> Result { diff --git a/src/nodes/mod.rs b/src/nodes/mod.rs index 193eb69..f9c3457 100644 --- a/src/nodes/mod.rs +++ b/src/nodes/mod.rs @@ -10,7 +10,6 @@ pub mod root; pub mod spatial; pub mod startup; -use async_recursion::async_recursion; use color_eyre::eyre::{eyre, Result}; use core::hash::BuildHasherDefault; use dashmap::DashMap; @@ -23,15 +22,14 @@ use stardust_xr::messenger::MessageSenderHandle; use stardust_xr::scenegraph::ScenegraphError; use stardust_xr::schemas::flex::deserialize; use std::fmt::Debug; -use std::future::Future; use std::os::fd::OwnedFd; -use std::pin::Pin; use std::sync::{Arc, Weak}; use std::vec::Vec; -use tracing::{debug_span, instrument}; +use tracing::instrument; use crate::core::client::Client; use crate::core::registry::Registry; +use crate::core::scenegraph::MethodResponseSender; use self::alias::Alias; use self::audio::Sound; @@ -63,11 +61,7 @@ impl AsRef<[u8]> for Message { } pub type Signal = fn(&Node, Arc, Message) -> Result<()>; -pub type Method = fn( - &Node, - Arc, - Message, -) -> Pin> + Send + Sync + 'static>>; +pub type Method = fn(&Node, Arc, Message, MethodResponseSender); pub struct Node { pub enabled: Arc, @@ -193,15 +187,8 @@ impl Node { pub fn add_local_signal(&self, name: &str, signal: Signal) { self.local_signals.insert(name.to_string(), signal); } - pub fn add_local_method> + Send + Sync + 'static>( - &self, - name: &str, - method: fn(&Node, Arc, Message) -> F, - ) { - self.local_methods - .insert(name.to_string(), |node, calling_client, message| { - Box::Pin(method(node, calling_client, message)) - }); + pub fn add_local_method(&self, name: &str, method: Method) { + self.local_methods.insert(name.to_string(), method); } pub fn get_aspect( @@ -243,41 +230,37 @@ impl Node { }) } } - #[async_recursion] - pub async fn execute_local_method( + pub fn execute_local_method( &self, calling_client: Arc, method: &str, message: Message, - ) -> Result { + response: MethodResponseSender, + ) { if let Some(alias) = self.alias.get() { if !alias.info.server_methods.iter().any(|e| e == &method) { - return Err(ScenegraphError::MethodNotFound); + response.send(Err(ScenegraphError::MethodNotFound)); + return; } - alias - .original - .upgrade() - .ok_or(ScenegraphError::BrokenAlias)? - .execute_local_method( - calling_client, - method, - Message { - data: message.data.clone(), - fds: Vec::new(), - }, - ) - .await + let Some(alias) = alias.original.upgrade() else { + response.send(Err(ScenegraphError::BrokenAlias)); + return; + }; + alias.execute_local_method( + calling_client, + method, + Message { + data: message.data.clone(), + fds: Vec::new(), + }, + response, + ) } else { - let method = self - .local_methods - .get(method) - .ok_or(ScenegraphError::MethodNotFound)?; - - method(self, calling_client, message) - .await - .map_err(|error| ScenegraphError::MethodError { - error: error.to_string(), - }) + let Some(method) = self.local_methods.get(method) else { + response.send(Err(ScenegraphError::MethodNotFound)); + return; + }; + method(self, calling_client, message, response); } } #[instrument(level = "debug", skip_all)] diff --git a/src/nodes/spatial/mod.rs b/src/nodes/spatial/mod.rs index f49ed87..75e86b0 100644 --- a/src/nodes/spatial/mod.rs +++ b/src/nodes/spatial/mod.rs @@ -4,6 +4,7 @@ use self::zone::{create_zone_flex, Zone}; use super::{Message, Node}; use crate::core::client::Client; use crate::core::registry::Registry; +use crate::core::scenegraph::MethodResponseSender; use color_eyre::eyre::{ensure, eyre, Result}; use glam::{vec3a, Mat4, Quat}; use mint::Vector3; @@ -233,64 +234,71 @@ impl Spatial { node: &Node, calling_client: Arc, message: Message, - ) -> Result { - let this_spatial = node - .spatial - .get() - .ok_or_else(|| eyre!("Node doesn't have a spatial?"))?; - let relative_spatial_path: Option<&str> = deserialize(message.as_ref())?; - let bounds = if let Some(relative_spatial_path) = relative_spatial_path { - let relative_spatial = find_reference_space(&calling_client, relative_spatial_path)?; - let center = - Spatial::space_to_space_matrix(Some(&this_spatial), Some(&relative_spatial)) - .transform_point3([0.0; 3].into()); - let bounds: Bounds = Bounds { - center, - dimensions: [0.0; 3].into(), + response: MethodResponseSender, + ) { + response.wrap_sync(move || { + let this_spatial = node + .spatial + .get() + .ok_or_else(|| eyre!("Node doesn't have a spatial?"))?; + let relative_spatial_path: Option<&str> = deserialize(message.as_ref())?; + let bounds = if let Some(relative_spatial_path) = relative_spatial_path { + let relative_spatial = + find_reference_space(&calling_client, relative_spatial_path)?; + let center = + Spatial::space_to_space_matrix(Some(&this_spatial), Some(&relative_spatial)) + .transform_point3([0.0; 3].into()); + let bounds: Bounds = Bounds { + center, + dimensions: [0.0; 3].into(), + }; + bounds_grow_to_fit_box( + bounds, + this_spatial.get_bounding_box(), + Some(Spatial::space_to_space_matrix( + Some(&this_spatial), + Some(&relative_spatial), + )), + ) + } else { + this_spatial.get_bounding_box() }; - bounds_grow_to_fit_box( - bounds, - this_spatial.get_bounding_box(), - Some(Spatial::space_to_space_matrix( - Some(&this_spatial), - Some(&relative_spatial), - )), - ) - } else { - this_spatial.get_bounding_box() - }; - Ok(serialize(( - mint::Vector3::from(bounds.center), - mint::Vector3::from(bounds.dimensions), - ))? - .into()) + Ok(serialize(( + mint::Vector3::from(bounds.center), + mint::Vector3::from(bounds.dimensions), + ))? + .into()) + }); } pub fn get_transform_flex( node: &Node, calling_client: Arc, message: Message, - ) -> Result { - let this_spatial = node - .spatial - .get() - .ok_or_else(|| eyre!("Node doesn't have a spatial?"))?; - let relative_spatial = - find_reference_space(&calling_client, deserialize(message.as_ref())?)?; + response: MethodResponseSender, + ) { + response.wrap_sync(move || { + let this_spatial = node + .spatial + .get() + .ok_or_else(|| eyre!("Node doesn't have a spatial?"))?; + let relative_spatial = + find_reference_space(&calling_client, deserialize(message.as_ref())?)?; - let (scale, rotation, position) = Spatial::space_to_space_matrix( - Some(this_spatial.as_ref()), - Some(relative_spatial.as_ref()), - ) - .to_scale_rotation_translation(); + let (scale, rotation, position) = Spatial::space_to_space_matrix( + Some(this_spatial.as_ref()), + Some(relative_spatial.as_ref()), + ) + .to_scale_rotation_translation(); - Ok(serialize(( - mint::Vector3::from(position), - mint::Quaternion::from(rotation), - mint::Vector3::from(scale), - ))? - .into()) + Ok(serialize(( + mint::Vector3::from(position), + mint::Quaternion::from(rotation), + mint::Vector3::from(scale), + ))? + .into()) + }); } pub fn set_transform_flex( node: &Node, @@ -354,70 +362,79 @@ impl Spatial { node: &Node, calling_client: Arc, message: Message, - ) -> Result { - let (point, fields): (Vector3, Vec>) = deserialize(message.as_ref())?; - let spatial = node.spatial.get().unwrap(); + response: MethodResponseSender, + ) { + response.wrap_sync(move || { + let (point, fields): (Vector3, Vec>) = deserialize(message.as_ref())?; + let spatial = node.spatial.get().unwrap(); - let output = fields - .into_iter() - .map(|f| { - calling_client - .get_node("Field", f?) - .ok()? - .get_aspect("Field", "field", |n| &n.field) - .ok() - .cloned() - }) - .map(|f| f.map(|f| f.distance(spatial, point.into()))) - .collect::>>(); + let output = fields + .into_iter() + .map(|f| { + calling_client + .get_node("Field", f?) + .ok()? + .get_aspect("Field", "field", |n| &n.field) + .ok() + .cloned() + }) + .map(|f| f.map(|f| f.distance(spatial, point.into()))) + .collect::>>(); - Ok(serialize(output)?.into()) + Ok(serialize(output)?.into()) + }); } pub fn field_normal_flex( node: &Node, calling_client: Arc, message: Message, - ) -> Result { - let (point, fields): (Vector3, Vec>) = deserialize(message.as_ref())?; - let spatial = node.spatial.get().unwrap(); + response: MethodResponseSender, + ) { + response.wrap_sync(move || { + let (point, fields): (Vector3, Vec>) = deserialize(message.as_ref())?; + let spatial = node.spatial.get().unwrap(); - let output = fields - .into_iter() - .map(|f| { - calling_client - .get_node("Field", f?) - .ok()? - .get_aspect("Field", "field", |n| &n.field) - .ok() - .cloned() - }) - .map(|f| f.map(|f| Vector3::from(f.normal(spatial, point.into(), 0.001)))) - .collect::>(); + let output = fields + .into_iter() + .map(|f| { + calling_client + .get_node("Field", f?) + .ok()? + .get_aspect("Field", "field", |n| &n.field) + .ok() + .cloned() + }) + .map(|f| f.map(|f| Vector3::from(f.normal(spatial, point.into(), 0.001)))) + .collect::>(); - Ok(serialize(output)?.into()) + Ok(serialize(output)?.into()) + }); } pub fn field_closest_point_flex( node: &Node, calling_client: Arc, message: Message, - ) -> Result { - let (point, fields): (Vector3, Vec>) = deserialize(message.as_ref())?; - let spatial = node.spatial.get().unwrap(); + response: MethodResponseSender, + ) { + response.wrap_sync(move || { + let (point, fields): (Vector3, Vec>) = deserialize(message.as_ref())?; + let spatial = node.spatial.get().unwrap(); - let output = fields - .into_iter() - .map(|f| { - calling_client - .get_node("Field", f?) - .ok()? - .get_aspect("Field", "field", |n| &n.field) - .ok() - .cloned() - }) - .map(|f| f.map(|f| Vector3::from(f.closest_point(spatial, point.into(), 0.001)))) - .collect::>(); + let output = fields + .into_iter() + .map(|f| { + calling_client + .get_node("Field", f?) + .ok()? + .get_aspect("Field", "field", |n| &n.field) + .ok() + .cloned() + }) + .map(|f| f.map(|f| Vector3::from(f.closest_point(spatial, point.into(), 0.001)))) + .collect::>(); - Ok(serialize(output)?.into()) + Ok(serialize(output)?.into()) + }); } #[instrument] diff --git a/src/nodes/startup.rs b/src/nodes/startup.rs index 6968319..0275539 100644 --- a/src/nodes/startup.rs +++ b/src/nodes/startup.rs @@ -1,6 +1,10 @@ #[cfg(feature = "xwayland")] use crate::wayland::xwayland::DISPLAY; -use crate::{core::client::Client, wayland::WAYLAND_DISPLAY, STARDUST_INSTANCE}; +use crate::{ + core::{client::Client, scenegraph::MethodResponseSender}, + wayland::WAYLAND_DISPLAY, + STARDUST_INSTANCE, +}; use super::{ items::{ItemAcceptor, TypeInfo}, @@ -65,13 +69,16 @@ impl StartupSettings { node: &Node, _calling_client: Arc, _message: Message, - ) -> Result { - let id = nanoid::nanoid!(); - let data = serialize(&id)?; - STARTUP_SETTINGS - .lock() - .insert(id, node.startup_settings.get().unwrap().lock().clone()); - Ok(data.into()) + response: MethodResponseSender, + ) { + response.wrap_sync(move || { + let id = nanoid::nanoid!(); + let data = serialize(&id)?; + STARTUP_SETTINGS + .lock() + .insert(id, node.startup_settings.get().unwrap().lock().clone()); + Ok(data.into()) + }); } } impl Debug for StartupSettings { @@ -136,20 +143,23 @@ pub fn get_connection_environment_flex( _node: &Node, _calling_client: Arc, _message: Message, -) -> Result { - let mut env: FxHashMap = FxHashMap::default(); - var_env_insert!(env, STARDUST_INSTANCE); - #[cfg(feature = "wayland")] - { - var_env_insert!(env, WAYLAND_DISPLAY); - #[cfg(feature = "xwayland")] - var_env_insert!(env, DISPLAY); - env.insert("GDK_BACKEND".to_string(), "wayland".to_string()); - env.insert("QT_QPA_PLATFORM".to_string(), "wayland".to_string()); - env.insert("MOZ_ENABLE_WAYLAND".to_string(), "1".to_string()); - env.insert("CLUTTER_BACKEND".to_string(), "wayland".to_string()); - env.insert("SDL_VIDEODRIVER".to_string(), "wayland".to_string()); - } + response: MethodResponseSender, +) { + response.wrap_sync(move || { + let mut env: FxHashMap = FxHashMap::default(); + var_env_insert!(env, STARDUST_INSTANCE); + #[cfg(feature = "wayland")] + { + var_env_insert!(env, WAYLAND_DISPLAY); + #[cfg(feature = "xwayland")] + var_env_insert!(env, DISPLAY); + env.insert("GDK_BACKEND".to_string(), "wayland".to_string()); + env.insert("QT_QPA_PLATFORM".to_string(), "wayland".to_string()); + env.insert("MOZ_ENABLE_WAYLAND".to_string(), "1".to_string()); + env.insert("CLUTTER_BACKEND".to_string(), "wayland".to_string()); + env.insert("SDL_VIDEODRIVER".to_string(), "wayland".to_string()); + } - Ok(serialize(env)?.into()) + Ok(serialize(env)?.into()) + }); }