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

refactor: remove many unwrap calls

Browse Source
This commit is contained in:
Nova
2023-01-25 11:50:53 -05:00
parent b5e87d5911
commit 529b86fa91
26 changed files with 163 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/core/client.rs
View File

@@ -66,7 +66,7 @@ pub struct Client {
pub startup_settings: Option<StartupSettings>,
}
impl Client {
pub fn from_connection(connection: UnixStream) -> Arc<Self> {
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());
@@ -98,15 +98,15 @@ impl Client {
startup_settings,
});
let _ = client.scenegraph.client.set(Arc::downgrade(&client));
let _ = client.root.set(Root::create(&client));
hmd::make_alias(&client);
spatial::create_interface(&client);
fields::create_interface(&client);
drawable::create_interface(&client);
data::create_interface(&client);
items::create_interface(&client);
input::create_interface(&client);
startup::create_interface(&client);
let _ = client.root.set(Root::create(&client)?);
hmd::make_alias(&client)?;
spatial::create_interface(&client)?;
fields::create_interface(&client)?;
drawable::create_interface(&client)?;
data::create_interface(&client)?;
items::create_interface(&client)?;
input::create_interface(&client)?;
startup::create_interface(&client)?;
let pid_printable = pid
.map(|pid| pid.to_string())
@@ -160,7 +160,7 @@ impl Client {
)
});
client
Ok(client)
}
#[inline]

5
src/core/eventloop.rs
View File

