use super::XrEye;
use crate::math::Matrix4;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Handedness {
#[default]
None,
Left,
Right,
}
impl Handedness {
pub fn parse(name: &str) -> Self {
match name {
"left" => Handedness::Left,
"right" => Handedness::Right,
_ => Handedness::None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum TargetRayMode {
#[default]
TrackedPointer,
Gaze,
Screen,
TransientPointer,
}
impl TargetRayMode {
pub fn parse(name: &str) -> Self {
match name {
"gaze" => TargetRayMode::Gaze,
"screen" => TargetRayMode::Screen,
"transient-pointer" => TargetRayMode::TransientPointer,
_ => TargetRayMode::TrackedPointer,
}
}
pub fn is_transient(self) -> bool {
matches!(
self,
TargetRayMode::Screen | TargetRayMode::TransientPointer
)
}
}
#[derive(Debug, Clone, Default, PartialEq)]
pub struct XrInput {
pub slot: usize,
pub handedness: Handedness,
pub target_ray_mode: TargetRayMode,
pub ray: Option<[f32; 16]>,
pub grip: Option<[f32; 16]>,
pub joints: Option<(Vec<f32>, Vec<f32>)>,
pub axes: Vec<f32>,
pub buttons: Vec<(bool, f32)>,
}
impl XrInput {
pub fn ray_line(&self) -> Option<(crate::math::Vector3, crate::math::Vector3)> {
self.ray.as_ref().map(ray_of)
}
pub fn thumbstick(&self) -> (f32, f32) {
let a = &self.axes;
if a.len() >= 4 {
(a[2], a[3])
} else if a.len() >= 2 {
(a[0], a[1])
} else {
(0.0, 0.0)
}
}
}
pub fn ray_of(m: &[f32; 16]) -> (crate::math::Vector3, crate::math::Vector3) {
use crate::math::Vector3;
(
Vector3::new(m[12], m[13], m[14]),
Vector3::new(-m[8], -m[9], -m[10]).normalize(),
)
}
pub fn ray_pose(start: crate::math::Vector3, direction: crate::math::Vector3) -> [f32; 16] {
use crate::math::Vector3;
let z = -direction.normalize();
let up = if z.y.abs() > 0.99 {
Vector3::new(0.0, 0.0, 1.0)
} else {
Vector3::new(0.0, 1.0, 0.0)
};
let x = up.cross(z).normalize();
let y = z.cross(x);
[
x.x, x.y, x.z, 0.0, y.x, y.y, y.z, 0.0, z.x, z.y, z.z, 0.0, start.x, start.y, start.z, 1.0,
]
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum XrEventKind {
Connected,
Disconnected,
SelectStart,
SelectEnd,
Select,
SqueezeStart,
SqueezeEnd,
Squeeze,
}
impl XrEventKind {
pub fn name(self) -> &'static str {
match self {
XrEventKind::Connected => "connected",
XrEventKind::Disconnected => "disconnected",
XrEventKind::SelectStart => "selectstart",
XrEventKind::SelectEnd => "selectend",
XrEventKind::Select => "select",
XrEventKind::SqueezeStart => "squeezestart",
XrEventKind::SqueezeEnd => "squeezeend",
XrEventKind::Squeeze => "squeeze",
}
}
pub fn parse(name: &str) -> Option<Self> {
Some(match name {
"connected" => XrEventKind::Connected,
"disconnected" => XrEventKind::Disconnected,
"selectstart" => XrEventKind::SelectStart,
"selectend" => XrEventKind::SelectEnd,
"select" => XrEventKind::Select,
"squeezestart" => XrEventKind::SqueezeStart,
"squeezeend" => XrEventKind::SqueezeEnd,
"squeeze" => XrEventKind::Squeeze,
_ => return None,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct XrEvent {
pub kind: XrEventKind,
pub slot: usize,
}
pub trait XrSource {
fn head(&self) -> Option<[f32; 16]>;
fn eyes(&self, origin: &Matrix4) -> Vec<XrEye>;
fn framebuffer_size(&self) -> (u32, u32);
fn inputs(&self) -> Vec<XrInput>;
fn take_events(&mut self) -> Vec<XrEvent>;
fn see_through(&self) -> bool;
fn hover_target(&self) -> Option<HoverTarget> {
None
}
fn declare_hover(&self, id: u64) -> Option<u32> {
let _ = id;
None
}
}
#[derive(Debug, Clone)]
pub struct HoverTarget {
pub view: wgpu::TextureView,
pub format: wgpu::TextureFormat,
pub size: (u32, u32),
}
#[cfg(test)]
mod tests {
use super::*;
use crate::math::Vector3;
#[test]
fn a_ray_pose_reads_back_as_its_ray() {
for (start, dir) in [
(Vector3::new(1.0, 2.0, 3.0), Vector3::new(0.0, 0.0, -2.0)),
(Vector3::ZERO, Vector3::new(0.0, 1.0, 0.0)),
(Vector3::ZERO, Vector3::new(0.3, -0.2, 0.9)),
] {
let (s, d) = ray_of(&ray_pose(start, dir));
assert!(
(s - start).length() < 1e-6 && (d - dir.normalize()).length() < 1e-5,
"{start:?} {dir:?}"
);
}
}
}