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

Merge pull request #184 from Schmarni-Dev/xr_space_sync_set

Browse Source 
XrSpaceSyncSet and OxrSessionConfig
This commit is contained in:
Schmarni
2025-05-02 17:00:31 +02:00
committed by GitHub
parent 84a69ea1ae 7bc9789358
commit 681f00c42d
13 changed files with 117 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
crates/bevy_openxr/examples/3d_scene.rs
View File

@@ -1,27 +1,28 @@
//! A simple 3D scene with light shining over a cube sitting on a plane.
use bevy::{prelude::*, render::pipelined_rendering::PipelinedRenderingPlugin};
use bevy_mod_openxr::{add_xr_plugins, init::OxrInitPlugin};
use bevy_mod_openxr::{add_xr_plugins, resources::OxrSessionConfig};
use openxr::EnvironmentBlendMode;
fn main() {
fn main() -> AppExit {
App::new()
.add_plugins(
add_xr_plugins(DefaultPlugins.build().disable::<PipelinedRenderingPlugin>()).set(
OxrInitPlugin {
.add_plugins(add_xr_plugins(
// Disabling Pipelined Rendering should reduce latency a little bit for button inputs
// and increase accuracy for hand tracking, controller positions and similar,
// the views are updated right before rendering so they are as accurate as possible
DefaultPlugins.build().disable::<PipelinedRenderingPlugin>(),
))
.insert_resource(OxrSessionConfig {
blend_modes: Some(vec![
EnvironmentBlendMode::ALPHA_BLEND,
EnvironmentBlendMode::ADDITIVE,
EnvironmentBlendMode::OPAQUE,
]),
..Default::default()
},
),
)
..default()
})
.add_plugins(bevy_xr_utils::hand_gizmos::HandGizmosPlugin)
.add_systems(Startup, setup)
.insert_resource(ClearColor(Color::NONE))
.run();
.run()
}
/// set up a simple 3D scene

9
crates/bevy_openxr/examples/overlay.rs
View File

@@ -3,7 +3,7 @@
use bevy::prelude::*;
use bevy_mod_openxr::{
add_xr_plugins, features::overlay::OxrOverlaySessionEvent, init::OxrInitPlugin,
types::OxrExtensions,
resources::OxrSessionConfig, types::OxrExtensions,
};
use openxr::EnvironmentBlendMode;
@@ -16,14 +16,17 @@ fn main() {
exts.extx_overlay = true;
exts
},
..OxrInitPlugin::default()
}))
.insert_resource(OxrSessionConfig {
blend_modes: Some({
vec![
EnvironmentBlendMode::ALPHA_BLEND,
EnvironmentBlendMode::OPAQUE,
]
}),
..OxrInitPlugin::default()
}))
..OxrSessionConfig::default()
})
.insert_resource(ClearColor(Color::NONE))
.add_plugins(bevy_xr_utils::hand_gizmos::HandGizmosPlugin)
.add_systems(Startup, setup)

15
crates/bevy_openxr/examples/sessions.rs
View File