@@ -6,6 +6,7 @@ use std::sync::atomic::AtomicU64;
use std::sync::Arc;
use tokio::net::UnixListener;
use tokio::task::JoinHandle;
use tracing::error;
pub static FRAME: AtomicU64 = AtomicU64::new(0);
@@ -20,7 +21,9 @@ impl EventLoop {
let join_handle = task::new(|| "event loop", async move {
loop {
let Ok((socket, _)) = socket.accept().await else { continue };
Client::from_connection(socket);
if let Err(e) = Client::from_connection(socket) {
error!(?e, "Unable to create client from connection");
}
}
})?;
let event_loop = Arc::new(EventLoop { join_handle });

10
src/core/scenegraph.rs
View File

@@ -18,8 +18,8 @@ pub struct Scenegraph {
}
impl Scenegraph {
pub fn get_client(&self) -> Arc<Client> {
self.client.get().unwrap().upgrade().unwrap()
pub fn get_client(&self) -> Option<Arc<Client>> {
self.client.get()?.upgrade()
}
pub fn add_node(&self, node: Node) -> Arc<Node> {
@@ -51,10 +51,11 @@ impl Scenegraph {
impl scenegraph::Scenegraph for Scenegraph {
fn send_signal(&self, path: &str, method: &str, data: &[u8]) -> Result<(), ScenegraphError> {
let Some(client) = self.get_client() else {return Err(ScenegraphError::SignalNotFound)};
debug_span!("Handle signal", path, method).in_scope(|| {
self.get_node(path)
.ok_or(ScenegraphError::NodeNotFound)?
.send_local_signal(self.get_client(), method, data)
.send_local_signal(client, method, data)
})
}
fn execute_method(
@@ -63,10 +64,11 @@ impl scenegraph::Scenegraph for Scenegraph {
method: &str,
data: &[u8],
) -> Result<Vec<u8>, ScenegraphError> {
let Some(client) = self.get_client() else {return Err(ScenegraphError::MethodNotFound)};
debug_span!("Handle method", path, method).in_scope(|| {
self.get_node(path)
.ok_or(ScenegraphError::NodeNotFound)?
.execute_local_method(self.get_client(), method, data)
.execute_local_method(client, method, data)
})
}
}

43
src/main.rs
View File

@@ -27,7 +27,7 @@ use stereokit::render::StereoKitRender;
use stereokit::texture::Texture;
use stereokit::time::StereoKitTime;
use tokio::{runtime::Handle, sync::oneshot};
use tracing::{debug_span, info};
use tracing::{debug_span, error, info};
use tracing_subscriber::{fmt, prelude::*, EnvFilter};
#[derive(Parser)]
@@ -71,7 +71,10 @@ fn main() -> Result<()> {
.with_filter(EnvFilter::from_default_env());
registry.with(log_layer).init();
let project_dirs = ProjectDirs::from("", "", "stardust").unwrap();
let project_dirs = ProjectDirs::from("", "", "stardust");
if project_dirs.is_none() {
error!("Unable to get Stardust project directories, default skybox and startup script will not work.");
}
let cli_args = Arc::new(CliArgs::parse());
let stereokit = stereokit::Settings::default()
@@ -92,10 +95,14 @@ fn main() -> Result<()> {
// Skytex/light stuff
{
let skytex_path = project_dirs.config_dir().join("skytex.hdr");
if let Some((tex, light)) = skytex_path
.exists()
.then(|| Texture::from_cubemap_equirectangular(&stereokit, &skytex_path, true, 100))
if let Some((tex, light)) = project_dirs
.as_ref()
.and_then(|dirs| {
let skytex_path = dirs.config_dir().join("skytex.hdr");
skytex_path.exists().then(|| {
Texture::from_cubemap_equirectangular(&stereokit, &skytex_path, true, 100)
})
})
.flatten()
{
stereokit.set_skytex(&tex);
@@ -111,7 +118,7 @@ fn main() -> Result<()> {
}
}
let mouse_pointer = cli_args.flatscreen.then(MousePointer::new);
let mouse_pointer = cli_args.flatscreen.then(MousePointer::new).transpose()?;
let mut hands =
(!cli_args.flatscreen).then(|| (SkHand::new(Handed::Left), SkHand::new(Handed::Right)));
let mut controllers = (!cli_args.flatscreen && !cli_args.disable_controller).then(|| {
@@ -140,13 +147,18 @@ fn main() -> Result<()> {
let mut wayland = wayland::Wayland::new()?;
info!("Stardust ready!");
let _startup = Command::new(project_dirs.config_dir().join("startup"))
.env("WAYLAND_DISPLAY", &wayland.socket_name)
.env(
"STARDUST_INSTANCE",
event_loop_info.socket_path.file_name().unwrap(),
)
.spawn();
if let Some(project_dirs) = project_dirs.as_ref() {
let _startup = Command::new(project_dirs.config_dir().join("startup"))
.env("WAYLAND_DISPLAY", &wayland.socket_name)
.env(
"STARDUST_INSTANCE",
event_loop_info
.socket_path
.file_name()
.expect("Stardust socket path not found"),
)
.spawn();
}
let mut last_frame_delta = Duration::ZERO;
let mut sleep_duration = Duration::ZERO;
@@ -222,7 +234,8 @@ async fn event_loop(
info_sender: oneshot::Sender<EventLoopInfo>,
stop_rx: oneshot::Receiver<()>,
) -> color_eyre::eyre::Result<()> {
let socket_path = server::get_free_socket_path().unwrap();
let socket_path =
server::get_free_socket_path().expect("Unable to find a free stardust socket path");
let _event_loop = EventLoop::new(socket_path.clone()).expect("Couldn't create server socket");
info!("Init event loop");
info!(

37
src/nodes/alias.rs
View File

@@ -1,6 +1,6 @@
use crate::core::client::Client;
use super::Node;
use crate::core::client::Client;
use color_eyre::eyre::{ensure, Result};
use std::sync::{Arc, Weak};
#[derive(Debug, Default, Clone)]
@@ -24,22 +24,23 @@ impl Alias {
name: &str,
original: &Arc<Node>,
info: AliasInfo,
) -> Option<Arc<Node>> {
let node_free = client
.scenegraph
.get_node(&(parent.to_string() + "/" + name))
.is_none();
) -> Result<Arc<Node>> {
ensure!(
client
.scenegraph
.get_node(&(parent.to_string() + "/" + name))
.is_none(),
"Node already exists"
);
node_free.then(|| {
let node = Node::create(client, parent, name, true).add_to_scenegraph();
let alias = Alias {
node: Arc::downgrade(&node),
original: Arc::downgrade(original),
info,
};
let alias = original.aliases.add(alias);
let _ = node.alias.set(alias);
node
})
let node = Node::create(client, parent, name, true).add_to_scenegraph()?;
let alias = Alias {
node: Arc::downgrade(&node),
original: Arc::downgrade(original),
info,
};
let alias = original.aliases.add(alias);
let _ = node.alias.set(alias);
Ok(node)
}
}

26
src/nodes/data.rs
View File

@@ -69,9 +69,8 @@ impl PulseSender {
aliases: LifeLinkedNodeMap::default(),
};
let sender = PULSE_SENDER_REGISTRY.add(sender);
let _ = node.pulse_sender.set(sender);
let _ = node.pulse_sender.set(sender.clone());
node.add_local_signal("send_data", PulseSender::send_data_flex);
let sender = node.pulse_sender.get().unwrap();
for receiver in PULSE_RECEIVER_REGISTRY.get_valid_contents() {
sender.handle_new_receiver(&receiver);
}
@@ -95,7 +94,7 @@ impl PulseSender {
..Default::default()
},
);
if let Some(rx_alias) = rx_alias {
if let Ok(rx_alias) = rx_alias {
self.aliases.add(receiver.uid.clone(), &rx_alias);
if let Some(rx_field_node) = receiver.field.spatial_ref().node.upgrade() {
@@ -110,7 +109,7 @@ impl PulseSender {
..Default::default()
},
);
if let Some(rx_field_alias) = rx_field_alias {
if let Ok(rx_field_alias) = rx_field_alias {
self.aliases
.add(receiver.uid.clone() + "-field", &rx_field_alias);
}
@@ -140,15 +139,16 @@ impl PulseSender {
rotation: rotation.into(),
};
let _ = tx_node.send_remote_signal("new_receiver", &serialize(info).unwrap());
let Ok(data) = serialize(info) else {return};
let _ = tx_node.send_remote_signal("new_receiver", &data);
}
fn handle_drop_receiver(&self, uid: String) {
if let Some(tx_node) = self.node.upgrade() {
let _ = tx_node.send_remote_signal("drop_receiver", &serialize(&uid).unwrap());
}
self.aliases.remove(&uid);
self.aliases.remove(&(uid + "-field"));
self.aliases.remove(&(uid.clone() + "-field"));
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: &Node, calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
@@ -222,11 +222,11 @@ impl Drop for PulseReceiver {
}
}
pub fn create_interface(client: &Arc<Client>) {
pub fn create_interface(client: &Arc<Client>) -> Result<()> {
let node = Node::create(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_to_scenegraph();
node.add_to_scenegraph().map(|_| ())
}
pub fn create_pulse_sender_flex(
@@ -249,7 +249,7 @@ pub fn create_pulse_sender_flex(
let mask = Mask(info.mask);
mask.get_mask()?;
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, false)?;
PulseSender::add_to(&node, mask)?;
Ok(())
@@ -276,7 +276,7 @@ pub fn create_pulse_receiver_flex(
let mask = Mask(info.mask);
mask.get_mask()?;
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, false)?;
PulseReceiver::add_to(&node, field, mask)?;
Ok(())

2
src/nodes/drawable/lines.rs
View File

@@ -130,7 +130,7 @@ pub fn create_flex(_node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Re
p.color[2] = p.color[2].powf(2.2);
}
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, false)?;
Lines::add_to(&node, info.points, info.cyclic)?;
Ok(())

4
src/nodes/drawable/mod.rs
View File

@@ -12,13 +12,13 @@ use std::{path::PathBuf, sync::Arc};
use stereokit::{lifecycle::StereoKitDraw, render::StereoKitRender, texture::Texture};
use tracing::instrument;
pub fn create_interface(client: &Arc<Client>) {
pub fn create_interface(client: &Arc<Client>) -> Result<()> {
let node = Node::create(client, "", "drawable", false);
node.add_local_signal("create_lines", lines::create_flex);
node.add_local_signal("create_model", model::create_flex);
node.add_local_signal("create_text", text::create_flex);
node.add_local_signal("set_sky_file", set_sky_file_flex);
node.add_to_scenegraph();
node.add_to_scenegraph().map(|_| ())
}
#[instrument(level = "debug", skip(sk))]

30
src/nodes/drawable/model.rs
View File

@@ -118,7 +118,7 @@ pub struct Model {
space: Arc<Spatial>,
resource_id: ResourceID,
pending_model_path: OnceCell<PathBuf>,
pending_material_parameters: Mutex<FxHashMap<(u32, String), MaterialParameter>>,
pending_material_parameters: Mutex<FxHashMap<(i32, String), MaterialParameter>>,
pub pending_material_replacements: Mutex<FxHashMap<u32, Arc<SendWrapper<Material>>>>,
sk_model: OnceCell<SendWrapper<SKModel>>,
}
@@ -179,7 +179,7 @@ impl Model {
.unwrap()
.pending_material_parameters
.lock()
.insert((info.idx, info.name), info.value);
.insert((info.idx as i32, info.name), info.value);
Ok(())
}
@@ -204,22 +204,20 @@ impl Model {
material_replacements.clear();
}
{
if let Some(client) = self.space.node.upgrade().and_then(|n| n.client.upgrade()) {
let mut material_parameters = self.pending_material_parameters.lock();
for ((material_idx, parameter_name), parameter_value) in material_parameters.iter()
for ((material_idx, parameter_name), parameter_value) in material_parameters.drain()
{
if let Some(material) = sk_model.get_material(sk, *material_idx as i32) {
let new_material = material.clone();
parameter_value.apply_to_material(
&self.space.node.upgrade().unwrap().client.upgrade().unwrap(), // TODO: don't unwrap
sk,
&new_material,
parameter_name.as_str(),
);
sk_model.set_material(sk, *material_idx as i32, &new_material);
}
let Some(material) = sk_model.get_material(sk, material_idx) else {continue};
let new_material = material.clone();
parameter_value.apply_to_material(
&client,
sk,
&new_material,
parameter_name.as_str(),
);
sk_model.set_material(sk, material_idx, &new_material);
}
material_parameters.clear();
}
let global_transform = self.space.global_transform().into();
@@ -254,7 +252,7 @@ pub fn create_flex(_node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Re
let node = Node::create(&calling_client, "/drawable/model", info.name, true);
let parent = find_spatial_parent(&calling_client, info.parent_path)?;
let transform = parse_transform(info.transform, true, true, true);
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, false)?;
Model::add_to(&node, info.resource)?;
Ok(())

2
src/nodes/drawable/text.rs
View File

@@ -192,7 +192,7 @@ pub fn create_flex(_node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Re
let transform = parse_transform(info.transform, true, true, true);
let color = Rgba::from_slice(&info.color);
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, false)?;
Text::add_to(
&node,

2
src/nodes/fields/box.rs
View File

@@ -75,7 +75,7 @@ pub fn create_box_field_flex(_node: &Node, calling_client: Arc<Client>, data: &[
let node = Node::create(&calling_client, "/field", info.name, true);
let parent = find_spatial_parent(&calling_client, info.parent_path)?;
let transform = parse_transform(info.transform, true, true, false);
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, false)?;
BoxField::add_to(&node, info.size)?;
Ok(())

2
src/nodes/fields/cylinder.rs
View File

@@ -81,7 +81,7 @@ pub fn create_cylinder_field_flex(
let node = Node::create(&calling_client, "/field", info.name, true);
let parent = find_spatial_parent(&calling_client, info.parent_path)?;
let transform = parse_transform(info.transform, true, true, false);
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, false)?;
CylinderField::add_to(&node, info.length, info.radius)?;
Ok(())

4
src/nodes/fields/mod.rs
View File

@@ -217,13 +217,13 @@ impl Deref for Field {
}
}
pub fn create_interface(client: &Arc<Client>) {
pub fn create_interface(client: &Arc<Client>) -> Result<()> {
let node = Node::create(client, "", "field", false);
node.add_local_signal("create_box_field", create_box_field_flex);
node.add_local_signal("create_cylinder_field", create_cylinder_field_flex);
node.add_local_signal("create_sphere_field", create_sphere_field_flex);
node.add_local_signal("create_torus_field", create_torus_field_flex);
node.add_to_scenegraph();
node.add_to_scenegraph().map(|_| ())
}
pub fn find_field(client: &Client, path: &str) -> Result<Arc<Field>> {

2
src/nodes/fields/sphere.rs
View File

@@ -81,7 +81,7 @@ pub fn create_sphere_field_flex(
.unwrap_or_else(|| Vector3::from([0.0; 3]))
.into(),
);
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, false)?;
SphereField::add_to(&node, info.radius)?;
Ok(())

2
src/nodes/fields/torus.rs
View File

@@ -81,7 +81,7 @@ pub fn create_torus_field_flex(
let node = Node::create(&calling_client, "/field", info.name, true);
let parent = find_spatial_parent(&calling_client, info.parent_path)?;
let transform = parse_transform(info.transform, true, true, false);
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, false)?;
TorusField::add_to(&node, info.radius_a, info.radius_b)?;
Ok(())

10
src/nodes/hmd.rs
View File

@@ -3,6 +3,7 @@ use crate::{
core::client::{Client, INTERNAL_CLIENT},
nodes::alias::AliasInfo,
};
use color_eyre::eyre::Result;
use glam::{vec3, Mat4};
use std::sync::Arc;
use stereokit::input::StereoKitInput;
@@ -14,14 +15,17 @@ lazy_static::lazy_static! {
fn create() -> Arc<Node> {
let node = Arc::new(Node::create(&INTERNAL_CLIENT, "", "hmd", false));
Spatial::add_to(&node, None, Mat4::IDENTITY, false).unwrap();
Spatial::add_to(&node, None, Mat4::IDENTITY, false).expect("Unable to make spatial for HMD");
node
}
#[instrument(level = "debug", name = "Update HMD Pose", skip(sk))]
pub fn frame(sk: &impl StereoKitInput) {
let spatial = HMD.spatial.get().unwrap();
let spatial = HMD
.spatial
.get()
.expect("Unable to get spatial to update HMD");
let hmd_pose = sk.input_head();
*spatial.transform.lock() = Mat4::from_scale_rotation_translation(
vec3(1.0, 1.0, 1.0),
@@ -30,7 +34,7 @@ pub fn frame(sk: &impl StereoKitInput) {
);
}
pub fn make_alias(client: &Arc<Client>) -> Option<Arc<Node>> {
pub fn make_alias(client: &Arc<Client>) -> Result<Arc<Node>> {
Alias::create(
client,
"",

9
src/nodes/input/mod.rs
View File

@@ -190,7 +190,7 @@ impl InputHandler {
#[instrument(level = "debug", skip(self, distance_link))]
fn send_input(&self, frame: u64, distance_link: &DistanceLink, datamap: Datamap) {
let data = distance_link.serialize(datamap);
let node = self.node.upgrade().unwrap();
let Some(node) = self.node.upgrade() else {return};
let method = Arc::downgrade(&distance_link.method);
let handler = Arc::downgrade(&distance_link.handler);
@@ -226,11 +226,11 @@ impl Drop for InputHandler {
}
}
pub fn create_interface(client: &Arc<Client>) {
pub fn create_interface(client: &Arc<Client>) -> Result<()> {
let node = Node::create(client, "", "input", false);
node.add_local_signal("create_input_handler", create_input_handler_flex);
node.add_local_signal("create_input_method_tip", tip::create_tip_flex);
node.add_to_scenegraph();
node.add_to_scenegraph().map(|_| ())
}
pub fn create_input_handler_flex(
@@ -250,7 +250,8 @@ pub fn create_input_handler_flex(
let transform = parse_transform(info.transform, true, true, true);
let field = find_field(&calling_client, info.field_path)?;
let node = Node::create(&calling_client, "/input/handler", info.name, true).add_to_scenegraph();
let node =
Node::create(&calling_client, "/input/handler", info.name, true).add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, false)?;
InputHandler::add_to(&node, &field)?;
Ok(())

2
src/nodes/input/tip.rs
View File

@@ -59,7 +59,7 @@ pub fn create_tip_flex(_node: &Node, calling_client: Arc<Client>, data: &[u8]) -
let parent = find_spatial_parent(&calling_client, info.parent_path)?;
let transform = parse_transform(info.transform, true, true, false);
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, false)?;
InputMethod::add_to(
&node,

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

@@ -74,12 +74,13 @@ pub(super) fn create_environment_item_flex(
let space = find_spatial_parent(&calling_client, info.parent_path)?;
let transform = parse_transform(info.transform, true, true, false);
let node = Node::create(&INTERNAL_CLIENT, &parent_name, info.name, false).add_to_scenegraph();
let node =
Node::create(&INTERNAL_CLIENT, &parent_name, info.name, false).add_to_scenegraph()?;
Spatial::add_to(&node, None, transform * space.global_transform(), false)?;
EnvironmentItem::add_to(&node, info.item_data);
node.item
.get()
.unwrap()
.make_alias_named(&calling_client, &parent_name, info.name);
.make_alias_named(&calling_client, &parent_name, info.name)?;
Ok(())
}

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

@@ -18,7 +18,6 @@ use parking_lot::Mutex;
use serde::Deserialize;
use stardust_xr::schemas::flex::{deserialize, serialize};
use stardust_xr::values::Transform;
use std::hash::Hash;
use std::ops::Deref;
use std::sync::{Arc, Weak};
@@ -123,7 +122,7 @@ impl Item {
client: &Arc<Client>,
parent: &str,
name: &str,
) -> Option<Arc<Node>> {
) -> Result<Arc<Node>> {
Alias::create(
client,
parent,
@@ -148,7 +147,7 @@ impl Item {
},
)
}
fn make_alias(&self, client: &Arc<Client>, parent: &str) -> Option<Arc<Node>> {
fn make_alias(&self, client: &Arc<Client>, parent: &str) -> Result<Arc<Node>> {
self.make_alias_named(client, parent, &self.uid)
}
@@ -230,8 +229,7 @@ impl ItemUI {
let Some(node) = self.node.upgrade() else { return };
let Some(client) = node.get_client() else { return };
if let Some(alias_node) = item.make_alias(&client, &(node.get_path().to_string() + "/item"))
{
if let Ok(alias_node) = item.make_alias(&client, &(node.get_path().to_string() + "/item")) {
self.item_aliases.add(item.uid.clone(), &alias_node);
}
@@ -268,10 +266,10 @@ impl ItemUI {
&client,
&format!("/item/{}/acceptor", self.type_info.type_name),
);
if let Some(alias) = alias {
if let Ok(alias) = alias {
self.acceptor_aliases.add(acceptor.uid.clone(), &alias);
}
if let Some(field_alias) = field_alias {
if let Some(Ok(field_alias)) = field_alias {
self.acceptor_field_aliases
.add(acceptor.uid.clone(), &field_alias);
}
@@ -326,7 +324,7 @@ impl ItemAcceptor {
&self,
client: &Arc<Client>,
parent: &str,
) -> (Option<Arc<Node>>, Option<Arc<Node>>) {
) -> (Result<Arc<Node>>, Option<Result<Arc<Node>>>) {
let acceptor_node = &self.node.upgrade().unwrap();
let acceptor_alias = Alias::create(
client,
@@ -339,7 +337,7 @@ impl ItemAcceptor {
},
);
let acceptor_field_alias = acceptor_alias.as_ref().and_then(|acceptor_alias| {
let acceptor_field_alias = acceptor_alias.as_ref().ok().map(|acceptor_alias| {
Alias::create(
client,
acceptor_alias.get_path(),
@@ -355,7 +353,7 @@ impl ItemAcceptor {
let Some(node) = self.node.upgrade() else { return };
let Some(client) = node.get_client() else { return };
if let Some(alias_node) = item.make_alias(&client, &node.path) {
if let Ok(alias_node) = item.make_alias(&client, &node.path) {
self.accepted.add(item.uid.clone(), &alias_node);
}
let _ = node.send_remote_signal(
@@ -379,7 +377,7 @@ impl Drop for ItemAcceptor {
}
}
pub fn create_interface(client: &Arc<Client>) {
pub fn create_interface(client: &Arc<Client>) -> Result<()> {
let node = Node::create(client, "", "item", false);
node.add_local_signal(
"create_environment_item",
@@ -387,7 +385,7 @@ pub fn create_interface(client: &Arc<Client>) {
);
node.add_local_signal("register_item_ui", register_item_ui_flex);
node.add_local_signal("create_item_acceptor", create_item_acceptor_flex);
node.add_to_scenegraph();
node.add_to_scenegraph().map(|_| ())
}
fn type_info(name: &str) -> Result<&'static TypeInfo> {
@@ -406,7 +404,8 @@ pub fn register_item_ui_flex(_node: &Node, calling_client: Arc<Client>, data: &[
}
let info: RegisterItemUIInfo = deserialize(data)?;
let type_info = type_info(info.item_type)?;
let ui = Node::create(&calling_client, "/item", type_info.type_name, true).add_to_scenegraph();
let ui =
Node::create(&calling_client, "/item", type_info.type_name, true).add_to_scenegraph()?;
ItemUI::add_to(&ui, type_info)?;
Ok(())
}
@@ -432,7 +431,7 @@ fn create_item_acceptor_flex(_node: &Node, calling_client: Arc<Client>, data: &[
info.name,
true,
)
.add_to_scenegraph();
.add_to_scenegraph()?;
Spatial::add_to(&node, Some(space), transform, false)?;
ItemAcceptor::add_to(&node, type_info, field);
Ok(())

8
src/nodes/mod.rs
View File

@@ -133,8 +133,12 @@ impl Node {
node.add_local_signal("destroy", Node::destroy_flex);
node
}
pub fn add_to_scenegraph(self) -> Arc<Node> {
self.get_client().unwrap().scenegraph.add_node(self)
pub fn add_to_scenegraph(self) -> Result<Arc<Node>> {
Ok(self
.get_client()
.ok_or_else(|| eyre!("Internal: Unable to get client"))?
.scenegraph
.add_node(self))
}
pub fn destroy(&self) {
if let Some(client) = self.get_client() {

8
src/nodes/root.rs
View File

@@ -17,11 +17,11 @@ pub struct Root {
logic_step: AtomicBool,
}
impl Root {
pub fn create(client: &Arc<Client>) -> Arc<Self> {
pub fn create(client: &Arc<Client>) -> Result<Arc<Self>> {
let node = Node::create(client, "", "", false);
node.add_local_signal("subscribe_logic_step", Root::subscribe_logic_step);
node.add_local_signal("set_base_prefixes", Root::set_base_prefixes);
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
let _ = Spatial::add_to(
&node,
None,
@@ -33,10 +33,10 @@ impl Root {
false,
);
ROOT_REGISTRY.add(Root {
Ok(ROOT_REGISTRY.add(Root {
node,
logic_step: AtomicBool::from(false),
})
}))
}
fn subscribe_logic_step(_node: &Node, calling_client: Arc<Client>, _data: &[u8]) -> Result<()> {

6
src/nodes/spatial/mod.rs
View File

@@ -345,11 +345,11 @@ pub fn find_reference_space(
find_spatial(calling_client, "Reference space", node_path)
}
pub fn create_interface(client: &Arc<Client>) {
pub fn create_interface(client: &Arc<Client>) -> Result<()> {
let node = Node::create(client, "", "spatial", false);
node.add_local_signal("create_spatial", create_spatial_flex);
node.add_local_signal("create_zone", create_zone_flex);
node.add_to_scenegraph();
node.add_to_scenegraph().map(|_| ())
}
pub fn create_spatial_flex(_node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
@@ -364,7 +364,7 @@ pub fn create_spatial_flex(_node: &Node, calling_client: Arc<Client>, data: &[u8
let node = Node::create(&calling_client, "/spatial/spatial", info.name, true);
let parent = find_spatial_parent(&calling_client, info.parent_path)?;
let transform = parse_transform(info.transform, true, true, true);
let node = node.add_to_scenegraph();
let node = node.add_to_scenegraph()?;
Spatial::add_to(&node, Some(parent), transform, info.zoneable)?;
Ok(())
}

6
src/nodes/spatial/zone.rs
View File

@@ -122,7 +122,8 @@ impl Zone {
local_methods: vec!["get_transform"],
..Default::default()
},
)?;
)
.ok()?;
Some((zoneable.uid.clone(), alias))
})
.collect::<FxHashMap<String, Arc<Node>>>();
@@ -160,7 +161,8 @@ pub fn create_zone_flex(_node: &Node, calling_client: Arc<Client>, data: &[u8])
let transform = parse_transform(info.transform, true, true, false);
let field = find_field(&calling_client, info.field_path)?;
let node = Node::create(&calling_client, "/spatial/zone", info.name, true).add_to_scenegraph();
let node =
Node::create(&calling_client, "/spatial/zone", info.name, true).add_to_scenegraph()?;
let space = Spatial::add_to(&node, Some(parent), transform, false)?;
Zone::add_to(&node, space, &field);
Ok(())

13
src/nodes/startup.rs
View File

@@ -26,9 +26,9 @@ pub struct StartupSettings {
}
impl StartupSettings {
pub fn add_to(node: &Arc<Node>) {
node.startup_settings
.set(Mutex::new(StartupSettings::default()))
.unwrap();
let _ = node
.startup_settings
.set(Mutex::new(StartupSettings::default()));
}
fn set_root_flex(node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
@@ -83,10 +83,10 @@ impl Debug for StartupSettings {
}
}
pub fn create_interface(client: &Arc<Client>) {
pub fn create_interface(client: &Arc<Client>) -> Result<()> {
let node = Node::create(client, "", "startup", false);
node.add_local_signal("create_startup_settings", create_startup_settings_flex);
node.add_to_scenegraph();
node.add_to_scenegraph().map(|_| ())
}
pub fn create_startup_settings_flex(
@@ -95,7 +95,8 @@ pub fn create_startup_settings_flex(
data: &[u8],
) -> Result<()> {
let name = flexbuffers::Reader::get_root(data)?.get_str()?;
let node = Node::create(&calling_client, "/startup/settings", name, true).add_to_scenegraph();
let node =
Node::create(&calling_client, "/startup/settings", name, true).add_to_scenegraph()?;
StartupSettings::add_to(&node);
node.add_local_signal("set_root", StartupSettings::set_root_flex);

9
src/objects/input/mouse_pointer.rs
View File

@@ -8,6 +8,7 @@ use crate::{
Node,
},
};
use color_eyre::eyre::Result;
use glam::{vec3, Mat4};
use nanoid::nanoid;
use stardust_xr::{schemas::flat::Datamap, values::Transform};
@@ -24,8 +25,8 @@ pub struct MousePointer {
keyboard_sender: Arc<PulseSender>,
}
impl MousePointer {
pub fn new() -> Self {
let node = Node::create(&INTERNAL_CLIENT, "", &nanoid!(), false).add_to_scenegraph();
pub fn new() -> Result<Self> {
let node = Node::create(&INTERNAL_CLIENT, "", &nanoid!(), false).add_to_scenegraph()?;
let spatial = Spatial::add_to(&node, None, Mat4::IDENTITY, false).unwrap();
let pointer =
InputMethod::add_to(&node, InputType::Pointer(Pointer::default()), None).unwrap();
@@ -39,12 +40,12 @@ impl MousePointer {
};
let keyboard_sender = PulseSender::add_to(&node, keyboard_mask).unwrap();
MousePointer {
Ok(MousePointer {
node,
spatial,
pointer,
keyboard_sender,
}
})
}
#[instrument(level = "debug", name = "Update Flatscreen Pointer Ray", skip_all)]
pub fn update(&self, sk: &impl StereoKitInput) {