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

5
Cargo.toml
View File

@@ -15,7 +15,7 @@ force-link = ["openxr/linked"]
members = ["examples/android", "examples/demo"] members = ["examples/android", "examples/demo"]
[dependencies] [dependencies]
anyhow = "1.0.75" # anyhow = "1.0.75"
ash = "0.37.3" ash = "0.37.3"
bevy = "0.12" bevy = "0.12"
futures-lite = "2.0.1" futures-lite = "2.0.1"
@@ -23,6 +23,7 @@ mint = "0.5.9"
wgpu = "0.17.1" wgpu = "0.17.1"
wgpu-core = { version = "0.17.1", features = ["vulkan"] } wgpu-core = { version = "0.17.1", features = ["vulkan"] }
wgpu-hal = "0.17.1" wgpu-hal = "0.17.1"
eyre = "0.6.11"
[target.'cfg(windows)'.dependencies] [target.'cfg(windows)'.dependencies]
openxr = { git = "https://github.com/Ralith/openxrs", rev = "0177d2d", features = [ openxr = { git = "https://github.com/Ralith/openxrs", rev = "0177d2d", features = [
@@ -42,8 +43,8 @@ openxr = { git = "https://github.com/Ralith/openxrs", rev = "0177d2d", features
[dev-dependencies] [dev-dependencies]
bevy = "0.12" bevy = "0.12"
color-eyre = "0.6.2"
bevy_rapier3d = { git = "https://github.com/devil-ira/bevy_rapier", branch = "bevy-0.12" } bevy_rapier3d = { git = "https://github.com/devil-ira/bevy_rapier", branch = "bevy-0.12" }
color-eyre = "0.6.2"
[[example]] [[example]]
name = "xr" name = "xr"

4
examples/demo/src/lib.rs
View File

@@ -560,8 +560,6 @@ fn request_cube_spawn(
) { ) {
timer.0.tick(time.delta()); timer.0.tick(time.delta());
if timer.0.finished() { if timer.0.finished() {
//lock frame
let frame_state = *frame_state.lock().unwrap();
//get controller //get controller
let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets); let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets);
//get controller triggers //get controller triggers
@@ -628,8 +626,6 @@ fn prototype_interaction_input(
>, >,
action_sets: Res<XrActionSets>, action_sets: Res<XrActionSets>,
) { ) {
//lock frame
let frame_state = *frame_state.lock().unwrap();
//get controller //get controller
let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets); let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets);
//get controller triggers //get controller triggers

13
src/graphics/mod.rs
View File

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

107
src/graphics/vulkan.rs
View File

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

4
src/input.rs
View File

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

55
src/resource_macros.rs
View File

@@ -1,7 +1,7 @@
#[macro_export] #[macro_export]
macro_rules! xr_resource_wrapper { macro_rules! xr_resource_wrapper {
($wrapper_type:ident, $xr_type:ty) => { ($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); pub struct $wrapper_type($xr_type);
impl $wrapper_type { impl $wrapper_type {
@@ -10,13 +10,13 @@ macro_rules! xr_resource_wrapper {
} }
} }
impl std::ops::Deref for $wrapper_type { // impl std::ops::Deref for $wrapper_type {
type Target = $xr_type; // type Target = $xr_type;
//
fn deref(&self) -> &Self::Target { // fn deref(&self) -> &Self::Target {
&self.0 // &self.0
} // }
} // }
impl From<$xr_type> for $wrapper_type { impl From<$xr_type> for $wrapper_type {
fn from(value: $xr_type) -> Self { fn from(value: $xr_type) -> Self {
@@ -29,7 +29,7 @@ macro_rules! xr_resource_wrapper {
#[macro_export] #[macro_export]
macro_rules! xr_arc_resource_wrapper { macro_rules! xr_arc_resource_wrapper {
($wrapper_type:ident, $xr_type:ty) => { ($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>); pub struct $wrapper_type(std::sync::Arc<$xr_type>);
impl $wrapper_type { impl $wrapper_type {
@@ -38,13 +38,41 @@ macro_rules! xr_arc_resource_wrapper {
} }
} }
impl std::ops::Deref for $wrapper_type { // impl std::ops::Deref for $wrapper_type {
type Target = $xr_type; // type Target = $xr_type;
//
// fn deref(&self) -> &Self::Target {
// self.0.as_ref()
// }
// }
fn deref(&self) -> &Self::Target { impl From<$xr_type> for $wrapper_type {
self.0.as_ref() 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 { impl From<$xr_type> for $wrapper_type {
fn from(value: $xr_type) -> Self { 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_arc_resource_wrapper;
pub use xr_no_clone_resource_wrapper;
pub use xr_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::atomic::AtomicBool;
use std::sync::Mutex; use std::sync::Mutex;
@@ -5,17 +6,31 @@ use std::sync::Mutex;
use crate::resource_macros::*; use crate::resource_macros::*;
use bevy::prelude::*; use bevy::prelude::*;
use openxr as xr; use openxr as xr;
use xr::ViewConfigurationView;
xr_resource_wrapper!(XrInstance, xr::Instance); xr_resource_wrapper!(XrInstance, xr::Instance);
xr_resource_wrapper!(XrSession, xr::Session<xr::AnyGraphics>); xr_resource_wrapper!(XrSession, xr::Session<xr::AnyGraphics>);
xr_resource_wrapper!(XrEnvironmentBlendMode, xr::EnvironmentBlendMode); xr_resource_wrapper!(XrEnvironmentBlendMode, xr::EnvironmentBlendMode);
xr_resource_wrapper!(XrResolution, UVec2); xr_resource_wrapper!(XrResolution, UVec2);
xr_resource_wrapper!(XrFormat, wgpu::TextureFormat); 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!(XrSessionRunning, AtomicBool);
xr_arc_resource_wrapper!(XrFrameWaiter, Mutex<xr::FrameWaiter>);
xr_arc_resource_wrapper!(XrSwapchain, Swapchain); xr_arc_resource_wrapper!(XrSwapchain, Swapchain);
xr_arc_resource_wrapper!(XrFrameState, Mutex<xr::FrameState>); xr_no_clone_resource_wrapper!(XrFrameWaiter, xr::FrameWaiter);
xr_arc_resource_wrapper!(XrViews, Mutex<Vec<xr::View>>);
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 { pub enum Swapchain {
Vulkan(SwapchainInner<xr::Vulkan>), Vulkan(SwapchainInner<xr::Vulkan>),

19
src/xr_init.rs
View File

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

2
src/xr_input/actions.rs
View File

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

2
src/xr_input/debug_gizmos.rs
View File

@@ -91,7 +91,7 @@ pub fn draw_gizmos(
// } // }
// } // }
//lock frame //lock frame
let frame_state = *frame_state.lock().unwrap(); // let frame_state = *frame_state.lock().unwrap();
//get controller //get controller
let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets); let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets);
let root = tracking_root_query.get_single(); 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::Left => &self.tracking.left_hand,
Hand::Right => &self.tracking.right_hand, Hand::Right => &self.tracking.right_hand,
}, },
self.frame_state.lock().unwrap().predicted_display_time, self.frame_state.predicted_display_time,
) )
.unwrap() .unwrap()
.map(|joints| { .map(|joints| {

2
src/xr_input/oculus_touch.rs
View File

@@ -371,7 +371,7 @@ pub struct OculusController {
pub aim_space: Option<Handed<Space>>, pub aim_space: Option<Handed<Space>>,
} }
impl OculusController { 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 = let action_set =
action_sets.add_action_set("oculus_input", "Oculus Touch Controller Input".into(), 0); action_sets.add_action_set("oculus_input", "Oculus Touch Controller Input".into(), 0);
action_set.new_action( 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>>, config_option: Option<ResMut<PrototypeLocomotionConfig>>,
action_sets: Res<XrActionSets>, action_sets: Res<XrActionSets>,
) { ) {
match config_option { let mut config = match config_option {
Some(_) => (), Some(c) => c,
None => { None => {
info!("no locomotion config"); info!("no locomotion config");
return; 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 //get controller
let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets); let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets);
let root = tracking_root_query.get_single_mut(); let root = tracking_root_query.get_single_mut();
@@ -92,8 +88,7 @@ pub fn proto_locomotion(
let reference_quat; let reference_quat;
match config.locomotion_type { match config.locomotion_type {
LocomotionType::Head => { LocomotionType::Head => {
let v = views.lock().unwrap(); let views = views.first();
let views = v.get(0);
match views { match views {
Some(view) => { Some(view) => {
reference_quat = view.pose.orientation.to_quat(); reference_quat = view.pose.orientation.to_quat();
@@ -127,8 +122,7 @@ pub fn proto_locomotion(
rot_input * config.smooth_rotation_speed * time.delta_seconds(), rot_input * config.smooth_rotation_speed * time.delta_seconds(),
); );
//apply rotation //apply rotation
let v = views.lock().unwrap(); let views = views.first();
let views = v.get(0);
match views { match views {
Some(view) => { Some(view) => {
let mut hmd_translation = view.pose.position.to_vec3(); let mut hmd_translation = view.pose.position.to_vec3();
@@ -159,8 +153,8 @@ pub fn proto_locomotion(
let smoth_rot = let smoth_rot =
Quat::from_axis_angle(position.0.up(), config.snap_angle * dir); Quat::from_axis_angle(position.0.up(), config.snap_angle * dir);
//apply rotation //apply rotation
let v = views.lock().unwrap(); let v = views;
let views = v.get(0); let views = v.first();
match views { match views {
Some(view) => { Some(view) => {
let mut hmd_translation = view.pose.position.to_vec3(); 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>, session: Res<XrSession>,
action_sets: Res<XrActionSets>, action_sets: Res<XrActionSets>,
) { ) {
//lock dat frame?
let frame_state = *frame_state.lock().unwrap();
//get controller //get controller
let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets); let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets);
//get left controller //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( pub fn xr_camera_head_sync(
views: ResMut<crate::resources::XrViews>, 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 //TODO calculate HMD position
for (mut transform, camera_type, mut xr_projection) in query.iter_mut() { for (mut transform, camera_type, mut xr_projection) in query.iter_mut() {
let view_idx = match camera_type { let view_idx = match camera_type {
XrCameraType::Xr(eye) => *eye as usize, XrCameraType::Xr(eye) => *eye as usize,
XrCameraType::Flatscreen => return None, XrCameraType::Flatscreen => return None,
}; };
let v = views.lock().unwrap(); let view = views.get(view_idx)?;
let view = v.get(view_idx)?;
xr_projection.fov = view.fov; xr_projection.fov = view.fov;
transform.rotation = view.pose.orientation.to_quat(); transform.rotation = view.pose.orientation.to_quat();
transform.translation = view.pose.position.to_vec3(); transform.translation = view.pose.position.to_vec3();
} }
Some(()) Some(())
}; }
let _ = f(); let _ = f(views, query);
} }