fix(logic step): proper procedure

src/core/client.rs

@@ -3,31 +3,40 @@ use crate::nodes::data;
 use crate::nodes::field;
 use crate::nodes::input;
 use crate::nodes::item;
-use crate::nodes::root;
+use crate::nodes::root::Root;
 use crate::nodes::spatial;
 use lazy_static::lazy_static;
 use libstardustxr::messenger::Messenger;
 use mio::net::UnixStream;
+use once_cell::sync::OnceCell;
 use std::sync::Arc;
 
 lazy_static! {
-	pub static ref INTERNAL_CLIENT: Arc<Client> = Default::default();
+	pub static ref INTERNAL_CLIENT: Arc<Client> = Client::new_local();
 }
 
-#[derive(Default)]
 pub struct Client {
 	pub messenger: Option<Messenger>,
 	pub scenegraph: Scenegraph,
+	pub root: OnceCell<Arc<Root>>,
 }
-
 impl Client {
+	pub fn new_local() -> Arc<Self> {
+		Arc::new(Client {
+			messenger: None,
+			scenegraph: Default::default(),
+			root: OnceCell::new(),
+		})
+	}
 	pub fn from_connection(connection: UnixStream) -> Arc<Self> {
+		println!("New client connected");
 		let client = Arc::new(Client {
 			messenger: Some(Messenger::new(connection)),
 			scenegraph: Default::default(),
+			root: OnceCell::new(),
 		});
 		let _ = client.scenegraph.client.set(Arc::downgrade(&client));
-		root::create_root(&client);
+		let _ = client.root.set(Root::create(&client));
 		spatial::create_interface(&client);
 		field::create_interface(&client);
 		data::create_interface(&client);
@@ -43,3 +52,8 @@ impl Client {
 		}
 	}
 }
+impl Drop for Client {
+	fn drop(&mut self) {
+		println!("Client disconnected");
+	}
+}

src/core/eventloop.rs

@@ -52,12 +52,10 @@ impl EventLoop {
 										let client = Client::from_connection(socket);
 										*clients.get_mut(client_number).unwrap() = Some(client);
 									}
-									Err(e) => {
+									Err(e) => match e.kind() {
-										if e.kind() == std::io::ErrorKind::WouldBlock {
+										std::io::ErrorKind::WouldBlock => break,
-											break;
+										_ => return Err(e.into()),
-										}
+									},
-										return Err(e.into());
-									}
 								}
 							},
 							STOP => return Ok(()),
@@ -66,7 +64,8 @@ impl EventLoop {
 									clients.get(token.0).and_then(|client| client.as_ref());
 								if let Some(client) = client {
 									loop {
-										match client.dispatch() {
+										let dispatch_result = client.dispatch();
+										match dispatch_result {
 											Ok(_) => continue,
 											Err(e) => match e.kind() {
 												std::io::ErrorKind::WouldBlock => break,
@@ -97,7 +96,8 @@ impl Drop for EventLoop {
 		let buf: [u8; 1] = [1; 1];
 		let _ = self.stop_write.write(buf.as_slice());
 		if let Some(handle) = self.join_handle.take() {
-			handle.join().unwrap().unwrap();
+			let _ = handle.join();
+			// handle.join().unwrap().unwrap();
 		}
 	}
 }

src/main.rs

@@ -29,10 +29,12 @@ fn main() -> Result<()> {
 	let event_loop = EventLoop::new(None).expect("Couldn't create server socket");
 	println!("Stardust socket created at {}", event_loop.socket_path);
 
+	let mut previous_time = 0_f64;
 	sk_run(
-		&mut Box::new(&mut || {
+		&mut Box::new(&mut move || {
-			let time = unsafe { sk::sys::time_get() };
+			let current_time = unsafe { sk::sys::time_get() };
-			nodes::root::logic_step(time);
+			nodes::root::Root::logic_step(current_time - previous_time);
+			previous_time = current_time;
 		}),
 		&mut Box::new(&mut || {
 			println!("Shutting down...");

src/nodes/root.rs

@@ -6,30 +6,55 @@ use anyhow::Result;
 use glam::Mat4;
 use lazy_static::lazy_static;
 use libstardustxr::flex::flexbuffer_from_vector_arguments;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
 lazy_static! {
-	static ref LOGIC_STEP_REGISTRY: Registry<Node> = Registry::default();
+	static ref ROOT_REGISTRY: Registry<Root> = Default::default();
 }
 
-pub fn logic_step(delta: f64) {
+pub struct Root {
-	let data = flexbuffer_from_vector_arguments(move |fbb| {
+	node: Arc<Node>,
-		fbb.push(delta);
+	logic_step: AtomicBool,
-		fbb.push(0_f64);
+}
-	});
+impl Root {
-	for root in LOGIC_STEP_REGISTRY.get_valid_contents() {
+	pub fn create(client: &Arc<Client>) -> Arc<Self> {
-		root.send_remote_signal("logicStep", &data);
+		let node = Node::create(client, "", "", false);
+		node.add_local_signal("subscribeLogicStep", Root::subscribe_logic_step);
+		let node = node.add_to_scenegraph();
+		let _ = Spatial::add_to(&node, None, Mat4::IDENTITY);
+
+		ROOT_REGISTRY.add(Root {
+			node,
+			logic_step: AtomicBool::from(false),
+		})
+	}
+
+	fn subscribe_logic_step(_node: &Node, calling_client: Arc<Client>, _data: &[u8]) -> Result<()> {
+		calling_client
+			.root
+			.get()
+			.unwrap()
+			.logic_step
+			.store(true, Ordering::Relaxed);
+		Ok(())
+	}
+
+	pub fn logic_step(delta: f64) {
+		let data = flexbuffer_from_vector_arguments(move |fbb| {
+			fbb.push(delta);
+			fbb.push(0_f64);
+		});
+		for root in ROOT_REGISTRY.get_valid_contents() {
+			if root.logic_step.load(Ordering::Relaxed) {
+				let _ = root.node.send_remote_signal("logicStep", &data);
+			}
+		}
 	}
 }
 
-pub fn create_root(client: &Arc<Client>) {
+impl Drop for Root {
-	let node = Node::create(client, "", "", false);
+	fn drop(&mut self) {
-	node.add_local_signal("subscribeLogicStep", subscribe_logic_step);
+		ROOT_REGISTRY.remove(self);
-	let node = node.add_to_scenegraph();
+	}
-	let _ = Spatial::add_to(&node, None, Mat4::IDENTITY);
-}
-
-fn subscribe_logic_step(node: &Node, calling_client: Arc<Client>, data: &[u8]) -> Result<()> {
-	LOGIC_STEP_REGISTRY.add_raw(&calling_client.scenegraph.get_node("/").unwrap());
-	Ok(())
 }