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

feat: update to bevy 0.17 and use individual bevy crates

Browse Source 
Signed-off-by: Schmarni <marnistromer@gmail.com>
This commit is contained in:
Schmarni
2025-10-19 16:13:59 +02:00
parent 9fd0c79759
commit eb3ec03d91
45 changed files with 1581 additions and 986 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
crates/bevy_openxr/Cargo.toml
View File

@@ -8,13 +8,15 @@ license.workspace = true
keywords = ["gamedev", "bevy", "Xr", "Vr", "OpenXR"]
[features]
default = ["vulkan", "d3d12", "passthrough"]
default = ["vulkan"]
vulkan = ["dep:ash", "dep:android_system_properties"]
d3d12 = ["wgpu/dx12", "wgpu-hal/dx12", "dep:winapi"]
passthrough = []
reflect = ["dep:bevy_reflect"]
window_support = ["dep:bevy_winit"]
[dev-dependencies]
bevy = { workspace = true, default-features = true }
bevy.workspace = true
[target.'cfg(target_os = "android")'.dependencies]
ndk-context = "0.1"
@@ -23,7 +25,18 @@ android_system_properties = { version = "0.1.5", optional = true }
# bevy can't be placed behind target or proc macros won't work properly
[dependencies]
bevy.workspace = true
bevy_ecs.workspace = true
bevy_math.workspace = true
bevy_render.workspace = true
bevy_app.workspace = true
bevy_reflect = { workspace = true, optional = true }
bevy_log.workspace = true
bevy_transform.workspace = true
bevy_camera.workspace = true
bevy_derive.workspace = true
bevy_platform.workspace = true
bevy_winit = { workspace = true, optional = true }
bevy_window = { workspace = true, optional = true }
# all other dependencies are placed under this since on wasm, this crate is completely empty
[target.'cfg(not(target_family = "wasm"))'.dependencies]

16
crates/bevy_openxr/examples/android/Cargo.toml
View File

@@ -10,14 +10,14 @@ publish = false
bevy_mod_openxr.workspace = true
bevy_xr_utils.workspace = true
bevy_mod_xr.workspace = true
bevy = { workspace = true, default-features = false, features = [
# Bevy 0.15 made GameActivity the default which breaks Quest builds
# To use NativeActivity instead of GameActivity all of the features have to be listed manually
"android-native-activity",
"bevy_window",
"multi_threaded",
"tonemapping_luts",
] }
# bevy = { workspace = true, default-features = false, features = [
# # Bevy 0.15 made GameActivity the default which breaks Quest builds
# # To use NativeActivity instead of GameActivity all of the features have to be listed manually
# "android-native-activity",
# "bevy_window",
# "multi_threaded",
# "tonemapping_luts",
# ] }
[build-dependencies]
reqwest = { version = "0.12", features = ["blocking"] }

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

