use std::collections::HashMap;
use std::ffi::c_void;
use std::sync::{Arc, Mutex};
use objc2::rc::Retained;
use objc2::runtime::ProtocolObject;
use objc2_metal::{MTLCommandBuffer, MTLCommandQueue, MTLPixelFormat, MTLTexture};
use super::{
Handedness, InputSlots, TargetRayMode, XrEvent, XrEventKind, XrEye, XrInput, XrSource,
};
use crate::math::{Matrix4, Vector3};
use crate::metal::visionos::frame_loop::*;
use crate::metal::visionos::{
AxisConvention, CpDrawable, CpFrame, CpLayerRenderer, LayerRendererState, SimdFloat2,
};
#[derive(Debug, Clone, Copy)]
struct Spatial {
id: u64,
phase: u32,
origin: [f32; 3],
direction: [f32; 3],
}
static SPATIAL: Mutex<Vec<Spatial>> = Mutex::new(Vec::new());
static SCRIPTED_TIP: Mutex<Option<[f32; 3]>> = Mutex::new(None);
pub fn set_scripted_fingertip(tip: Option<[f32; 3]>) {
if let Ok(mut t) = SCRIPTED_TIP.lock() {
*t = tip;
}
}
struct Newer {
tracking_texture_count: Option<unsafe extern "C" fn(CpDrawable) -> usize>,
tracking_texture: Option<unsafe extern "C" fn(CpDrawable, usize) -> *mut c_void>,
add_tracking_area: Option<unsafe extern "C" fn(CpDrawable, u64) -> *mut c_void>,
render_value: Option<unsafe extern "C" fn(*mut c_void) -> u16>,
add_hover_effect: Option<unsafe extern "C" fn(*mut c_void) -> *mut c_void>,
query_drawables: Option<unsafe extern "C" fn(CpFrame) -> *mut c_void>,
drawable_count: Option<unsafe extern "C" fn(*mut c_void) -> usize>,
drawable_at: Option<unsafe extern "C" fn(*mut c_void, usize) -> CpDrawable>,
drawable_target: Option<unsafe extern "C" fn(CpDrawable) -> u32>,
}
unsafe extern "C" {
fn dlsym(handle: *mut c_void, symbol: *const std::ffi::c_char) -> *mut c_void;
}
#[link(name = "CompositorServices", kind = "framework")]
unsafe extern "C" {
fn cp_layer_renderer_set_minimum_frame_repeat_count(
layer_renderer: CpLayerRenderer,
count: i32,
);
}
impl Newer {
fn get() -> &'static Newer {
static NEWER: std::sync::OnceLock<Newer> = std::sync::OnceLock::new();
NEWER.get_or_init(|| {
let find =
|name: &std::ffi::CStr| unsafe { dlsym(-2isize as *mut c_void, name.as_ptr()) };
macro_rules! f {
($name:literal) => {{
let p = find($name);
(!p.is_null()).then(|| unsafe { std::mem::transmute::<*mut c_void, _>(p) })
}};
}
Newer {
tracking_texture_count: f!(c"cp_drawable_get_tracking_areas_texture_count"),
tracking_texture: f!(c"cp_drawable_get_tracking_areas_texture"),
add_tracking_area: f!(c"cp_drawable_add_tracking_area"),
render_value: f!(c"cp_tracking_area_get_render_value"),
add_hover_effect: f!(c"cp_tracking_area_add_automatic_hover_effect"),
query_drawables: f!(c"cp_frame_query_drawables"),
drawable_count: f!(c"cp_drawable_array_get_count"),
drawable_at: f!(c"cp_drawable_array_get_drawable"),
drawable_target: f!(c"cp_drawable_get_target"),
}
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SystemAccessibility {
pub reduce_motion: bool,
pub bold_text: bool,
pub increase_contrast: bool,
pub reduce_transparency: bool,
pub voice_over: bool,
pub dark: bool,
pub text_scale: f32,
}
impl Default for SystemAccessibility {
fn default() -> Self {
SystemAccessibility {
reduce_motion: false,
bold_text: false,
increase_contrast: false,
reduce_transparency: false,
voice_over: false,
dark: false,
text_scale: 1.0,
}
}
}
static ACCESSIBILITY: Mutex<Option<SystemAccessibility>> = Mutex::new(None);
#[unsafe(no_mangle)]
pub extern "C" fn threers_xr_set_accessibility(flags: u32, text_scale: f32) {
let a = SystemAccessibility {
reduce_motion: flags & 1 != 0,
bold_text: flags & 2 != 0,
increase_contrast: flags & 4 != 0,
reduce_transparency: flags & 8 != 0,
voice_over: flags & 16 != 0,
dark: flags & 32 != 0,
text_scale: if text_scale.is_finite() && text_scale > 0.0 {
text_scale.clamp(0.5, 4.0)
} else {
1.0
},
};
if let Ok(mut s) = ACCESSIBILITY.lock() {
*s = Some(a);
}
}
pub fn system_accessibility() -> Option<SystemAccessibility> {
ACCESSIBILITY.lock().ok().and_then(|s| *s)
}
type Announcer = extern "C" fn(*const std::ffi::c_char, bool);
static ANNOUNCER: Mutex<Option<Announcer>> = Mutex::new(None);
#[unsafe(no_mangle)]
pub extern "C" fn threers_xr_set_announcer(announcer: Option<Announcer>) {
if let Ok(mut a) = ANNOUNCER.lock() {
*a = announcer;
}
}
pub fn announce(message: &str, assertive: bool) -> bool {
let Some(f) = ANNOUNCER.lock().ok().and_then(|a| *a) else {
return false;
};
let Ok(text) = std::ffi::CString::new(message.replace('\0', " ")) else {
return false;
};
f(text.as_ptr(), assertive);
true
}
#[unsafe(no_mangle)]
pub extern "C" fn threers_xr_spatial_event(
id: u64,
phase: u32,
ox: f32,
oy: f32,
oz: f32,
dx: f32,
dy: f32,
dz: f32,
) {
if let Ok(mut q) = SPATIAL.lock() {
q.push(Spatial {
id,
phase,
origin: [ox, oy, oz],
direction: [dx, dy, dz],
});
}
}
#[link(name = "ARKit", kind = "framework")]
unsafe extern "C" {
fn ar_hand_tracking_provider_is_supported() -> bool;
fn ar_hand_tracking_configuration_create() -> *mut c_void;
fn ar_hand_tracking_provider_create(configuration: *mut c_void) -> *mut c_void;
fn ar_hand_anchor_create() -> *mut c_void;
fn ar_hand_tracking_provider_get_latest_anchors(
provider: *mut c_void,
left: *mut c_void,
right: *mut c_void,
) -> bool;
fn ar_hand_anchor_is_tracked(anchor: *mut c_void) -> bool;
fn ar_hand_anchor_get_hand_skeleton(anchor: *mut c_void) -> *mut c_void;
fn ar_hand_skeleton_get_joint_named(skeleton: *mut c_void, name: u64) -> *mut c_void;
#[link_name = "ar_hand_anchor_get_origin_from_anchor_transform"]
fn ar_hand_anchor_get_origin_from_anchor_transform_sym();
#[link_name = "ar_skeleton_joint_get_anchor_from_joint_transform"]
fn ar_skeleton_joint_get_anchor_from_joint_transform_sym();
#[link_name = "ar_release"]
fn ar_release_hand(object: *mut c_void);
}
const HAND_LEFT: u64 = 1 << 40;
const HAND_RIGHT: u64 = (1 << 40) + 1;
const HAND_RADII: [f32; 25] = [
0.02, 0.012, 0.01, 0.009, 0.008, 0.011, 0.01, 0.009, 0.008, 0.007, 0.011, 0.01, 0.009, 0.008,
0.007, 0.011, 0.01, 0.009, 0.008, 0.007, 0.011, 0.009, 0.008, 0.007, 0.006,
];
struct HandTracking {
provider: *mut c_void,
left: *mut c_void,
right: *mut c_void,
}
impl HandTracking {
fn new() -> Option<Self> {
unsafe {
if !ar_hand_tracking_provider_is_supported() {
return None;
}
let configuration = ar_hand_tracking_configuration_create();
let provider = ar_hand_tracking_provider_create(configuration);
ar_release_hand(configuration);
(!provider.is_null()).then(|| HandTracking {
provider,
left: ar_hand_anchor_create(),
right: ar_hand_anchor_create(),
})
}
}
unsafe fn latest(&self) -> Vec<(u64, Handedness, Vec<f32>)> {
let mut out = vec![];
if !unsafe {
ar_hand_tracking_provider_get_latest_anchors(self.provider, self.left, self.right)
} {
return out;
}
for (anchor, id, handed) in [
(self.left, HAND_LEFT, Handedness::Left),
(self.right, HAND_RIGHT, Handedness::Right),
] {
unsafe {
if !ar_hand_anchor_is_tracked(anchor) {
continue;
}
let skeleton = ar_hand_anchor_get_hand_skeleton(anchor);
if skeleton.is_null() {
continue;
}
let origin: Matrix4 = call_returning_float4x4(
ar_hand_anchor_get_origin_from_anchor_transform_sym,
anchor as usize,
0,
0,
)
.into();
let mut joints = Vec::with_capacity(25 * 16);
for k in 0..25u64 {
let joint = ar_hand_skeleton_get_joint_named(skeleton, k);
let local: Matrix4 = call_returning_float4x4(
ar_skeleton_joint_get_anchor_from_joint_transform_sym,
joint as usize,
0,
0,
)
.into();
joints.extend_from_slice(&origin.multiply(&local).elements);
}
out.push((id, handed, joints));
}
}
out
}
}
impl Drop for HandTracking {
fn drop(&mut self) {
unsafe {
ar_release_hand(self.left);
ar_release_hand(self.right);
ar_release_hand(self.provider);
}
}
}
pub enum Frame {
Draw(wgpu::TextureView),
Skip,
Ended,
}
#[derive(Debug, Clone, Copy)]
struct Eye {
pose: Matrix4,
projection: [f32; 16],
viewport: [i32; 4],
}
struct Current {
frame: CpFrame,
drawable: CpDrawable,
color: wgpu::Texture,
depth: Option<wgpu::Texture>,
hover: Option<wgpu::Texture>,
}
pub struct ImmersiveSession {
layer: CpLayerRenderer,
tracking: Option<WorldTracking>,
hands: Option<HandTracking>,
hands_now: Vec<(u64, Handedness, Vec<f32>)>,
device: Arc<wgpu::Device>,
queue: Arc<wgpu::Queue>,
near: f32,
far: f32,
see_through: bool,
current: Option<Current>,
eyes: Vec<Eye>,
head: Option<[f32; 16]>,
tracked: Option<Matrix4>,
untracked_head: Matrix4,
size: (u32, u32),
format: wgpu::TextureFormat,
slots: InputSlots<u64>,
rays: HashMap<u64, [f32; 16]>,
events: Vec<XrEvent>,
leaving: Vec<u64>,
hover_areas: std::cell::RefCell<HashMap<u64, u32>>,
}
unsafe impl Send for ImmersiveSession {}
impl ImmersiveSession {
pub unsafe fn new(layer_renderer: *mut c_void) -> Result<Self, String> {
let mut d = wgpu::InstanceDescriptor::new_without_display_handle();
d.backends = wgpu::Backends::METAL;
let instance = wgpu::Instance::new(d);
let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
apply_limit_buckets: false,
}))
.map_err(|e| format!("no Metal adapter: {e}"))?;
let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
label: Some("threers visionOS"),
required_limits: adapter.limits(),
..Default::default()
}))
.map_err(|e| format!("no device: {e}"))?;
let hands = HandTracking::new();
Ok(ImmersiveSession {
layer: layer_renderer,
tracking: WorldTracking::with_providers(
&hands.as_ref().map(|h| vec![h.provider]).unwrap_or_default(),
)
.ok(),
hands,
hands_now: vec![],
device: Arc::new(device),
queue: Arc::new(queue),
near: 0.1,
far: 100.0,
see_through: false,
current: None,
eyes: vec![],
head: None,
tracked: None,
untracked_head: Matrix4::translation(Vector3::new(0.0, 1.6, 0.0)),
size: (1, 1),
format: wgpu::TextureFormat::Bgra8UnormSrgb,
slots: InputSlots::new(),
rays: HashMap::new(),
events: vec![],
leaving: vec![],
hover_areas: Default::default(),
})
}
pub fn device(&self) -> Arc<wgpu::Device> {
self.device.clone()
}
pub fn queue(&self) -> Arc<wgpu::Queue> {
self.queue.clone()
}
pub fn format(&self) -> wgpu::TextureFormat {
self.format
}
pub fn set_depth_range(&mut self, near: f32, far: f32) {
(self.near, self.far) = (near.max(0.1), far.max(near.max(0.1) + 0.01));
}
pub fn set_see_through(&mut self, on: bool) {
self.see_through = on;
}
pub fn set_frame_repeat(&self, count: u32) {
unsafe {
cp_layer_renderer_set_minimum_frame_repeat_count(self.layer, count.min(8) as i32)
};
}
pub fn begin_frame(&mut self) -> Frame {
unsafe {
match LayerRendererState::from_raw(cp_layer_renderer_get_state(self.layer)) {
LayerRendererState::Invalidated => return Frame::Ended,
LayerRendererState::Paused => {
cp_layer_renderer_wait_until_running(self.layer);
return Frame::Skip;
}
LayerRendererState::Running => {}
}
let frame = cp_layer_renderer_query_next_frame(self.layer);
if frame.is_null() {
return Frame::Skip;
}
let timing = cp_frame_predict_timing(frame);
if !timing.is_null() {
cp_time_wait_until(cp_frame_timing_get_optimal_input_time(timing));
}
cp_frame_start_update(frame);
self.take_spatial();
self.read_hands();
cp_frame_end_update(frame);
cp_frame_start_submission(frame);
let drawable = Self::query_drawable(frame);
if drawable.is_null() {
cp_frame_end_submission(frame);
return Frame::Skip;
}
cp_drawable_set_depth_range(
drawable,
SimdFloat2 {
x: self.far,
y: self.near,
},
);
let origin_from_device = self.device_anchor(drawable);
self.head = Some(origin_from_device.elements);
let color_raw = cp_drawable_get_color_texture(drawable, 0) as *mut c_void;
let depth_raw = cp_drawable_get_depth_texture(drawable, 0) as *mut c_void;
let Some(color) = self.wrap(color_raw, wgpu::TextureUsages::RENDER_ATTACHMENT) else {
cp_frame_end_submission(frame);
return Frame::Skip;
};
self.size = (color.width(), color.height());
self.format = color.format();
let depth = self.wrap(depth_raw, wgpu::TextureUsages::RENDER_ATTACHMENT);
self.hover_areas.borrow_mut().clear();
let newer = Newer::get();
let hover = match (newer.tracking_texture_count, newer.tracking_texture) {
(Some(count), Some(get)) if count(drawable) > 0 => {
self.wrap(get(drawable, 0), wgpu::TextureUsages::RENDER_ATTACHMENT)
}
_ => None,
};
self.eyes.clear();
let count = cp_drawable_get_view_count(drawable);
for i in 0..count {
let view = cp_drawable_get_view(drawable, i);
if view.is_null() {
continue;
}
let device_from_eye: Matrix4 = cp_view_get_transform(view).into();
let reversed: Matrix4 =
cp_drawable_compute_projection(drawable, AxisConvention::RightUpBack as u8, i)
.into();
let mut projection = reversed.elements;
for c in 0..4 {
projection[c * 4 + 2] = projection[c * 4 + 3] - projection[c * 4 + 2];
}
let map = cp_view_get_view_texture_map(view);
let viewport = if map.is_null() {
[0, 0, self.size.0 as i32, self.size.1 as i32]
} else {
let v = cp_view_texture_map_get_viewport(map);
let (x, y, w, h) = (
v.origin_x as i32,
v.origin_y as i32,
v.width as i32,
v.height as i32,
);
[x, self.size.1 as i32 - y - h, w, h]
};
self.eyes.push(Eye {
pose: origin_from_device.multiply(&device_from_eye),
projection,
viewport,
});
}
if std::env::var_os("THREERS_XR_DEBUG").is_some() {
eprintln!(
"threers xr: {:?} {:?} head {:?} eyes {:?}",
self.size, self.format, self.head, self.eyes
);
}
let target = color.create_view(&Default::default());
self.current = Some(Current {
frame,
drawable,
color,
depth,
hover,
});
Frame::Draw(target)
}
}
pub fn end_frame(&mut self) {
let Some(cur) = self.current.take() else {
return;
};
if let Some(depth) = &cur.depth {
let view = depth.create_view(&Default::default());
let mut encoder = self.device.create_command_encoder(&Default::default());
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("threers visionOS depth"),
color_attachments: &[],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(0.0),
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
}),
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
});
self.queue.submit(Some(encoder.finish()));
}
unsafe {
if let Some(hal) = self.queue.as_hal::<wgpu::hal::api::Metal>()
&& let Some(buffer) = hal.as_raw().commandBuffer()
{
cp_drawable_encode_present(
cur.drawable,
Retained::as_ptr(&buffer) as *mut c_void as _,
);
buffer.commit();
}
cp_frame_end_submission(cur.frame);
}
drop(cur.color);
}
unsafe fn query_drawable(frame: CpFrame) -> CpDrawable {
let newer = Newer::get();
let (Some(all), Some(count), Some(get), Some(target)) = (
newer.query_drawables,
newer.drawable_count,
newer.drawable_at,
newer.drawable_target,
) else {
return unsafe { cp_frame_query_drawable(frame) };
};
let array = unsafe { all(frame) };
if array.is_null() {
return std::ptr::null_mut();
}
let n = unsafe { count(array) };
let drawables: Vec<CpDrawable> = (0..n)
.map(|i| unsafe { get(array, i) })
.filter(|d| !d.is_null())
.collect();
drawables
.iter()
.copied()
.find(|&d| unsafe { target(d) } == 0)
.or(drawables.first().copied())
.unwrap_or(std::ptr::null_mut())
}
unsafe fn device_anchor(&mut self, drawable: CpDrawable) -> Matrix4 {
let fallback = self.tracked.unwrap_or(self.untracked_head);
let Some(tracking) = &self.tracking else {
return fallback;
};
let timing = unsafe { cp_drawable_get_frame_timing(drawable) };
if timing.is_null() {
return fallback;
}
let at =
unsafe { cp_time_to_cf_time_interval(cp_frame_timing_get_presentation_time(timing)) };
match tracking.device_pose(at) {
Some(pose) if pose != Matrix4::identity() => {
unsafe { cp_drawable_set_device_anchor(drawable, tracking.anchor_ptr()) };
self.tracked = Some(pose);
pose
}
_ => fallback,
}
}
pub fn set_untracked_head(&mut self, pose: Matrix4) {
self.untracked_head = pose;
}
pub fn is_tracked(&self) -> bool {
self.tracked.is_some()
}
unsafe fn wrap(&self, raw: *mut c_void, usage: wgpu::TextureUsages) -> Option<wgpu::Texture> {
let texture: Retained<ProtocolObject<dyn MTLTexture>> =
unsafe { Retained::retain(raw.cast()) }?;
let format = match texture.pixelFormat() {
MTLPixelFormat::BGRA8Unorm_sRGB => wgpu::TextureFormat::Bgra8UnormSrgb,
MTLPixelFormat::BGRA8Unorm => wgpu::TextureFormat::Bgra8Unorm,
MTLPixelFormat::RGBA8Unorm_sRGB => wgpu::TextureFormat::Rgba8UnormSrgb,
MTLPixelFormat::RGBA8Unorm => wgpu::TextureFormat::Rgba8Unorm,
MTLPixelFormat::RGBA16Float => wgpu::TextureFormat::Rgba16Float,
MTLPixelFormat::Depth32Float => wgpu::TextureFormat::Depth32Float,
MTLPixelFormat::R8Uint => wgpu::TextureFormat::R8Uint,
MTLPixelFormat::R16Uint => wgpu::TextureFormat::R16Uint,
_ => return None,
};
let (w, h, layers) = (
texture.width() as u32,
texture.height() as u32,
(texture.arrayLength() as u32).max(1),
);
let kind = texture.textureType();
let hal = unsafe {
wgpu::hal::metal::Device::texture_from_raw(
texture,
format,
kind,
layers,
1,
wgpu::hal::CopyExtent {
width: w,
height: h,
depth: 1,
},
None,
)
};
let desc = wgpu::TextureDescriptor {
label: Some("threers visionOS drawable"),
size: wgpu::Extent3d {
width: w,
height: h,
depth_or_array_layers: layers,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage,
view_formats: &[],
};
Some(unsafe {
self.device
.create_texture_from_hal::<wgpu::hal::api::Metal>(
hal,
&desc,
wgpu::TextureUses::UNINITIALIZED,
)
})
}
fn read_hands(&mut self) {
let mut now = match &self.hands {
Some(h) => unsafe { h.latest() },
None => vec![],
};
if let Some([x, y, z]) = SCRIPTED_TIP.lock().ok().and_then(|t| *t) {
now.retain(|h| h.0 != HAND_RIGHT);
let joints = Matrix4::translation(Vector3::new(x, y, z))
.elements
.repeat(25);
now.push((HAND_RIGHT, Handedness::Right, joints));
}
for (id, _) in [(HAND_LEFT, ()), (HAND_RIGHT, ())] {
let tracked = now.iter().any(|x| x.0 == id);
match (tracked, self.slots.slot_of(&id)) {
(true, None) => {
let slot = self.slots.connect(id);
self.events.push(XrEvent {
kind: XrEventKind::Connected,
slot,
});
}
(false, Some(slot)) => {
self.slots.disconnect(&id);
self.events.push(XrEvent {
kind: XrEventKind::Disconnected,
slot,
});
}
_ => {}
}
}
self.hands_now = now;
}
fn take_spatial(&mut self) {
for id in std::mem::take(&mut self.leaving) {
if let Some(slot) = self.slots.disconnect(&id) {
self.events.push(XrEvent {
kind: XrEventKind::Disconnected,
slot,
});
}
self.rays.remove(&id);
}
let events = SPATIAL
.lock()
.map(|mut q| std::mem::take(&mut *q))
.unwrap_or_default();
for e in events {
self.rays.insert(
e.id,
super::ray_pose(
Vector3::new(e.origin[0], e.origin[1], e.origin[2]),
Vector3::new(e.direction[0], e.direction[1], e.direction[2]),
),
);
let starts = e.phase == 0 || (e.phase == 1 && self.slots.slot_of(&e.id).is_none());
match e.phase {
_ if starts => {
let slot = self.slots.connect(e.id);
self.events.push(XrEvent {
kind: XrEventKind::Connected,
slot,
});
self.events.push(XrEvent {
kind: XrEventKind::SelectStart,
slot,
});
}
2 | 3 => {
if let Some(slot) = self.slots.slot_of(&e.id) {
self.events.push(XrEvent {
kind: XrEventKind::SelectEnd,
slot,
});
if e.phase == 2 {
self.events.push(XrEvent {
kind: XrEventKind::Select,
slot,
});
}
}
self.leaving.push(e.id);
}
_ => {}
}
}
}
}
impl XrSource for ImmersiveSession {
fn head(&self) -> Option<[f32; 16]> {
self.head
}
fn eyes(&self, origin: &Matrix4) -> Vec<XrEye> {
self.eyes
.iter()
.map(|e| XrEye {
projection: e.projection,
world: origin.multiply(&e.pose),
viewport: e.viewport,
})
.collect()
}
fn framebuffer_size(&self) -> (u32, u32) {
self.size
}
fn inputs(&self) -> Vec<XrInput> {
self.slots
.iter()
.map(
|(slot, id)| match self.hands_now.iter().find(|h| h.0 == *id) {
Some((_, handedness, joints)) => XrInput {
slot,
handedness: *handedness,
joints: Some((joints.clone(), HAND_RADII.to_vec())),
..Default::default()
},
None => XrInput {
slot,
target_ray_mode: TargetRayMode::TransientPointer,
ray: self.rays.get(id).copied(),
..Default::default()
},
},
)
.collect()
}
fn take_events(&mut self) -> Vec<XrEvent> {
std::mem::take(&mut self.events)
}
fn see_through(&self) -> bool {
self.see_through
}
fn hover_target(&self) -> Option<super::HoverTarget> {
let t = self.current.as_ref()?.hover.as_ref()?;
Some(super::HoverTarget {
view: t.create_view(&Default::default()),
format: t.format(),
size: (t.width(), t.height()),
})
}
fn declare_hover(&self, id: u64) -> Option<u32> {
let cur = self.current.as_ref()?;
cur.hover.as_ref()?;
if id == 0 {
return None;
}
if let Some(&v) = self.hover_areas.borrow().get(&id) {
return Some(v);
}
let newer = Newer::get();
let (add, value) = (newer.add_tracking_area?, newer.render_value?);
let area = unsafe { add(cur.drawable, id) };
if area.is_null() {
return None;
}
if let Some(effect) = newer.add_hover_effect {
unsafe { effect(area) };
}
let v = unsafe { value(area) } as u32;
(v != 0).then(|| {
self.hover_areas.borrow_mut().insert(id, v);
v
})
}
}
pub unsafe fn run<A: super::App>(layer_renderer: *mut c_void) {
let mut session = match unsafe { ImmersiveSession::new(layer_renderer) } {
Ok(s) => s,
Err(e) => {
eprintln!("threers: no immersive session: {e}");
return;
}
};
let mut scene = crate::scene::Scene::new();
let mut app = A::setup(&mut scene);
let lens = app.lens();
session.set_depth_range(lens.near, lens.far);
let (device, queue) = (session.device(), session.queue());
let mut renderer: Option<crate::renderer::Renderer> = None;
let start = std::time::Instant::now();
let mut last = 0.0;
loop {
let target = match session.begin_frame() {
Frame::Draw(target) => target,
Frame::Skip => continue,
Frame::Ended => break,
};
let time = start.elapsed().as_secs_f64();
let frame = super::Frame::take(&mut session, time, time - last);
last = time;
app.update(&mut scene, &frame);
if frame.see_through {
scene.background_alpha = 0.0;
}
let (w, h) = session.framebuffer_size();
let format = session.format();
let renderer = renderer.get_or_insert_with(|| {
crate::renderer::Renderer::new_lazy(device.clone(), queue.clone(), format, w, h)
});
let mut gpu = super::Gpu {
device: &device,
queue: &queue,
format,
target: &target,
renderer,
source: &session,
};
app.draw(&mut scene, &frame, &mut gpu);
session.end_frame();
}
}