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

feat: upgrade stereokit

Browse Source
This commit is contained in:
Nova
2024-05-28 09:13:15 -04:00
parent 01c5ad3b04
commit eda50b7d51
27 changed files with 1498 additions and 592 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/objects/input/eye_pointer.rs
View File

@@ -13,7 +13,7 @@ use nanoid::nanoid;
use serde::{Deserialize, Serialize};
use stardust_xr::values::Datamap;
use std::sync::Arc;
use stereokit::StereoKitMultiThread;
use stereokit_rust::system::Input;
#[derive(Default, Deserialize, Serialize)]
pub struct EyeDatamap {
@@ -46,13 +46,11 @@ impl EyePointer {
Ok(EyePointer { spatial, pointer })
}
pub fn update(&self, sk: &impl StereoKitMultiThread) {
let ray = sk.input_eyes();
self.spatial
.set_local_transform(Mat4::from_rotation_translation(
ray.orientation,
ray.position,
));
pub fn update(&self) {
let ray = Input::get_eyes();
self.spatial.set_local_transform(
Mat4::from_rotation_translation(ray.orientation.into(), ray.position.into()).into(),
);
{
// Set pointer input datamap
*self.pointer.datamap.lock() = Datamap::from_typed(EyeDatamap { eye: 2 }).unwrap();

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

@@ -11,24 +11,38 @@ use crate::{
},
};
use color_eyre::eyre::Result;
use glam::{vec2, vec3, Mat4, Vec2, Vec3};
use glam::{vec3, Mat4, Vec3};
use mint::Vector2;
use nanoid::nanoid;
use serde::{Deserialize, Serialize};
use stardust_xr::values::Datamap;
use std::{convert::TryFrom, sync::Arc};
use stereokit::{ray_from_mouse, ButtonState, Key, StereoKitMultiThread};
use std::sync::Arc;
use stereokit_rust::system::{Input, Key};
use xkbcommon::xkb::{Context, Keymap, FORMAT_TEXT_V1};
#[derive(Default, Deserialize, Serialize)]
#[derive(Deserialize, Serialize)]
struct MouseEvent {
select: f32,
middle: f32,
context: f32,
grab: f32,
scroll_continuous: Vec2,
scroll_discrete: Vec2,
scroll_continuous: Vector2<f32>,
scroll_discrete: Vector2<f32>,
raw_input_events: Vec<u32>,
}
impl Default for MouseEvent {
fn default() -> Self {
MouseEvent {
select: 0.0,
middle: 0.0,
context: 0.0,
grab: 0.0,
scroll_continuous: [0.0; 2].into(),
scroll_discrete: [0.0; 2].into(),
raw_input_events: vec![],
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct KeyboardEvent {
@@ -91,53 +105,48 @@ impl MousePointer {
keyboard_sender,
})
}
pub fn update(&mut self, sk: &impl StereoKitMultiThread) {
let mouse = sk.input_mouse();
pub fn update(&mut self) {
let mouse = Input::get_mouse();
let ray = ray_from_mouse(mouse.pos).unwrap();
let ray = mouse.get_ray();
self.spatial.set_local_transform(
Mat4::look_to_rh(
Vec3::from(ray.pos),
Vec3::from(ray.dir),
Vec3::from(ray.position),
Vec3::from(ray.direction),
vec3(0.0, 1.0, 0.0),
)
.inverse(),
);
{
// Set pointer input datamap
self.mouse_datamap.select =
if sk.input_key(Key::MouseLeft).contains(ButtonState::ACTIVE) {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.middle =
if sk.input_key(Key::MouseCenter).contains(ButtonState::ACTIVE) {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.context =
if sk.input_key(Key::MouseRight).contains(ButtonState::ACTIVE) {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.grab = if sk.input_key(Key::MouseBack).contains(ButtonState::ACTIVE)
|| sk
.input_key(Key::MouseForward)
.contains(ButtonState::ACTIVE)
self.mouse_datamap.select = if Input::key(Key::MouseLeft).is_active() {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.middle = if Input::key(Key::MouseCenter).is_active() {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.context = if Input::key(Key::MouseRight).is_active() {
1.0f32
} else {
0.0f32
};
self.mouse_datamap.grab = if Input::key(Key::MouseBack).is_active()
|| Input::key(Key::MouseForward).is_active()
{
1.0f32
} else {
0.0f32
};
self.mouse_datamap.scroll_continuous = vec2(0.0, mouse.scroll_change / 120.0);
self.mouse_datamap.scroll_discrete = vec2(0.0, mouse.scroll_change / 120.0);
self.mouse_datamap.scroll_continuous = [0.0, mouse.scroll_change / 120.0].into();
self.mouse_datamap.scroll_discrete = [0.0, mouse.scroll_change / 120.0].into();
*self.pointer.datamap.lock() = Datamap::from_typed(&self.mouse_datamap).unwrap();
}
self.target_pointer_input();
self.send_keyboard_input(sk);
self.send_keyboard_input();
}
fn target_pointer_input(&mut self) {
@@ -145,7 +154,7 @@ impl MousePointer {
if let Some(capture) = &self.capture {
if !self
.pointer
.captures
.capture_requests
.get_valid_contents()
.contains(&capture)
{
@@ -156,7 +165,7 @@ impl MousePointer {
if self.capture.is_none() {
if let Some(new_capture) = self
.pointer
.captures
.capture_requests
.get_valid_contents()
.into_iter()
.map(|h| {
@@ -183,8 +192,10 @@ impl MousePointer {
}
// make sure that if something is captured only send input to it
self.pointer.captures.clear();
if let Some(capture) = &self.capture {
self.pointer.set_handler_order([capture].into_iter());
self.pointer.captures.add_raw(capture);
return;
}
@@ -236,7 +247,7 @@ impl MousePointer {
);
}
fn send_keyboard_input(&mut self, sk: &impl StereoKitMultiThread) {
fn send_keyboard_input(&mut self) {
let rx = PULSE_RECEIVER_REGISTRY
.get_valid_contents()
.into_iter()
@@ -263,12 +274,12 @@ impl MousePointer {
if let Some(rx) = rx {
let keys = (8_u32..254)
.filter_map(|i| Key::try_from(i).ok())
.filter_map(|k| Some((map_key(k)?, sk.input_key(k))))
.map(|i| unsafe { std::mem::transmute(i) })
.filter_map(|k| Some((map_key(k)?, Input::key(k))))
.filter_map(|(i, k)| {
if k.contains(ButtonState::JUST_ACTIVE) {
if k.is_just_active() {
Some(i as i32)
} else if k.contains(ButtonState::JUST_INACTIVE) {
} else if k.is_just_inactive() {
Some(-(i as i32))
} else {
None

42
src/objects/input/sk_controller.rs
View File

@@ -11,9 +11,10 @@ use glam::{Mat4, Vec2, Vec3};
use serde::{Deserialize, Serialize};
use stardust_xr::values::Datamap;
use std::sync::Arc;
use stereokit::{
named_colors::WHITE, ButtonState, Handed, Model, RenderLayer, StereoKitDraw,
StereoKitMultiThread,
use stereokit_rust::{
model::Model,
sk::MainThreadToken,
system::{Handed, Input},
};
#[derive(Default, Deserialize, Serialize)]
@@ -32,7 +33,7 @@ pub struct SkController {
datamap: ControllerDatamap,
}
impl SkController {
pub fn new(sk: &impl StereoKitMultiThread, handed: Handed) -> Result<Self> {
pub fn new(handed: Handed) -> Result<Self> {
let _node = Node::create_parent_name(
&INTERNAL_CLIENT,
"",
@@ -45,7 +46,7 @@ impl SkController {
)
.add_to_scenegraph()?;
Spatial::add_to(&_node, None, Mat4::IDENTITY, false);
let model = sk.model_create_mem("cursor.glb", include_bytes!("cursor.glb"), None)?;
let model = Model::from_memory("cursor.glb", include_bytes!("cursor.glb"), None)?;
let tip = InputDataType::Tip(Tip::default());
let input = InputMethod::add_to(
&_node,
@@ -61,30 +62,35 @@ impl SkController {
datamap: Default::default(),
})
}
pub fn update(&mut self, sk: &impl StereoKitDraw) {
let controller = sk.input_controller(self.handed);
*self.input.enabled.lock() = controller.tracked.contains(ButtonState::ACTIVE);
pub fn update(&mut self, token: &MainThreadToken) {
let controller = Input::controller(self.handed);
*self.input.enabled.lock() = controller.tracked.is_active();
if *self.input.enabled.lock() {
let world_transform = Mat4::from_rotation_translation(
controller.aim.orientation,
controller.aim.position,
controller.aim.orientation.into(),
controller.aim.position.into(),
);
sk.model_draw(
&self.model,
self.model.draw(
token,
world_transform * Mat4::from_scale(Vec3::ONE * 0.02),
WHITE,
RenderLayer::LAYER0,
None,
None,
);
self.input.spatial.set_local_transform(world_transform);
}
self.datamap.select = controller.trigger;
self.datamap.grab = controller.grip;
self.datamap.scroll = controller.stick;
self.datamap.scroll = controller.stick.into();
*self.input.datamap.lock() = Datamap::from_typed(&self.datamap).unwrap();
// remove the capture when it's removed from captures list
if let Some(capture) = &self.capture {
if !self.input.captures.get_valid_contents().contains(&capture) {
if !self
.input
.capture_requests
.get_valid_contents()
.contains(&capture)
{
self.capture.take();
}
}
@@ -92,7 +98,7 @@ impl SkController {
if self.capture.is_none() {
self.capture = self
.input
.captures
.capture_requests
.get_valid_contents()
.into_iter()
.map(|handler| {
@@ -115,8 +121,10 @@ impl SkController {
}
// make sure that if something is captured only send input to it
self.input.captures.clear();
if let Some(capture) = &self.capture {
self.input.set_handler_order([capture].into_iter());
self.input.captures.add_raw(capture);
return;
}

145
src/objects/input/sk_hand.rs
View File

@@ -7,18 +7,20 @@ use crate::nodes::{
Node,
};
use color_eyre::eyre::Result;
use glam::Mat4;
use glam::{Mat4, Quat, Vec3};
use nanoid::nanoid;
use serde::{Deserialize, Serialize};
use stardust_xr::values::Datamap;
use std::f32::INFINITY;
use std::sync::Arc;
use stereokit::{ButtonState, Color128, HandJoint, Handed, Material, StereoKitMultiThread};
use stereokit_rust::sk::MainThreadToken;
use stereokit_rust::system::{HandJoint, Handed, Input, LinePoint, Lines};
use stereokit_rust::util::Color128;
fn convert_joint(joint: HandJoint) -> Joint {
Joint {
position: joint.position.into(),
rotation: joint.orientation.into(),
position: Vec3::from(joint.position).into(),
rotation: Quat::from(joint.orientation).into(),
radius: joint.radius,
distance: 0.0,
}
@@ -33,13 +35,12 @@ struct HandDatamap {
pub struct SkHand {
_node: Arc<Node>,
handed: Handed,
material: Material,
input: Arc<InputMethod>,
capture: Option<Arc<InputHandler>>,
datamap: HandDatamap,
}
impl SkHand {
pub fn new(handed: Handed, sk: &impl StereoKitMultiThread) -> Result<Self> {
pub fn new(handed: Handed) -> Result<Self> {
let _node = Node::create_parent_name(&INTERNAL_CLIENT, "", &nanoid!(), false)
.add_to_scenegraph()?;
Spatial::add_to(&_node, None, Mat4::IDENTITY, false);
@@ -50,29 +51,21 @@ impl SkHand {
let datamap = Datamap::from_typed(HandDatamap::default())?;
let input = InputMethod::add_to(&_node, hand, datamap)?;
let material = sk.material_copy(Material::HAND);
unsafe { sk.material_addref(&material); }
sk.input_hand_material(handed, Material(material.0));
Input::hand_visible(handed, false);
Ok(SkHand {
_node,
handed,
material,
input,
capture: None,
datamap: Default::default(),
})
}
pub fn update(&mut self, controller_enabled: bool, sk: &impl StereoKitMultiThread) {
let sk_hand = sk.input_hand(self.handed);
pub fn update(&mut self, controller_enabled: bool, token: &MainThreadToken) {
let sk_hand = Input::hand(self.handed);
if let InputDataType::Hand(hand) = &mut *self.input.data.lock() {
let controller_active = controller_enabled
&& sk
.input_controller(self.handed)
.tracked
.contains(ButtonState::ACTIVE);
*self.input.enabled.lock() =
!controller_active && sk_hand.tracked_state.contains(ButtonState::ACTIVE);
sk.input_hand_visible(self.handed, *self.input.enabled.lock());
let controller_active =
controller_enabled && Input::controller(self.handed).is_tracked();
*self.input.enabled.lock() = !controller_active && sk_hand.tracked.is_active();
if *self.input.enabled.lock() {
hand.thumb.tip = convert_joint(sk_hand.fingers[0][4]);
hand.thumb.distal = convert_joint(sk_hand.fingers[0][3]);
@@ -92,17 +85,27 @@ impl SkHand {
finger.metacarpal = convert_joint(sk_finger[0]);
}
hand.palm.position = sk_hand.palm.position.into();
hand.palm.rotation = sk_hand.palm.orientation.into();
hand.palm.position = Vec3::from(sk_hand.palm.position).into();
hand.palm.rotation = Quat::from(sk_hand.palm.orientation).into();
hand.palm.radius =
(sk_hand.fingers[2][0].radius + sk_hand.fingers[2][1].radius) * 0.5;
hand.wrist.position = sk_hand.wrist.position.into();
hand.wrist.rotation = sk_hand.wrist.orientation.into();
hand.wrist.position = Vec3::from(sk_hand.wrist.position).into();
hand.wrist.rotation = Quat::from(sk_hand.wrist.orientation).into();
hand.wrist.radius =
(sk_hand.fingers[0][0].radius + sk_hand.fingers[4][0].radius) * 0.5;
hand.elbow = None;
self.draw(
token,
if self.capture.is_none() {
Color128::new_rgb(1.0, 1.0, 1.0)
} else {
Color128::new_rgb(0.0, 1.0, 0.75)
},
hand,
);
}
}
self.datamap.pinch_strength = sk_hand.pinch_activation;
@@ -111,16 +114,20 @@ impl SkHand {
// remove the capture when it's removed from captures list
if let Some(capture) = &self.capture {
if !self.input.captures.get_valid_contents().contains(&capture) {
if !self
.input
.capture_requests
.get_valid_contents()
.contains(&capture)
{
self.capture.take();
sk.material_set_color(&self.material, "color", Color128::new_rgb(1.0, 1.0, 1.0));
}
}
// add the capture that's the closest if we don't have one
if self.capture.is_none() {
self.capture = self
.input
.captures
.capture_requests
.get_valid_contents()
.into_iter()
.map(|handler| (handler.clone(), self.compare_distance(&handler.field).abs()))
@@ -132,14 +139,13 @@ impl SkHand {
}
})
.map(|(rx, _)| rx);
if self.capture.is_some() {
sk.material_set_color(&self.material, "color", Color128::new_rgb(0.0, 1.0, 0.75));
}
}
// make sure that if something is captured only send input to it
self.input.captures.clear();
if let Some(capture) = &self.capture {
self.input.set_handler_order([capture].into_iter());
self.input.captures.add_raw(capture);
return;
}
@@ -183,6 +189,77 @@ impl SkHand {
);
}
fn draw(&self, token: &MainThreadToken, color: Color128, hand: &Hand) {
// thumb
Lines::add_list(
token,
&[
joint_to_line_point(&hand.thumb.tip, color),
joint_to_line_point(&hand.thumb.distal, color),
joint_to_line_point(&hand.thumb.proximal, color),
joint_to_line_point(&hand.thumb.metacarpal, color),
],
);
// index
Lines::add_list(
token,
&[
joint_to_line_point(&hand.index.tip, color),
joint_to_line_point(&hand.index.distal, color),
joint_to_line_point(&hand.index.intermediate, color),
joint_to_line_point(&hand.index.proximal, color),
joint_to_line_point(&hand.index.metacarpal, color),
],
);
// middle
Lines::add_list(
token,
&[
joint_to_line_point(&hand.middle.tip, color),
joint_to_line_point(&hand.middle.distal, color),
joint_to_line_point(&hand.middle.intermediate, color),
joint_to_line_point(&hand.middle.proximal, color),
joint_to_line_point(&hand.middle.metacarpal, color),
],
);
// ring
Lines::add_list(
token,
&[
joint_to_line_point(&hand.ring.tip, color),
joint_to_line_point(&hand.ring.distal, color),
joint_to_line_point(&hand.ring.intermediate, color),
joint_to_line_point(&hand.ring.proximal, color),
joint_to_line_point(&hand.ring.metacarpal, color),
],
);
// little
Lines::add_list(
token,
&[
joint_to_line_point(&hand.little.tip, color),
joint_to_line_point(&hand.little.distal, color),
joint_to_line_point(&hand.little.intermediate, color),
joint_to_line_point(&hand.little.proximal, color),
joint_to_line_point(&hand.little.metacarpal, color),
],
);
// palm
Lines::add_list(
token,
&[
joint_to_line_point(&hand.wrist, color),
joint_to_line_point(&hand.thumb.metacarpal, color),
joint_to_line_point(&hand.index.metacarpal, color),
joint_to_line_point(&hand.middle.metacarpal, color),
joint_to_line_point(&hand.ring.metacarpal, color),
joint_to_line_point(&hand.little.metacarpal, color),
joint_to_line_point(&hand.wrist, color),
],
);
}
fn compare_distance(&self, field: &Field) -> f32 {
let InputDataType::Hand(hand) = &*self.input.data.lock() else {
return INFINITY;
@@ -199,3 +276,11 @@ impl SkHand {
+ (ring_tip_distance * 0.15)
}
}
fn joint_to_line_point(joint: &Joint, color: Color128) -> LinePoint {
LinePoint {
pt: Vec3::from(joint.position).into(),
thickness: joint.radius * 2.0,
color: color.into(),
}
}

23
src/objects/play_space.rs
View File

@@ -6,7 +6,7 @@ use mint::Vector2;
use nanoid::nanoid;
use serde::{Deserialize, Serialize};
use stardust_xr::values::Datamap;
use stereokit::StereoKitMultiThread;
use stereokit_rust::system::World;
use crate::{
core::client::INTERNAL_CLIENT,
@@ -59,23 +59,14 @@ impl PlaySpace {
_pulse_rx: pulse_rx,
})
}
pub fn update(&self, sk: &impl StereoKitMultiThread) {
let pose = sk.world_get_bounds_pose();
self.spatial
.set_local_transform(Mat4::from_rotation_translation(
pose.orientation,
pose.position,
));
pub fn update(&self) {
let pose = World::get_bounds_pose();
self.spatial.set_local_transform(
Mat4::from_rotation_translation(pose.orientation.into(), pose.position.into()).into(),
);
let Field::Box(box_field) = self.field.as_ref() else {
return;
};
box_field.set_size(
[
sk.world_get_bounds_size().x,
0.0,
sk.world_get_bounds_size().y,
]
.into(),
);
box_field.set_size([World::get_bounds_size().x, 0.0, World::get_bounds_size().y].into());
}
}