Skip to content

Commit

Permalink
refactor: modularize input object capture system
Browse files Browse the repository at this point in the history
  • Loading branch information
@technobaboo
technobaboo committed Aug 6, 2024
1 parent 827c630 commit 72f7fd8
Show file tree
Hide file tree
Showing 4 changed files with 144 additions and 304 deletions.
71 changes: 71 additions & 0 deletions src/objects/input/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,3 +2,74 @@ pub mod eye_pointer;
pub mod mouse_pointer;
pub mod sk_controller;
pub mod sk_hand;

use crate::nodes::{
fields::{Field, FieldTrait, Ray}, input::{InputDataTrait, InputDataType, InputHandler, InputMethod, INPUT_HANDLER_REGISTRY}, spatial::Spatial
};
use glam::vec3;
use std::sync::Arc;


#[derive(Default)]
pub struct CaptureManager {
pub capture: Option<Arc<InputHandler>>,
}
impl CaptureManager {
pub fn update_capture(&mut self, pointer: &InputMethod) {
if let Some(capture) = &self.capture {
if !pointer.internal_capture_requests.get_valid_contents().contains(capture) {
self.capture.take();
}
}
}
pub fn set_new_capture(&mut self, pointer: &InputMethod, distance_calculator: DistanceCalculator) {
if self.capture.is_none() {
self.capture = find_closest_capture(pointer, distance_calculator);
}
}
pub fn apply_capture(&self, method: &InputMethod) {
method.captures.clear();
if let Some(capture) = &self.capture {
method.set_handler_order([capture].into_iter());
method.captures.add_raw(capture);
}
}
}


type DistanceCalculator = fn(&Arc<Spatial>, &InputDataType, &Field) -> Option<f32>;

pub fn find_closest_capture(method: &InputMethod, distance_calculator: DistanceCalculator) -> Option<Arc<InputHandler>> {
method
.internal_capture_requests
.get_valid_contents()
.into_iter()
.filter_map(|h| distance_calculator(&method.spatial, &method.data.lock(), &h.field).map(|dist| (h.clone(), dist)))
.min_by(|(_, dist_a), (_, dist_b)| dist_a.partial_cmp(dist_b).unwrap())
.map(|(handler, _)| handler)
}

pub fn get_sorted_handlers(method: &InputMethod, distance_calculator: DistanceCalculator) -> Vec<Arc<InputHandler>> {
INPUT_HANDLER_REGISTRY
.get_valid_contents()
.into_iter()
.filter(|handler| handler.spatial.node().map_or(false, |node| node.enabled()))
.filter(|handler| handler.field.spatial.node().map_or(false, |node| node.enabled()))
.filter_map(|handler| {
distance_calculator(&method.spatial, &method.data.lock(), &handler.field)
.map(|distance| (vec![handler], distance))
})
.filter(|(_, distance)| *distance > 0.0)
.reduce(|(mut handlers_a, distance_a), (handlers_b, distance_b)| {
if (distance_a - distance_b).abs() < 0.001 {
handlers_a.extend(handlers_b);
(handlers_a, distance_a)
} else if distance_a < distance_b {
(handlers_a, distance_a)
} else {
(handlers_b, distance_b)
}
})
.map(|(handlers, _)| handlers)
.unwrap_or_default()
}
122 changes: 23 additions & 99 deletions src/objects/input/mouse_pointer.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,6 +20,8 @@ use std::sync::Arc;
use stereokit_rust::system::{Input, Key};
use xkbcommon::xkb::{Context, Keymap, FORMAT_TEXT_V1};

use super::{get_sorted_handlers, CaptureManager, DistanceCalculator};

