diff --git a/codegen/src/lib.rs b/codegen/src/lib.rs index 7c297dc..19b2a3e 100644 --- a/codegen/src/lib.rs +++ b/codegen/src/lib.rs @@ -306,7 +306,7 @@ fn generate_member(member: &Member) -> TokenStream { (Side::Server, MemberType::Method) => { quote! { #[doc = #description] - fn #name(#argument_decls) -> impl std::future::Future)>> + Send + 'static; + fn #name(#argument_decls) -> impl std::future::Future> + Send + 'static; } } (Side::Server, MemberType::Signal) => { @@ -375,7 +375,7 @@ fn generate_handler(member: &Member) -> TokenStream { node.add_local_method(#member_name, |_node, _calling_client, _message, _method_response| { _method_response.wrap_async(async move { #deserialize - Self::#member_name_ident(_node, _calling_client.clone(), #argument_uses).await + Ok((Self::#member_name_ident(_node, _calling_client.clone(), #argument_uses).await?, Vec::new())) }); }); }, diff --git a/src/nodes/data.rs b/src/nodes/data.rs index 26c29aa..3a5b488 100644 --- a/src/nodes/data.rs +++ b/src/nodes/data.rs @@ -1,24 +1,20 @@ use super::alias::AliasInfo; -use super::fields::Field; -use super::spatial::{parse_transform, Spatial}; -use super::{Alias, Message, Node}; +use super::fields::get_field; +use super::spatial::{get_spatial, parse_transform, Spatial}; +use super::{Alias, Node}; use crate::core::client::Client; use crate::core::node_collections::LifeLinkedNodeMap; use crate::core::registry::Registry; -use crate::core::scenegraph::MethodResponseSender; -use crate::nodes::fields::{find_field, FIELD_ALIAS_INFO}; -use crate::nodes::spatial::{find_spatial_parent, Transform}; +use crate::create_interface; +use crate::nodes::fields::FIELD_ALIAS_INFO; +use crate::nodes::spatial::Transform; use color_eyre::eyre::{bail, ensure, eyre, Result}; -use glam::vec3a; use lazy_static::lazy_static; -use mint::{Quaternion, Vector3}; use nanoid::nanoid; use parking_lot::Mutex; use rustc_hash::FxHashMap; -use serde::{Deserialize, Serialize}; -use stardust_xr::schemas::flex::{deserialize, flexbuffers, serialize}; - -use std::fmt::Display; +use stardust_xr::schemas::flex::flexbuffers; +use stardust_xr::values::Datamap; use std::sync::{Arc, Weak}; lazy_static! { @@ -28,11 +24,17 @@ lazy_static! { static PULSE_SENDER_REGISTRY: Registry = Registry::new(); pub static PULSE_RECEIVER_REGISTRY: Registry = Registry::new(); -pub fn mask_matches(mask_map_lesser: &Mask, mask_map_greater: &Mask) -> bool { +pub fn get_mask(datamap: &Datamap) -> Result> { + flexbuffers::Reader::get_root(datamap.raw().as_slice()) + .map_err(|_| eyre!("Mask is not a valid flexbuffer"))? + .get_map() + .map_err(|_| eyre!("Mask is not a valid map")) +} +pub fn mask_matches(mask_map_lesser: &Datamap, mask_map_greater: &Datamap) -> bool { (|| -> Result<_> { - for key in mask_map_lesser.get_mask()?.iter_keys() { - let lesser_key = mask_map_lesser.get_mask()?.index(key)?; - let greater_key = mask_map_greater.get_mask()?.index(key)?; + for key in get_mask(mask_map_lesser)?.iter_keys() { + let lesser_key = get_mask(mask_map_lesser)?.index(key)?; + let greater_key = get_mask(mask_map_greater)?.index(key)?; // otherwise zero-length vectors don't count the same as a single type vector if lesser_key.flexbuffer_type().is_heterogenous_vector() && lesser_key.as_vector().len() == 0 @@ -51,57 +53,27 @@ pub fn mask_matches(mask_map_lesser: &Mask, mask_map_greater: &Mask) -> bool { .is_ok() } -pub struct Mask(pub Vec); -impl Mask { - pub fn from_struct() -> Self { - let mut serializer = flexbuffers::FlexbufferSerializer::new(); - T::default().serialize(&mut serializer).unwrap(); - Mask(serializer.take_buffer()) - } - pub fn get_mask(&self) -> Result> { - flexbuffers::Reader::get_root(self.0.as_slice()) - .map_err(|_| eyre!("Mask is not a valid flexbuffer"))? - .get_map() - .map_err(|_| eyre!("Mask is not a valid map")) - } -} -impl Display for Mask { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - flexbuffers::Reader::get_root(self.0.as_slice()) - .unwrap() - .to_string() - .fmt(f) - } -} - -#[derive(Serialize, Deserialize)] -struct SendDataInfo<'a> { - uid: &'a str, - data: Vec, -} +stardust_xr_server_codegen::codegen_data_protocol!(); pub struct PulseSender { - uid: String, node: Weak, - pub mask: Mask, + pub mask: Datamap, aliases: LifeLinkedNodeMap, } impl PulseSender { - pub fn add_to(node: &Arc, mask: Mask) -> Result> { + pub fn add_to(node: &Arc, mask: Datamap) -> Result> { ensure!( node.spatial.get().is_some(), "Internal: Node does not have a spatial attached!" ); let sender = PulseSender { - uid: nanoid!(), node: Arc::downgrade(node), mask, aliases: LifeLinkedNodeMap::default(), }; let sender = PULSE_SENDER_REGISTRY.add(sender); let _ = node.pulse_sender.set(sender.clone()); - node.add_local_signal("send_data", PulseSender::send_data_flex); for receiver in PULSE_RECEIVER_REGISTRY.get_valid_contents() { sender.handle_new_receiver(&receiver); } @@ -127,54 +99,28 @@ impl PulseSender { receiver.uid.as_str(), &rx_node, AliasInfo { - server_methods: vec!["sendData", "getTransform"], + server_methods: vec!["send_data"], ..Default::default() }, ); - if let Ok(rx_alias) = rx_alias { - self.aliases.add(receiver.uid.clone(), &rx_alias); + let Ok(rx_alias) = rx_alias else { return }; + self.aliases.add(receiver.uid.clone(), &rx_alias); - if let Some(rx_field_node) = receiver.field.spatial_ref().node.upgrade() { - // Receiver's field - let rx_field_alias = Alias::create( - &tx_client, - rx_alias.get_path(), - "field", - &rx_field_node, - FIELD_ALIAS_INFO.clone(), - ); - if let Ok(rx_field_alias) = rx_field_alias { - self.aliases - .add(receiver.uid.clone() + "-field", &rx_field_alias); - } - } - } - - #[derive(Serialize)] - struct NewReceiverInfo<'a> { - uid: &'a str, - distance: f32, - position: Vector3, - rotation: Quaternion, - } - - let (_, rotation, position) = Spatial::space_to_space_matrix( - rx_node.spatial.get().map(|s| s.as_ref()), - tx_node.spatial.get().map(|s| s.as_ref()), - ) - .to_scale_rotation_translation(); - - let info = NewReceiverInfo { - uid: &receiver.uid, - distance: receiver - .field - .distance(tx_node.spatial.get().unwrap(), vec3a(0.0, 0.0, 0.0)), - position: position.into(), - rotation: rotation.into(), + // Receiver's field + let Ok(rx_field_alias) = Alias::create( + &tx_client, + rx_alias.get_path(), + "field", + &rx_node.pulse_receiver.get().unwrap().field_node, + FIELD_ALIAS_INFO.clone(), + ) else { + return; }; + self.aliases + .add(receiver.uid.clone() + "-field", &rx_field_alias); - let Ok(data) = serialize(info) else { return }; - let _ = tx_node.send_remote_signal("new_receiver", data); + let _ = + pulse_sender_client::new_receiver(&tx_node, &receiver.uid, &rx_alias, &rx_field_alias); } fn handle_drop_receiver(&self, receiver: &PulseReceiver) { @@ -184,36 +130,10 @@ impl PulseSender { let Some(tx_node) = self.node.upgrade() else { return; }; - let Ok(data) = serialize(&uid) else { return }; - let _ = tx_node.send_remote_signal("drop_receiver", data); - } - - fn send_data_flex( - node: Arc, - calling_client: Arc, - message: Message, - ) -> Result<()> { - let info: SendDataInfo = deserialize(message.as_ref())?; - let receiver_node = calling_client.get_node("Pulse receiver", info.uid)?; - let receiver = - receiver_node.get_aspect("Pulse Receiver", "pulse receiver", |n| &n.pulse_receiver)?; - let receiver_mask = &receiver_node - .get_aspect("Pulse receiver", "pulse receiver", |node| { - &node.pulse_receiver - })? - .mask; - - let data_mask = Mask(info.data); - data_mask.get_mask()?; - ensure!( - mask_matches(receiver_mask, &data_mask), - "Message ({}) does not contain the same keys as the receiver's mask ({})", - data_mask, - receiver_mask - ); - receiver.send_data(&node.pulse_sender.get().unwrap().uid, data_mask.0) + let _ = pulse_sender_client::drop_receiver(&tx_node, uid); } } +impl PulseSenderAspect for PulseSender {} impl Drop for PulseSender { fn drop(&mut self) { PULSE_SENDER_REGISTRY.remove(self); @@ -223,11 +143,15 @@ impl Drop for PulseSender { pub struct PulseReceiver { uid: String, pub node: Weak, - pub field: Arc, - pub mask: Mask, + pub field_node: Arc, + pub mask: Datamap, } impl PulseReceiver { - pub fn add_to(node: &Arc, field: Arc, mask: Mask) -> Result> { + pub fn add_to( + node: &Arc, + field_node: Arc, + mask: Datamap, + ) -> Result> { ensure!( node.spatial.get().is_some(), "Internal: Node does not have a spatial attached!" @@ -236,7 +160,7 @@ impl PulseReceiver { let receiver = PulseReceiver { uid: nanoid!(), node: Arc::downgrade(node), - field, + field_node, mask, }; let receiver = PULSE_RECEIVER_REGISTRY.add(receiver); @@ -247,15 +171,25 @@ impl PulseReceiver { let _ = node.pulse_receiver.set(receiver.clone()); Ok(receiver) } +} +impl PulseReceiverAspect for PulseReceiver { + fn send_data( + node: Arc, + _calling_client: Arc, + sender: Arc, + data: Datamap, + ) -> Result<()> { + let this_receiver = node.pulse_receiver.get().unwrap(); - pub fn send_data(&self, uid: &str, data: Vec) -> Result<()> { - if let Some(node) = self.node.upgrade() { - node.send_remote_signal("data", serialize(SendDataInfo { uid, data })?)?; - } + ensure!( + mask_matches(&this_receiver.mask, &data), + "Message ({data:?}) does not contain the same keys as the receiver's mask ({:?})", + this_receiver.mask + ); + pulse_receiver_client::data(&node, &sender.uid, &data)?; Ok(()) } } - impl Drop for PulseReceiver { fn drop(&mut self) { PULSE_RECEIVER_REGISTRY.remove(self); @@ -265,76 +199,64 @@ impl Drop for PulseReceiver { } } -pub fn create_interface(client: &Arc) -> Result<()> { - let node = Node::create_parent_name(client, "", "data", false); - node.add_local_signal("create_pulse_sender", create_pulse_sender_flex); - node.add_local_signal("create_pulse_receiver", create_pulse_receiver_flex); - node.add_local_method("register_keymap", register_keymap_flex); - node.add_local_method("get_keymap", get_keymap_flex); - node.add_to_scenegraph().map(|_| ()) -} - -pub fn create_pulse_sender_flex( - _node: Arc, - calling_client: Arc, - message: Message, -) -> Result<()> { - #[derive(Deserialize)] - struct CreatePulseSenderInfo<'a> { - name: &'a str, - parent_path: &'a str, +create_interface!(DataInterface, DataInterfaceAspect, "/data"); +struct DataInterface; +impl DataInterfaceAspect for DataInterface { + fn create_pulse_sender( + _node: Arc, + calling_client: Arc, + name: String, + parent: Arc, transform: Transform, - mask: Vec, + mask: Datamap, + ) -> Result<()> { + get_mask(&mask)?; + let node = Node::create_parent_name( + &calling_client, + Self::CREATE_PULSE_SENDER_PARENT_PATH, + &name, + true, + ); + let parent = get_spatial(&parent, "Spatial parent")?; + let transform = transform.to_mat4(true, true, false); + + let node = node.add_to_scenegraph()?; + Spatial::add_to(&node, Some(parent), transform, false)?; + PulseSender::add_to(&node, mask)?; + Ok(()) } - let info: CreatePulseSenderInfo = deserialize(message.as_ref())?; - let node = Node::create_parent_name(&calling_client, "/data/sender", info.name, true); - let parent = find_spatial_parent(&calling_client, info.parent_path)?; - let transform = parse_transform(info.transform, true, true, false); - let mask = Mask(info.mask); - mask.get_mask()?; - - let node = node.add_to_scenegraph()?; - Spatial::add_to(&node, Some(parent), transform, false)?; - PulseSender::add_to(&node, mask)?; - Ok(()) -} - -pub fn create_pulse_receiver_flex( - _node: Arc, - calling_client: Arc, - message: Message, -) -> Result<()> { - #[derive(Deserialize)] - struct CreatePulseReceiverInfo<'a> { - name: &'a str, - parent_path: &'a str, + fn create_pulse_receiver( + _node: Arc, + calling_client: Arc, + name: String, + parent: Arc, transform: Transform, - field_path: &'a str, - mask: Vec, + field: Arc, + mask: Datamap, + ) -> Result<()> { + get_mask(&mask)?; + let node = Node::create_parent_name( + &calling_client, + Self::CREATE_PULSE_RECEIVER_PARENT_PATH, + &name, + true, + ); + let parent = get_spatial(&parent, "Spatial parent")?; + let transform = parse_transform(transform, true, true, false); + get_field(&field)?; + + let node = node.add_to_scenegraph()?; + Spatial::add_to(&node, Some(parent), transform, false)?; + PulseReceiver::add_to(&node, field, mask)?; + Ok(()) } - let info: CreatePulseReceiverInfo = deserialize(message.as_ref())?; - let node = Node::create_parent_name(&calling_client, "/data/receiver", info.name, true); - let parent = find_spatial_parent(&calling_client, info.parent_path)?; - let transform = parse_transform(info.transform, true, true, false); - let field = find_field(&calling_client, info.field_path)?; - let mask = Mask(info.mask); - mask.get_mask()?; - let node = node.add_to_scenegraph()?; - Spatial::add_to(&node, Some(parent), transform, false)?; - PulseReceiver::add_to(&node, field, mask)?; - Ok(()) -} - -pub fn register_keymap_flex( - _node: Arc, - _calling_client: Arc, - message: Message, - response: MethodResponseSender, -) { - response.wrap_sync(move || { - let keymap: String = deserialize(message.as_ref())?; + async fn register_keymap( + _node: Arc, + _calling_client: Arc, + keymap: String, + ) -> Result { let mut keymaps = KEYMAPS.lock(); if let Some(found_keymap_id) = keymaps .iter() @@ -342,28 +264,25 @@ pub fn register_keymap_flex( .map(|(k, _v)| k) .last() { - return Ok(serialize(found_keymap_id)?.into()); + return Ok(found_keymap_id.clone()); } let generated_id = nanoid!(); keymaps.insert(generated_id.clone(), keymap); - Ok(serialize(generated_id)?.into()) - }); -} -pub fn get_keymap_flex( - _node: Arc, - _calling_client: Arc, - message: Message, - response: MethodResponseSender, -) { - response.wrap_sync(move || { - let keymap_id: &str = deserialize(message.as_ref())?; + Ok(generated_id) + } + + async fn get_keymap( + _node: Arc, + _calling_client: Arc, + keymap_id: String, + ) -> Result { let keymaps = KEYMAPS.lock(); - let Some(keymap) = keymaps.get(keymap_id) else { + let Some(keymap) = keymaps.get(&keymap_id) else { bail!("Could not find keymap. Try registering it") }; - Ok(serialize(keymap)?.into()) - }); + Ok(keymap.clone()) + } } diff --git a/src/nodes/fields/mod.rs b/src/nodes/fields/mod.rs index c2275f7..10b5f91 100644 --- a/src/nodes/fields/mod.rs +++ b/src/nodes/fields/mod.rs @@ -16,10 +16,9 @@ use crate::create_interface; use crate::nodes::spatial::Transform; use color_eyre::eyre::Result; use glam::{vec2, vec3a, Mat4, Vec3, Vec3A}; +use mint::Vector3; use once_cell::sync::Lazy; - use std::ops::Deref; -use std::os::fd::OwnedFd; use std::sync::Arc; // TODO: get SDFs working properly with non-uniform scale and so on, output distance relative to the spatial it's compared against @@ -108,74 +107,58 @@ pub trait FieldTrait { result } } -impl FieldAspect for Fi { - fn distance( +impl FieldAspect for Fi { + async fn distance( node: Arc, _calling_client: Arc, space: Arc, point: mint::Vector3, - ) -> impl std::future::Future)>> + Send + 'static { - async move { - let reference_space = get_spatial(&space, "Reference space")?; - let this_field = node.field.get().unwrap(); - - let distance = this_field.distance(reference_space.as_ref(), point.into()); - Ok((distance, Vec::new())) - } + ) -> Result { + let reference_space = get_spatial(&space, "Reference space")?; + let this_field = node.field.get().unwrap(); + Ok(this_field.distance(reference_space.as_ref(), point.into())) } - fn normal( + async fn normal( node: Arc, _calling_client: Arc, space: Arc, point: mint::Vector3, - ) -> impl std::future::Future, Vec)>> + Send + 'static - { - async move { - let reference_space = get_spatial(&space, "Reference space")?; - let this_field = node.field.get().unwrap(); - - let normal = this_field.normal(reference_space.as_ref(), point.into(), 0.001); - Ok((normal.into(), Vec::new())) - } + ) -> Result> { + let reference_space = get_spatial(&space, "Reference space")?; + let this_field = node.field.get().unwrap(); + Ok(this_field + .normal(reference_space.as_ref(), point.into(), 0.001) + .into()) } - fn closest_point( + async fn closest_point( node: Arc, _calling_client: Arc, space: Arc, point: mint::Vector3, - ) -> impl std::future::Future, Vec)>> + Send + 'static - { - async move { - let reference_space = get_spatial(&space, "Reference space")?; - let this_field = node.field.get().unwrap(); - - let closest_point = - this_field.closest_point(reference_space.as_ref(), point.into(), 0.001); - Ok((closest_point.into(), Vec::new())) - } + ) -> Result> { + let reference_space = get_spatial(&space, "Reference space")?; + let this_field = node.field.get().unwrap(); + Ok(this_field + .closest_point(reference_space.as_ref(), point.into(), 0.001) + .into()) } - fn ray_march( + async fn ray_march( node: Arc, _calling_client: Arc, space: Arc, ray_origin: mint::Vector3, ray_direction: mint::Vector3, - ) -> impl std::future::Future)>> + Send + 'static - { - async move { - let reference_space = get_spatial(&space, "Reference space")?; - let this_field = node.field.get().unwrap(); - - let ray_march = this_field.ray_march(Ray { - origin: ray_origin.into(), - direction: ray_direction.into(), - space: reference_space, - }); - Ok((ray_march, Vec::new())) - } + ) -> Result { + let reference_space = get_spatial(&space, "Reference space")?; + let this_field = node.field.get().unwrap(); + Ok(this_field.ray_march(Ray { + origin: ray_origin.into(), + direction: ray_direction.into(), + space: reference_space, + })) } } diff --git a/src/nodes/spatial/mod.rs b/src/nodes/spatial/mod.rs index 592eff0..c3c057c 100644 --- a/src/nodes/spatial/mod.rs +++ b/src/nodes/spatial/mod.rs @@ -13,7 +13,6 @@ use nanoid::nanoid; use once_cell::sync::OnceCell; use parking_lot::Mutex; use std::fmt::Debug; -use std::os::fd::OwnedFd; use std::ptr; use std::sync::{Arc, Weak}; use stereokit::{bounds_grow_to_fit_box, Bounds}; @@ -244,85 +243,75 @@ impl Spatial { } } impl SpatialAspect for Spatial { - fn get_local_bounding_box( + async fn get_local_bounding_box( node: Arc, _calling_client: Arc, - ) -> impl std::future::Future)>> + Send + 'static { - async move { - let this_spatial = node - .spatial - .get() - .ok_or_else(|| eyre!("Node doesn't have a spatial?"))?; - let bounds = this_spatial.get_bounding_box(); + ) -> Result { + let this_spatial = node + .spatial + .get() + .ok_or_else(|| eyre!("Node doesn't have a spatial?"))?; + let bounds = this_spatial.get_bounding_box(); - let return_value = BoundingBox { - center: mint::Vector3::from(bounds.center), - size: mint::Vector3::from(bounds.dimensions), - }; - Ok((return_value, Vec::new())) - } + Ok(BoundingBox { + center: mint::Vector3::from(bounds.center), + size: mint::Vector3::from(bounds.dimensions), + }) } - fn get_relative_bounding_box( + async fn get_relative_bounding_box( node: Arc, _calling_client: Arc, relative_to: Arc, - ) -> impl std::future::Future)>> + Send + 'static { - async move { - let this_spatial = node - .spatial - .get() - .ok_or_else(|| eyre!("Node doesn't have a spatial?"))?; - let relative_spatial = get_spatial(&relative_to, "Relative node")?; - let center = - Spatial::space_to_space_matrix(Some(&this_spatial), Some(&relative_spatial)) - .transform_point3([0.0; 3].into()); - let 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), - )), - ); + ) -> Result { + let this_spatial = node + .spatial + .get() + .ok_or_else(|| eyre!("Node doesn't have a spatial?"))?; + let relative_spatial = get_spatial(&relative_to, "Relative node")?; + let center = Spatial::space_to_space_matrix(Some(&this_spatial), Some(&relative_spatial)) + .transform_point3([0.0; 3].into()); + let 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), + )), + ); - let return_value = BoundingBox { - center: mint::Vector3::from(bounds.center), - size: mint::Vector3::from(bounds.dimensions), - }; - Ok((return_value, Vec::new())) - } + Ok(BoundingBox { + center: mint::Vector3::from(bounds.center), + size: mint::Vector3::from(bounds.dimensions), + }) } - fn get_transform( + async fn get_transform( node: Arc, _calling_client: Arc, relative_to: Arc, - ) -> impl std::future::Future)>> + Send + 'static { - async move { - let this_spatial = node - .spatial - .get() - .ok_or_else(|| eyre!("Node doesn't have a spatial?"))?; - let relative_spatial = get_spatial(&relative_to, "Relative node")?; + ) -> Result { + let this_spatial = node + .spatial + .get() + .ok_or_else(|| eyre!("Node doesn't have a spatial?"))?; + let relative_spatial = get_spatial(&relative_to, "Relative node")?; - 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(); - let return_value = Transform { - translation: Some(position.into()), - rotation: Some(rotation.into()), - scale: Some(scale.into()), - }; - Ok((return_value, Vec::new())) - } + Ok(Transform { + translation: Some(position.into()), + rotation: Some(rotation.into()), + scale: Some(scale.into()), + }) } fn set_local_transform( diff --git a/src/objects/input/mouse_pointer.rs b/src/objects/input/mouse_pointer.rs index 6efa091..7cdc912 100644 --- a/src/objects/input/mouse_pointer.rs +++ b/src/objects/input/mouse_pointer.rs @@ -1,7 +1,9 @@ use crate::{ core::client::INTERNAL_CLIENT, nodes::{ - data::{mask_matches, Mask, PulseSender, KEYMAPS, PULSE_RECEIVER_REGISTRY}, + data::{ + mask_matches, pulse_receiver_client, PulseSender, KEYMAPS, PULSE_RECEIVER_REGISTRY, + }, fields::Ray, input::{pointer::Pointer, InputMethod, InputType}, spatial::Spatial, @@ -69,8 +71,11 @@ impl MousePointer { .get_as_string(FORMAT_TEXT_V1), ); - let keyboard_sender = - PulseSender::add_to(&node, Mask::from_struct::()).unwrap(); + let keyboard_sender = PulseSender::add_to( + &node, + Datamap::from_typed(KeyboardEvent::default()).unwrap(), + ) + .unwrap(); Ok(MousePointer { node, @@ -135,7 +140,7 @@ impl MousePointer { .into_iter() .filter(|rx| mask_matches(&rx.mask, &self.keyboard_sender.mask)) .map(|rx| { - let result = rx.field.ray_march(Ray { + let result = rx.field_node.field.get().unwrap().ray_march(Ray { origin: vec3(0.0, 0.0, 0.0), direction: vec3(0.0, 0.0, -1.0), space: self.spatial.clone(), @@ -171,12 +176,10 @@ impl MousePointer { self.keyboard_datamap.keys = keys; if !self.keyboard_datamap.keys.is_empty() { - rx.send_data( + pulse_receiver_client::data( + &rx.node.upgrade().unwrap(), &self.node.uid, - Datamap::from_typed(&self.keyboard_datamap) - .unwrap() - .raw() - .clone(), + &Datamap::from_typed(&self.keyboard_datamap).unwrap(), ) .unwrap(); } diff --git a/src/objects/play_space.rs b/src/objects/play_space.rs index c47a011..dfff8d5 100644 --- a/src/objects/play_space.rs +++ b/src/objects/play_space.rs @@ -5,12 +5,13 @@ use glam::Mat4; use mint::Vector2; use nanoid::nanoid; use serde::{Deserialize, Serialize}; +use stardust_xr::values::Datamap; use stereokit::StereoKitMultiThread; use crate::{ core::client::INTERNAL_CLIENT, nodes::{ - data::{Mask, PulseReceiver}, + data::PulseReceiver, fields::{r#box::BoxField, Field}, spatial::Spatial, Node, @@ -44,8 +45,11 @@ impl PlaySpace { let spatial = Spatial::add_to(&node, None, Mat4::IDENTITY, false)?; let field = BoxField::add_to(&node, [0.0; 3].into())?; - let pulse_rx = - PulseReceiver::add_to(&node, field.clone(), Mask::from_struct::())?; + let pulse_rx = PulseReceiver::add_to( + &node, + node.clone(), + Datamap::from_typed(PlaySpaceMap::default())?, + )?; Ok(PlaySpace { _node: node,