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

fix(object/mouse pointer): update keyboard protocol

Browse Source
This commit is contained in:
Nova
2023-09-04 11:40:44 -04:00
parent 9042a004d3
commit 102fc2ef79
1 changed files with 55 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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