From 4c56c31bfc54d53509e60d520eaf5c5a66825051 Mon Sep 17 00:00:00 2001
From: Nova <technobaboo@gmail.com>
Date: Mon, 4 Sep 2023 11:40:44 -0400
Subject: [PATCH] fix(object/mouse pointer): update keyboard protocol

---
 src/objects/input/mouse_pointer.rs | 105 +++++++++++++++--------------
 1 file changed, 55 insertions(+), 50 deletions(-)

diff --git a/src/objects/input/mouse_pointer.rs b/src/objects/input/mouse_pointer.rs
index df2b61b..1acbddf 100644
--- a/src/objects/input/mouse_pointer.rs
+++ b/src/objects/input/mouse_pointer.rs
@@ -1,7 +1,7 @@
 use crate::{
 	core::{client::INTERNAL_CLIENT, typed_datamap::TypedDatamap},
 	nodes::{
-		data::{mask_matches, Mask, PulseSender, PULSE_RECEIVER_REGISTRY},
+		data::{mask_matches, Mask, PulseSender, KEYMAPS, PULSE_RECEIVER_REGISTRY},
 		fields::Ray,
 		input::{pointer::Pointer, InputMethod, InputType},
 		spatial::Spatial,
@@ -12,33 +12,41 @@ use color_eyre::eyre::Result;
 use glam::{vec2, vec3, Mat4, Vec2, Vec3};
 use nanoid::nanoid;
 use serde::{Deserialize, Serialize};
-use stardust_xr::schemas::flex::flexbuffers;
 use std::{convert::TryFrom, sync::Arc};
 use stereokit::{ray_from_mouse, ButtonState, Key, StereoKitMultiThread};
 use tracing::instrument;
 
-const SK_KEYMAP: &str = include_str!("sk.kmp");
-
 #[derive(Default, Deserialize, Serialize)]
-struct MouseDatamap {
+struct MouseEvent {
 	select: f32,
 	grab: f32,
 	scroll: Vec2,
 }
 
-#[derive(Debug, Clone, Serialize)]
-struct KeyboardEvent {
-	pub keyboard: String,
-	pub keymap: Option<String>,
-	pub keys_up: Option<Vec<u32>>,
-	pub keys_down: Option<Vec<u32>>,
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct KeyboardEvent {
+	pub keyboard: (),
+	pub xkbv1: (),
+	pub keymap_id: String,
+	pub keys: Vec<i32>,
+}
+impl Default for KeyboardEvent {
+	fn default() -> Self {
+		Self {
+			keyboard: (),
+			xkbv1: (),
+			keymap_id: "flatscreen".to_string(),
+			keys: Default::default(),
+		}
+	}
 }
 
 pub struct MousePointer {
 	node: Arc<Node>,
 	spatial: Arc<Spatial>,
 	pointer: Arc<InputMethod>,
-	datamap: TypedDatamap<MouseDatamap>,
+	mouse_datamap: TypedDatamap<MouseEvent>,
+	keyboard_datamap: TypedDatamap<KeyboardEvent>,
 	keyboard_sender: Arc<PulseSender>,
 }
 impl MousePointer {
@@ -48,20 +56,19 @@ impl MousePointer {
 		let pointer =
 			InputMethod::add_to(&node, InputType::Pointer(Pointer::default()), None).unwrap();
 
-		let keyboard_mask = {
-			let mut fbb = flexbuffers::Builder::default();
-			let mut map = fbb.start_map();
-			map.push("keyboard", "xkbv1");
-			map.end_map();
-			Mask(fbb.take_buffer())
-		};
-		let keyboard_sender = PulseSender::add_to(&node, keyboard_mask).unwrap();
+		KEYMAPS
+			.lock()
+			.insert("flatscreen".to_string(), include_str!("sk.kmp").to_string());
+
+		let keyboard_sender =
+			PulseSender::add_to(&node, Mask::from_struct::<KeyboardEvent>()).unwrap();
 
 		Ok(MousePointer {
 			node,
 			spatial,
 			pointer,
-			datamap: Default::default(),
+			mouse_datamap: Default::default(),
+			keyboard_datamap: Default::default(),
 			keyboard_sender,
 		})
 	}
@@ -80,23 +87,25 @@ impl MousePointer {
 		);
 		{
 			// Set pointer input datamap
-			self.datamap.select = if sk.input_key(Key::MouseLeft).contains(ButtonState::ACTIVE) {
+			self.mouse_datamap.select =
+				if sk.input_key(Key::MouseLeft).contains(ButtonState::ACTIVE) {
+					1.0f32
+				} else {
+					0.0f32
+				};
+			self.mouse_datamap.grab = if sk.input_key(Key::MouseRight).contains(ButtonState::ACTIVE)
+			{
 				1.0f32
 			} else {
 				0.0f32
 			};
-			self.datamap.grab = if sk.input_key(Key::MouseRight).contains(ButtonState::ACTIVE) {
-				1.0f32
-			} else {
-				0.0f32
-			};
-			self.datamap.scroll = vec2(0.0, mouse.scroll_change / 120.0);
-			*self.pointer.datamap.lock() = self.datamap.to_datamap().ok();
+			self.mouse_datamap.scroll = vec2(0.0, mouse.scroll_change / 120.0);
+			*self.pointer.datamap.lock() = self.mouse_datamap.to_datamap().ok();
 		}
 		self.send_keyboard_input(sk);
 	}
 
-	fn send_keyboard_input(&self, sk: &impl StereoKitMultiThread) {
+	fn send_keyboard_input(&mut self, sk: &impl StereoKitMultiThread) {
 		let rx = PULSE_RECEIVER_REGISTRY
 			.get_valid_contents()
 			.into_iter()
@@ -122,29 +131,25 @@ impl MousePointer {
 			.map(|(rx, _)| rx);
 
 		if let Some(rx) = rx {
-			let mut keys_up = vec![];
-			let mut keys_down = vec![];
 			let keys = (8_u32..254)
 				.filter_map(|i| Some((i, Key::try_from(i).ok()?)))
-				.map(|(i, k)| (i - 8, sk.input_key(k)));
-			for (key, state) in keys {
-				if state.contains(ButtonState::JUST_ACTIVE) {
-					keys_down.push(key);
-				} else if state.contains(ButtonState::JUST_INACTIVE) {
-					keys_up.push(key);
-				}
-			}
+				.map(|(i, k)| (i - 8, sk.input_key(k)))
+				.filter_map(|(i, k)| {
+					if k.contains(ButtonState::JUST_ACTIVE) {
+						Some(i as i32)
+					} else if k.contains(ButtonState::JUST_INACTIVE) {
+						Some(-(i as i32))
+					} else {
+						None
+					}
+				})
+				.collect();
 
-			let key_event = KeyboardEvent {
-				keyboard: "xkbv1".to_string(),
-				keymap: Some(SK_KEYMAP.to_string()),
-				keys_up: Some(keys_up),
-				keys_down: Some(keys_down),
-			};
-			let mut serializer = flexbuffers::FlexbufferSerializer::new();
-			let _ = key_event.serialize(&mut serializer);
-			rx.send_data(&self.node.uid, serializer.take_buffer())
-				.unwrap();
+			self.keyboard_datamap.keys = keys;
+			if !self.keyboard_datamap.keys.is_empty() {
+				rx.send_data(&self.node.uid, self.keyboard_datamap.serialize().unwrap())
+					.unwrap();
+			}
 		}
 	}
 }