Avii/bevy_oxr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

changed vulkan init code

Browse Source
This commit is contained in:
Schmarni
2024-01-09 20:34:10 +01:00
parent b2efa802cb
commit aae751bdab
16 changed files with 191 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/graphics/mod.rs
View File

@@ -7,8 +7,8 @@ use wgpu::Instance;
use crate::input::XrInput;
use crate::resources::{
XrEnvironmentBlendMode, XrFormat, XrFrameState, XrFrameWaiter, XrInstance, XrResolution,
XrSession, XrSessionRunning, XrSwapchain, XrViews,
XrEnvironmentBlendMode, XrFormat, XrFrameState, XrInstance, XrResolution, XrSession,
XrSessionRunning, XrSwapchain, XrViews, XrFrameWaiter,
};
use openxr as xr;
@@ -44,7 +44,7 @@ pub fn initialize_xr_graphics(
reqeusted_extensions: XrExtensions,
prefered_blend_mode: XrPreferdBlendMode,
app_info: XrAppInfo,
) -> anyhow::Result<(
) -> eyre::Result<(
RenderDevice,
RenderQueue,
RenderAdapterInfo,
@@ -62,13 +62,14 @@ pub fn initialize_xr_graphics(
XrViews,
XrFrameState,
)> {
vulkan::initialize_xr_graphics(window, reqeusted_extensions, prefered_blend_mode, app_info)
// vulkan::initialize_xr_graphics(window, reqeusted_extensions, prefered_blend_mode, app_info)
todo!()
}
pub fn xr_entry() -> anyhow::Result<xr::Entry> {
pub fn xr_entry() -> eyre::Result<xr::Entry> {
#[cfg(windows)]
let entry = Ok(xr::Entry::linked());
#[cfg(not(windows))]
let entry = unsafe { xr::Entry::load().map_err(|e| anyhow::anyhow!(e)) };
let entry = unsafe { xr::Entry::load().map_err(|e| eyre::eyre!(e)) };
entry
}

107
src/graphics/vulkan.rs
View File

@@ -1,52 +1,45 @@
use std::ffi::{c_void, CString};
use std::sync::atomic::AtomicBool;
use std::sync::{Arc, Mutex};
use std::sync::Mutex;
use anyhow::Context;
// use anyhow::Context;
use ash::vk::{self, Handle};
use bevy::math::uvec2;
use bevy::prelude::*;
use bevy::render::renderer::{RenderAdapter, RenderAdapterInfo, RenderDevice, RenderQueue};
use bevy::window::RawHandleWrapper;
use eyre::{Context, ContextCompat};
use openxr as xr;
use wgpu::Instance;
use wgpu_hal::{api::Vulkan as V, Api};
use xr::EnvironmentBlendMode;
use crate::graphics::extensions::XrExtensions;
use crate::input::XrInput;
use crate::resources::{
Swapchain, SwapchainInner, XrEnvironmentBlendMode, XrFormat, XrFrameState, XrFrameWaiter,
XrInstance, XrResolution, XrSession, XrSessionRunning, XrSwapchain, XrViews,
OXrSessionSetupInfo, Swapchain, SwapchainInner, VulkanOXrSessionSetupInfo,
XrEnvironmentBlendMode, XrFormat, XrFrameState, XrFrameWaiter, XrInstance, XrResolution,
XrSession, XrSessionRunning, XrSwapchain, XrViews,
};
use crate::VIEW_TYPE;
use super::{XrAppInfo, XrPreferdBlendMode};
pub fn initialize_xr_graphics(
pub fn initialize_xr_instance(
window: Option<RawHandleWrapper>,
reqeusted_extensions: XrExtensions,
prefered_blend_mode: XrPreferdBlendMode,
app_info: XrAppInfo,
) -> anyhow::Result<(
) -> eyre::Result<(
XrInstance,
OXrSessionSetupInfo,
XrEnvironmentBlendMode,
RenderDevice,
RenderQueue,
RenderAdapterInfo,
RenderAdapter,
Instance,
XrInstance,
XrSession,
XrEnvironmentBlendMode,
XrResolution,
XrFormat,
XrSessionRunning,
XrFrameWaiter,
XrSwapchain,
XrInput,
XrViews,
XrFrameState,
)> {
use wgpu_hal::{api::Vulkan as V, Api};
let xr_entry = super::xr_entry()?;
#[cfg(target_os = "android")]
@@ -108,7 +101,6 @@ pub fn initialize_xr_graphics(
_ => EnvironmentBlendMode::OPAQUE,
};
#[cfg(not(target_os = "android"))]
let vk_target_version = vk::make_api_version(0, 1, 2, 0);
#[cfg(not(target_os = "android"))]
@@ -296,22 +288,66 @@ pub fn initialize_xr_graphics(
None,
)
}?;
Ok((
xr_instance.into(),
OXrSessionSetupInfo::Vulkan(VulkanOXrSessionSetupInfo {
device_ptr: vk_device_ptr,
physical_device_ptr: vk_physical_device_ptr,
vk_instance_ptr,
queue_family_index,
xr_system_id,
}),
blend_mode.into(),
wgpu_device.into(),
RenderQueue(wgpu_queue.into()),
RenderAdapterInfo(wgpu_adapter.get_info()),
RenderAdapter(wgpu_adapter.into()),
wgpu_instance.into(),
))
}
pub fn initialize_xr_graphics(
window: Option<RawHandleWrapper>,
ptrs: &OXrSessionSetupInfo,
xr_instance: &XrInstance,
render_device: &RenderDevice,
render_adapter: &RenderAdapter,
wgpu_instance: &Instance,
) -> eyre::Result<(
XrInstance,
XrSession,
XrResolution,
XrFormat,
XrSessionRunning,
XrFrameWaiter,
XrSwapchain,
XrInput,
XrViews,
XrFrameState,
)> {
let wgpu_device = render_device.wgpu_device();
let wgpu_adapter = &render_adapter.0;
#[allow(unreachable_patterns)]
let setup_info = match ptrs {
OXrSessionSetupInfo::Vulkan(v) => v,
_ => eyre::bail!("Wrong Graphics Api"),
};
let (session, frame_wait, frame_stream) = unsafe {
xr_instance.create_session::<xr::Vulkan>(
xr_system_id,
xr_instance.system(xr::FormFactor::HEAD_MOUNTED_DISPLAY)?,
&xr::vulkan::SessionCreateInfo {
instance: vk_instance_ptr,
physical_device: vk_physical_device_ptr,
device: vk_device_ptr,
queue_family_index,
instance: setup_info.vk_instance_ptr,
physical_device: setup_info.physical_device_ptr,
device: setup_info.device_ptr,
queue_family_index: setup_info.queue_family_index,
queue_index: 0,
},
)
}?;
let views = xr_instance.enumerate_view_configuration_views(xr_system_id, VIEW_TYPE)?;
let views =
xr_instance.enumerate_view_configuration_views(setup_info.xr_system_id, VIEW_TYPE)?;
let surface = window.map(|wrapper| unsafe {
// SAFETY: Plugins should be set up on the main thread.
let handle = wrapper.get_handle();
@@ -346,6 +382,7 @@ pub fn initialize_xr_graphics(
mip_count: 1,
})
.unwrap();
let images = handle.enumerate_images().unwrap();
let buffers = images
@@ -399,18 +436,12 @@ pub fn initialize_xr_graphics(
.collect();
Ok((
wgpu_device.into(),
RenderQueue(Arc::new(wgpu_queue)),
RenderAdapterInfo(wgpu_adapter.get_info()),
RenderAdapter(Arc::new(wgpu_adapter)),
wgpu_instance,
xr_instance.clone().into(),
session.clone().into_any_graphics().into(),
blend_mode.into(),
resolution.into(),
swapchain_format.into(),
AtomicBool::new(false).into(),
Mutex::new(frame_wait).into(),
frame_wait.into(),
Swapchain::Vulkan(SwapchainInner {
stream: Mutex::new(frame_stream),
handle: Mutex::new(handle),
@@ -418,13 +449,13 @@ pub fn initialize_xr_graphics(
image_index: Mutex::new(0),
})
.into(),
XrInput::new(xr_instance, session.into_any_graphics())?,
Mutex::default().into(),
Mutex::new(xr::FrameState {
XrInput::new(xr_instance, &session.into_any_graphics())?,
Vec::default().into(),
xr::FrameState {
predicted_display_time: xr::Time::from_nanos(1),
predicted_display_period: xr::Duration::from_nanos(1),
should_render: true,
})
}
.into(),
))
}

4
src/input.rs
View File

@@ -16,8 +16,8 @@ pub struct XrInput {
impl XrInput {
pub fn new(
instance: xr::Instance,
session: xr::Session<xr::AnyGraphics>,
instance: &xr::Instance,
session: &xr::Session<xr::AnyGraphics>,
// frame_state: &FrameState,
) -> xr::Result<Self> {
// let right_hand_subaction_path = instance.string_to_path("/user/hand/right").unwrap();

39
src/lib.rs
View File

@@ -26,7 +26,7 @@ use input::XrInput;
use openxr as xr;
// use passthrough::{start_passthrough, supports_passthrough, XrPassthroughLayer};
use resources::*;
use xr::FormFactor;
use xr::{FormFactor, FrameWaiter};
use xr_init::{xr_only, XrEnableStatus, XrRenderData};
use xr_input::controllers::XrControllerType;
use xr_input::hands::emulated::HandEmulationPlugin;
@@ -57,7 +57,7 @@ pub struct FutureXrResources(
XrResolution,
XrFormat,
XrSessionRunning,
XrFrameWaiter,
// XrFrameWaiter,
XrSwapchain,
XrInput,
XrViews,
@@ -110,7 +110,7 @@ impl Plugin for OpenXrPlugin {
app.insert_resource(resolution.clone());
app.insert_resource(format.clone());
app.insert_resource(session_running.clone());
app.insert_resource(frame_waiter.clone());
app.insert_resource(frame_waiter);
app.insert_resource(swapchain.clone());
app.insert_resource(input.clone());
app.insert_resource(views.clone());
@@ -122,7 +122,6 @@ impl Plugin for OpenXrPlugin {
xr_resolution: resolution,
xr_format: format,
xr_session_running: session_running,
xr_frame_waiter: frame_waiter,
xr_swapchain: swapchain,
xr_input: input,
xr_views: views,
@@ -221,7 +220,7 @@ impl Plugin for OpenXrPlugin {
render_app.insert_resource(data.xr_resolution.clone());
render_app.insert_resource(data.xr_format.clone());
render_app.insert_resource(data.xr_session_running.clone());
render_app.insert_resource(data.xr_frame_waiter.clone());
// render_app.insert_resource(data.xr_frame_waiter.clone());
render_app.insert_resource(data.xr_swapchain.clone());
render_app.insert_resource(data.xr_input.clone());
render_app.insert_resource(data.xr_views.clone());
@@ -286,10 +285,10 @@ pub fn xr_begin_frame(
instance: Res<XrInstance>,
session: Res<XrSession>,
session_running: Res<XrSessionRunning>,
frame_state: Res<XrFrameState>,
frame_waiter: Res<XrFrameWaiter>,
mut frame_state: ResMut<XrFrameState>,
mut frame_waiter: ResMut<XrFrameWaiter>,
swapchain: Res<XrSwapchain>,
views: Res<XrViews>,
mut views: ResMut<XrViews>,
input: Res<XrInput>,
mut app_exit: EventWriter<AppExit>,
) {
@@ -303,6 +302,7 @@ pub fn xr_begin_frame(
// find quit messages!
info!("entered XR state {:?}", e.state());
match e.state() {
// xr_frame_waiter: frame_waiter,
xr::SessionState::READY => {
session.begin(VIEW_TYPE).unwrap();
session_running.store(true, std::sync::atomic::Ordering::Relaxed);
@@ -316,6 +316,7 @@ pub fn xr_begin_frame(
app_exit.send(AppExit);
return;
}
_ => {}
}
}
@@ -329,8 +330,8 @@ pub fn xr_begin_frame(
}
{
let _span = info_span!("xr_wait_frame").entered();
*frame_state.lock().unwrap() = match frame_waiter.lock().unwrap().wait() {
Ok(a) => a,
*frame_state = match frame_waiter.wait() {
Ok(a) => a.into(),
Err(e) => {
warn!("error: {}", e);
return;
@@ -343,12 +344,8 @@ pub fn xr_begin_frame(
}
{
let _span = info_span!("xr_locate_views").entered();
*views.lock().unwrap() = session
.locate_views(
VIEW_TYPE,
frame_state.lock().unwrap().predicted_display_time,
&input.stage,
)
**views = session
.locate_views(VIEW_TYPE, frame_state.predicted_display_time, &input.stage)
.unwrap()
.1;
}
@@ -402,8 +399,8 @@ pub fn end_frame(
{
let _span = info_span!("xr_end_frame").entered();
let result = swapchain.end(
xr_frame_state.lock().unwrap().predicted_display_time,
&views.lock().unwrap(),
xr_frame_state.predicted_display_time,
&views,
&input.stage,
**resolution,
**environment_blend_mode,
@@ -417,15 +414,15 @@ pub fn end_frame(
}
pub fn locate_views(
views: Res<XrViews>,
mut views: ResMut<XrViews>,
input: Res<XrInput>,
session: Res<XrSession>,
xr_frame_state: Res<XrFrameState>,
) {
let _span = info_span!("xr_locate_views").entered();
*views.lock().unwrap() = match session.locate_views(
**views = match session.locate_views(
VIEW_TYPE,
xr_frame_state.lock().unwrap().predicted_display_time,
xr_frame_state.predicted_display_time,
&input.stage,
) {
Ok(this) => this,

55
src/resource_macros.rs
View File

@@ -1,7 +1,7 @@
#[macro_export]
macro_rules! xr_resource_wrapper {
($wrapper_type:ident, $xr_type:ty) => {
#[derive(Clone, bevy::prelude::Resource)]
#[derive(Clone, bevy::prelude::Resource, bevy::prelude::Deref, bevy::prelude::DerefMut)]
pub struct $wrapper_type($xr_type);
impl $wrapper_type {
@@ -10,13 +10,13 @@ macro_rules! xr_resource_wrapper {
}
}
impl std::ops::Deref for $wrapper_type {
type Target = $xr_type;
fn deref(&self) -> &Self::Target {
&self.0
}
}
// impl std::ops::Deref for $wrapper_type {
// type Target = $xr_type;
//
// fn deref(&self) -> &Self::Target {
// &self.0
// }
// }
impl From<$xr_type> for $wrapper_type {
fn from(value: $xr_type) -> Self {
@@ -29,7 +29,7 @@ macro_rules! xr_resource_wrapper {
#[macro_export]
macro_rules! xr_arc_resource_wrapper {
($wrapper_type:ident, $xr_type:ty) => {
#[derive(Clone, bevy::prelude::Resource)]
#[derive(Clone, bevy::prelude::Resource, bevy::prelude::Deref, bevy::prelude::DerefMut)]
pub struct $wrapper_type(std::sync::Arc<$xr_type>);
impl $wrapper_type {
@@ -38,13 +38,41 @@ macro_rules! xr_arc_resource_wrapper {
}
}
impl std::ops::Deref for $wrapper_type {
type Target = $xr_type;
// impl std::ops::Deref for $wrapper_type {
// type Target = $xr_type;
//
// fn deref(&self) -> &Self::Target {
// self.0.as_ref()
// }
// }
fn deref(&self) -> &Self::Target {
self.0.as_ref()
impl From<$xr_type> for $wrapper_type {
fn from(value: $xr_type) -> Self {
Self::new(value)
}
}
};
}
#[macro_export]
macro_rules! xr_no_clone_resource_wrapper {
($wrapper_type:ident, $xr_type:ty) => {
#[derive(bevy::prelude::Resource, bevy::prelude::Deref, bevy::prelude::DerefMut)]
pub struct $wrapper_type($xr_type);
impl $wrapper_type {
pub fn new(value: $xr_type) -> Self {
Self(value)
}
}
// impl std::ops::Deref for $wrapper_type {
// type Target = $xr_type;
//
// fn deref(&self) -> &Self::Target {
// &self.0
// }
// }
impl From<$xr_type> for $wrapper_type {
fn from(value: $xr_type) -> Self {
@@ -55,4 +83,5 @@ macro_rules! xr_arc_resource_wrapper {
}
pub use xr_arc_resource_wrapper;
pub use xr_no_clone_resource_wrapper;
pub use xr_resource_wrapper;

21
src/resources.rs
View File

@@ -1,3 +1,4 @@
use std::ffi::c_void;
use std::sync::atomic::AtomicBool;
use std::sync::Mutex;
@@ -5,17 +6,31 @@ use std::sync::Mutex;
use crate::resource_macros::*;
use bevy::prelude::*;
use openxr as xr;
use xr::ViewConfigurationView;
xr_resource_wrapper!(XrInstance, xr::Instance);
xr_resource_wrapper!(XrSession, xr::Session<xr::AnyGraphics>);
xr_resource_wrapper!(XrEnvironmentBlendMode, xr::EnvironmentBlendMode);
xr_resource_wrapper!(XrResolution, UVec2);
xr_resource_wrapper!(XrFormat, wgpu::TextureFormat);
xr_resource_wrapper!(XrFrameState, xr::FrameState);
xr_resource_wrapper!(XrViews, Vec<xr::View>);
xr_arc_resource_wrapper!(XrSessionRunning, AtomicBool);
xr_arc_resource_wrapper!(XrFrameWaiter, Mutex<xr::FrameWaiter>);
xr_arc_resource_wrapper!(XrSwapchain, Swapchain);
xr_arc_resource_wrapper!(XrFrameState, Mutex<xr::FrameState>);
xr_arc_resource_wrapper!(XrViews, Mutex<Vec<xr::View>>);
xr_no_clone_resource_wrapper!(XrFrameWaiter, xr::FrameWaiter);
pub(crate) struct VulkanOXrSessionSetupInfo {
pub(crate) device_ptr: *const c_void,
pub(crate) physical_device_ptr: *const c_void,
pub(crate) vk_instance_ptr: *const c_void,
pub(crate) queue_family_index: u32,
pub(crate) xr_system_id: xr::SystemId,
// pub(crate) swapchain_create_info: xr::SwapchainCreateInfo<xr::Vulkan>
}
pub(crate) enum OXrSessionSetupInfo {
Vulkan(VulkanOXrSessionSetupInfo),
}
pub enum Swapchain {
Vulkan(SwapchainInner<xr::Vulkan>),

19
src/xr_init.rs
View File

@@ -11,16 +11,16 @@ use bevy::{
renderer::{self, RenderAdapter, RenderAdapterInfo, RenderDevice, RenderQueue},
settings::WgpuSettings,
},
window::RawHandleWrapper,
window::{RawHandleWrapper, PrimaryWindow},
};
use wgpu::Instance;
use crate::{
input::XrInput,
resources::{
XrEnvironmentBlendMode, XrFormat, XrFrameState, XrFrameWaiter, XrInstance, XrResolution,
XrSession, XrSessionRunning, XrSwapchain, XrViews,
},
XrEnvironmentBlendMode, XrFormat, XrFrameState, XrInstance, XrResolution, XrSession,
XrSessionRunning, XrSwapchain, XrViews,
}, graphics,
};
#[derive(Resource, Clone)]
@@ -40,7 +40,7 @@ pub struct XrRenderData {
pub xr_resolution: XrResolution,
pub xr_format: XrFormat,
pub xr_session_running: XrSessionRunning,
pub xr_frame_waiter: XrFrameWaiter,
// pub xr_frame_waiter: XrFrameWaiter,
pub xr_swapchain: XrSwapchain,
pub xr_input: XrInput,
pub xr_views: XrViews,
@@ -174,6 +174,14 @@ pub fn update_xr_stuff(world: &mut World) {
world.run_schedule(XrPostRenderUpdate);
}
fn setup_xr_graphics() {
}
fn enable_xr(
) {}
// fn handle_xr_enable_requests(
// primary_window: Query<&RawHandleWrapper, With<PrimaryWindow>>,
// mut commands: Commands,
@@ -183,7 +191,6 @@ pub fn update_xr_stuff(world: &mut World) {
// // Just to force this system onto the main thread because of unsafe code
// let _ = on_main;
//
// commands.insert_resource(XrEnableStatus::Waiting);
// let (creation_data, xr_data) = match next_state.into_inner() {
// XrNextEnabledState::Enabled => {
// let (

2
src/xr_input/actions.rs
View File

@@ -206,7 +206,7 @@ impl SetupActionSet {
for binding in bindings {
self.actions
.get_mut(binding.action)
.ok_or(anyhow::anyhow!("Missing Action: {}", binding.action))
.ok_or(eyre::eyre!("Missing Action: {}", binding.action))
.unwrap()
.bindings
.entry(device_path)

2
src/xr_input/debug_gizmos.rs
View File

@@ -91,7 +91,7 @@ pub fn draw_gizmos(
// }
// }
//lock frame
let frame_state = *frame_state.lock().unwrap();
// let frame_state = *frame_state.lock().unwrap();
//get controller
let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets);
let root = tracking_root_query.get_single();

2
src/xr_input/hands/hand_tracking.rs
View File

@@ -87,7 +87,7 @@ impl<'a> HandTrackingRef<'a> {
Hand::Left => &self.tracking.left_hand,
Hand::Right => &self.tracking.right_hand,
},
self.frame_state.lock().unwrap().predicted_display_time,
self.frame_state.predicted_display_time,
)
.unwrap()
.map(|joints| {

2
src/xr_input/oculus_touch.rs
View File

@@ -371,7 +371,7 @@ pub struct OculusController {
pub aim_space: Option<Handed<Space>>,
}
impl OculusController {
pub fn new(mut action_sets: ResMut<SetupActionSets>) -> anyhow::Result<Self> {
pub fn new(mut action_sets: ResMut<SetupActionSets>) -> eyre::Result<Self> {
let action_set =
action_sets.add_action_set("oculus_input", "Oculus Touch Controller Input".into(), 0);
action_set.new_action(

20
src/xr_input/prototype_locomotion.rs
View File

@@ -70,17 +70,13 @@ pub fn proto_locomotion(
config_option: Option<ResMut<PrototypeLocomotionConfig>>,
action_sets: Res<XrActionSets>,
) {
match config_option {
Some(_) => (),
let mut config = match config_option {
Some(c) => c,
None => {
info!("no locomotion config");
return;
}
}
//i hate this but im too tired to think
let mut config = config_option.unwrap();
//lock frame
let frame_state = *frame_state.lock().unwrap();
};
//get controller
let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets);
let root = tracking_root_query.get_single_mut();
@@ -92,8 +88,7 @@ pub fn proto_locomotion(
let reference_quat;
match config.locomotion_type {
LocomotionType::Head => {
let v = views.lock().unwrap();
let views = v.get(0);
let views = views.first();
match views {
Some(view) => {
reference_quat = view.pose.orientation.to_quat();
@@ -127,8 +122,7 @@ pub fn proto_locomotion(
rot_input * config.smooth_rotation_speed * time.delta_seconds(),
);
//apply rotation
let v = views.lock().unwrap();
let views = v.get(0);
let views = views.first();
match views {
Some(view) => {
let mut hmd_translation = view.pose.position.to_vec3();
@@ -159,8 +153,8 @@ pub fn proto_locomotion(
let smoth_rot =
Quat::from_axis_angle(position.0.up(), config.snap_angle * dir);
//apply rotation
let v = views.lock().unwrap();
let views = v.get(0);
let v = views;
let views = v.first();
match views {
Some(view) => {
let mut hmd_translation = view.pose.position.to_vec3();

2
src/xr_input/trackers.rs
View File

@@ -66,8 +66,6 @@ pub fn update_open_xr_controllers(
session: Res<XrSession>,
action_sets: Res<XrActionSets>,
) {
//lock dat frame?
let frame_state = *frame_state.lock().unwrap();
//get controller
let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets);
//get left controller

14
src/xr_input/xr_camera.rs
View File

@@ -241,22 +241,24 @@ impl CameraProjection for XRProjection {
pub fn xr_camera_head_sync(
views: ResMut<crate::resources::XrViews>,
mut query: Query<(&mut Transform, &XrCameraType, &mut XRProjection)>,
query: Query<(&mut Transform, &XrCameraType, &mut XRProjection)>,
) {
let mut f = || -> Option<()> {
fn f(
views: ResMut<crate::resources::XrViews>,
mut query: Query<(&mut Transform, &XrCameraType, &mut XRProjection)>,
) -> Option<()> {
//TODO calculate HMD position
for (mut transform, camera_type, mut xr_projection) in query.iter_mut() {
let view_idx = match camera_type {
XrCameraType::Xr(eye) => *eye as usize,
XrCameraType::Flatscreen => return None,
};
let v = views.lock().unwrap();
let view = v.get(view_idx)?;
let view = views.get(view_idx)?;
xr_projection.fov = view.fov;
transform.rotation = view.pose.orientation.to_quat();
transform.translation = view.pose.position.to_vec3();
}
Some(())
};
let _ = f();
}
let _ = f(views, query);
}