@@ -2,7 +2,7 @@
use bevy::prelude::*;
use bevy_mod_openxr::{
add_xr_plugins, features::overlay::OxrOverlaySessionEvent, init::OxrInitPlugin,
add_xr_plugins, features::overlay::OxrOverlaySessionMessage, init::OxrInitPlugin,
resources::OxrSessionConfig, types::OxrExtensions,
};
use openxr::EnvironmentBlendMode;
@@ -36,20 +36,20 @@ fn main() {
.run();
}
fn print_main_session_changes(mut events: EventReader<OxrOverlaySessionEvent>) {
fn print_main_session_changes(mut events: MessageReader<OxrOverlaySessionMessage>) {
for event in events.read() {
let OxrOverlaySessionEvent::MainSessionVisibilityChanged { visible, flags: _ } = event;
let OxrOverlaySessionMessage::MainSessionVisibilityChanged { visible, flags: _ } = event;
info!("main session visible: {visible}");
}
}
fn handle_input(
keys: Res<ButtonInput<KeyCode>>,
mut end: EventWriter<bevy_mod_xr::session::XrEndSessionEvent>,
mut destroy: EventWriter<bevy_mod_xr::session::XrDestroySessionEvent>,
mut begin: EventWriter<bevy_mod_xr::session::XrBeginSessionEvent>,
mut create: EventWriter<bevy_mod_xr::session::XrCreateSessionEvent>,
mut request_exit: EventWriter<bevy_mod_xr::session::XrRequestExitEvent>,
mut end: MessageWriter<bevy_mod_xr::session::XrEndSessionMessage>,
mut destroy: MessageWriter<bevy_mod_xr::session::XrDestroySessionMessage>,
mut begin: MessageWriter<bevy_mod_xr::session::XrBeginSessionMessage>,
mut create: MessageWriter<bevy_mod_xr::session::XrCreateSessionMessage>,
mut request_exit: MessageWriter<bevy_mod_xr::session::XrRequestExitMessage>,
) {
if keys.just_pressed(KeyCode::KeyE) {
info!("sending end");

6
crates/bevy_openxr/examples/raw_actions.rs
View File

@@ -35,7 +35,7 @@ fn main() -> AppExit {
app.run()
}
fn attach_set(actions: Res<ControllerActions>, mut attach: EventWriter<OxrAttachActionSet>) {
fn attach_set(actions: Res<ControllerActions>, mut attach: MessageWriter<OxrAttachActionSet>) {
attach.write(OxrAttachActionSet(actions.set.clone()));
}
@@ -45,7 +45,7 @@ struct ControllerActions {
left: openxr::Action<Posef>,
right: openxr::Action<Posef>,
}
fn sync_actions(actions: Res<ControllerActions>, mut sync: EventWriter<OxrSyncActionSet>) {
fn sync_actions(actions: Res<ControllerActions>, mut sync: MessageWriter<OxrSyncActionSet>) {
sync.write(OxrSyncActionSet(actions.set.clone()));
}
/// set up a simple 3D scene
@@ -81,7 +81,7 @@ fn setup(
}
fn suggest_action_bindings(
actions: Res<ControllerActions>,
mut bindings: EventWriter<OxrSuggestActionBinding>,
mut bindings: MessageWriter<OxrSuggestActionBinding>,
) {
bindings.write(OxrSuggestActionBinding {
action: actions.left.as_raw(),

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

@@ -16,11 +16,11 @@ fn main() -> AppExit {
fn handle_input(
keys: Res<ButtonInput<KeyCode>>,
mut end: EventWriter<bevy_mod_xr::session::XrEndSessionEvent>,
mut destroy: EventWriter<bevy_mod_xr::session::XrDestroySessionEvent>,
mut begin: EventWriter<bevy_mod_xr::session::XrBeginSessionEvent>,
mut create: EventWriter<bevy_mod_xr::session::XrCreateSessionEvent>,
mut request_exit: EventWriter<bevy_mod_xr::session::XrRequestExitEvent>,
mut end: MessageWriter<bevy_mod_xr::session::XrEndSessionMessage>,
mut destroy: MessageWriter<bevy_mod_xr::session::XrDestroySessionMessage>,
mut begin: MessageWriter<bevy_mod_xr::session::XrBeginSessionMessage>,
mut create: MessageWriter<bevy_mod_xr::session::XrCreateSessionMessage>,
mut request_exit: MessageWriter<bevy_mod_xr::session::XrRequestExitMessage>,
state: Res<XrState>,
) {
if keys.just_pressed(KeyCode::KeyE) {

23
crates/bevy_openxr/src/openxr/action_binding.rs
View File

@@ -1,11 +1,15 @@
use std::borrow::Cow;
use std::ptr;
use bevy::ecs::schedule::ScheduleLabel;
use bevy::ecs::system::RunSystemOnce;
use bevy::platform::collections::HashMap;
use bevy::prelude::*;
use bevy_mod_xr::session::XrSessionCreatedEvent;
use bevy_app::{App, Plugin, Update};
use bevy_ecs::message::{Message, MessageReader};
use bevy_ecs::schedule::common_conditions::on_message;
use bevy_ecs::schedule::{IntoScheduleConfigs as _, Schedule, ScheduleLabel};
use bevy_ecs::system::{Res, RunSystemOnce};
use bevy_ecs::world::World;
use bevy_log::error;
use bevy_mod_xr::session::XrSessionCreatedMessage;
use bevy_platform::collections::HashMap;
use openxr::sys::ActionSuggestedBinding;
use crate::resources::OxrInstance;
@@ -13,10 +17,10 @@ use crate::resources::OxrInstance;
impl Plugin for OxrActionBindingPlugin {
fn build(&self, app: &mut App) {
app.add_schedule(Schedule::new(OxrSendActionBindings));
app.add_event::<OxrSuggestActionBinding>();
app.add_message::<OxrSuggestActionBinding>();
app.add_systems(
Update,
run_action_binding_sugestion.run_if(on_event::<XrSessionCreatedEvent>),
run_action_binding_sugestion.run_if(on_message::<XrSessionCreatedMessage>),
);
}
}
@@ -28,7 +32,7 @@ pub(crate) fn run_action_binding_sugestion(world: &mut World) {
_ = world.run_system_once(bind_actions);
}
fn bind_actions(instance: Res<OxrInstance>, mut actions: EventReader<OxrSuggestActionBinding>) {
fn bind_actions(instance: Res<OxrInstance>, mut actions: MessageReader<OxrSuggestActionBinding>) {
let mut bindings: HashMap<&str, Vec<ActionSuggestedBinding>> = HashMap::new();
for e in actions.read() {
bindings.entry(&e.interaction_profile).or_default().extend(
@@ -88,7 +92,7 @@ fn bind_actions(instance: Res<OxrInstance>, mut actions: EventReader<OxrSuggestA
}
}
#[derive(Event, Clone)]
#[derive(Message, Clone)]
/// Only Send this for Actions that were not attached yet!
pub struct OxrSuggestActionBinding {
pub action: openxr::sys::Action,
@@ -97,6 +101,5 @@ pub struct OxrSuggestActionBinding {
}
pub struct OxrActionBindingPlugin;
// Maybe use a SystemSet in an XrStartup Schedule?
#[derive(ScheduleLabel, Hash, Debug, Clone, Copy, PartialEq, Eq)]
pub struct OxrSendActionBindings;

14
crates/bevy_openxr/src/openxr/action_set_attaching.rs
View File

@@ -1,20 +1,22 @@
use crate::{action_binding::run_action_binding_sugestion, session::OxrSession};
use bevy::prelude::*;
use bevy_mod_xr::session::XrSessionCreatedEvent;
use bevy_app::{App, Plugin, PostUpdate};
use bevy_ecs::{message::{Message, MessageReader}, schedule::{IntoScheduleConfigs as _, common_conditions::on_message}, system::Res};
use bevy_log::{error, info};
use bevy_mod_xr::session::XrSessionCreatedMessage;
impl Plugin for OxrActionAttachingPlugin {
fn build(&self, app: &mut App) {
app.add_event::<OxrAttachActionSet>();
app.add_message::<OxrAttachActionSet>();
app.add_systems(
PostUpdate,
attach_sets
.run_if(on_event::<XrSessionCreatedEvent>)
.run_if(on_message::<XrSessionCreatedMessage>)
.after(run_action_binding_sugestion),
);
}
}
fn attach_sets(session: Res<OxrSession>, mut events: EventReader<OxrAttachActionSet>) {
fn attach_sets(session: Res<OxrSession>, mut events: MessageReader<OxrAttachActionSet>) {
let sets = events.read().map(|v| &v.0).collect::<Vec<_>>();
if sets.is_empty() {
return;
@@ -36,7 +38,7 @@ fn attach_sets(session: Res<OxrSession>, mut events: EventReader<OxrAttachAction
};
}
#[derive(Event, Clone)]
#[derive(Message, Clone)]
/// Send this event for every ActionSet you want to attach to the [`OxrSession`] once the Session Status changed to Ready. all requests will
/// be applied in [`PostUpdate`]
pub struct OxrAttachActionSet(pub openxr::ActionSet);

13
crates/bevy_openxr/src/openxr/action_set_syncing.rs
View File

@@ -1,12 +1,15 @@
use bevy_app::{App, Plugin, PreUpdate};
use bevy_ecs::{message::{Message, MessageReader}, schedule::{IntoScheduleConfigs as _, SystemSet}, system::Res};
use bevy_log::warn;
use crate::{openxr_session_running, session::OxrSession};
use bevy::prelude::*;
#[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone, Copy)]
pub struct OxrActionSetSyncSet;
impl Plugin for OxrActionSyncingPlugin {
fn build(&self, app: &mut App) {
app.add_event::<OxrSyncActionSet>();
app.add_message::<OxrSyncActionSet>();
app.add_systems(
PreUpdate,
sync_sets
@@ -16,8 +19,8 @@ impl Plugin for OxrActionSyncingPlugin {
}
}
fn sync_sets(session: Res<OxrSession>, mut events: EventReader<OxrSyncActionSet>) {
let sets = events
fn sync_sets(session: Res<OxrSession>, mut messages: MessageReader<OxrSyncActionSet>) {
let sets = messages
.read()
.map(|v| &v.0)
.map(openxr::ActiveActionSet::new)
@@ -31,7 +34,7 @@ fn sync_sets(session: Res<OxrSession>, mut events: EventReader<OxrSyncActionSet>
}
}
#[derive(Event, Clone)]
#[derive(Message, Clone)]
/// Send this event for every ActionSet you want to attach to the [`OxrSession`] once the Session Status changed to Ready. all requests will
pub struct OxrSyncActionSet(pub openxr::ActionSet);

3
crates/bevy_openxr/src/openxr/environment_blend_mode.rs
View File

@@ -1,4 +1,5 @@
use bevy::{ecs::resource::Resource, render::extract_resource::ExtractResource};
use bevy_ecs::resource::Resource;
use bevy_render::extract_resource::ExtractResource;
use openxr::EnvironmentBlendMode;
#[derive(Resource, ExtractResource, Clone)]

3
crates/bevy_openxr/src/openxr/exts.rs
View File

@@ -1,4 +1,5 @@
use bevy::prelude::{Deref, DerefMut, Resource};
use bevy_derive::{Deref, DerefMut};
use bevy_ecs::resource::Resource;
use openxr::ExtensionSet;
#[derive(Clone, Debug, Eq, PartialEq, Deref, DerefMut, Resource)]

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

@@ -1,7 +1,8 @@
use bevy::prelude::*;
use bevy::render::Render;
use bevy::render::RenderApp;
use bevy::render::RenderSet;
use bevy_log::error;
use bevy_log::info;
use bevy_render::Render;
use bevy_render::RenderApp;
use bevy_render::RenderSystems;
use openxr::sys::SystemPassthroughProperties2FB;
use openxr::PassthroughCapabilityFlagsFB;
@@ -105,7 +106,7 @@ pub fn supports_passthrough(instance: &OxrInstance, system: OxrSystemId) -> OxrR
system.0,
p.as_mut_ptr(),
))?;
bevy::log::info!(
info!(
"From supports_passthrough: Passthrough capabilities: {:?}",
properties.capabilities
);

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

@@ -1,4 +1,12 @@
use bevy::prelude::*;
use bevy_app::{App, Plugin, PreUpdate, Startup};
use bevy_derive::{Deref, DerefMut};
use bevy_ecs::component::Component;
use bevy_ecs::entity::Entity;
use bevy_ecs::query::{Or, With};
use bevy_ecs::schedule::IntoScheduleConfigs as _;
use bevy_ecs::system::{Commands, Query, Res};
use bevy_ecs::world::World;
use bevy_log::{debug, error, warn};
use bevy_mod_xr::hands::{
spawn_hand_bones, HandBone, HandSide, SpawnHandTracker, SpawnHandTrackerCommandExecutor,
XrHandBoneRadius,
@@ -9,6 +17,7 @@ use bevy_mod_xr::spaces::{
XrPrimaryReferenceSpace, XrReferenceSpace, XrSpaceLocationFlags, XrSpaceSyncSet,
XrSpaceVelocityFlags, XrVelocity,
};
use bevy_transform::components::Transform;
use openxr::{SpaceLocationFlags, SpaceVelocityFlags};
use crate::helper_traits::ToVec3;

15
crates/bevy_openxr/src/openxr/features/overlay.rs
View File

@@ -1,6 +1,7 @@
use std::{mem, ptr};
use bevy::prelude::*;
use bevy_app::{App, First, Plugin};
use bevy_ecs::{message::{Message, MessageWriter}, resource::Resource, schedule::IntoScheduleConfigs as _, system::{NonSendMut, Res}};
use openxr::{sys, Event};
use crate::{
@@ -14,8 +15,8 @@ use crate::{
pub struct OxrOverlayPlugin;
impl Plugin for OxrOverlayPlugin {
fn build(&self, app: &mut bevy::prelude::App) {
app.add_event::<OxrOverlaySessionEvent>();
fn build(&self, app: &mut App) {
app.add_message::<OxrOverlaySessionMessage>();
app.init_resource::<OxrOverlaySettings>();
app.add_systems(
First,
@@ -25,9 +26,9 @@ impl Plugin for OxrOverlayPlugin {
}
}
fn handle_overlay_event(event: OxrEventIn, mut writer: EventWriter<OxrOverlaySessionEvent>) {
fn handle_overlay_event(event: OxrEventIn, mut writer: MessageWriter<OxrOverlaySessionMessage>) {
if let Event::MainSessionVisibilityChangedEXTX(event) = *event {
writer.write(OxrOverlaySessionEvent::MainSessionVisibilityChanged {
writer.write(OxrOverlaySessionMessage::MainSessionVisibilityChanged {
visible: event.visible(),
flags: event.flags(),
});
@@ -62,8 +63,8 @@ fn add_overlay_info_to_chain(
}
}
#[derive(Event, Clone, Copy, Debug)]
pub enum OxrOverlaySessionEvent {
#[derive(Message, Clone, Copy, Debug)]
pub enum OxrOverlaySessionMessage {
MainSessionVisibilityChanged {
visible: bool,
flags: openxr::OverlayMainSessionFlagsEXTX,

3
crates/bevy_openxr/src/openxr/graphics.rs
View File

@@ -5,7 +5,8 @@ pub mod vulkan;
use std::{any::TypeId, ffi::CStr};
use bevy::{ecs::resource::Resource, math::UVec2};
use bevy_ecs::resource::Resource;
use bevy_math::UVec2;
use openxr::{FrameStream, FrameWaiter, Session};
use crate::{

30
crates/bevy_openxr/src/openxr/graphics/vulkan.rs
View File

@@ -2,10 +2,11 @@ use std::ffi::{c_void, CStr, CString};
use std::str::FromStr;
use ash::vk::{self, Handle};
use bevy::log::{debug, error};
use bevy::math::UVec2;
use bevy_log::{debug, error};
use bevy_math::UVec2;
use openxr::{sys, Version};
use wgpu::InstanceFlags;
use wgpu::{InstanceFlags, MemoryBudgetThresholds};
use wgpu::TextureUses;
use wgpu_hal::api::Vulkan;
use wgpu_hal::Api;
@@ -53,7 +54,15 @@ unsafe impl GraphicsExt for openxr::Vulkan {
) -> Result<wgpu::Texture> {
let color_image = vk::Image::from_raw(color_image);
let wgpu_hal_texture = unsafe {
<wgpu_hal::vulkan::Api as wgpu_hal::Api>::Device::texture_from_raw(
let hal_dev =
device
.as_hal::<wgpu_hal::vulkan::Api>()
.ok_or(OxrError::GraphicsBackendMismatch {
item: "Wgpu Device",
backend: "unknown",
expected_backend: "vulkan",
})?;
hal_dev.texture_from_raw(
color_image,
&wgpu_hal::TextureDescriptor {
label: Some("VR Swapchain"),
@@ -66,7 +75,7 @@ unsafe impl GraphicsExt for openxr::Vulkan {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu_hal::TextureUses::COLOR_TARGET | wgpu_hal::TextureUses::COPY_DST,
usage: TextureUses::COLOR_TARGET | TextureUses::COPY_DST,
memory_flags: wgpu_hal::MemoryFlags::empty(),
view_formats: vec![],
},
@@ -151,7 +160,7 @@ unsafe impl GraphicsExt for openxr::Vulkan {
vk_physical_device,
instance_exts,
flags,
device_exts.into(),
device_exts,
|info| unsafe {
let vk_device = instance
.create_vulkan_device(
@@ -262,8 +271,8 @@ unsafe impl GraphicsExt for openxr::Vulkan {
vk_physical_device,
instance_exts,
instance_flags,
device_exts.into(),
|info| unsafe { Ok(vk_instance.create_device(vk_physical_device, &info, None)?) },
device_exts,
|info| unsafe { Ok(vk_instance.create_device(vk_physical_device, info, None)?) },
)
.map(|v| v.0)
}
@@ -275,7 +284,7 @@ fn get_extensions(
) -> Result<(wgpu::InstanceFlags, Vec<&'static CStr>, Vec<&'static CStr>)> {
let flags = wgpu::InstanceFlags::default().with_env();
let mut instance_exts =
<Vulkan as Api>::Instance::desired_extensions(&vk_entry, VK_TARGET_VERSION_ASH, flags)?;
<Vulkan as Api>::Instance::desired_extensions(vk_entry, VK_TARGET_VERSION_ASH, flags)?;
let mut device_exts = vec![
ash::khr::swapchain::NAME,
ash::khr::draw_indirect_count::NAME,
@@ -370,6 +379,7 @@ fn init_from_instance_and_dev(
None,
instance_exts,
instance_flags,
MemoryBudgetThresholds::default(),
has_nv_optimus,
None,
)?
@@ -442,8 +452,8 @@ fn init_from_instance_and_dev(
required_features: wgpu_features,
required_limits: limits,
memory_hints: wgpu::MemoryHints::Performance,
trace: wgpu::Trace::Off,
},
None,
)
}?;
Ok((

3
crates/bevy_openxr/src/openxr/helper_traits.rs
View File

@@ -1,4 +1,5 @@
use bevy::{math::Vec3A, prelude::*};
use bevy_math::{Isometry3d, Quat, Vec2, Vec3, Vec3A};
use bevy_transform::components::Transform;
pub trait ToPosef {
fn to_posef(&self) -> openxr::Posef;

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

@@ -1,23 +1,45 @@
use std::sync::atomic::Ordering;
use std::sync::Arc;
use bevy::prelude::*;
use bevy::render::extract_resource::ExtractResourcePlugin;
use bevy::render::renderer::RenderAdapter;
use bevy::render::renderer::RenderAdapterInfo;
use bevy::render::renderer::RenderDevice;
use bevy::render::renderer::RenderInstance;
use bevy::render::renderer::RenderQueue;
use bevy::render::renderer::WgpuWrapper;
use bevy::render::settings::RenderCreation;
use bevy::render::MainWorld;
use bevy::render::Render;
use bevy::render::RenderApp;
use bevy::render::RenderDebugFlags;
use bevy::render::RenderPlugin;
use bevy::winit::UpdateMode;
use bevy::winit::WinitSettings;
use bevy_app::App;
use bevy_app::Plugin;
use bevy_ecs::message::MessageWriter;
use bevy_ecs::message::Messages;
use bevy_ecs::resource::Resource;
use bevy_ecs::schedule::SystemCondition as _;
use bevy_ecs::schedule::common_conditions::on_message;
use bevy_ecs::schedule::common_conditions::resource_exists;
use bevy_ecs::schedule::IntoScheduleConfigs as _;
use bevy_ecs::system::Commands;
use bevy_ecs::system::Local;
use bevy_ecs::system::Res;
use bevy_ecs::system::ResMut;
use bevy_ecs::world::World;
use bevy_log::debug;
use bevy_log::debug_span;
use bevy_log::error;
use bevy_log::info;
use bevy_log::warn;
use bevy_math::UVec2;
use bevy_mod_xr::session::*;
use bevy_render::extract_resource::ExtractResourcePlugin;
use bevy_render::renderer::RenderAdapter;
use bevy_render::renderer::RenderAdapterInfo;
use bevy_render::renderer::RenderDevice;
use bevy_render::renderer::RenderInstance;
use bevy_render::renderer::RenderQueue;
use bevy_render::renderer::WgpuWrapper;
use bevy_render::settings::RenderCreation;
use bevy_render::ExtractSchedule;
use bevy_render::MainWorld;
use bevy_render::Render;
use bevy_render::RenderApp;
use bevy_render::RenderDebugFlags;
use bevy_render::RenderPlugin;
#[cfg(feature = "window_support")]
use bevy_winit::UpdateMode;
#[cfg(feature = "window_support")]
use bevy_winit::WinitSettings;
use crate::error::OxrError;
use crate::graphics::*;
@@ -63,15 +85,15 @@ pub struct OxrInitPlugin {
impl Default for OxrInitPlugin {
fn default() -> Self {
Self {
app_info: default(),
app_info: Default::default(),
exts: {
let mut exts = OxrExtensions::default();
exts.enable_hand_tracking();
exts
},
backends: default(),
backends: Default::default(),
synchronous_pipeline_compilation: false,
render_debug_flags: default(),
render_debug_flags: Default::default(),
}
}
}
@@ -110,7 +132,7 @@ impl Plugin for OxrInitPlugin {
(
create_xr_session
.run_if(state_equals(XrState::Available))
.run_if(on_event::<XrCreateSessionEvent>),
.run_if(on_message::<XrCreateSessionMessage>),
(
destroy_xr_session,
(|v: Res<XrDestroySessionRender>| {
@@ -120,16 +142,16 @@ impl Plugin for OxrInitPlugin {
)
.chain()
.run_if(state_matches!(XrState::Exiting { .. }))
.run_if(on_event::<XrDestroySessionEvent>),
.run_if(on_message::<XrDestroySessionMessage>),
begin_xr_session
.run_if(state_equals(XrState::Ready))
.run_if(on_event::<XrBeginSessionEvent>),
.run_if(on_message::<XrBeginSessionMessage>),
end_xr_session
.run_if(state_equals(XrState::Stopping))
.run_if(on_event::<XrEndSessionEvent>),
.run_if(on_message::<XrEndSessionMessage>),
request_exit_xr_session
.run_if(session_created)
.run_if(on_event::<XrRequestExitEvent>),
.run_if(on_message::<XrRequestExitMessage>),
detect_session_destroyed,
)
.in_set(XrHandleEvents::SessionStateUpdateEvents),
@@ -137,17 +159,20 @@ impl Plugin for OxrInitPlugin {
.insert_resource(instance.clone())
.insert_resource(system_id)
.insert_resource(XrState::Available)
.insert_resource(WinitSettings {
focused_mode: UpdateMode::Continuous,
unfocused_mode: UpdateMode::Continuous,
})
.insert_resource(OxrSessionStarted(false))
.insert_non_send_resource(graphics_info)
.init_non_send_resource::<OxrSessionCreateNextChain>();
#[cfg(feature = "window_support")]
{
app.insert_resource(WinitSettings {
focused_mode: UpdateMode::Continuous,
unfocused_mode: UpdateMode::Continuous,
});
};
app.world_mut()
.resource_mut::<Events<XrStateChanged>>()
.send(XrStateChanged(XrState::Available));
.resource_mut::<Messages<XrStateChanged>>()
.write(XrStateChanged(XrState::Available));
let render_app = app.sub_app_mut(RenderApp);
@@ -213,7 +238,7 @@ impl Plugin for OxrInitPlugin {
fn detect_session_destroyed(
mut last_state: Local<bool>,
state: Res<XrDestroySessionRender>,
mut sender: EventWriter<XrSessionDestroyedEvent>,
mut sender: MessageWriter<XrSessionDestroyedMessage>,
mut cmds: Commands,
) {
let state = state.0.load(Ordering::Relaxed);
@@ -307,7 +332,7 @@ impl OxrInitPlugin {
pub fn handle_events(
event: OxrEventIn,
mut status: ResMut<XrState>,
mut changed_event: EventWriter<XrStateChanged>,
mut changed_event: MessageWriter<XrStateChanged>,
) {
use openxr::Event::*;
match *event {
@@ -511,7 +536,7 @@ pub fn create_xr_session(world: &mut World) {
}
world.insert_non_send_resource(chain);
world.run_schedule(XrSessionCreated);
world.send_event(XrSessionCreatedEvent);
world.write_message(XrSessionCreatedMessage);
}
pub fn destroy_xr_session(world: &mut World) {
@@ -525,9 +550,7 @@ pub fn destroy_xr_session(world: &mut World) {
world.insert_resource(XrState::Available);
}
pub fn begin_xr_session(
world: &mut World,
) {
pub fn begin_xr_session(world: &mut World) {
let _span = debug_span!("xr_begin_session").entered();
world
.get_resource::<OxrSession>()
@@ -539,9 +562,7 @@ pub fn begin_xr_session(
world.run_schedule(XrPostSessionBegin);
}
pub fn end_xr_session(
world: &mut World,
) {
pub fn end_xr_session(world: &mut World) {
world.run_schedule(XrPreSessionEnd);
let _span = debug_span!("xr_end_session").entered();
world

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

@@ -1,6 +1,6 @@
use std::mem;
use bevy::ecs::world::World;
use bevy_ecs::world::World;
use bevy_mod_xr::spaces::{XrPrimaryReferenceSpace, XrSpace};
use openxr::{sys, CompositionLayerFlags, Fovf, Posef, Rect2Di};
@@ -63,7 +63,7 @@ impl LayerProvider for ProjectionLayer {
}
impl LayerProvider for PassthroughLayer {
fn get(&self, world: &World) -> Option<Box<dyn CompositionLayer>> {
fn get(&self, world: &World) -> Option<Box<dyn CompositionLayer<'_>>> {
Some(Box::new(
CompositionLayerPassthrough::new()
.layer_handle(world.get_resource::<OxrPassthroughLayer>()?)
@@ -171,7 +171,7 @@ impl Default for CompositionLayerProjectionView<'_> {
}
}
/// # Safety
/// the header function must return a ref to a valid Composition Layer struct.
/// the header function must return a ref to a valid Composition Layer struct.
/// it has to use `repr(C)` and it has to follow the shape of a Composition Layer struct from the
/// OpenXR specification
pub unsafe trait CompositionLayer<'a> {

36
crates/bevy_openxr/src/openxr/mod.rs
View File

@@ -1,13 +1,11 @@
// use actions::XrActionPlugin;
use bevy::{
app::{PluginGroup, PluginGroupBuilder},
prelude::Res,
render::RenderPlugin,
utils::default,
window::{PresentMode, Window, WindowPlugin},
};
use bevy_app::{PluginGroup, PluginGroupBuilder};
use bevy_ecs::system::Res;
use bevy_mod_xr::session::XrSessionPlugin;
use bevy_mod_xr::{camera::XrCameraPlugin, session::XrState};
use bevy_render::RenderPlugin;
#[cfg(feature = "window_support")]
use bevy_window::{PresentMode, Window, WindowPlugin};
use init::OxrInitPlugin;
use poll_events::OxrEventsPlugin;
use render::OxrRenderPlugin;
@@ -54,7 +52,7 @@ pub fn openxr_session_running(
}
pub fn add_xr_plugins<G: PluginGroup>(plugins: G) -> PluginGroupBuilder {
plugins
let plugins = plugins
.build()
.disable::<RenderPlugin>()
.add_before::<RenderPlugin>(XrSessionPlugin { auto_handle: true })
@@ -69,15 +67,17 @@ pub fn add_xr_plugins<G: PluginGroup>(plugins: G) -> PluginGroupBuilder {
.add(action_set_syncing::OxrActionSyncingPlugin)
.add(features::overlay::OxrOverlayPlugin)
.add(spaces::OxrSpatialPlugin)
.add(spaces::OxrSpacePatchingPlugin)
// we should probably handle the exiting ourselfs so that we can correctly end the
// session and instance
.set(WindowPlugin {
primary_window: Some(Window {
transparent: true,
present_mode: PresentMode::AutoNoVsync,
..default()
}),
.add(spaces::OxrSpacePatchingPlugin);
// we should probably handle the exiting ourselfs so that we can correctly end the
// session and instance
#[cfg(feature = "window_support")]
let plugins = plugins.set(WindowPlugin {
primary_window: Some(Window {
transparent: true,
present_mode: PresentMode::AutoNoVsync,
..default()
})
}),
..default()
});
plugins
}

5
crates/bevy_openxr/src/openxr/poll_events.rs
View File

@@ -1,5 +1,8 @@
use super::{openxr_session_available, resources::OxrInstance};
use bevy::{ecs::system::SystemId, prelude::*};
use bevy_app::{App, Plugin};
use bevy_derive::Deref;
use bevy_ecs::{entity::Entity, resource::Resource, schedule::IntoScheduleConfigs as _, system::{IntoSystem, SystemId, SystemInput}, world::World};
use bevy_log::{debug_span, error};
use bevy_mod_xr::session::{XrFirst, XrHandleEvents};
use openxr::{Event, EventDataBuffer};

14
crates/bevy_openxr/src/openxr/reference_space.rs
View File

@@ -1,11 +1,17 @@
use bevy::{
prelude::*,
render::{extract_resource::ExtractResourcePlugin, RenderApp},
use bevy_app::{App, Plugin};
use bevy_ecs::{
entity::Entity,
query::With,
resource::Resource,
system::{Commands, Query, Res},
};
use bevy_log::error;
use bevy_math::Isometry3d;
use bevy_mod_xr::{
session::{XrPreDestroySession, XrSessionCreated},
spaces::{XrPrimaryReferenceSpace, XrReferenceSpace},
};
use bevy_render::{RenderApp, extract_resource::ExtractResourcePlugin};
use crate::session::OxrSession;
@@ -51,7 +57,7 @@ fn set_primary_ref_space(
space_type: Res<OxrDefaultPrimaryReferenceSpaceType>,
mut cmds: Commands,
) {
match session.create_reference_space(space_type.0, Transform::IDENTITY) {
match session.create_reference_space(space_type.0, Isometry3d::IDENTITY) {
Ok(space) => {
cmds.insert_resource(XrPrimaryReferenceSpace(space));
}

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

@@ -1,25 +1,33 @@
use bevy::{
prelude::*,
render::{
camera::{ManualTextureView, ManualTextureViewHandle, ManualTextureViews, RenderTarget},
extract_resource::ExtractResourcePlugin,
pipelined_rendering::PipelinedRenderingPlugin,
view::{ExtractedView, NoFrustumCulling},
Render, RenderApp,
},
transform::TransformSystem,
use bevy_app::{App, Plugin, PostUpdate};
use bevy_camera::{Camera, ManualTextureViewHandle, Projection, RenderTarget};
use bevy_ecs::{
change_detection::DetectChanges as _,
entity::Entity,
schedule::{IntoScheduleConfigs as _, SystemSet},
system::{Commands, Query, Res, ResMut},
world::World,
};
use bevy_log::{debug_span, error, info};
use bevy_render::{
extract_resource::ExtractResourcePlugin,
pipelined_rendering::PipelinedRenderingPlugin,
texture::{ManualTextureView, ManualTextureViews},
view::ExtractedView,
Render, RenderApp,
};
use bevy_mod_xr::{
camera::{calculate_projection, Fov, XrCamera, XrProjection, XrViewInit},
session::{
XrFirst, XrHandleEvents, XrPreDestroySession, XrRenderSet, XrRootTransform,
XrFirst, XrHandleEvents, XrPreDestroySession, XrRenderSystems, XrRootTransform,
XrSessionCreated,
},
spaces::XrPrimaryReferenceSpace,
};
use bevy_transform::{components::Transform, TransformSystems};
use openxr::ViewStateFlags;
use crate::{init::should_run_frame_loop, resources::*};
use crate::{helper_traits::ToTransform as _, init::should_run_frame_loop, resources::*};
use crate::{layer_builder::ProjectionLayer, session::OxrSession};
use super::environment_blend_mode::OxrEnvironmentBlendModes;
@@ -88,9 +96,8 @@ impl Plugin for OxrRenderPlugin {
.add_systems(
PostUpdate,
(locate_views, update_views)
.before(TransformSystem::TransformPropagate)
.before(TransformSystems::Propagate)
.chain()
// .run_if(should_render)
.run_if(should_run_frame_loop),
)
.init_resource::<OxrViews>();
@@ -109,7 +116,7 @@ impl Plugin for OxrRenderPlugin {
wait_image,
)
.chain()
.in_set(XrRenderSet::PreRender)
.in_set(XrRenderSystems::PreRender)
.run_if(should_run_frame_loop),
)
.add_systems(
@@ -117,40 +124,12 @@ impl Plugin for OxrRenderPlugin {
(release_image, end_frame)
.chain()
.run_if(should_run_frame_loop)
.in_set(XrRenderSet::PostRender),
.in_set(XrRenderSystems::PostRender),
)
.insert_resource(OxrRenderLayers(vec![Box::new(ProjectionLayer)]));
}
}
// fn update_rendering(app_world: &mut World, _sub_app: &mut App) {
// app_world.resource_scope(|world, main_thread_executor: Mut<MainThreadExecutor>| {
// world.resource_scope(|world, mut render_channels: Mut<RenderAppChannels>| {
// // we use a scope here to run any main thread tasks that the render world still needs to run
// // while we wait for the render world to be received.
// let mut render_app = ComputeTaskPool::get()
// .scope_with_executor(true, Some(&*main_thread_executor.0), |s| {
// s.spawn(async { render_channels.recv().await });
// })
// .pop()
// .unwrap();
// if matches!(world.resource::<XrState>(), XrState::Stopping) {
// world.run_schedule(XrEndSession);
// }
// if matches!(world.resource::<XrState>(), XrState::Exiting { .. }) {
// world.run_schedule(XrDestroySession);
// render_app.app.world.run_schedule(XrDestroySession);
// }
// render_app.extract(world);
// render_channels.send_blocking(render_app);
// });
// });
// }
pub const XR_TEXTURE_INDEX: u32 = 3383858418;
pub fn clean_views(
@@ -185,7 +164,7 @@ pub fn init_views<const SPAWN_CAMERAS: bool>(
},
XrCamera(index),
Projection::custom(XrProjection::default()),
NoFrustumCulling,
// NoFrustumCulling,
));
}
}
@@ -283,12 +262,7 @@ pub fn update_views(
);
projection.projection_matrix = projection_matrix;
let openxr::Quaternionf { x, y, z, w } = view.pose.orientation;
let rotation = Quat::from_xyzw(x, y, z, w);
transform.rotation = rotation;
let openxr::Vector3f { x, y, z } = view.pose.position;
let translation = Vec3::new(x, y, z);
transform.translation = translation;
*transform = view.pose.to_transform();
}
}
@@ -301,14 +275,7 @@ pub fn update_views_render_world(
let Some(view) = views.get(camera.0 as usize) else {
continue;
};
let mut transform = Transform::IDENTITY;
let openxr::Quaternionf { x, y, z, w } = view.pose.orientation;
let rotation = Quat::from_xyzw(x, y, z, w);
transform.rotation = rotation;
let openxr::Vector3f { x, y, z } = view.pose.position;
let translation = Vec3::new(x, y, z);
transform.translation = translation;
extracted_view.world_from_view = root.0.mul_transform(transform);
extracted_view.world_from_view = root.0.mul_transform(view.pose.to_transform());
}
}
@@ -345,7 +312,7 @@ pub fn add_texture_view(
dimension: Some(wgpu::TextureViewDimension::D2),
array_layer_count: Some(1),
base_array_layer: index,
..default()
..Default::default()
});
let view = ManualTextureView {
texture_view: view.into(),

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

@@ -1,5 +1,8 @@
use bevy::prelude::*;
use bevy::render::extract_resource::ExtractResource;
use bevy_derive::{Deref, DerefMut};
use bevy_ecs::resource::Resource;
use bevy_math::UVec2;
use bevy_render::extract_resource::ExtractResource;
use bevy_log::error;
use crate::error::OxrError;
use crate::graphics::*;
@@ -351,7 +354,7 @@ impl Default for OxrSessionConfig {
Self {
blend_mode_preference: vec![openxr::EnvironmentBlendMode::OPAQUE],
formats: Some(vec![wgpu::TextureFormat::Rgba8UnormSrgb]),
resolutions: default(),
resolutions: None,
}
}
}

3
crates/bevy_openxr/src/openxr/session.rs
View File

@@ -3,7 +3,8 @@ use std::ffi::c_void;
use crate::next_chain::{OxrNextChain, OxrNextChainStructBase, OxrNextChainStructProvider};
use crate::resources::{OxrPassthrough, OxrPassthroughLayer, OxrSwapchain};
use crate::types::{Result, SwapchainCreateInfo};
use bevy::prelude::*;
use bevy_derive::Deref;
use bevy_ecs::resource::Resource;
use openxr::AnyGraphics;
use crate::graphics::{graphics_match, GraphicsExt, GraphicsType, GraphicsWrap};

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

@@ -1,16 +1,24 @@
use std::{mem::MaybeUninit, ptr, sync::Mutex};
use bevy::{platform::collections::hash_set::HashSet, prelude::*};
use bevy_app::{App, Plugin, PreUpdate, Startup};
use bevy_ecs::{
component::Component, message::MessageReader, schedule::IntoScheduleConfigs as _, system::{Query, Res, ResMut}
};
use bevy_log::{error, info};
use bevy_log::warn;
use bevy_math::Isometry3d;
use bevy_mod_xr::{
session::{XrFirst, XrHandleEvents},
spaces::{
XrDestroySpace, XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace, XrSpaceLocationFlags, XrSpaceSyncSet, XrSpaceVelocityFlags, XrVelocity
XrDestroySpace, XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace, XrSpaceLocationFlags,
XrSpaceSyncSet, XrSpaceVelocityFlags, XrVelocity,
},
};
use bevy_platform::collections::hash_set::HashSet;
use bevy_transform::components::Transform;
use openxr::{
sys, HandJointLocation, HandJointLocations, HandJointVelocities, HandJointVelocity,
ReferenceSpaceType, SpaceLocationFlags, SpaceVelocityFlags, HAND_JOINT_COUNT,
};
use std::{mem::MaybeUninit, ptr, sync::Mutex};
use crate::{
helper_traits::{ToPosef, ToQuat, ToVec3},
@@ -33,7 +41,7 @@ impl Plugin for OxrSpacePatchingPlugin {
pub struct OxrSpatialPlugin;
impl Plugin for OxrSpatialPlugin {
fn build(&self, app: &mut App) {
app.add_event::<XrDestroySpace>()
app.add_message::<XrDestroySpace>()
.add_systems(
XrFirst,
destroy_space_event
@@ -51,7 +59,7 @@ impl Plugin for OxrSpatialPlugin {
}
}
fn destroy_space_event(instance: Res<OxrInstance>, mut events: EventReader<XrDestroySpace>) {
fn destroy_space_event(instance: Res<OxrInstance>, mut events: MessageReader<XrDestroySpace>) {
for space in events.read() {
match instance.destroy_space(space.0) {
Ok(_) => (),
@@ -231,7 +239,7 @@ impl OxrSession {
pub fn create_reference_space(
&self,
ref_space_type: ReferenceSpaceType,
pose_in_ref_space: Transform,
pose_in_ref_space: Isometry3d,
) -> openxr::Result<XrReferenceSpace> {
let info = sys::ReferenceSpaceCreateInfo {
ty: sys::ReferenceSpaceCreateInfo::TYPE,
@@ -579,6 +587,7 @@ fn cvt(x: sys::Result) -> openxr::Result<sys::Result> {
Err(x)
}
}
#[allow(clippy::obfuscated_if_else)]
unsafe fn create_view(flags: openxr::ViewStateFlags, raw: &MaybeUninit<sys::View>) -> openxr::View {
// Applications *must* not read invalid parts of a poses, i.e. they may be uninitialized
let ptr = raw.as_ptr();
@@ -596,6 +605,7 @@ unsafe fn create_view(flags: openxr::ViewStateFlags, raw: &MaybeUninit<sys::View
fov: *ptr::addr_of!((*ptr).fov),
}
}
#[allow(clippy::obfuscated_if_else)]
unsafe fn create_space_location(raw: &MaybeUninit<sys::SpaceLocation>) -> openxr::SpaceLocation {
// Applications *must* not read invalid parts of a pose, i.e. they may be uninitialized
let ptr = raw.as_ptr();
@@ -614,6 +624,7 @@ unsafe fn create_space_location(raw: &MaybeUninit<sys::SpaceLocation>) -> openxr
},
}
}
#[allow(clippy::obfuscated_if_else)]
unsafe fn create_space_velocity(raw: &MaybeUninit<sys::SpaceVelocity>) -> openxr::SpaceVelocity {
// Applications *must* not read invalid velocities, i.e. they may be uninitialized
let ptr = raw.as_ptr();

2
crates/bevy_webxr/Cargo.toml
View File

@@ -8,7 +8,7 @@ license.workspace = true
# bevy can't be placed behind target or proc macros won't work properly
[dependencies]
bevy.workspace = true
# bevy.workspace = true
# all dependencies are placed under this since on anything but wasm, this crate is completely empty
[target.'cfg(target_family = "wasm")'.dependencies]

15
crates/bevy_xr/Cargo.toml
View File

@@ -10,10 +10,21 @@ keywords = ["gamedev", "bevy", "Xr", "Vr"]
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[features]
default = ["gizmos"]
gizmos = ["bevy/bevy_gizmos"]
gizmos = ["dep:bevy_gizmos", "dep:bevy_color"]
reflect = ["dep:bevy_reflect"]
[dependencies]
bevy = { workspace = true, features = ["bevy_log"] }
bevy_ecs.workspace = true
bevy_math.workspace = true
bevy_render.workspace = true
bevy_app.workspace = true
bevy_reflect = { workspace = true, optional = true }
bevy_log.workspace = true
bevy_gizmos = { workspace = true, optional = true }
bevy_color = { workspace = true, optional = true }
bevy_transform.workspace = true
bevy_camera.workspace = true
bevy_derive.workspace = true
[lints.clippy]
too_many_arguments = "allow"

6
crates/bevy_xr/src/actions.rs
View File

@@ -1,8 +1,8 @@
use std::{any::TypeId, marker::PhantomData};
use bevy::app::{App, Plugin};
use bevy::math::Vec2;
use bevy::prelude::Resource;
use bevy_app::{App, Plugin};
use bevy_ecs::resource::Resource;
use bevy_math::Vec2;
pub struct ActionPlugin<A: Action>(PhantomData<A>);

37
crates/bevy_xr/src/camera.rs
View File

@@ -1,14 +1,15 @@
use core::panic;
use bevy::app::{App, Plugin};
use bevy::core_pipeline::core_3d::Camera3d;
use bevy::ecs::component::Component;
use bevy::math::{Mat4, Vec3A, Vec4};
use bevy::prelude::SystemSet;
use bevy::reflect::std_traits::ReflectDefault;
use bevy::reflect::Reflect;
use bevy::render::camera::CameraProjection;
use bevy::render::extract_component::{ExtractComponent, ExtractComponentPlugin};
use bevy_app::{App, Plugin};
use bevy_camera::{Camera3d, CameraProjection};
use bevy_ecs::{component::Component, schedule::SystemSet};
use bevy_math::{Mat4, Vec3A, Vec4};
// use bevy::prelude::SystemSet;
#[cfg(feature = "reflect")]
use bevy_reflect::std_traits::ReflectDefault;
#[cfg(feature = "reflect")]
use bevy_reflect::Reflect;
use bevy_render::extract_component::{ExtractComponent, ExtractComponentPlugin};
use crate::session::XrTracker;
@@ -23,8 +24,9 @@ impl Plugin for XrCameraPlugin {
#[derive(Clone, Copy, Default, PartialEq, Eq, Debug, Hash, SystemSet)]
pub struct XrViewInit;
#[derive(Debug, Clone, Reflect)]
#[reflect(Default)]
#[derive(Debug, Clone)]
#[cfg_attr(feature = "reflect", derive(Reflect))]
#[cfg_attr(feature = "reflect", reflect(Default))]
pub struct XrProjection {
pub projection_matrix: Mat4,
pub near: f32,
@@ -83,7 +85,7 @@ impl CameraProjection for XrProjection {
self.projection_matrix
}
fn get_clip_from_view_for_sub(&self, _sub_view: &bevy::render::camera::SubCameraView) -> Mat4 {
fn get_clip_from_view_for_sub(&self, _sub_view: &bevy_camera::SubCameraView) -> Mat4 {
panic!("sub view not supported for xr camera");
}
}
@@ -194,11 +196,8 @@ pub fn calculate_projection(near_z: f32, fov: Fov) -> Mat4 {
mod tests {
use std::f32::{self, consts::PI};
use bevy::{
math::{Mat4, Vec3A},
render::camera::{CameraProjection, PerspectiveProjection},
utils::default,
};
use bevy_math::{Mat4,Vec3A};
use bevy_camera::{CameraProjection, PerspectiveProjection};
const TEST_VALUES: &[(f32, f32)] = &[(0.5, 100.0), (50.0, 200.0)];
@@ -230,7 +229,7 @@ mod tests {
fn test_get_frustum_corners_symmetrical() {
let control_proj = PerspectiveProjection {
near: 0.1,
..default()
..Default::default()
};
let projection = XrProjection {
@@ -252,7 +251,7 @@ mod tests {
fn test_get_frustum_corners_symmetrical_far_plane() {
let control_proj = PerspectiveProjection {
near: 0.1,
..default()
..Default::default()
};
let projection = XrProjection {

14
crates/bevy_xr/src/hand_debug_gizmos.rs
View File

@@ -1,13 +1,21 @@
use crate::hands::{HandBone, XrHandBoneRadius};
use crate::spaces::XrSpaceLocationFlags;
use bevy::color::palettes::css;
use bevy::{prelude::*, transform::TransformSystem};
use bevy_app::{App, Plugin, PostUpdate};
use bevy_color::palettes::css;
use bevy_color::Srgba;
use bevy_ecs::schedule::IntoScheduleConfigs as _;
use bevy_ecs::system::Query;
use bevy_gizmos::gizmos::Gizmos;
use bevy_math::Isometry3d;
use bevy_transform::TransformSystems;
use bevy_transform::components::GlobalTransform;
pub struct HandGizmosPlugin;
impl Plugin for HandGizmosPlugin {
fn build(&self, app: &mut App) {
app.add_systems(
PostUpdate,
draw_hand_gizmos.after(TransformSystem::TransformPropagate),
draw_hand_gizmos.after(TransformSystems::Propagate),
);
}
}

13
crates/bevy_xr/src/hands.rs
View File

@@ -1,10 +1,11 @@
use bevy::{
ecs::{component::Component, entity::Entity},
log::warn,
math::bool,
prelude::{Bundle, Command, Commands, Deref, DerefMut, Resource, Transform, Visibility, World},
};
use crate::{session::XrTracker, spaces::XrSpaceLocationFlags};
use bevy_camera::visibility::Visibility;
use bevy_derive::{Deref, DerefMut};
use bevy_ecs::{bundle::Bundle, component::Component, entity::Entity, resource::Resource, system::{Command, Commands}, world::World};
use bevy_log::warn;
use bevy_math::bool;
use bevy_transform::components::Transform;
pub const HAND_JOINT_COUNT: usize = 26;
pub fn spawn_hand_bones<T: Bundle>(

1
crates/bevy_xr/src/lib.rs
View File

@@ -5,4 +5,3 @@ pub mod hand_debug_gizmos;
pub mod hands;
pub mod session;
pub mod spaces;
pub mod types;

157
crates/bevy_xr/src/session.rs
View File

@@ -2,30 +2,45 @@ use std::convert::identity;
use std::sync::atomic::AtomicBool;
use std::sync::Arc;
use bevy::app::{AppExit, MainScheduleOrder};
use bevy::ecs::component::HookContext;
use bevy::ecs::schedule::ScheduleLabel;
use bevy::ecs::world::DeferredWorld;
use bevy::prelude::*;
use bevy::render::extract_resource::{ExtractResource, ExtractResourcePlugin};
use bevy::render::{Render, RenderApp, RenderSet};
use bevy_app::{App, AppExit, MainScheduleOrder, Plugin, PostUpdate, PreUpdate};
use bevy_camera::visibility::Visibility;
use bevy_derive::Deref;
use bevy_ecs::component::Component;
use bevy_ecs::entity::Entity;
use bevy_ecs::hierarchy::Children;
use bevy_ecs::lifecycle::HookContext;
use bevy_ecs::message::{Message, MessageReader, MessageWriter};
use bevy_ecs::query::{Has, With};
use bevy_ecs::resource::Resource;
use bevy_ecs::schedule::common_conditions::on_message;
use bevy_ecs::schedule::{
ExecutorKind, IntoScheduleConfigs as _, Schedule, ScheduleLabel, SystemCondition as _, SystemSet
};
use bevy_ecs::system::{Local, Query, Res, ResMut};
use bevy_ecs::world::DeferredWorld;
use bevy_render::extract_resource::{ExtractResource, ExtractResourcePlugin};
use bevy_render::{Render, RenderApp, RenderSystems};
use bevy_transform::components::{GlobalTransform, Transform};
use bevy_transform::TransformSystems;
#[cfg(feature="reflect")]
use bevy_reflect::Reflect;
/// Event sent to instruct backends to create an XR session. Only works when the [`XrState`] is [`Available`](XrState::Available).
#[derive(Event, Clone, Copy, Default)]
pub struct XrCreateSessionEvent;
/// Message sent to instruct backends to create an XR session. Only works when the [`XrState`] is [`Available`](XrState::Available).
#[derive(Message, Clone, Copy, Default)]
pub struct XrCreateSessionMessage;
/// A schedule thats ran whenever an [`XrCreateSessionEvent`] is recieved while the [`XrState`] is [`Available`](XrState::Available)
/// A schedule thats ran whenever an [`XrCreateSessionMessage`] is recieved while the [`XrState`] is [`Available`](XrState::Available)
#[derive(Clone, Copy, Default, PartialEq, Eq, Debug, Hash, ScheduleLabel)]
pub struct XrSessionCreated;
/// Event sent after the XrSession was created.
#[derive(Event, Clone, Copy, Default)]
pub struct XrSessionCreatedEvent;
/// Message sent after the XrSession was created.
#[derive(Message, Clone, Copy, Default)]
pub struct XrSessionCreatedMessage;
/// Event sent to instruct backends to destroy an XR session. Only works when the [`XrState`] is [`Exiting`](XrState::Exiting).
/// If you would like to request that a running session be destroyed, send the [`XrRequestExitEvent`] instead.
#[derive(Event, Clone, Copy, Default)]
pub struct XrDestroySessionEvent;
/// Message sent to instruct backends to destroy an XR session. Only works when the [`XrState`] is [`Exiting`](XrState::Exiting).
/// If you would like to request that a running session be destroyed, send the [`XrRequestExitMessage`] instead.
#[derive(Message, Clone, Copy, Default)]
pub struct XrDestroySessionMessage;
/// Resource flag thats inserted into the world and extracted to the render world to inform any session resources in the render world to drop.
#[derive(Resource, Clone, Default)]
@@ -35,29 +50,29 @@ pub struct XrDestroySessionRender(pub Arc<AtomicBool>);
#[derive(Clone, Copy, Default, PartialEq, Eq, Debug, Hash, ScheduleLabel)]
pub struct XrPreDestroySession;
/// Event sent to instruct backends to begin an XR session. Only works when the [`XrState`] is [`Ready`](XrState::Ready).
#[derive(Event, Clone, Copy, Default)]
pub struct XrBeginSessionEvent;
/// Message sent to instruct backends to begin an XR session. Only works when the [`XrState`] is [`Ready`](XrState::Ready).
#[derive(Message, Clone, Copy, Default)]
pub struct XrBeginSessionMessage;
/// Schedule thats ran when the XrSession has begun.
#[derive(Clone, Copy, Default, PartialEq, Eq, Debug, Hash, ScheduleLabel)]
pub struct XrPostSessionBegin;
/// Event sent to backends to end an XR session. Only works when the [`XrState`] is [`Stopping`](XrState::Stopping).
#[derive(Event, Clone, Copy, Default)]
pub struct XrEndSessionEvent;
/// Message sent to backends to end an XR session. Only works when the [`XrState`] is [`Stopping`](XrState::Stopping).
#[derive(Message, Clone, Copy, Default)]
pub struct XrEndSessionMessage;
/// Schedule thats ran whenever the XrSession is about to end
#[derive(Clone, Copy, Default, PartialEq, Eq, Debug, Hash, ScheduleLabel)]
pub struct XrPreSessionEnd;
/// Event that is emitted when the XrSession is fully destroyed
#[derive(Clone, Copy, Default, PartialEq, Eq, Debug, Hash, Event)]
pub struct XrSessionDestroyedEvent;
/// Message that is emitted when the XrSession is fully destroyed
#[derive(Message, Clone, Copy, Default, PartialEq, Eq, Debug, Hash)]
pub struct XrSessionDestroyedMessage;
/// Event sent to backends to request the [`XrState`] proceed to [`Exiting`](XrState::Exiting) and for the session to be exited. Can be called at any time a session exists.
#[derive(Event, Clone, Copy, Default)]
pub struct XrRequestExitEvent;
/// Message sent to backends to request the [`XrState`] proceed to [`Exiting`](XrState::Exiting) and for the session to be exited. Can be called at any time a session exists.
#[derive(Message, Clone, Copy, Default)]
pub struct XrRequestExitMessage;
/// Schedule ran before [`First`] to handle XR events.
#[derive(Clone, Copy, Default, PartialEq, Eq, Debug, Hash, ScheduleLabel)]
@@ -75,13 +90,13 @@ pub enum XrHandleEvents {
/// System sets ran in the render world for XR.
#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy, SystemSet)]
pub enum XrRenderSet {
/// Ran before [`XrRenderSet::PreRender`] but after [`RenderSet::ExtractCommands`].
pub enum XrRenderSystems {
/// Ran before [`XrRenderSet::PreRender`] but after [`RenderSystems::ExtractCommands`].
HandleEvents,
/// For any XR systems needing to be ran before rendering begins.
/// Ran after [`XrRenderSet::HandleEvents`] but before every render set except [`RenderSet::ExtractCommands`].
/// Ran after [`XrRenderSet::HandleEvents`] but before every render set except [`RenderSystems::ExtractCommands`].
PreRender,
/// For any XR systems needing to be ran after [`RenderSet::Render`] but before [`RenderSet::Cleanup`].
/// For any XR systems needing to be ran after [`RenderSystems::Render`] but before [`RenderSystems::Cleanup`].
PostRender,
}
@@ -97,7 +112,8 @@ pub struct XrTrackingRoot;
struct TrackingRootRes(Entity);
/// Makes the entity a child of the XrTrackingRoot if the entity has no parent
#[derive(Clone, Copy, Hash, PartialEq, Eq, Reflect, Debug, Default, Component)]
#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug, Default, Component)]
#[cfg_attr(feature = "reflect", derive(Reflect))]
#[component(on_add = on_tracker_add)]
pub struct XrTracker;
fn on_tracker_add(mut world: DeferredWorld, HookContext { entity, .. }: HookContext) {
@@ -122,15 +138,15 @@ impl Plugin for XrSessionPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<XrDestroySessionRender>();
let mut xr_first = Schedule::new(XrFirst);
xr_first.set_executor_kind(bevy::ecs::schedule::ExecutorKind::Simple);
app.add_event::<XrCreateSessionEvent>()
.add_event::<XrDestroySessionEvent>()
.add_event::<XrBeginSessionEvent>()
.add_event::<XrEndSessionEvent>()
.add_event::<XrRequestExitEvent>()
.add_event::<XrStateChanged>()
.add_event::<XrSessionCreatedEvent>()
.add_event::<XrSessionDestroyedEvent>()
xr_first.set_executor_kind(ExecutorKind::SingleThreaded);
app.add_message::<XrCreateSessionMessage>()
.add_message::<XrDestroySessionMessage>()
.add_message::<XrBeginSessionMessage>()
.add_message::<XrEndSessionMessage>()
.add_message::<XrRequestExitMessage>()
.add_message::<XrStateChanged>()
.add_message::<XrSessionCreatedMessage>()
.add_message::<XrSessionDestroyedMessage>()
.init_schedule(XrSessionCreated)
.init_schedule(XrPreDestroySession)
.init_schedule(XrPostSessionBegin)
@@ -150,7 +166,7 @@ impl Plugin for XrSessionPlugin {
.add_systems(
XrFirst,
exits_session_on_app_exit
.run_if(on_event::<AppExit>)
.run_if(on_message::<AppExit>)
.run_if(session_created)
.in_set(XrHandleEvents::ExitEvents),
);
@@ -178,13 +194,13 @@ impl Plugin for XrSessionPlugin {
.init_resource::<XrRootTransform>()
.add_systems(
PostUpdate,
update_root_transform.after(TransformSystem::TransformPropagate),
update_root_transform.after(TransformSystems::Propagate),
)
.add_systems(
XrFirst,
exits_session_on_app_exit
.before(XrHandleEvents::ExitEvents)
.run_if(on_event::<AppExit>.and(session_running)),
.run_if(on_message::<AppExit>.and(session_running)),
);
let render_app = app.sub_app_mut(RenderApp);
@@ -194,33 +210,33 @@ impl Plugin for XrSessionPlugin {
// .init_resource::<XrRootTransform>()
.configure_sets(
Render,
(XrRenderSet::HandleEvents, XrRenderSet::PreRender).chain(),
(XrRenderSystems::HandleEvents, XrRenderSystems::PreRender).chain(),
)
.configure_sets(
Render,
XrRenderSet::HandleEvents.after(RenderSet::ExtractCommands),
XrRenderSystems::HandleEvents.after(RenderSystems::ExtractCommands),
)
.configure_sets(
Render,
XrRenderSet::PreRender
.before(RenderSet::ManageViews)
.before(RenderSet::PrepareAssets),
XrRenderSystems::PreRender
.before(RenderSystems::ManageViews)
.before(RenderSystems::PrepareAssets),
)
.configure_sets(
Render,
XrRenderSet::PostRender
.after(RenderSet::Render)
.before(RenderSet::Cleanup),
XrRenderSystems::PostRender
.after(RenderSystems::Render)
.before(RenderSystems::Cleanup),
);
}
}
fn exits_session_on_app_exit(mut request_exit: EventWriter<XrRequestExitEvent>) {
fn exits_session_on_app_exit(mut request_exit: MessageWriter<XrRequestExitMessage>) {
request_exit.write_default();
}
/// Event sent by backends whenever [`XrState`] is changed.
#[derive(Event, Clone, Copy, Deref)]
/// Message sent by backends whenever [`XrState`] is changed.
#[derive(Message, Clone, Copy, Deref)]
pub struct XrStateChanged(pub XrState);
/// A resource in the main world and render world representing the current session state.
@@ -229,17 +245,17 @@ pub struct XrStateChanged(pub XrState);
pub enum XrState {
/// An XR session is not available here
Unavailable,
/// An XR session is available and ready to be created with an [`XrCreateSessionEvent`].
/// An XR session is available and ready to be created with an [`XrCreateSessionMessage`].
Available,
/// An XR session is created but not ready to begin. Backends are not required to use this state.
Idle,
/// An XR session has been created and is ready to start rendering with an [`XrBeginSessionEvent`].
/// An XR session has been created and is ready to start rendering with an [`XrBeginSessionMessage`].
Ready,
/// The XR session is running and can be stopped with an [`XrEndSessionEvent`].
/// The XR session is running and can be stopped with an [`XrEndSessionMessage`].
Running,
/// The runtime has requested that the session should be ended with an [`XrEndSessionEvent`].
/// The runtime has requested that the session should be ended with an [`XrEndSessionMessage`].
Stopping,
/// The XR session should be destroyed with an [`XrDestroySessionEvent`].
/// The XR session should be destroyed with an [`XrDestroySessionMessage`].
Exiting {
/// Whether we should automatically restart the session
should_restart: bool,
@@ -247,11 +263,11 @@ pub enum XrState {
}
pub fn auto_handle_session(
mut state_changed: EventReader<XrStateChanged>,
mut create_session: EventWriter<XrCreateSessionEvent>,
mut begin_session: EventWriter<XrBeginSessionEvent>,
mut end_session: EventWriter<XrEndSessionEvent>,
mut destroy_session: EventWriter<XrDestroySessionEvent>,
mut state_changed: MessageReader<XrStateChanged>,
mut create_session: MessageWriter<XrCreateSessionMessage>,
mut begin_session: MessageWriter<XrBeginSessionMessage>,
mut end_session: MessageWriter<XrEndSessionMessage>,
mut destroy_session: MessageWriter<XrDestroySessionMessage>,
mut no_auto_restart: Local<bool>,
) {
for XrStateChanged(state) in state_changed.read() {
@@ -290,8 +306,8 @@ pub fn update_root_transform(
/// A [`Condition`](bevy::ecs::schedule::Condition) that allows the system to run when the xr status changed to a specific [`XrStatus`].
pub fn status_changed_to(
status: XrState,
) -> impl FnMut(EventReader<XrStateChanged>) -> bool + Clone {
move |mut reader: EventReader<XrStateChanged>| {
) -> impl FnMut(MessageReader<XrStateChanged>) -> bool + Clone {
move |mut reader: MessageReader<XrStateChanged>| {
reader.read().any(|new_status| new_status.0 == status)
}
}
@@ -332,5 +348,4 @@ macro_rules! state_matches {
};
}
use bevy::transform::TransformSystem;
pub use state_matches;

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

@@ -1,7 +1,11 @@
use bevy::{
prelude::*,
render::{extract_component::ExtractComponent, extract_resource::ExtractResource},
};
use bevy_camera::visibility::Visibility;
use bevy_derive::{Deref, DerefMut};
use bevy_ecs::{component::Component, message::Message, resource::Resource, schedule::SystemSet};
use bevy_math::Vec3;
use bevy_render::{extract_component::ExtractComponent, extract_resource::ExtractResource};
use bevy_transform::components::Transform;
#[cfg(feature="reflect")]
use bevy_reflect::Reflect;
use crate::session::XrTracker;
@@ -10,11 +14,13 @@ 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)]
#[derive(Component, Clone, Copy, Hash, PartialEq, Eq, Debug, ExtractComponent)]
#[cfg_attr(feature = "reflect", derive(Reflect))]
#[require(XrSpaceLocationFlags, Transform, Visibility, XrTracker)]
pub struct XrSpace(u64);
#[derive(Component, Clone, Copy, Reflect, Debug, ExtractComponent, Default)]
#[derive(Component, Clone, Copy, Debug, ExtractComponent, Default)]
#[cfg_attr(feature = "reflect", derive(Reflect))]
#[require(XrSpaceVelocityFlags)]
pub struct XrVelocity {
/// Velocity of a space relative to it's reference space
@@ -34,32 +40,30 @@ impl XrVelocity {
}
}
#[derive(Event, Clone, Copy, Deref, DerefMut)]
#[derive(Message, Clone, Copy, Deref, DerefMut)]
pub struct XrDestroySpace(pub XrSpace);
#[repr(transparent)]
#[derive(
Clone, Copy, Hash, PartialEq, Eq, Reflect, Debug, Component, Deref, DerefMut, ExtractComponent,
)]
#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug, Component, Deref, DerefMut, ExtractComponent)]
#[cfg_attr(feature = "reflect", derive(Reflect))]
pub struct XrReferenceSpace(pub XrSpace);
#[repr(transparent)]
#[derive(
Clone, Copy, Hash, PartialEq, Eq, Reflect, Debug, Resource, Deref, DerefMut, ExtractResource,
)]
#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug, Resource, Deref, DerefMut, ExtractResource)]
#[cfg_attr(feature = "reflect", derive(Reflect))]
pub struct XrPrimaryReferenceSpace(pub XrReferenceSpace);
#[derive(
Clone, Copy, Hash, PartialEq, Eq, Reflect, Debug, Component, ExtractComponent, Default,
)]
#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug, Component, ExtractComponent, Default)]
#[cfg_attr(feature = "reflect", derive(Reflect))]
pub struct XrSpaceLocationFlags {
pub position_tracked: bool,
pub rotation_tracked: bool,
}
#[derive(
Clone, Copy, Hash, PartialEq, Eq, Reflect, Debug, Component, ExtractComponent, Default,
Clone, Copy, Hash, PartialEq, Eq, Debug, Component, ExtractComponent, Default,
)]
#[cfg_attr(feature = "reflect", derive(Reflect))]
pub struct XrSpaceVelocityFlags {
pub linear_valid: bool,
pub angular_valid: bool,

4
crates/bevy_xr/src/types.rs
View File

@@ -1,4 +0,0 @@
use bevy::math::Isometry3d;
#[deprecated = "Use Isometry3d instead"]
pub type XrPose = Isometry3d;

12
crates/bevy_xr_utils/Cargo.toml
View File

@@ -9,12 +9,20 @@ description = "utils for bevy_mod_xr and bevy_mod_openxr"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
bevy = { workspace = true, features = ["bevy_gizmos"] }
# bevy = { workspace = true, features = ["bevy_gizmos"] }
bevy_mod_xr.workspace = true
bevy_mod_openxr.workspace = true
bevy_ecs.workspace=true
bevy_app.workspace=true
bevy_transform.workspace=true
bevy_color.workspace=true
bevy_gizmos.workspace=true
bevy_log.workspace=true
bevy_derive.workspace=true
bevy_math.workspace=true
[dev-dependencies]
bevy = { workspace = true, default-features = true }
bevy.workspace = true
[target.'cfg(not(target_family = "wasm"))'.dependencies]
openxr.workspace = true

4
crates/bevy_xr_utils/examples/actions.rs
View File

@@ -3,7 +3,7 @@ use bevy::{math::vec3, prelude::*};
use bevy_mod_openxr::{add_xr_plugins, helper_traits::ToQuat, resources::OxrViews};
use bevy_mod_xr::session::XrTrackingRoot;
use bevy_xr_utils::xr_utils_actions::{
ActiveSet, XRUtilsAction, XRUtilsActionSet, XRUtilsActionState, XRUtilsActionSystemSet,
ActiveSet, XRUtilsAction, XRUtilsActionSet, XRUtilsActionState, XRUtilsActionSystems,
XRUtilsActionsPlugin, XRUtilsBinding,
};
@@ -14,7 +14,7 @@ fn main() {
.add_systems(Startup, setup_scene)
.add_systems(
Startup,
create_action_entities.before(XRUtilsActionSystemSet::CreateEvents),
create_action_entities.before(XRUtilsActionSystems::CreateEvents),
)
.add_plugins(XRUtilsActionsPlugin)
.add_systems(Update, read_action_with_marker_component)

8
crates/bevy_xr_utils/examples/transform_utils.rs
View File

@@ -4,7 +4,7 @@ use bevy::prelude::*;
use bevy_mod_openxr::add_xr_plugins;
use bevy_xr_utils::transform_utils::{self, SnapToPosition, SnapToRotation};
use bevy_xr_utils::xr_utils_actions::{
ActiveSet, XRUtilsAction, XRUtilsActionSet, XRUtilsActionState, XRUtilsActionSystemSet,
ActiveSet, XRUtilsAction, XRUtilsActionSet, XRUtilsActionState, XRUtilsActionSystems,
XRUtilsActionsPlugin, XRUtilsBinding,
};
@@ -17,15 +17,15 @@ fn main() -> AppExit {
.add_plugins(XRUtilsActionsPlugin)
.add_systems(
Startup,
create_action_entities.before(XRUtilsActionSystemSet::CreateEvents),
create_action_entities.before(XRUtilsActionSystems::CreateEvents),
)
.add_systems(
Update,
send_look_at_red_cube_event.after(XRUtilsActionSystemSet::SyncActionStates),
send_look_at_red_cube_event.after(XRUtilsActionSystems::SyncActionStates),
)
.add_systems(
Update,
send_recenter.after(XRUtilsActionSystemSet::SyncActionStates),
send_recenter.after(XRUtilsActionSystems::SyncActionStates),
)
.insert_resource(AmbientLight {
brightness: 500.0,

11
crates/bevy_xr_utils/src/generic_tracker.rs
View File

@@ -1,4 +1,8 @@
use bevy::{color::palettes::css, prelude::*};
use bevy_app::{App, Plugin, PostUpdate};
use bevy_color::palettes::css;
use bevy_ecs::{component::Component, query::With, schedule::IntoScheduleConfigs as _, system::Query};
use bevy_gizmos::gizmos::Gizmos;
use bevy_transform::{TransformSystems, components::{GlobalTransform, Transform}};
#[derive(Clone, Copy, Component)]
#[require(Transform)]
@@ -8,10 +12,7 @@ pub struct GenericTrackerGizmoPlugin;
impl Plugin for GenericTrackerGizmoPlugin {
fn build(&self, app: &mut App) {
app.add_systems(
PostUpdate,
draw_gizmos.after(TransformSystem::TransformPropagate),
);
app.add_systems(PostUpdate, draw_gizmos.after(TransformSystems::Propagate));
}
}

5
crates/bevy_xr_utils/src/mndx_xdev_spaces_trackers.rs
View File

@@ -1,6 +1,9 @@
use std::convert::identity;
use bevy::prelude::*;
use bevy_app::{App, Plugin, PreUpdate};
use bevy_derive::{Deref, DerefMut};
use bevy_ecs::{component::Component, entity::Entity, query::With, resource::Resource, schedule::{IntoScheduleConfigs as _, common_conditions::resource_exists}, system::{Commands, Query, Res, ResMut}};
use bevy_log::{error, info};
use bevy_mod_openxr::{
resources::{OxrInstance, OxrSystemId},
session::OxrSession,

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

@@ -1,4 +1,13 @@
use bevy::prelude::*;
use bevy_app::{App, Plugin, PreUpdate, Startup};
use bevy_ecs::{
component::Component,
message::MessageWriter,
query::{With, Without},
resource::Resource,
schedule::IntoScheduleConfigs as _,
system::{Commands, Query, Res},
};
use bevy_math::{EulerRot, Isometry3d, Quat};
use bevy_mod_openxr::{
action_binding::OxrSuggestActionBinding,
action_set_attaching::OxrAttachActionSet,
@@ -13,6 +22,7 @@ use bevy_mod_xr::{
session::{XrSessionCreated, XrTracker, XrTrackingRoot},
spaces::{XrPrimaryReferenceSpace, XrReferenceSpace, XrSpaceSyncSet},
};
use bevy_transform::components::Transform;
use openxr::Posef;
//exernal api
@@ -203,14 +213,9 @@ fn spawn_tracking_rig(
) {
//head
let head_space = session
.create_reference_space(openxr::ReferenceSpaceType::VIEW, Transform::IDENTITY)
.create_reference_space(openxr::ReferenceSpaceType::VIEW, Isometry3d::IDENTITY)
.unwrap();
cmds.spawn((
Transform::default(),
Visibility::default(),
XrTracker,
HeadXRSpace(head_space),
));
cmds.spawn((Transform::default(), XrTracker, HeadXRSpace(head_space)));
// let local_floor = cmds.spawn((SpatialBundle::default(), LocalFloor)).id();
let left_space = session
@@ -227,7 +232,7 @@ fn spawn_tracking_rig(
//TODO figure out how to make these better, specifically not be controller specific
pub fn suggest_action_bindings(
actions: Res<ControllerActions>,
mut bindings: EventWriter<OxrSuggestActionBinding>,
mut bindings: MessageWriter<OxrSuggestActionBinding>,
) {
bindings.write(OxrSuggestActionBinding {
action: actions.left.as_raw(),
@@ -241,11 +246,11 @@ pub fn suggest_action_bindings(
});
}
fn sync_actions(actions: Res<ControllerActions>, mut sync: EventWriter<OxrSyncActionSet>) {
fn sync_actions(actions: Res<ControllerActions>, mut sync: MessageWriter<OxrSyncActionSet>) {
sync.write(OxrSyncActionSet(actions.set.clone()));
}
fn attach_set(actions: Res<ControllerActions>, mut attach: EventWriter<OxrAttachActionSet>) {
fn attach_set(actions: Res<ControllerActions>, mut attach: MessageWriter<OxrAttachActionSet>) {
attach.write(OxrAttachActionSet(actions.set.clone()));
}

22
crates/bevy_xr_utils/src/transform_utils.rs
View File

@@ -1,32 +1,36 @@
use bevy::prelude::*;
use bevy_app::{App, Plugin, PostUpdate};
use bevy_ecs::{message::{Message, MessageReader}, query::With, system::{Query, ResMut}};
use bevy_log::debug;
use bevy_math::{Quat, Vec3};
use bevy_mod_openxr::{
helper_traits::{ToQuat, ToVec3},
resources::OxrViews,
};
use bevy_mod_xr::session::XrTrackingRoot;
use bevy_transform::components::Transform;
pub struct TransformUtilitiesPlugin;
impl Plugin for TransformUtilitiesPlugin {
fn build(&self, app: &mut App) {
app.add_event::<SnapToRotation>();
app.add_event::<SnapToPosition>();
app.add_message::<SnapToRotation>();
app.add_message::<SnapToPosition>();
app.add_systems(PostUpdate, handle_transform_events);
}
}
//events
#[derive(Event, Debug)]
#[derive(Message, Debug)]
pub struct SnapToRotation(pub Quat);
#[derive(Event, Debug)]
#[derive(Message, Debug)]
pub struct SnapToPosition(pub Vec3);
pub fn handle_transform_events(
mut root_query: Query<&mut Transform, With<XrTrackingRoot>>,
views: ResMut<OxrViews>,
mut position_reader: EventReader<SnapToPosition>,
mut rotation_reader: EventReader<SnapToRotation>,
mut position_reader: MessageReader<SnapToPosition>,
mut rotation_reader: MessageReader<SnapToRotation>,
) {
let result = root_query.single_mut();
match result {
@@ -52,11 +56,11 @@ pub fn handle_transform_events(
let root_rot = root_transform.rotation;
let view_global_rotation = root_rot.mul_quat(view_rot).normalize();
let (global_view_yaw, _pitch, _roll) =
view_global_rotation.to_euler(bevy::math::EulerRot::YXZ);
view_global_rotation.to_euler(bevy_math::EulerRot::YXZ);
let up = Vec3::Y;
for rotation in rotation_reader.read() {
let (target_yaw, _pitch, _roll) =
rotation.0.normalize().to_euler(bevy::math::EulerRot::YXZ);
rotation.0.normalize().to_euler(bevy_math::EulerRot::YXZ);
let diff_yaw = target_yaw - global_view_yaw;
//build a rotation quat?

32
crates/bevy_xr_utils/src/xr_utils_actions.rs
View File

@@ -53,7 +53,9 @@
//! }
//!
//!
use bevy::prelude::*;
use bevy_app::{App, Plugin, PreUpdate, Startup, Update};
use bevy_ecs::{component::Component, entity::Entity, hierarchy::Children, message::MessageWriter, query::With, schedule::{IntoScheduleConfigs as _, SystemSet}, system::{Commands, Query, Res, ResMut}};
use bevy_log::info;
use bevy_mod_openxr::{
action_binding::OxrSuggestActionBinding,
action_set_attaching::OxrAttachActionSet,
@@ -71,16 +73,16 @@ impl Plugin for XRUtilsActionsPlugin {
fn build(&self, app: &mut App) {
app.configure_sets(
Startup,
XRUtilsActionSystemSet::CreateEvents.run_if(openxr_session_available),
XRUtilsActionSystems::CreateEvents.run_if(openxr_session_available),
);
app.configure_sets(
PreUpdate,
XRUtilsActionSystemSet::SyncActionStates.run_if(openxr_session_running),
XRUtilsActionSystems::SyncActionStates.run_if(openxr_session_running),
);
app.add_systems(
Startup,
create_openxr_events
.in_set(XRUtilsActionSystemSet::CreateEvents)
.in_set(XRUtilsActionSystems::CreateEvents)
.run_if(openxr_session_available),
);
app.add_systems(
@@ -91,21 +93,21 @@ impl Plugin for XRUtilsActionsPlugin {
PreUpdate,
sync_and_update_action_states_f32
.run_if(openxr_session_running)
.in_set(XRUtilsActionSystemSet::SyncActionStates)
.in_set(XRUtilsActionSystems::SyncActionStates)
.after(OxrActionSetSyncSet),
);
app.add_systems(
PreUpdate,
sync_and_update_action_states_bool
.run_if(openxr_session_running)
.in_set(XRUtilsActionSystemSet::SyncActionStates)
.in_set(XRUtilsActionSystems::SyncActionStates)
.after(OxrActionSetSyncSet),
);
app.add_systems(
PreUpdate,
sync_and_update_action_states_vector
.run_if(openxr_session_running)
.in_set(XRUtilsActionSystemSet::SyncActionStates)
.in_set(XRUtilsActionSystems::SyncActionStates)
.after(OxrActionSetSyncSet),
);
}
@@ -116,8 +118,8 @@ fn create_openxr_events(
actions_query: Query<(&XRUtilsAction, &Children)>,
bindings_query: Query<&XRUtilsBinding>,
instance: ResMut<OxrInstance>,
mut binding_writer: EventWriter<OxrSuggestActionBinding>,
mut attach_writer: EventWriter<OxrAttachActionSet>,
mut binding_writer: MessageWriter<OxrSuggestActionBinding>,
mut attach_writer: MessageWriter<OxrAttachActionSet>,
mut commands: Commands,
) {
//lets create some sets!
@@ -131,7 +133,7 @@ fn create_openxr_events(
commands.entity(id).insert(oxr_action_set);
//since the actions are made from the sets lets go
for child in children.iter() {
for child in children.iter().copied() {
//first get the action entity and stuff
let (create_action, bindings) = actions_query.get(child).unwrap();
//lets create dat action
@@ -158,7 +160,7 @@ fn create_openxr_events(
}),
));
//since we need actions for bindings lets go!!
for bind in bindings.iter() {
for bind in bindings.iter().copied() {
//interaction profile
//get the binding entity and stuff
let create_binding = bindings_query.get(bind).unwrap();
@@ -197,7 +199,7 @@ fn create_openxr_events(
}),
));
//since we need actions for bindings lets go!!
for bind in bindings.iter() {
for bind in bindings.iter().copied() {
//interaction profile
//get the binding entity and stuff
let create_binding = bindings_query.get(bind).unwrap();
@@ -236,7 +238,7 @@ fn create_openxr_events(
}),
));
//since we need actions for bindings lets go!!
for bind in bindings.iter() {
for bind in bindings.iter().copied() {
//interaction profile
//get the binding entity and stuff
let create_binding = bindings_query.get(bind).unwrap();
@@ -260,7 +262,7 @@ fn create_openxr_events(
}
fn sync_active_action_sets(
mut sync_set: EventWriter<OxrSyncActionSet>,
mut sync_set: MessageWriter<OxrSyncActionSet>,
active_action_set_query: Query<&XRUtilsActionSetReference, With<ActiveSet>>,
) {
for set in &active_action_set_query {
@@ -344,7 +346,7 @@ fn sync_and_update_action_states_vector(
}
#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy, SystemSet)]
pub enum XRUtilsActionSystemSet {
pub enum XRUtilsActionSystems {
/// Runs in Startup
CreateEvents,
/// Runs in PreUpdate