@@ -1,24 +1,17 @@
//! A simple 3D scene with light shining over a cube sitting on a plane.
use bevy::prelude::*;
use bevy_mod_openxr::{add_xr_plugins, init::OxrInitPlugin};
use bevy_mod_openxr::add_xr_plugins;
use bevy_mod_xr::session::{XrSessionPlugin, XrState};
fn main() {
fn main() -> AppExit {
App::new()
.add_plugins(
add_xr_plugins(DefaultPlugins)
.set(XrSessionPlugin { auto_handle: true })
.set(OxrInitPlugin {
blend_modes: Some(vec![openxr::EnvironmentBlendMode::OPAQUE]),
..Default::default()
}),
)
.add_plugins(add_xr_plugins(DefaultPlugins).set(XrSessionPlugin { auto_handle: true }))
.add_plugins(bevy_xr_utils::hand_gizmos::HandGizmosPlugin)
.add_systems(Startup, setup)
.add_systems(Update, handle_input)
.insert_resource(AmbientLight::default())
.run();
.run()
}
fn handle_input(

11
crates/bevy_openxr/src/openxr/features/handtracking.rs
View File

@@ -6,8 +6,8 @@ use bevy_mod_xr::hands::{
use bevy_mod_xr::hands::{LeftHand, RightHand, XrHandBoneEntities};
use bevy_mod_xr::session::{XrPreDestroySession, XrSessionCreated};
use bevy_mod_xr::spaces::{
XrPrimaryReferenceSpace, XrReferenceSpace, XrSpaceLocationFlags, XrSpaceVelocityFlags,
XrVelocity,
XrPrimaryReferenceSpace, XrReferenceSpace, XrSpaceLocationFlags, XrSpaceSyncSet,
XrSpaceVelocityFlags, XrVelocity,
};
use openxr::{SpaceLocationFlags, SpaceVelocityFlags};
@@ -31,7 +31,12 @@ impl Default for HandTrackingPlugin {
impl Plugin for HandTrackingPlugin {
fn build(&self, app: &mut App) {
app.add_systems(PreUpdate, locate_hands.run_if(openxr_session_running));
app.add_systems(
PreUpdate,
locate_hands
.in_set(XrSpaceSyncSet)
.run_if(openxr_session_running),
);
if self.default_hands {
app.add_systems(XrPreDestroySession, clean_up_default_hands)
.add_systems(XrSessionCreated, spawn_default_hands);

12
crates/bevy_openxr/src/openxr/features/passthrough.rs
View File

@@ -5,6 +5,7 @@ use bevy::render::RenderSet;
use openxr::sys::SystemPassthroughProperties2FB;
use openxr::PassthroughCapabilityFlagsFB;
use crate::exts::OxrEnabledExtensions;
use crate::layer_builder::PassthroughLayer;
use crate::resources::*;
use crate::session::OxrSession;
@@ -14,6 +15,11 @@ pub struct OxrPassthroughPlugin;
impl Plugin for OxrPassthroughPlugin {
fn build(&self, app: &mut App) {
if app
.world()
.get_resource::<OxrEnabledExtensions>()
.is_some_and(|e| e.fb_passthrough)
{
let resources = app
.world()
.get_resource::<OxrInstance>()
@@ -36,6 +42,7 @@ impl Plugin for OxrPassthroughPlugin {
}
}
}
}
pub fn insert_passthrough(world: &mut World) {
let session = world.resource::<OxrSession>();
@@ -82,10 +89,7 @@ pub fn create_passthrough(
}
#[inline]
pub fn supports_passthrough(
instance: &OxrInstance,
system: OxrSystemId,
) -> OxrResult<bool> {
pub fn supports_passthrough(instance: &OxrInstance, system: OxrSystemId) -> OxrResult<bool> {
if instance.exts().fb_passthrough.is_none() {
return Ok(false);
}

45
crates/bevy_openxr/src/openxr/init.rs
View File

@@ -54,14 +54,8 @@ pub struct OxrInitPlugin {
/// Extensions wanted for this session.
// TODO!() This should be changed to take a simpler list of features wanted that this crate supports. i.e. hand tracking
pub exts: OxrExtensions,
/// List of blend modes the openxr session can use. If [None], pick the first available blend mode.
pub blend_modes: Option<Vec<EnvironmentBlendMode>>,
/// List of backends the openxr session can use. If [None], pick the first available backend.
pub backends: Option<Vec<GraphicsBackend>>,
/// List of formats the openxr session can use. If [None], pick the first available format
pub formats: Option<Vec<wgpu::TextureFormat>>,
/// List of resolutions that the openxr swapchain can use. If [None] pick the first available resolution.
pub resolutions: Option<Vec<UVec2>>,
/// Passed into the render plugin when added to the app.
pub synchronous_pipeline_compilation: bool,
pub render_debug_flags: RenderDebugFlags,
@@ -76,10 +70,7 @@ impl Default for OxrInitPlugin {
exts.enable_hand_tracking();
exts
},
blend_modes: Some(vec![openxr::EnvironmentBlendMode::OPAQUE]),
backends: default(),
formats: Some(vec![wgpu::TextureFormat::Rgba8UnormSrgb]),
resolutions: default(),
synchronous_pipeline_compilation: false,
render_debug_flags: default(),
}
@@ -89,13 +80,14 @@ impl Default for OxrInitPlugin {
impl Plugin for OxrInitPlugin {
fn build(&self, app: &mut App) {
app.add_event::<OxrInteractionProfileChanged>();
app.init_resource::<OxrSessionConfig>();
match self.init_xr() {
Ok((
instance,
system_id,
WgpuGraphics(device, queue, adapter_info, adapter, wgpu_instance),
session_create_info,
enabled_exts,
graphics_info,
)) => {
app.insert_resource(enabled_exts)
.add_plugins((
@@ -150,7 +142,7 @@ impl Plugin for OxrInitPlugin {
unfocused_mode: UpdateMode::Continuous,
})
.insert_resource(OxrSessionStarted(false))
.insert_non_send_resource(session_create_info)
.insert_non_send_resource(graphics_info)
.init_non_send_resource::<OxrSessionCreateNextChain>();
app.world_mut()
@@ -215,8 +207,8 @@ impl OxrInitPlugin {
OxrInstance,
OxrSystemId,
WgpuGraphics,
SessionConfigInfo,
OxrEnabledExtensions,
SessionGraphicsCreateInfo,
)> {
#[cfg(windows)]
let entry = OxrEntry(openxr::Entry::linked());
@@ -282,19 +274,12 @@ impl OxrInitPlugin {
let (graphics, graphics_info) = instance.init_graphics(system_id)?;
let session_create_info = SessionConfigInfo {
blend_modes: self.blend_modes.clone(),
formats: self.formats.clone(),
resolutions: self.resolutions.clone(),
graphics_info,
};
Ok((
instance,
OxrSystemId(system_id),
graphics,
session_create_info,
OxrEnabledExtensions(exts),
graphics_info,
))
}
}
@@ -349,19 +334,19 @@ fn init_xr_session(
instance: &OxrInstance,
system_id: openxr::SystemId,
chain: &mut OxrSessionCreateNextChain,
SessionConfigInfo {
OxrSessionConfig {
blend_modes,
formats,
resolutions,
graphics_info,
}: SessionConfigInfo,
}: OxrSessionConfig,
graphics_info: SessionGraphicsCreateInfo,
) -> OxrResult<(
OxrSession,
OxrFrameWaiter,
OxrFrameStream,
OxrSwapchain,
OxrSwapchainImages,
OxrGraphicsInfo,
OxrCurrentSessionConfig,
)> {
let (session, frame_waiter, frame_stream) =
unsafe { instance.create_session(system_id, graphics_info, chain)? };
@@ -463,7 +448,7 @@ fn init_xr_session(
}
.ok_or(OxrError::NoAvailableBlendMode)?;
let graphics_info = OxrGraphicsInfo {
let graphics_info = OxrCurrentSessionConfig {
blend_mode,
resolution,
format,
@@ -485,14 +470,16 @@ pub fn create_xr_session(world: &mut World) {
.unwrap();
let device = world.resource::<RenderDevice>();
let instance = world.resource::<OxrInstance>();
let create_info = world.non_send_resource::<SessionConfigInfo>();
let session_config = world.resource::<OxrSessionConfig>();
let session_create_info = world.non_send_resource::<SessionGraphicsCreateInfo>();
let system_id = world.resource::<OxrSystemId>();
match init_xr_session(
device.wgpu_device(),
instance,
**system_id,
&mut chain,
create_info.clone(),
session_config.clone(),
session_create_info.clone(),
) {
Ok((session, frame_waiter, frame_stream, swapchain, images, graphics_info)) => {
world.insert_resource(session.clone());
@@ -525,7 +512,7 @@ pub fn destroy_xr_session(world: &mut World) {
world.remove_resource::<OxrFrameStream>();
world.remove_resource::<OxrSwapchain>();
world.remove_resource::<OxrSwapchainImages>();
world.remove_resource::<OxrGraphicsInfo>();
world.remove_resource::<OxrCurrentSessionConfig>();
world.insert_resource(XrState::Available);
}
@@ -570,7 +557,7 @@ struct OxrRenderResources {
frame_stream: OxrFrameStream,
swapchain: OxrSwapchain,
images: OxrSwapchainImages,
graphics_info: OxrGraphicsInfo,
graphics_info: OxrCurrentSessionConfig,
session_destroy_flag: XrDestroySessionRender,
}

2
crates/bevy_openxr/src/openxr/layer_builder.rs
View File

@@ -21,7 +21,7 @@ impl LayerProvider for ProjectionLayer {
let stage = world.get_resource::<XrPrimaryReferenceSpace>()?;
let openxr_views = world.get_resource::<OxrViews>()?;
let swapchain = world.get_resource::<OxrSwapchain>()?;
let graphics_info = world.get_resource::<OxrGraphicsInfo>()?;
let graphics_info = world.get_resource::<OxrCurrentSessionConfig>()?;
let rect = openxr::Rect2Di {
offset: openxr::Offset2Di { x: 0, y: 0 },
extent: openxr::Extent2Di {

10
crates/bevy_openxr/src/openxr/render.rs
View File

@@ -48,7 +48,7 @@ impl Plugin for OxrRenderPlugin {
app.add_plugins((
ExtractResourcePlugin::<OxrFrameState>::default(),
ExtractResourcePlugin::<OxrGraphicsInfo>::default(),
ExtractResourcePlugin::<OxrCurrentSessionConfig>::default(),
ExtractResourcePlugin::<OxrSwapchainImages>::default(),
ExtractResourcePlugin::<OxrViews>::default(),
))
@@ -151,7 +151,7 @@ pub fn clean_views(
}
pub fn init_views<const SPAWN_CAMERAS: bool>(
graphics_info: Res<OxrGraphicsInfo>,
graphics_info: Res<OxrCurrentSessionConfig>,
mut manual_texture_views: ResMut<ManualTextureViews>,
swapchain_images: Res<OxrSwapchainImages>,
mut commands: Commands,
@@ -304,7 +304,7 @@ pub fn insert_texture_views(
swapchain_images: Res<OxrSwapchainImages>,
mut swapchain: ResMut<OxrSwapchain>,
mut manual_texture_views: ResMut<ManualTextureViews>,
graphics_info: Res<OxrGraphicsInfo>,
graphics_info: Res<OxrCurrentSessionConfig>,
) {
let index = swapchain.acquire_image().expect("Failed to acquire image");
let image = &swapchain_images[index as usize];
@@ -324,7 +324,7 @@ pub fn wait_image(mut swapchain: ResMut<OxrSwapchain>) {
pub fn add_texture_view(
manual_texture_views: &mut ManualTextureViews,
texture: &wgpu::Texture,
info: &OxrGraphicsInfo,
info: &OxrCurrentSessionConfig,
index: u32,
) -> ManualTextureViewHandle {
let view = texture.create_view(&wgpu::TextureViewDescriptor {
@@ -381,7 +381,7 @@ pub fn end_frame(world: &mut World) {
let _span = debug_span!("xr_end_frame").entered();
if let Err(e) = frame_stream.end(
frame_state.predicted_display_time,
world.resource::<OxrGraphicsInfo>().blend_mode,
world.resource::<OxrCurrentSessionConfig>().blend_mode,
&layers,
) {
error!("Failed to end frame stream: {e}");

34
crates/bevy_openxr/src/openxr/resources.rs
View File

@@ -106,13 +106,13 @@ impl OxrInstance {
pub fn init_graphics(
&self,
system_id: openxr::SystemId,
) -> OxrResult<(WgpuGraphics, SessionCreateInfo)> {
) -> OxrResult<(WgpuGraphics, SessionGraphicsCreateInfo)> {
graphics_match!(
self.1;
_ => {
let (graphics, session_info) = Api::init_graphics(&self.2, self, system_id)?;
Ok((graphics, SessionCreateInfo(Api::wrap(session_info))))
Ok((graphics, SessionGraphicsCreateInfo(Api::wrap(session_info))))
}
)
}
@@ -127,12 +127,12 @@ impl OxrInstance {
pub unsafe fn create_session(
&self,
system_id: openxr::SystemId,
info: SessionCreateInfo,
info: SessionGraphicsCreateInfo,
chain: &mut OxrSessionCreateNextChain,
) -> OxrResult<(OxrSession, OxrFrameWaiter, OxrFrameStream)> {
if !info.0.using_graphics_of_val(&self.1) {
return OxrResult::Err(OxrError::GraphicsBackendMismatch {
item: std::any::type_name::<SessionCreateInfo>(),
item: std::any::type_name::<SessionGraphicsCreateInfo>(),
backend: info.0.graphics_name(),
expected_backend: self.1.graphics_name(),
});
@@ -330,23 +330,39 @@ pub struct OxrRenderLayers(pub Vec<Box<dyn LayerProvider + Send + Sync>>);
/// Resource storing graphics info for the currently running session.
#[derive(Clone, Copy, Resource, ExtractResource)]
pub struct OxrGraphicsInfo {
pub struct OxrCurrentSessionConfig {
pub blend_mode: EnvironmentBlendMode,
pub resolution: UVec2,
pub format: wgpu::TextureFormat,
}
#[derive(Clone)]
#[derive(Clone, Resource, Debug)]
/// This is used to store information from startup that is needed to create the session after the instance has been created.
pub struct SessionConfigInfo {
pub struct OxrSessionConfig {
/// List of blend modes the openxr session can use. If [None], pick the first available blend mode.
pub blend_modes: Option<Vec<EnvironmentBlendMode>>,
/// List of formats the openxr session can use. If [None], pick the first available format
pub formats: Option<Vec<wgpu::TextureFormat>>,
/// List of resolutions that the openxr swapchain can use. If [None] pick the first available resolution.
pub resolutions: Option<Vec<UVec2>>,
/// Graphics info used to create a session.
pub graphics_info: SessionCreateInfo,
}
impl Default for OxrSessionConfig {
fn default() -> Self {
Self {
blend_modes: Some(vec![openxr::EnvironmentBlendMode::OPAQUE]),
formats: Some(vec![wgpu::TextureFormat::Rgba8UnormSrgb]),
resolutions: default(),
}
}
}
/// Info needed to create a session. Mostly contains graphics info.
/// This is an API agnostic version of [openxr::Graphics::SessionCreateInfo] used for some of this library's functions
#[derive(Clone)]
pub struct SessionGraphicsCreateInfo(pub GraphicsWrap<Self>);
impl GraphicsType for SessionGraphicsCreateInfo {
type Inner<G: GraphicsExt> = G::SessionCreateInfo;
}
#[derive(ExtractResource, Resource, Clone, Default)]

8
crates/bevy_openxr/src/openxr/spaces.rs
View File

@@ -4,8 +4,7 @@ use bevy::{platform::collections::hash_set::HashSet, prelude::*};
use bevy_mod_xr::{
session::{XrFirst, XrHandleEvents},
spaces::{
XrDestroySpace, XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace, XrSpaceLocationFlags,
XrSpaceVelocityFlags, XrVelocity,
XrDestroySpace, XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace, XrSpaceLocationFlags, XrSpaceSyncSet, XrSpaceVelocityFlags, XrVelocity
},
};
use openxr::{
@@ -20,9 +19,6 @@ use crate::{
session::OxrSession,
};
#[derive(SystemSet, Hash, Debug, Clone, Copy, PartialEq, Eq)]
pub struct OxrSpaceSyncSet;
/// VERY IMPORTANT!! only disable when you know what you are doing
pub struct OxrSpacePatchingPlugin;
impl Plugin for OxrSpacePatchingPlugin {
@@ -47,7 +43,7 @@ impl Plugin for OxrSpatialPlugin {
.add_systems(
PreUpdate,
update_space_transforms
.in_set(OxrSpaceSyncSet)
.in_set(XrSpaceSyncSet)
.run_if(openxr_session_running),
)
.register_required_components::<XrSpaceLocationFlags, OxrSpaceLocationFlags>()

9
crates/bevy_openxr/src/openxr/types.rs
View File

@@ -87,12 +87,3 @@ impl<G: GraphicsExt> TryFrom<SwapchainCreateInfo> for openxr::SwapchainCreateInf
})
}
}
/// Info needed to create a session. Mostly contains graphics info.
/// This is an API agnostic version of [openxr::Graphics::SessionCreateInfo] used for some of this library's functions
#[derive(Clone)]
pub struct SessionCreateInfo(pub GraphicsWrap<Self>);
impl GraphicsType for SessionCreateInfo {
type Inner<G: GraphicsExt> = G::SessionCreateInfo;
}

3
crates/bevy_xr/src/spaces.rs
View File

@@ -5,6 +5,9 @@ use bevy::{
use crate::session::XrTracker;
#[derive(SystemSet, Hash, Debug, Clone, Copy, PartialEq, Eq)]
pub struct XrSpaceSyncSet;
/// Any Spaces will be invalid after the owning session exits
#[repr(transparent)]
#[derive(Component, Clone, Copy, Hash, PartialEq, Eq, Reflect, Debug, ExtractComponent)]

10
crates/bevy_xr_utils/src/tracking_utils.rs
View File

@@ -7,11 +7,11 @@ use bevy_mod_openxr::{
openxr_session_available, openxr_session_running,
resources::{OxrFrameState, OxrInstance, Pipelined},
session::OxrSession,
spaces::{OxrSpaceLocationFlags, OxrSpaceSyncSet},
spaces::OxrSpaceLocationFlags,
};
use bevy_mod_xr::{
session::{XrSessionCreated, XrTracker, XrTrackingRoot},
spaces::{XrPrimaryReferenceSpace, XrReferenceSpace},
spaces::{XrPrimaryReferenceSpace, XrReferenceSpace, XrSpaceSyncSet},
};
use openxr::Posef;
@@ -47,7 +47,7 @@ impl Plugin for TrackingUtilitiesPlugin {
app.add_systems(
PreUpdate,
update_head_transforms
.in_set(OxrSpaceSyncSet)
.in_set(XrSpaceSyncSet)
.run_if(openxr_session_running),
);
//external
@@ -73,8 +73,8 @@ impl Plugin for TrackingUtilitiesPlugin {
//create actions
app.add_systems(Startup, create_actions.run_if(openxr_session_available));
app.add_systems(PreUpdate, update_left_grip.after(OxrSpaceSyncSet));
app.add_systems(PreUpdate, update_right_grip.after(OxrSpaceSyncSet));
app.add_systems(PreUpdate, update_left_grip.after(XrSpaceSyncSet));
app.add_systems(PreUpdate, update_right_grip.after(XrSpaceSyncSet));
}
}