#[derive(Deserialize, Serialize)]
struct MouseEvent {
select: f32,
Expand Down Expand Up @@ -58,7 +60,7 @@ pub struct MousePointer {
keymap: DefaultKey,
spatial: Arc<Spatial>,
pointer: Arc<InputMethod>,
capture: Option<Arc<InputHandler>>,
capture_manager: CaptureManager,
mouse_datamap: MouseEvent,
keyboard_datamap: KeyboardEvent,
keyboard_sender: Arc<PulseSender>,
Expand Down Expand Up @@ -89,7 +91,7 @@ impl MousePointer {
node,
spatial,
pointer,
capture: None,
capture_manager: CaptureManager::default(),
mouse_datamap: Default::default(),
keyboard_datamap: KeyboardEvent {
keyboard: (),
Expand Down Expand Up @@ -146,108 +148,30 @@ impl MousePointer {
}

fn target_pointer_input(&mut self) {
// remove the capture when it's removed from captures list
if let Some(capture) = &self.capture {
if !self
.pointer
.internal_capture_requests
.get_valid_contents()
.contains(capture)
{
self.capture.take();
}
}
// add the capture that's the closest if we don't have one
if self.capture.is_none() {
if let Some(new_capture) = self
.pointer
.internal_capture_requests
.get_valid_contents()
.into_iter()
.map(|h| {
(
h.clone(),
h.field.ray_march(Ray {
origin: vec3(0.0, 0.0, 0.0),
direction: vec3(0.0, 0.0, -1.0),
space: self.spatial.clone(),
}),
)
})
.reduce(|(handlers_a, result_a), (handlers_b, result_b)| {
if result_a.min_distance < result_b.min_distance {
(handlers_a, result_a)
} else {
(handlers_b, result_b)
}
})
.map(|(rx, _)| rx)
{
self.capture = Some(new_capture.clone());
let distance_calculator: DistanceCalculator = |space, data, field| {
let result = field.ray_march(Ray {
origin: vec3(0.0, 0.0, 0.0),
direction: vec3(0.0, 0.0, -1.0),
space: space.clone(),
});
if result.deepest_point_distance > 0.0 && result.min_distance < 0.05 {
Some(result.deepest_point_distance)
} else {
None
}
}
};

self.capture_manager.update_capture(&self.pointer);
self.capture_manager
.set_new_capture(&self.pointer, distance_calculator);
self.capture_manager.apply_capture(&self.pointer);

// 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);
if self.capture_manager.capture.is_some() {
return;
}

// send input to all the input handlers that are the closest to the ray as possible
self.pointer.set_handler_order(
INPUT_HANDLER_REGISTRY
.get_valid_contents()
.into_iter()
// filter out all the disabled handlers
.filter(|handler| {
let Some(node) = handler.spatial.node() else {
return false;
};
node.enabled()
})
// filter out all the fields with disabled handlers
.filter(|handler| {
let Some(node) = handler.field.spatial.node() else {
return false;
};
node.enabled()
})
// ray march to all the enabled handlers' fields
.map(|handler| {
let result = handler.field.ray_march(Ray {
origin: vec3(0.0, 0.0, 0.0),
direction: vec3(0.0, 0.0, -1.0),
space: self.spatial.clone(),
});
(vec![handler], result)
})
// make sure the field isn't at the pointer origin and that it's being hit
.filter(|(_, result)| {
result.deepest_point_distance > 0.01 && result.min_distance < 0.0
})
// .inspect(|(_, result)| {
// dbg!(result);
// })
// now collect all handlers that are same distance if they're the closest
.reduce(|(mut handlers_a, result_a), (handlers_b, result_b)| {
if (result_a.deepest_point_distance - result_b.deepest_point_distance).abs()
< 0.001
{
// distance is basically the same
handlers_a.extend(handlers_b);
(handlers_a, result_a)
} else if result_a.deepest_point_distance < result_b.deepest_point_distance {
(handlers_a, result_a)
} else {
(handlers_b, result_b)
}
})
.map(|(rx, _)| rx)
.unwrap_or_default()
.iter(),
);
let sorted_handlers = get_sorted_handlers(&self.pointer, distance_calculator);
self.pointer.set_handler_order(sorted_handlers.iter());
}

fn send_keyboard_input(&mut self) {
Expand Down
118 changes: 21 additions & 97 deletions src/objects/input/sk_controller.rs
View file
Original file line number Diff line number Diff line change
@@ -1,7 +1,8 @@
use super::{get_sorted_handlers, CaptureManager};
use crate::{
core::client::INTERNAL_CLIENT,
nodes::{
fields::FieldTrait,
fields::{Field, FieldTrait},
input::{InputDataType, InputHandler, InputMethod, Tip, INPUT_HANDLER_REGISTRY},
spatial::Spatial,
Node, OwnedNode,
Expand Down Expand Up @@ -35,7 +36,7 @@ pub struct SkController {
handed: Handed,
model: Model,
material: Material,
capture: Option<Arc<InputHandler>>,
capture_manager: CaptureManager,
datamap: ControllerDatamap,
}
impl SkController {
Expand Down Expand Up @@ -69,7 +70,7 @@ impl SkController {
handed,
model,
material,
capture: None,
capture_manager: CaptureManager::default(),
datamap: Default::default(),
})
}
Expand All @@ -82,11 +83,12 @@ impl SkController {
controller.aim.orientation.into(),
controller.aim.position.into(),
);
self.material.color_tint(if self.capture.is_none() {
Color128::new_rgb(1.0, 1.0, 1.0)
} else {
Color128::new_rgb(0.0, 1.0, 0.75)
});
self.material
.color_tint(if self.capture_manager.capture.is_none() {
Color128::new_rgb(1.0, 1.0, 1.0)
} else {
Color128::new_rgb(0.0, 1.0, 0.75)
});
self.model.draw(
token,
world_transform * Mat4::from_scale(Vec3::ONE * 0.02),
Expand All @@ -100,98 +102,20 @@ impl SkController {
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
.internal_capture_requests
.get_valid_contents()
.contains(capture)
{
self.capture.take();
}
}
// add the capture that's the closest if we don't have one
if self.capture.is_none() {
self.capture = self
.input
.internal_capture_requests
.get_valid_contents()
.into_iter()
.map(|handler| {
(
handler.clone(),
handler
.field
.distance(&self.input.spatial, [0.0; 3].into())
.abs(),
)
})
.reduce(|(handlers_a, distance_a), (handlers_b, distance_b)| {
if distance_a < distance_b {
(handlers_a, distance_a)
} else {
(handlers_b, distance_b)
}
})
.map(|(rx, _)| rx);
}
let distance_calculator = |space: &Arc<Spatial>, _data: &InputDataType, field: &Field| {
Some(field.distance(space, [0.0; 3].into()).abs())
};

// 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);
self.capture_manager.update_capture(&self.input);
self.capture_manager
.set_new_capture(&self.input, distance_calculator);
self.capture_manager.apply_capture(&self.input);

if self.capture_manager.capture.is_some() {
return;
}

// send input to all the input handlers that are the closest to the ray as possible
self.input.set_handler_order(
INPUT_HANDLER_REGISTRY
.get_valid_contents()
.into_iter()
// filter out all the disabled handlers
.filter(|handler| {
let Some(node) = handler.spatial.node() else {
return false;
};
node.enabled()
})
// filter out all the fields with disabled handlers
.filter(|handler| {
let Some(node) = handler.field.spatial.node() else {
return false;
};
node.enabled()
})
// get the unsigned distance to the handler's field (unsigned so giant fields won't always eat input)
.map(|handler| {
(
vec![handler.clone()],
handler
.field
.distance(&self.input.spatial, [0.0; 3].into())
.abs(),
)
})
// .inspect(|(_, result)| {
// dbg!(result);
// })
// now collect all handlers that are same distance if they're the closest
.reduce(|(mut handlers_a, distance_a), (handlers_b, distance_b)| {
if (distance_a - distance_b).abs() < 0.001 {
// distance is basically the same (within 1mm)
handlers_a.extend(handlers_b);
(handlers_a, distance_a)
} else if distance_a < distance_b {
(handlers_a, distance_a)
} else {
(handlers_b, distance_b)
}
})
.map(|(rx, _)| rx)
.unwrap_or_default()
.iter(),
);
let sorted_handlers = get_sorted_handlers(&self.input, distance_calculator);
self.input.set_handler_order(sorted_handlers.iter());
}
}
Loading

0 comments on commit 72f7fd8

Please sign in to comment.