StardustXR/server
1
0
Fork 0
Code Issues 11 Pull Requests 3 Actions Packages Projects Releases 5 Wiki Activity

feat: fd passing

Browse Source
This commit is contained in:
Nova
2023-07-31 23:44:17 -04:00
parent 4bbe3ad8d0
commit 0736f99631
29 changed files with 484 additions and 309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/nodes/items/environment.rs
View File

@@ -7,7 +7,7 @@ use crate::{
nodes::{
items::TypeInfo,
spatial::{find_spatial_parent, parse_transform, Spatial},
Node,
Message, Node,
},
};
use color_eyre::eyre::{eyre, Result};
@@ -15,7 +15,7 @@ use lazy_static::lazy_static;
use nanoid::nanoid;
use serde::Deserialize;
use stardust_xr::{
schemas::flex::{deserialize, flexbuffers, serialize},
schemas::flex::{deserialize, serialize},
values::Transform,
};
use std::sync::Arc;
@@ -46,22 +46,26 @@ impl EnvironmentItem {
node.add_local_method("get_path", EnvironmentItem::get_path_flex);
}
fn get_path_flex(node: &Node, _calling_client: Arc<Client>, _data: &[u8]) -> Result<Vec<u8>> {
fn get_path_flex(
node: &Node,
_calling_client: Arc<Client>,
_message: Message,
) -> Result<Message> {
let ItemType::Environment(environment_item) = &node.item.get().unwrap().specialization else {
return Err(eyre!("Wrong item type?"))
};
Ok(flexbuffers::singleton(environment_item.path.as_str()))
Ok(serialize(environment_item.path.as_str())?.into())
}
pub fn serialize_start_data(&self, id: &str) -> Result<Vec<u8>> {
serialize((id, self.path.as_str())).map_err(|e| e.into())
pub fn serialize_start_data(&self, id: &str) -> Result<Message> {
Ok(serialize((id, self.path.as_str()))?.into())
}
}
pub(super) fn create_environment_item_flex(
_node: &Node,
calling_client: Arc<Client>,
data: &[u8],
message: Message,
) -> Result<()> {
#[derive(Deserialize)]
struct CreateEnvironmentItemInfo<'a> {
@@ -70,7 +74,7 @@ pub(super) fn create_environment_item_flex(
transform: Transform,
item_data: String,
}
let info: CreateEnvironmentItemInfo = deserialize(data)?;
let info: CreateEnvironmentItemInfo = deserialize(message.as_ref())?;
let parent_name = format!("/item/{}/item", ITEM_TYPE_INFO_ENVIRONMENT.type_name);
let space = find_spatial_parent(&calling_client, info.parent_path)?;
let transform = parse_transform(info.transform, true, true, false);

71
src/nodes/items/mod.rs
View File

@@ -5,7 +5,7 @@ use self::environment::{EnvironmentItem, ITEM_TYPE_INFO_ENVIRONMENT};
use self::panel::{PanelItemTrait, ITEM_TYPE_INFO_PANEL};
use super::fields::Field;
use super::spatial::{find_spatial_parent, parse_transform, Spatial};
use super::{Alias, Node};
use super::{Alias, Message, Node};
use crate::core::client::Client;
use crate::core::node_collections::LifeLinkedNodeMap;
use crate::core::registry::Registry;
@@ -17,7 +17,7 @@ use nanoid::nanoid;
use parking_lot::Mutex;
use portable_atomic::Ordering;
use serde::Deserialize;
use stardust_xr::schemas::flex::{deserialize, flexbuffers, serialize};
use stardust_xr::schemas::flex::{deserialize, serialize};
use stardust_xr::values::Transform;
use std::hash::Hash;
use std::sync::{Arc, Weak};
@@ -153,7 +153,7 @@ impl Item {
self.make_alias_named(client, parent, &self.uid)
}
fn release_flex(node: &Node, _calling_client: Arc<Client>, _data: &[u8]) -> Result<()> {
fn release_flex(node: &Node, _calling_client: Arc<Client>, _message: Message) -> Result<()> {
let item = node.get_aspect("Item", "item", |n| &n.item)?;
release(item, None);
@@ -175,7 +175,7 @@ pub enum ItemType {
Panel(Arc<dyn PanelItemTrait>),
}
impl ItemType {
fn serialize_start_data(&self, id: &str) -> Result<Vec<u8>> {
fn serialize_start_data(&self, id: &str) -> Result<Message> {
match self {
ItemType::Environment(e) => e.serialize_start_data(id),
ItemType::Panel(p) => p.serialize_start_data(id),
@@ -226,47 +226,44 @@ impl ItemUI {
Ok(())
}
fn send_state(&self, state: &str, name: &str) {
let Ok(serialized_data) = serialize(name) else {return};
let _ = self
.node
.upgrade()
.unwrap()
.send_remote_signal(state, flexbuffers::singleton(name).as_slice());
.send_remote_signal(state, serialized_data);
}
fn handle_create_item(&self, item: &Item) {
let Some(node) = self.node.upgrade() else { return };
let Some(client) = node.get_client() else { return };
let Some(node) = self.node.upgrade() else {return};
let Some(client) = node.get_client() else {return};
if let Ok(alias_node) = item.make_alias(&client, &(node.get_path().to_string() + "/item")) {
self.item_aliases.add(item.uid.clone(), &alias_node);
}
let Ok(serialized_data) = item.specialization.serialize_start_data(&item.uid) else {return};
let _ = node.send_remote_signal("create_item", &serialized_data);
let _ = node.send_remote_signal("create_item", serialized_data);
}
fn handle_destroy_item(&self, item: &Item) {
self.item_aliases.remove(&item.uid);
self.send_state("destroy_item", item.uid.as_str());
}
fn handle_capture_item(&self, item: &Item, acceptor: &ItemAcceptor) {
let Some(node) = self.node.upgrade() else { return };
let Some(node) = self.node.upgrade() else {return};
let _ = node.send_remote_signal(
"capture_item",
&serialize((item.uid.as_str(), acceptor.uid.as_str())).unwrap(),
);
let Ok(message) = serialize((item.uid.as_str(), acceptor.uid.as_str())) else {return};
let _ = node.send_remote_signal("capture_item", message);
}
fn handle_release_item(&self, item: &Item, acceptor: &ItemAcceptor) {
let Some(node) = self.node.upgrade() else { return };
let Some(node) = self.node.upgrade() else {return};
let _ = node.send_remote_signal(
"release_item",
&serialize((item.uid.as_str(), acceptor.uid.as_str())).unwrap(),
);
let Ok(message) = serialize((item.uid.as_str(), acceptor.uid.as_str())) else {return};
let _ = node.send_remote_signal("release_item", message);
}
fn handle_create_acceptor(&self, acceptor: &ItemAcceptor) {
let Some(node) = self.node.upgrade() else { return };
let Some(client) = node.get_client() else { return };
let Some(node) = self.node.upgrade() else {return};
let Some(client) = node.get_client() else {return};
let Ok((alias, field_alias)) = acceptor.make_aliases(
&client,
@@ -275,7 +272,8 @@ impl ItemUI {
self.acceptor_aliases.add(acceptor.uid.clone(), &alias);
self.acceptor_field_aliases
.add(acceptor.uid.clone(), &field_alias);
let _ = node.send_remote_signal("create_acceptor", &serialize(&acceptor.uid).unwrap());
let Ok(message) = serialize(&acceptor.uid) else {return};
let _ = node.send_remote_signal("create_acceptor", message);
}
fn handle_destroy_acceptor(&self, acceptor: &ItemAcceptor) {
self.send_state("destroy_acceptor", acceptor.uid.as_str());
@@ -314,13 +312,13 @@ impl ItemAcceptor {
let _ = node.item_acceptor.set(acceptor);
}
fn capture_flex(node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
fn capture_flex(node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
if !node.enabled.load(Ordering::Relaxed) {
return Ok(());
}
let acceptor = node.item_acceptor.get().unwrap();
let item_path: &str = deserialize(data)?;
let item_path: &str = deserialize(message.as_ref())?;
let item_node = calling_client.get_node("Item", item_path)?;
let item = item_node.get_aspect("Item", "item", |n| &n.item)?;
capture(item, acceptor);
@@ -352,8 +350,8 @@ impl ItemAcceptor {
Ok((acceptor_alias, acceptor_field_alias))
}
fn handle_capture(&self, item: &Arc<Item>) {
let Some(node) = self.node.upgrade() else { return };
let Some(client) = node.get_client() else { return };
let Some(node) = self.node.upgrade() else {return};
let Some(client) = node.get_client() else {return};
self.accepted_registry.add_raw(item);
if let Ok(alias_node) = item.make_alias(&client, &node.path) {
@@ -361,14 +359,15 @@ impl ItemAcceptor {
}
let Ok(serialized_data) = item.specialization.serialize_start_data(&item.uid) else {return};
let _ = node.send_remote_signal("capture", &serialized_data);
let _ = node.send_remote_signal("capture", serialized_data);
}
fn handle_release(&self, item: &Item) {
let Some(node) = self.node.upgrade() else { return };
let Some(node) = self.node.upgrade() else {return};
self.accepted_registry.remove(item);
self.accepted_aliases.remove(&item.uid);
let _ = node.send_remote_signal("release", &serialize(&item.uid).unwrap());
let Ok(message) = serialize(&item.uid) else {return};
let _ = node.send_remote_signal("release", message);
}
}
impl Drop for ItemAcceptor {
@@ -403,12 +402,16 @@ fn type_info(name: &str) -> Result<&'static TypeInfo> {
}
}
pub fn register_item_ui_flex(_node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
pub fn register_item_ui_flex(
_node: &Node,
calling_client: Arc<Client>,
message: Message,
) -> Result<()> {
#[derive(Deserialize)]
struct RegisterItemUIInfo<'a> {
item_type: &'a str,
}
let info: RegisterItemUIInfo = deserialize(data)?;
let info: RegisterItemUIInfo = deserialize(message.as_ref())?;
let type_info = type_info(info.item_type)?;
let ui =
Node::create(&calling_client, "/item", type_info.type_name, true).add_to_scenegraph()?;
@@ -416,7 +419,11 @@ pub fn register_item_ui_flex(_node: &Node, calling_client: Arc<Client>, data: &[
Ok(())
}
fn create_item_acceptor_flex(_node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
fn create_item_acceptor_flex(
_node: &Node,
calling_client: Arc<Client>,
message: Message,
) -> Result<()> {
#[derive(Deserialize)]
struct CreateItemAcceptorInfo<'a> {
name: &'a str,
@@ -425,7 +432,7 @@ fn create_item_acceptor_flex(_node: &Node, calling_client: Arc<Client>, data: &[
field_path: &'a str,
item_type: &'a str,
}
let info: CreateItemAcceptorInfo = deserialize(data)?;
let info: CreateItemAcceptorInfo = deserialize(message.as_ref())?;
let space = 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)?;

75
src/nodes/items/panel.rs
View File

@@ -7,7 +7,7 @@ use crate::{
drawable::{model::ModelPart, Drawable},
items::{self, Item, ItemType, TypeInfo},
spatial::Spatial,
Node,
Message, Node,
},
};
use color_eyre::eyre::{bail, eyre, Result};
@@ -129,8 +129,8 @@ pub enum RecommendedState {
}
pub trait Backend: Send + Sync + 'static {
fn serialize_start_data(&self, id: &str) -> Result<Vec<u8>>;
fn serialize_toplevel(&self) -> Result<Vec<u8>>;
fn serialize_start_data(&self, id: &str) -> Result<Message>;
fn serialize_toplevel(&self) -> Result<Message>;
fn set_toplevel_capabilities(&self, capabilities: Vec<u8>);
fn configure_toplevel(
&self,
@@ -244,7 +244,7 @@ impl<B: Backend + ?Sized> PanelItem<B> {
fn apply_surface_material_flex(
node: &Node,
calling_client: Arc<Client>,
data: &[u8],
message: Message,
) -> Result<()> {
let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
@@ -254,7 +254,7 @@ impl<B: Backend + ?Sized> PanelItem<B> {
model_node_path: &'a str,
}
let info: SurfaceMaterialInfo = deserialize(data)?;
let info: SurfaceMaterialInfo = deserialize(message.as_ref())?;
let model_node = calling_client
.scenegraph
@@ -268,26 +268,38 @@ impl<B: Backend + ?Sized> PanelItem<B> {
Ok(())
}
fn pointer_motion_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
fn pointer_motion_flex(
node: &Node,
_calling_client: Arc<Client>,
message: Message,
) -> Result<()> {
let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
let (surface_id, position): (SurfaceID, Vector2<f32>) = deserialize(data)?;
let (surface_id, position): (SurfaceID, Vector2<f32>) = deserialize(message.as_ref())?;
debug!(?surface_id, ?position, "Pointer deactivate");
panel_item.pointer_motion(&surface_id, position);
Ok(())
}
fn pointer_button_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
fn pointer_button_flex(
node: &Node,
_calling_client: Arc<Client>,
message: Message,
) -> Result<()> {
let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
let (surface_id, button, state): (SurfaceID, u32, u32) = deserialize(data)?;
let (surface_id, button, state): (SurfaceID, u32, u32) = deserialize(message.as_ref())?;
debug!(?surface_id, button, state, "Pointer button");
panel_item.pointer_button(&surface_id, button, state == 0);
Ok(())
}
fn pointer_scroll_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
fn pointer_scroll_flex(
node: &Node,
_calling_client: Arc<Client>,
message: Message,
) -> Result<()> {
let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
#[derive(Debug, Deserialize)]
@@ -296,7 +308,7 @@ impl<B: Backend + ?Sized> PanelItem<B> {
axis_continuous: Option<Vector2<f32>>,
axis_discrete: Option<Vector2<f32>>,
}
let info: PointerScrollInfo = deserialize(data)?;
let info: PointerScrollInfo = deserialize(message.as_ref())?;
debug!(?info, "Pointer scroll");
panel_item.pointer_scroll(&info.surface_id, info.axis_continuous, info.axis_discrete);
@@ -307,9 +319,9 @@ impl<B: Backend + ?Sized> PanelItem<B> {
fn keyboard_set_keymap_string_flex(
node: &Node,
_calling_client: Arc<Client>,
data: &[u8],
message: Message,
) -> Result<()> {
let keymap_string: &str = deserialize(data)?;
let keymap_string: &str = deserialize(message.as_ref())?;
let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
debug!("Keyboard set keymap");
@@ -320,7 +332,7 @@ impl<B: Backend + ?Sized> PanelItem<B> {
// fn keyboard_set_keymap_names_flex(
// node: &Node,
// _calling_client: Arc<Client>,
// data: &[u8],
// message: Message,
// ) -> Result<()> {
// #[derive(Debug, Deserialize)]
// struct Names<'a> {
@@ -330,7 +342,7 @@ impl<B: Backend + ?Sized> PanelItem<B> {
// variant: &'a str,
// options: Option<String>,
// }
// let names: Names = deserialize(data)?;
// let names: Names = deserialize(message.as_ref())?;
// let context = xkb::Context::new(0);
// let keymap = Keymap::new_from_names(
// &context,
@@ -363,9 +375,13 @@ impl<B: Backend + ?Sized> PanelItem<B> {
// Ok(())
// }
fn keyboard_key_flex(node: &Node, _calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
fn keyboard_key_flex(
node: &Node,
_calling_client: Arc<Client>,
message: Message,
) -> Result<()> {
let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
let (surface_id, key, state): (SurfaceID, u32, u32) = deserialize(data)?;
let (surface_id, key, state): (SurfaceID, u32, u32) = deserialize(message.as_ref())?;
debug!(key, state, "Set keyboard key state");
panel_item.keyboard_key(&surface_id, key, state == 0);
@@ -373,15 +389,16 @@ impl<B: Backend + ?Sized> PanelItem<B> {
Ok(())
}
pub fn grab_keyboard(&self, sid: Option<SurfaceID>) {
let Some(node) = self.node.upgrade() else { return };
let Some(node) = self.node.upgrade() else {return};
let _ = node.send_remote_signal("grab_keyboard", &serialize(sid).unwrap());
let Ok(message) = serialize(sid) else {return};
let _ = node.send_remote_signal("grab_keyboard", message);
}
fn configure_toplevel_flex(
node: &Node,
_calling_client: Arc<Client>,
data: &[u8],
message: Message,
) -> Result<()> {
let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
@@ -391,7 +408,7 @@ impl<B: Backend + ?Sized> PanelItem<B> {
states: Vec<u32>,
bounds: Option<Vector2<u32>>,
}
let info: ConfigureToplevelInfo = deserialize(data)?;
let info: ConfigureToplevelInfo = deserialize(message.as_ref())?;
panel_item.configure_toplevel(info.size, info.states, info.bounds);
Ok(())
@@ -400,11 +417,11 @@ impl<B: Backend + ?Sized> PanelItem<B> {
fn set_toplevel_capabilities_flex(
node: &Node,
_calling_client: Arc<Client>,
data: &[u8],
message: Message,
) -> Result<()> {
let Some(panel_item) = panel_item_from_node(node) else { return Ok(()) };
let capabilities: Vec<u8> = deserialize(data)?;
let capabilities: Vec<u8> = deserialize(message.as_ref())?;
debug!("Set toplevel capabilities");
panel_item.set_toplevel_capabilities(capabilities);
@@ -413,17 +430,17 @@ impl<B: Backend + ?Sized> PanelItem<B> {
pub fn commit_toplevel(&self) {
debug!("Commit toplevel");
let Some(node) = self.node.upgrade() else { return };
let Some(node) = self.node.upgrade() else {return};
let Ok(data) = self.backend.serialize_toplevel() else {return};
let _ = node.send_remote_signal("commit_toplevel", &data);
let _ = node.send_remote_signal("commit_toplevel", data);
}
pub fn recommend_toplevel_state(&self, state: RecommendedState) {
let Some(node) = self.node.upgrade() else { return };
let Some(node) = self.node.upgrade() else {return};
let data = serialize(state).unwrap();
debug!(?state, "Recommend toplevel state");
let _ = node.send_remote_signal("recommend_toplevel_state", &data);
let _ = node.send_remote_signal("recommend_toplevel_state", data);
}
}
impl<B: Backend + ?Sized> PanelItemTrait for PanelItem<B> {
@@ -432,11 +449,11 @@ impl<B: Backend + ?Sized> PanelItemTrait for PanelItem<B> {
}
}
impl<B: Backend + ?Sized> Backend for PanelItem<B> {
fn serialize_start_data(&self, id: &str) -> Result<Vec<u8>> {
fn serialize_start_data(&self, id: &str) -> Result<Message> {
self.backend.serialize_start_data(id)
}
fn serialize_toplevel(&self) -> Result<Vec<u8>> {
fn serialize_toplevel(&self) -> Result<Message> {
self.backend.serialize_toplevel()
}