From 6aadf5bd3e2048d237ce17f966ca71ccf770fb41 Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 13:13:00 -0400 Subject: [PATCH 01/13] copied work from actions --- .../bevy_openxr/examples/common_entities.rs | 168 ++++++++++++++++++ 1 file changed, 168 insertions(+) create mode 100644 crates/bevy_openxr/examples/common_entities.rs diff --git a/crates/bevy_openxr/examples/common_entities.rs b/crates/bevy_openxr/examples/common_entities.rs new file mode 100644 index 0000000..20c3da1 --- /dev/null +++ b/crates/bevy_openxr/examples/common_entities.rs @@ -0,0 +1,168 @@ +//! A simple 3D scene with light shining over a cube sitting on a plane. + +use std::ops::Deref; + +use bevy::prelude::*; +use bevy_mod_openxr::{ + action_binding::{OxrSendActionBindings, OxrSuggestActionBinding}, + action_set_attaching::OxrAttachActionSet, + action_set_syncing::{OxrActionSetSyncSet, OxrSyncActionSet}, + add_xr_plugins, + resources::OxrInstance, + session::OxrSession, + spaces::OxrSpaceExt, +}; +use bevy_mod_xr::{ + session::{session_available, session_running, XrSessionCreated, XrTrackingRoot}, + spaces::XrSpace, + types::XrPose, +}; +use openxr::Posef; + +fn main() { + let mut app = App::new(); + app.add_plugins(add_xr_plugins(DefaultPlugins)); + app.add_systems(Startup, setup); + //create bindings + app.add_systems(OxrSendActionBindings, suggest_action_bindings); + //sync actions + app.add_systems( + PreUpdate, + sync_actions + .before(OxrActionSetSyncSet) + .run_if(session_running), + ); + //things? + app.add_systems(XrSessionCreated, spawn_hands); + app.add_systems(XrSessionCreated, attach_set); + app.add_systems(Startup, create_actions.run_if(session_available)); + + app.run(); +} + +/// set up a simple 3D scene +fn setup( + mut commands: Commands, + mut meshes: ResMut>, + mut materials: ResMut>, +) { + // circular base + commands.spawn(PbrBundle { + mesh: meshes.add(Circle::new(4.0)), + material: materials.add(Color::WHITE), + transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)), + ..default() + }); + // cube + commands.spawn(PbrBundle { + mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)), + material: materials.add(Color::srgb_u8(124, 144, 255)), + transform: Transform::from_xyz(0.0, 0.5, 0.0), + ..default() + }); + // light + commands.spawn(PointLightBundle { + point_light: PointLight { + shadows_enabled: true, + ..default() + }, + transform: Transform::from_xyz(4.0, 8.0, 4.0), + ..default() + }); + commands.spawn(Camera3dBundle { + transform: Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y), + ..default() + }); +} + +#[derive(Resource)] +struct ControllerActions { + set: openxr::ActionSet, + left: openxr::Action, + right: openxr::Action, +} + +fn suggest_action_bindings( + actions: Res, + mut bindings: EventWriter, +) { + bindings.send(OxrSuggestActionBinding { + action: actions.left.as_raw(), + interaction_profile: "/interaction_profiles/oculus/touch_controller".into(), + bindings: vec!["/user/hand/left/input/grip/pose".into()], + }); + bindings.send(OxrSuggestActionBinding { + action: actions.right.as_raw(), + interaction_profile: "/interaction_profiles/oculus/touch_controller".into(), + bindings: vec!["/user/hand/right/input/grip/pose".into()], + }); +} + +fn sync_actions(actions: Res, mut sync: EventWriter) { + sync.send(OxrSyncActionSet(actions.set.clone())); +} + +fn attach_set(actions: Res, mut attach: EventWriter) { + attach.send(OxrAttachActionSet(actions.set.clone())); +} + +fn create_actions(instance: Res, mut cmds: Commands) { + let set = instance.create_action_set("hands", "Hands", 0).unwrap(); + let left = set + .create_action("left_pose", "Left Hand Grip Pose", &[]) + .unwrap(); + let right = set + .create_action("right_pose", "Right Hand Grip Pose", &[]) + .unwrap(); + + cmds.insert_resource(ControllerActions { set, left, right }) +} + +fn spawn_hands( + actions: Res, + mut cmds: Commands, + root: Query>, + session: Res, + mut meshes: ResMut>, + mut materials: ResMut>, +) { + // This is a demonstation of how to integrate with the openxr crate, the right space is the + // recommended way + let left_space = XrSpace::from_openxr_space( + actions + .left + .create_space( + session.deref().deref().clone(), + openxr::Path::NULL, + Posef::IDENTITY, + ) + .unwrap(), + ); + let right_space = session + .create_action_space(&actions.right, openxr::Path::NULL, XrPose::IDENTITY) + .unwrap(); + let left = cmds + .spawn(( + PbrBundle { + mesh: meshes.add(Cuboid::new(0.1, 0.1, 0.05)), + material: materials.add(Color::srgb_u8(124, 144, 255)), + transform: Transform::from_xyz(0.0, 0.5, 0.0), + ..default() + }, + left_space, + )) + .id(); + let right = cmds + .spawn(( + PbrBundle { + mesh: meshes.add(Cuboid::new(0.1, 0.1, 0.05)), + material: materials.add(Color::srgb_u8(124, 144, 255)), + transform: Transform::from_xyz(0.0, 0.5, 0.0), + ..default() + }, + right_space, + )) + .id(); + + cmds.entity(root.single()).push_children(&[left, right]); +} From d0f2b01a06ffe904faad14ae314f69773190800e Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 14:05:45 -0400 Subject: [PATCH 02/13] added an emulated local floor --- .../bevy_openxr/examples/common_entities.rs | 104 +++++++++++++++++- 1 file changed, 100 insertions(+), 4 deletions(-) diff --git a/crates/bevy_openxr/examples/common_entities.rs b/crates/bevy_openxr/examples/common_entities.rs index 20c3da1..4c7ae4b 100644 --- a/crates/bevy_openxr/examples/common_entities.rs +++ b/crates/bevy_openxr/examples/common_entities.rs @@ -8,13 +8,14 @@ use bevy_mod_openxr::{ action_set_attaching::OxrAttachActionSet, action_set_syncing::{OxrActionSetSyncSet, OxrSyncActionSet}, add_xr_plugins, - resources::OxrInstance, + helper_traits::{ToQuat, ToVec3}, + resources::{OxrFrameState, OxrInstance, Pipelined}, session::OxrSession, - spaces::OxrSpaceExt, + spaces::{OxrSpaceExt, OxrSpaceLocationFlags, OxrSpaceSyncSet, OxrSpaceVelocityFlags}, }; use bevy_mod_xr::{ session::{session_available, session_running, XrSessionCreated, XrTrackingRoot}, - spaces::XrSpace, + spaces::{XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace, XrVelocity}, types::XrPose, }; use openxr::Posef; @@ -37,6 +38,16 @@ fn main() { app.add_systems(XrSessionCreated, attach_set); app.add_systems(Startup, create_actions.run_if(session_available)); + //head space + app.add_systems( + PreUpdate, + update_head_transforms + .in_set(OxrSpaceSyncSet) + .run_if(session_running), + ); + //local floor emulated + app.add_systems(PreUpdate, update_local_floor.after(update_head_transforms)); + app.run(); } @@ -163,6 +174,91 @@ fn spawn_hands( right_space, )) .id(); + //head? + let head_space = session + .create_reference_space(openxr::ReferenceSpaceType::VIEW, Transform::IDENTITY) + .unwrap(); + let head = cmds + .spawn(( + PbrBundle { + mesh: meshes.add(Cuboid::new(0.2, 0.2, 0.2)), + material: materials.add(Color::srgb_u8(255, 144, 144)), + transform: Transform::from_xyz(0.0, 0.0, 0.0), + ..default() + }, + HeadXRSpace(head_space), + )) + .id(); + //local_floor? emulated + let local_floor = cmds + .spawn(( + PbrBundle { + mesh: meshes.add(Cuboid::new(0.5, 0.1, 0.5)), + material: materials.add(Color::srgb_u8(144, 255, 144)), + transform: Transform::from_xyz(0.0, 0.0, 0.0), + ..default() + }, + LocalFloor, + )) + .id(); - cmds.entity(root.single()).push_children(&[left, right]); + cmds.entity(root.single()) + .push_children(&[left, right, head, local_floor]); +} + +#[derive(Component)] +struct HeadXRSpace(XrReferenceSpace); + +#[allow(clippy::type_complexity)] +fn update_head_transforms( + session: Res, + default_ref_space: Res, + pipelined: Option>, + frame_state: Res, + mut query: Query<(&mut Transform, &HeadXRSpace, Option<&XrReferenceSpace>)>, +) { + for (mut transform, space, ref_space) in &mut query { + let ref_space = ref_space.unwrap_or(&default_ref_space); + let time = if pipelined.is_some() { + openxr::Time::from_nanos( + frame_state.predicted_display_time.as_nanos() + + frame_state.predicted_display_period.as_nanos(), + ) + } else { + frame_state.predicted_display_time + }; + let space_location = session.locate_space(&space.0, ref_space, time); + + if let Ok(space_location) = space_location { + let flags = OxrSpaceLocationFlags(space_location.location_flags); + if flags.pos_valid() { + transform.translation = space_location.pose.position.to_vec3(); + } + if flags.rot_valid() { + transform.rotation = space_location.pose.orientation.to_quat(); + } + } + } +} + +//emulated local_floor +#[derive(Component)] +struct LocalFloor; + +fn update_local_floor( + mut headSpace: Query<&mut Transform, (With, Without)>, + mut local_floor: Query<&mut Transform, (With, Without)>, +) { + let head_transform = headSpace.get_single_mut(); + match head_transform { + Ok(head) => { + let mut calc_floor = head.clone(); + calc_floor.translation.y = 0.0; + calc_floor.rotation = Quat::IDENTITY; + for (mut transform) in &mut local_floor { + *transform = calc_floor; + } + } + Err(_) => (), + } } From fa9b79761066dfac1f20dc2606e124bd64386b04 Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 14:52:49 -0400 Subject: [PATCH 03/13] refactor stage, hmd, and local floor --- .../bevy_openxr/examples/common_entities.rs | 108 +++------- crates/bevy_xr_utils/src/lib.rs | 5 +- crates/bevy_xr_utils/src/tracking_utils.rs | 192 ++++++++++++++++++ 3 files changed, 224 insertions(+), 81 deletions(-) create mode 100644 crates/bevy_xr_utils/src/tracking_utils.rs diff --git a/crates/bevy_openxr/examples/common_entities.rs b/crates/bevy_openxr/examples/common_entities.rs index 4c7ae4b..595b2bf 100644 --- a/crates/bevy_openxr/examples/common_entities.rs +++ b/crates/bevy_openxr/examples/common_entities.rs @@ -11,13 +11,16 @@ use bevy_mod_openxr::{ helper_traits::{ToQuat, ToVec3}, resources::{OxrFrameState, OxrInstance, Pipelined}, session::OxrSession, - spaces::{OxrSpaceExt, OxrSpaceLocationFlags, OxrSpaceSyncSet, OxrSpaceVelocityFlags}, + spaces::{OxrSpaceExt, OxrSpaceLocationFlags, OxrSpaceSyncSet}, }; use bevy_mod_xr::{ session::{session_available, session_running, XrSessionCreated, XrTrackingRoot}, - spaces::{XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace, XrVelocity}, + spaces::{XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace}, types::XrPose, }; +use bevy_xr_utils::tracking_utils::{ + TrackingUtilitiesPlugin, XRTrackedLocalFloor, XRTrackedStage, XRTrackedView, +}; use openxr::Posef; fn main() { @@ -38,15 +41,8 @@ fn main() { app.add_systems(XrSessionCreated, attach_set); app.add_systems(Startup, create_actions.run_if(session_available)); - //head space - app.add_systems( - PreUpdate, - update_head_transforms - .in_set(OxrSpaceSyncSet) - .run_if(session_running), - ); - //local floor emulated - app.add_systems(PreUpdate, update_local_floor.after(update_head_transforms)); + //tracking utils plugin + app.add_plugins(TrackingUtilitiesPlugin); app.run(); } @@ -64,13 +60,13 @@ fn setup( transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)), ..default() }); - // cube - commands.spawn(PbrBundle { - mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)), - material: materials.add(Color::srgb_u8(124, 144, 255)), - transform: Transform::from_xyz(0.0, 0.5, 0.0), - ..default() - }); + // // cube + // commands.spawn(PbrBundle { + // mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)), + // material: materials.add(Color::srgb_u8(124, 144, 255)), + // transform: Transform::from_xyz(0.0, 0.5, 0.0), + // ..default() + // }); // light commands.spawn(PointLightBundle { point_light: PointLight { @@ -175,9 +171,7 @@ fn spawn_hands( )) .id(); //head? - let head_space = session - .create_reference_space(openxr::ReferenceSpaceType::VIEW, Transform::IDENTITY) - .unwrap(); + let head = cmds .spawn(( PbrBundle { @@ -186,7 +180,7 @@ fn spawn_hands( transform: Transform::from_xyz(0.0, 0.0, 0.0), ..default() }, - HeadXRSpace(head_space), + XRTrackedView, )) .id(); //local_floor? emulated @@ -198,7 +192,19 @@ fn spawn_hands( transform: Transform::from_xyz(0.0, 0.0, 0.0), ..default() }, - LocalFloor, + XRTrackedLocalFloor, + )) + .id(); + + let rooter = cmds + .spawn(( + PbrBundle { + mesh: meshes.add(Cuboid::new(0.5, 0.1, 0.5)), + material: materials.add(Color::srgb_u8(144, 255, 255)), + transform: Transform::from_xyz(0.0, 0.0, 0.0), + ..default() + }, + XRTrackedStage, )) .id(); @@ -206,59 +212,3 @@ fn spawn_hands( .push_children(&[left, right, head, local_floor]); } -#[derive(Component)] -struct HeadXRSpace(XrReferenceSpace); - -#[allow(clippy::type_complexity)] -fn update_head_transforms( - session: Res, - default_ref_space: Res, - pipelined: Option>, - frame_state: Res, - mut query: Query<(&mut Transform, &HeadXRSpace, Option<&XrReferenceSpace>)>, -) { - for (mut transform, space, ref_space) in &mut query { - let ref_space = ref_space.unwrap_or(&default_ref_space); - let time = if pipelined.is_some() { - openxr::Time::from_nanos( - frame_state.predicted_display_time.as_nanos() - + frame_state.predicted_display_period.as_nanos(), - ) - } else { - frame_state.predicted_display_time - }; - let space_location = session.locate_space(&space.0, ref_space, time); - - if let Ok(space_location) = space_location { - let flags = OxrSpaceLocationFlags(space_location.location_flags); - if flags.pos_valid() { - transform.translation = space_location.pose.position.to_vec3(); - } - if flags.rot_valid() { - transform.rotation = space_location.pose.orientation.to_quat(); - } - } - } -} - -//emulated local_floor -#[derive(Component)] -struct LocalFloor; - -fn update_local_floor( - mut headSpace: Query<&mut Transform, (With, Without)>, - mut local_floor: Query<&mut Transform, (With, Without)>, -) { - let head_transform = headSpace.get_single_mut(); - match head_transform { - Ok(head) => { - let mut calc_floor = head.clone(); - calc_floor.translation.y = 0.0; - calc_floor.rotation = Quat::IDENTITY; - for (mut transform) in &mut local_floor { - *transform = calc_floor; - } - } - Err(_) => (), - } -} diff --git a/crates/bevy_xr_utils/src/lib.rs b/crates/bevy_xr_utils/src/lib.rs index df9edfd..67b1d71 100644 --- a/crates/bevy_xr_utils/src/lib.rs +++ b/crates/bevy_xr_utils/src/lib.rs @@ -1,6 +1,7 @@ // use bevy::prelude::*; pub mod hand_gizmos; -#[cfg(not(target_family = "wasm"))] -pub mod xr_utils_actions; +pub mod tracking_utils; #[cfg(not(target_family = "wasm"))] pub mod transform_utils; +#[cfg(not(target_family = "wasm"))] +pub mod xr_utils_actions; diff --git a/crates/bevy_xr_utils/src/tracking_utils.rs b/crates/bevy_xr_utils/src/tracking_utils.rs new file mode 100644 index 0000000..655a3e9 --- /dev/null +++ b/crates/bevy_xr_utils/src/tracking_utils.rs @@ -0,0 +1,192 @@ +use bevy::prelude::*; +use bevy_mod_openxr::{ + helper_traits::{ToQuat, ToVec3}, + resources::{OxrFrameState, Pipelined}, + session::OxrSession, + spaces::{OxrSpaceLocationFlags, OxrSpaceSyncSet}, +}; +use bevy_mod_xr::{ + session::{session_running, XrSessionCreated, XrTrackingRoot}, + spaces::{XrPrimaryReferenceSpace, XrReferenceSpace}, +}; +use openxr::Posef; + +//exernal api +#[derive(Component)] +pub struct XRTrackedStage; + +#[derive(Component)] +pub struct XRTrackedLocalFloor; + +#[derive(Component)] +pub struct XRTrackedView; + +#[derive(Component)] +pub struct XRTrackedLeftGrip; + +#[derive(Component)] +pub struct XRTRackedRightGrip; + +pub struct TrackingUtilitiesPlugin; + +impl Plugin for TrackingUtilitiesPlugin { + fn build(&self, app: &mut App) { + //spawn tracking rig + app.add_systems(XrSessionCreated, spawn_tracking_rig); + + //update stage transforms + //external + app.add_systems(PreUpdate, update_stage); + + //head view transforms + //internal + app.add_systems( + PreUpdate, + update_head_transforms + .in_set(OxrSpaceSyncSet) + .run_if(session_running), + ); + //external + app.add_systems(PreUpdate, update_view.after(update_head_transforms)); + + //local floor transforms + //internal + app.add_systems( + PreUpdate, + update_local_floor_transforms.after(update_head_transforms), + ); + //external + app.add_systems( + PreUpdate, + update_local_floor.after(update_local_floor_transforms), + ); + } +} + +//stage +fn update_stage( + mut root_query: Query<&mut Transform, (With, Without)>, + mut stage_query: Query<&mut Transform, (With, Without)>, +) { + let tracking_root_transform = root_query.get_single_mut(); + match tracking_root_transform { + Ok(root) => { + for (mut transform) in &mut stage_query { + *transform = root.clone(); + } + } + Err(_) => (), + } +} + +//view +#[derive(Component)] +struct HeadXRSpace(XrReferenceSpace); + +fn update_head_transforms( + session: Res, + default_ref_space: Res, + pipelined: Option>, + frame_state: Res, + mut query: Query<(&mut Transform, &HeadXRSpace, Option<&XrReferenceSpace>)>, +) { + for (mut transform, space, ref_space) in &mut query { + let ref_space = ref_space.unwrap_or(&default_ref_space); + let time = if pipelined.is_some() { + openxr::Time::from_nanos( + frame_state.predicted_display_time.as_nanos() + + frame_state.predicted_display_period.as_nanos(), + ) + } else { + frame_state.predicted_display_time + }; + let space_location = session.locate_space(&space.0, ref_space, time); + + if let Ok(space_location) = space_location { + let flags = OxrSpaceLocationFlags(space_location.location_flags); + if flags.pos_valid() { + transform.translation = space_location.pose.position.to_vec3(); + } + if flags.rot_valid() { + transform.rotation = space_location.pose.orientation.to_quat(); + } + } + } +} + +fn update_view( + mut head_query: Query<&mut Transform, (With, Without)>, + mut view_query: Query<&mut Transform, (With, Without)>, +) { + let head_transform = head_query.get_single_mut(); + match head_transform { + Ok(root) => { + for (mut transform) in &mut view_query { + *transform = root.clone(); + } + } + Err(_) => (), + } +} + +//local floor +#[derive(Component)] +struct LocalFloor; +//internal +fn update_local_floor_transforms( + mut head_space: Query<&mut Transform, (With, Without)>, + mut local_floor: Query<&mut Transform, (With, Without)>, +) { + let head_transform = head_space.get_single_mut(); + match head_transform { + Ok(head) => { + let mut calc_floor = head.clone(); + calc_floor.translation.y = 0.0; + //TODO: use yaw + calc_floor.rotation = Quat::IDENTITY; + for (mut transform) in &mut local_floor { + *transform = calc_floor; + } + } + Err(_) => (), + } +} +//external +fn update_local_floor( + mut local_floor: Query<&mut Transform, (With, Without)>, + mut tracked_floor: Query<&mut Transform, (With, Without)>, +) { + let head_transform = local_floor.get_single_mut(); + match head_transform { + Ok(head) => { + for (mut transform) in &mut tracked_floor { + *transform = head.clone(); + } + } + Err(_) => (), + } +} + +//tracking rig +#[derive(Resource)] +struct ControllerActions { + set: openxr::ActionSet, + left: openxr::Action, + right: openxr::Action, +} + +fn spawn_tracking_rig( + // actions: Res, + mut cmds: Commands, + // root: Query>, + session: Res, +) { + //head + let head_space = session + .create_reference_space(openxr::ReferenceSpaceType::VIEW, Transform::IDENTITY) + .unwrap(); + let head = cmds + .spawn((SpatialBundle { ..default() }, HeadXRSpace(head_space))) + .id(); + let local_floor = cmds.spawn((SpatialBundle { ..default() }, LocalFloor)).id(); +} From f30c590cc77435f7a8db9426d6a0a0c2da836bcd Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 15:13:08 -0400 Subject: [PATCH 04/13] refactored grips as well --- .../bevy_openxr/examples/common_entities.rs | 119 +++------------- crates/bevy_openxr/src/openxr/spaces.rs | 2 +- crates/bevy_xr_utils/src/tracking_utils.rs | 131 +++++++++++++++++- 3 files changed, 141 insertions(+), 111 deletions(-) diff --git a/crates/bevy_openxr/examples/common_entities.rs b/crates/bevy_openxr/examples/common_entities.rs index 595b2bf..be14890 100644 --- a/crates/bevy_openxr/examples/common_entities.rs +++ b/crates/bevy_openxr/examples/common_entities.rs @@ -1,45 +1,20 @@ //! A simple 3D scene with light shining over a cube sitting on a plane. -use std::ops::Deref; - use bevy::prelude::*; -use bevy_mod_openxr::{ - action_binding::{OxrSendActionBindings, OxrSuggestActionBinding}, - action_set_attaching::OxrAttachActionSet, - action_set_syncing::{OxrActionSetSyncSet, OxrSyncActionSet}, - add_xr_plugins, - helper_traits::{ToQuat, ToVec3}, - resources::{OxrFrameState, OxrInstance, Pipelined}, - session::OxrSession, - spaces::{OxrSpaceExt, OxrSpaceLocationFlags, OxrSpaceSyncSet}, -}; -use bevy_mod_xr::{ - session::{session_available, session_running, XrSessionCreated, XrTrackingRoot}, - spaces::{XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace}, - types::XrPose, -}; +use bevy_mod_openxr::add_xr_plugins; +use bevy_mod_xr::session::{XrSessionCreated, XrTrackingRoot}; use bevy_xr_utils::tracking_utils::{ - TrackingUtilitiesPlugin, XRTrackedLocalFloor, XRTrackedStage, XRTrackedView, + TrackingUtilitiesPlugin, XRTrackedLeftGrip, XRTrackedLocalFloor, XRTrackedRightGrip, + XRTrackedStage, XRTrackedView, }; -use openxr::Posef; fn main() { let mut app = App::new(); app.add_plugins(add_xr_plugins(DefaultPlugins)); app.add_systems(Startup, setup); - //create bindings - app.add_systems(OxrSendActionBindings, suggest_action_bindings); - //sync actions - app.add_systems( - PreUpdate, - sync_actions - .before(OxrActionSetSyncSet) - .run_if(session_running), - ); + //things? app.add_systems(XrSessionCreated, spawn_hands); - app.add_systems(XrSessionCreated, attach_set); - app.add_systems(Startup, create_actions.run_if(session_available)); //tracking utils plugin app.add_plugins(TrackingUtilitiesPlugin); @@ -82,72 +57,12 @@ fn setup( }); } -#[derive(Resource)] -struct ControllerActions { - set: openxr::ActionSet, - left: openxr::Action, - right: openxr::Action, -} - -fn suggest_action_bindings( - actions: Res, - mut bindings: EventWriter, -) { - bindings.send(OxrSuggestActionBinding { - action: actions.left.as_raw(), - interaction_profile: "/interaction_profiles/oculus/touch_controller".into(), - bindings: vec!["/user/hand/left/input/grip/pose".into()], - }); - bindings.send(OxrSuggestActionBinding { - action: actions.right.as_raw(), - interaction_profile: "/interaction_profiles/oculus/touch_controller".into(), - bindings: vec!["/user/hand/right/input/grip/pose".into()], - }); -} - -fn sync_actions(actions: Res, mut sync: EventWriter) { - sync.send(OxrSyncActionSet(actions.set.clone())); -} - -fn attach_set(actions: Res, mut attach: EventWriter) { - attach.send(OxrAttachActionSet(actions.set.clone())); -} - -fn create_actions(instance: Res, mut cmds: Commands) { - let set = instance.create_action_set("hands", "Hands", 0).unwrap(); - let left = set - .create_action("left_pose", "Left Hand Grip Pose", &[]) - .unwrap(); - let right = set - .create_action("right_pose", "Right Hand Grip Pose", &[]) - .unwrap(); - - cmds.insert_resource(ControllerActions { set, left, right }) -} - fn spawn_hands( - actions: Res, mut cmds: Commands, root: Query>, - session: Res, mut meshes: ResMut>, mut materials: ResMut>, ) { - // This is a demonstation of how to integrate with the openxr crate, the right space is the - // recommended way - let left_space = XrSpace::from_openxr_space( - actions - .left - .create_space( - session.deref().deref().clone(), - openxr::Path::NULL, - Posef::IDENTITY, - ) - .unwrap(), - ); - let right_space = session - .create_action_space(&actions.right, openxr::Path::NULL, XrPose::IDENTITY) - .unwrap(); let left = cmds .spawn(( PbrBundle { @@ -156,20 +71,19 @@ fn spawn_hands( transform: Transform::from_xyz(0.0, 0.5, 0.0), ..default() }, - left_space, - )) - .id(); - let right = cmds - .spawn(( - PbrBundle { - mesh: meshes.add(Cuboid::new(0.1, 0.1, 0.05)), - material: materials.add(Color::srgb_u8(124, 144, 255)), - transform: Transform::from_xyz(0.0, 0.5, 0.0), - ..default() - }, - right_space, + XRTrackedLeftGrip, )) .id(); + let bundle = ( + PbrBundle { + mesh: meshes.add(Cuboid::new(0.1, 0.1, 0.05)), + material: materials.add(Color::srgb_u8(124, 144, 255)), + transform: Transform::from_xyz(0.0, 0.5, 0.0), + ..default() + }, + XRTrackedRightGrip, + ); + let right = cmds.spawn(bundle).id(); //head? let head = cmds @@ -211,4 +125,3 @@ fn spawn_hands( cmds.entity(root.single()) .push_children(&[left, right, head, local_floor]); } - diff --git a/crates/bevy_openxr/src/openxr/spaces.rs b/crates/bevy_openxr/src/openxr/spaces.rs index 028cc42..2e80425 100644 --- a/crates/bevy_openxr/src/openxr/spaces.rs +++ b/crates/bevy_openxr/src/openxr/spaces.rs @@ -140,7 +140,7 @@ impl OxrSpaceVelocityFlags { } #[allow(clippy::type_complexity)] -fn update_space_transforms( +pub fn update_space_transforms( session: Res, default_ref_space: Res, pipelined: Option>, diff --git a/crates/bevy_xr_utils/src/tracking_utils.rs b/crates/bevy_xr_utils/src/tracking_utils.rs index 655a3e9..00f6a77 100644 --- a/crates/bevy_xr_utils/src/tracking_utils.rs +++ b/crates/bevy_xr_utils/src/tracking_utils.rs @@ -1,13 +1,19 @@ +use std::ops::Deref; + use bevy::prelude::*; use bevy_mod_openxr::{ + action_binding::{OxrSendActionBindings, OxrSuggestActionBinding}, + action_set_attaching::OxrAttachActionSet, + action_set_syncing::{OxrActionSetSyncSet, OxrSyncActionSet}, helper_traits::{ToQuat, ToVec3}, - resources::{OxrFrameState, Pipelined}, + resources::{OxrFrameState, OxrInstance, Pipelined}, session::OxrSession, - spaces::{OxrSpaceLocationFlags, OxrSpaceSyncSet}, + spaces::{update_space_transforms, OxrSpaceExt, OxrSpaceLocationFlags, OxrSpaceSyncSet}, }; use bevy_mod_xr::{ - session::{session_running, XrSessionCreated, XrTrackingRoot}, - spaces::{XrPrimaryReferenceSpace, XrReferenceSpace}, + session::{session_available, session_running, XrSessionCreated, XrTrackingRoot}, + spaces::{XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace}, + types::XrPose, }; use openxr::Posef; @@ -25,7 +31,7 @@ pub struct XRTrackedView; pub struct XRTrackedLeftGrip; #[derive(Component)] -pub struct XRTRackedRightGrip; +pub struct XRTrackedRightGrip; pub struct TrackingUtilitiesPlugin; @@ -60,6 +66,28 @@ impl Plugin for TrackingUtilitiesPlugin { PreUpdate, update_local_floor.after(update_local_floor_transforms), ); + //bindings + app.add_systems(OxrSendActionBindings, suggest_action_bindings); + //sync actions + app.add_systems( + PreUpdate, + sync_actions + .before(OxrActionSetSyncSet) + .run_if(session_running), + ); + //attach sets + app.add_systems(XrSessionCreated, attach_set); + //create actions + app.add_systems(Startup, create_actions.run_if(session_available)); + //left grip + // .add_systems( + // PreUpdate, + // update_space_transforms + // .in_set(OxrSpaceSyncSet) + // .run_if(session_running), + // ) + app.add_systems(PreUpdate, update_left_grip.after(update_space_transforms)); + app.add_systems(PreUpdate, update_right_grip.after(update_space_transforms)); } } @@ -167,6 +195,44 @@ fn update_local_floor( } } +//left grip +#[derive(Component)] +struct LeftGrip; + +fn update_left_grip( + mut left_grip: Query<&mut Transform, (With, Without)>, + mut tracked_left_grip: Query<&mut Transform, (With, Without)>, +) { + let head_transform = left_grip.get_single_mut(); + match head_transform { + Ok(head) => { + for (mut transform) in &mut tracked_left_grip { + *transform = head.clone(); + } + } + Err(_) => (), + } +} + +//right grip +#[derive(Component)] +struct RightGrip; + +fn update_right_grip( + mut right_grip: Query<&mut Transform, (With, Without)>, + mut tracked_right_grip: Query<&mut Transform, (With, Without)>, +) { + let head_transform = right_grip.get_single_mut(); + match head_transform { + Ok(head) => { + for (mut transform) in &mut tracked_right_grip { + *transform = head.clone(); + } + } + Err(_) => (), + } +} + //tracking rig #[derive(Resource)] struct ControllerActions { @@ -176,9 +242,9 @@ struct ControllerActions { } fn spawn_tracking_rig( - // actions: Res, + actions: Res, mut cmds: Commands, - // root: Query>, + root: Query>, session: Res, ) { //head @@ -189,4 +255,55 @@ fn spawn_tracking_rig( .spawn((SpatialBundle { ..default() }, HeadXRSpace(head_space))) .id(); let local_floor = cmds.spawn((SpatialBundle { ..default() }, LocalFloor)).id(); + + let left_space = session + .create_action_space(&actions.left, openxr::Path::NULL, XrPose::IDENTITY) + .unwrap(); + let right_space = session + .create_action_space(&actions.right, openxr::Path::NULL, XrPose::IDENTITY) + .unwrap(); + let left = cmds + .spawn((SpatialBundle { ..default() }, left_space, LeftGrip)) + .id(); + let right = cmds + .spawn((SpatialBundle { ..default() }, right_space, RightGrip)) + .id(); +} + +//bindings +//TODO figure out how to make these better +fn suggest_action_bindings( + actions: Res, + mut bindings: EventWriter, +) { + bindings.send(OxrSuggestActionBinding { + action: actions.left.as_raw(), + interaction_profile: "/interaction_profiles/oculus/touch_controller".into(), + bindings: vec!["/user/hand/left/input/grip/pose".into()], + }); + bindings.send(OxrSuggestActionBinding { + action: actions.right.as_raw(), + interaction_profile: "/interaction_profiles/oculus/touch_controller".into(), + bindings: vec!["/user/hand/right/input/grip/pose".into()], + }); +} + +fn sync_actions(actions: Res, mut sync: EventWriter) { + sync.send(OxrSyncActionSet(actions.set.clone())); +} + +fn attach_set(actions: Res, mut attach: EventWriter) { + attach.send(OxrAttachActionSet(actions.set.clone())); +} + +fn create_actions(instance: Res, mut cmds: Commands) { + let set = instance.create_action_set("hands", "Hands", 0).unwrap(); + let left = set + .create_action("left_pose", "Left Hand Grip Pose", &[]) + .unwrap(); + let right = set + .create_action("right_pose", "Right Hand Grip Pose", &[]) + .unwrap(); + + cmds.insert_resource(ControllerActions { set, left, right }) } From 1f016501f3c8747670cc9ff25d0fde5abe71e7f7 Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 15:20:13 -0400 Subject: [PATCH 05/13] small fixes --- crates/bevy_openxr/examples/common_entities.rs | 10 +--------- crates/bevy_xr_utils/src/tracking_utils.rs | 3 +++ 2 files changed, 4 insertions(+), 9 deletions(-) diff --git a/crates/bevy_openxr/examples/common_entities.rs b/crates/bevy_openxr/examples/common_entities.rs index be14890..668b42d 100644 --- a/crates/bevy_openxr/examples/common_entities.rs +++ b/crates/bevy_openxr/examples/common_entities.rs @@ -35,13 +35,6 @@ fn setup( transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)), ..default() }); - // // cube - // commands.spawn(PbrBundle { - // mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)), - // material: materials.add(Color::srgb_u8(124, 144, 255)), - // transform: Transform::from_xyz(0.0, 0.5, 0.0), - // ..default() - // }); // light commands.spawn(PointLightBundle { point_light: PointLight { @@ -59,7 +52,6 @@ fn setup( fn spawn_hands( mut cmds: Commands, - root: Query>, mut meshes: ResMut>, mut materials: ResMut>, ) { @@ -122,6 +114,6 @@ fn spawn_hands( )) .id(); - cmds.entity(root.single()) + cmds.entity(rooter) .push_children(&[left, right, head, local_floor]); } diff --git a/crates/bevy_xr_utils/src/tracking_utils.rs b/crates/bevy_xr_utils/src/tracking_utils.rs index 00f6a77..7bb22b0 100644 --- a/crates/bevy_xr_utils/src/tracking_utils.rs +++ b/crates/bevy_xr_utils/src/tracking_utils.rs @@ -268,6 +268,9 @@ fn spawn_tracking_rig( let right = cmds .spawn((SpatialBundle { ..default() }, right_space, RightGrip)) .id(); + + cmds.entity(root.single()) + .push_children(&[head, local_floor, left, right]); } //bindings From cd14a2455b8fec8434d9fa8ae0e54f99cc57fb8b Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 15:32:04 -0400 Subject: [PATCH 06/13] added yaw to local floor --- crates/bevy_xr_utils/src/tracking_utils.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/crates/bevy_xr_utils/src/tracking_utils.rs b/crates/bevy_xr_utils/src/tracking_utils.rs index 7bb22b0..679f3ef 100644 --- a/crates/bevy_xr_utils/src/tracking_utils.rs +++ b/crates/bevy_xr_utils/src/tracking_utils.rs @@ -171,7 +171,9 @@ fn update_local_floor_transforms( let mut calc_floor = head.clone(); calc_floor.translation.y = 0.0; //TODO: use yaw - calc_floor.rotation = Quat::IDENTITY; + let (y, x, z) = calc_floor.rotation.to_euler(EulerRot::YXZ); + let new_rot = Quat::from_rotation_y(y); + calc_floor.rotation = new_rot; for (mut transform) in &mut local_floor { *transform = calc_floor; } From b16b559c947dd7c9c4c8ea138afec5fe7343defe Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 15:32:39 -0400 Subject: [PATCH 07/13] renamed example --- .../examples/{common_entities.rs => tracking_utils.rs} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename crates/bevy_openxr/examples/{common_entities.rs => tracking_utils.rs} (100%) diff --git a/crates/bevy_openxr/examples/common_entities.rs b/crates/bevy_openxr/examples/tracking_utils.rs similarity index 100% rename from crates/bevy_openxr/examples/common_entities.rs rename to crates/bevy_openxr/examples/tracking_utils.rs From aa4e5d333b009b11b0bc3372e02c6ff0ec35c880 Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 15:33:30 -0400 Subject: [PATCH 08/13] renamed a few things --- crates/bevy_openxr/examples/tracking_utils.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/crates/bevy_openxr/examples/tracking_utils.rs b/crates/bevy_openxr/examples/tracking_utils.rs index 668b42d..f05efd1 100644 --- a/crates/bevy_openxr/examples/tracking_utils.rs +++ b/crates/bevy_openxr/examples/tracking_utils.rs @@ -76,7 +76,7 @@ fn spawn_hands( XRTrackedRightGrip, ); let right = cmds.spawn(bundle).id(); - //head? + //head let head = cmds .spawn(( @@ -89,7 +89,7 @@ fn spawn_hands( XRTrackedView, )) .id(); - //local_floor? emulated + //local_floor emulated let local_floor = cmds .spawn(( PbrBundle { @@ -102,7 +102,7 @@ fn spawn_hands( )) .id(); - let rooter = cmds + let stage = cmds .spawn(( PbrBundle { mesh: meshes.add(Cuboid::new(0.5, 0.1, 0.5)), @@ -114,6 +114,6 @@ fn spawn_hands( )) .id(); - cmds.entity(rooter) + cmds.entity(stage) .push_children(&[left, right, head, local_floor]); } From 0e2be1740f137a00d04e226db13d975bfcfc3178 Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 20:11:30 -0400 Subject: [PATCH 09/13] Update crates/bevy_xr_utils/src/lib.rs Co-authored-by: Schmarni <51007916+Schmarni-Dev@users.noreply.github.com> --- crates/bevy_xr_utils/src/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/bevy_xr_utils/src/lib.rs b/crates/bevy_xr_utils/src/lib.rs index 67b1d71..13f8460 100644 --- a/crates/bevy_xr_utils/src/lib.rs +++ b/crates/bevy_xr_utils/src/lib.rs @@ -1,5 +1,6 @@ // use bevy::prelude::*; pub mod hand_gizmos; +#[cfg(not(target_family = "wasm"))] pub mod tracking_utils; #[cfg(not(target_family = "wasm"))] pub mod transform_utils; From ac1364f4a616060238857997334a3d213e7679b9 Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 20:13:49 -0400 Subject: [PATCH 10/13] renamed public components --- crates/bevy_openxr/examples/tracking_utils.rs | 14 ++++----- crates/bevy_xr_utils/src/tracking_utils.rs | 30 +++++++++---------- 2 files changed, 22 insertions(+), 22 deletions(-) diff --git a/crates/bevy_openxr/examples/tracking_utils.rs b/crates/bevy_openxr/examples/tracking_utils.rs index f05efd1..7f79a54 100644 --- a/crates/bevy_openxr/examples/tracking_utils.rs +++ b/crates/bevy_openxr/examples/tracking_utils.rs @@ -4,8 +4,8 @@ use bevy::prelude::*; use bevy_mod_openxr::add_xr_plugins; use bevy_mod_xr::session::{XrSessionCreated, XrTrackingRoot}; use bevy_xr_utils::tracking_utils::{ - TrackingUtilitiesPlugin, XRTrackedLeftGrip, XRTrackedLocalFloor, XRTrackedRightGrip, - XRTrackedStage, XRTrackedView, + TrackingUtilitiesPlugin, XrTrackedLeftGrip, XrTrackedLocalFloor, XrTrackedRightGrip, + XrTrackedStage, XrTrackedView, }; fn main() { @@ -63,7 +63,7 @@ fn spawn_hands( transform: Transform::from_xyz(0.0, 0.5, 0.0), ..default() }, - XRTrackedLeftGrip, + XrTrackedLeftGrip, )) .id(); let bundle = ( @@ -73,7 +73,7 @@ fn spawn_hands( transform: Transform::from_xyz(0.0, 0.5, 0.0), ..default() }, - XRTrackedRightGrip, + XrTrackedRightGrip, ); let right = cmds.spawn(bundle).id(); //head @@ -86,7 +86,7 @@ fn spawn_hands( transform: Transform::from_xyz(0.0, 0.0, 0.0), ..default() }, - XRTrackedView, + XrTrackedView, )) .id(); //local_floor emulated @@ -98,7 +98,7 @@ fn spawn_hands( transform: Transform::from_xyz(0.0, 0.0, 0.0), ..default() }, - XRTrackedLocalFloor, + XrTrackedLocalFloor, )) .id(); @@ -110,7 +110,7 @@ fn spawn_hands( transform: Transform::from_xyz(0.0, 0.0, 0.0), ..default() }, - XRTrackedStage, + XrTrackedStage, )) .id(); diff --git a/crates/bevy_xr_utils/src/tracking_utils.rs b/crates/bevy_xr_utils/src/tracking_utils.rs index 679f3ef..bcd9688 100644 --- a/crates/bevy_xr_utils/src/tracking_utils.rs +++ b/crates/bevy_xr_utils/src/tracking_utils.rs @@ -19,19 +19,19 @@ use openxr::Posef; //exernal api #[derive(Component)] -pub struct XRTrackedStage; +pub struct XrTrackedStage; #[derive(Component)] -pub struct XRTrackedLocalFloor; +pub struct XrTrackedLocalFloor; #[derive(Component)] -pub struct XRTrackedView; +pub struct XrTrackedView; #[derive(Component)] -pub struct XRTrackedLeftGrip; +pub struct XrTrackedLeftGrip; #[derive(Component)] -pub struct XRTrackedRightGrip; +pub struct XrTrackedRightGrip; pub struct TrackingUtilitiesPlugin; @@ -93,8 +93,8 @@ impl Plugin for TrackingUtilitiesPlugin { //stage fn update_stage( - mut root_query: Query<&mut Transform, (With, Without)>, - mut stage_query: Query<&mut Transform, (With, Without)>, + mut root_query: Query<&mut Transform, (With, Without)>, + mut stage_query: Query<&mut Transform, (With, Without)>, ) { let tracking_root_transform = root_query.get_single_mut(); match tracking_root_transform { @@ -143,8 +143,8 @@ fn update_head_transforms( } fn update_view( - mut head_query: Query<&mut Transform, (With, Without)>, - mut view_query: Query<&mut Transform, (With, Without)>, + mut head_query: Query<&mut Transform, (With, Without)>, + mut view_query: Query<&mut Transform, (With, Without)>, ) { let head_transform = head_query.get_single_mut(); match head_transform { @@ -183,8 +183,8 @@ fn update_local_floor_transforms( } //external fn update_local_floor( - mut local_floor: Query<&mut Transform, (With, Without)>, - mut tracked_floor: Query<&mut Transform, (With, Without)>, + mut local_floor: Query<&mut Transform, (With, Without)>, + mut tracked_floor: Query<&mut Transform, (With, Without)>, ) { let head_transform = local_floor.get_single_mut(); match head_transform { @@ -202,8 +202,8 @@ fn update_local_floor( struct LeftGrip; fn update_left_grip( - mut left_grip: Query<&mut Transform, (With, Without)>, - mut tracked_left_grip: Query<&mut Transform, (With, Without)>, + mut left_grip: Query<&mut Transform, (With, Without)>, + mut tracked_left_grip: Query<&mut Transform, (With, Without)>, ) { let head_transform = left_grip.get_single_mut(); match head_transform { @@ -221,8 +221,8 @@ fn update_left_grip( struct RightGrip; fn update_right_grip( - mut right_grip: Query<&mut Transform, (With, Without)>, - mut tracked_right_grip: Query<&mut Transform, (With, Without)>, + mut right_grip: Query<&mut Transform, (With, Without)>, + mut tracked_right_grip: Query<&mut Transform, (With, Without)>, ) { let head_transform = right_grip.get_single_mut(); match head_transform { From 667c6092a790f0f8d9b5ac29099577c289554eec Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 20:14:48 -0400 Subject: [PATCH 11/13] changed to spatial bundle default --- crates/bevy_xr_utils/src/tracking_utils.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/crates/bevy_xr_utils/src/tracking_utils.rs b/crates/bevy_xr_utils/src/tracking_utils.rs index bcd9688..c9db21c 100644 --- a/crates/bevy_xr_utils/src/tracking_utils.rs +++ b/crates/bevy_xr_utils/src/tracking_utils.rs @@ -254,9 +254,9 @@ fn spawn_tracking_rig( .create_reference_space(openxr::ReferenceSpaceType::VIEW, Transform::IDENTITY) .unwrap(); let head = cmds - .spawn((SpatialBundle { ..default() }, HeadXRSpace(head_space))) + .spawn((SpatialBundle::default(), HeadXRSpace(head_space))) .id(); - let local_floor = cmds.spawn((SpatialBundle { ..default() }, LocalFloor)).id(); + let local_floor = cmds.spawn((SpatialBundle::default(), LocalFloor)).id(); let left_space = session .create_action_space(&actions.left, openxr::Path::NULL, XrPose::IDENTITY) @@ -265,10 +265,10 @@ fn spawn_tracking_rig( .create_action_space(&actions.right, openxr::Path::NULL, XrPose::IDENTITY) .unwrap(); let left = cmds - .spawn((SpatialBundle { ..default() }, left_space, LeftGrip)) + .spawn((SpatialBundle::default(), left_space, LeftGrip)) .id(); let right = cmds - .spawn((SpatialBundle { ..default() }, right_space, RightGrip)) + .spawn((SpatialBundle::default(), right_space, RightGrip)) .id(); cmds.entity(root.single()) From ec14bf82c91393dfc4b09c3539d9579e23a079b8 Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 20:16:50 -0400 Subject: [PATCH 12/13] used OxrSpaceSyncSet instead of system itself --- crates/bevy_openxr/src/openxr/spaces.rs | 2 +- crates/bevy_xr_utils/src/tracking_utils.rs | 9 ++++----- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/crates/bevy_openxr/src/openxr/spaces.rs b/crates/bevy_openxr/src/openxr/spaces.rs index 2e80425..028cc42 100644 --- a/crates/bevy_openxr/src/openxr/spaces.rs +++ b/crates/bevy_openxr/src/openxr/spaces.rs @@ -140,7 +140,7 @@ impl OxrSpaceVelocityFlags { } #[allow(clippy::type_complexity)] -pub fn update_space_transforms( +fn update_space_transforms( session: Res, default_ref_space: Res, pipelined: Option>, diff --git a/crates/bevy_xr_utils/src/tracking_utils.rs b/crates/bevy_xr_utils/src/tracking_utils.rs index c9db21c..fc7dbed 100644 --- a/crates/bevy_xr_utils/src/tracking_utils.rs +++ b/crates/bevy_xr_utils/src/tracking_utils.rs @@ -1,4 +1,3 @@ -use std::ops::Deref; use bevy::prelude::*; use bevy_mod_openxr::{ @@ -8,11 +7,11 @@ use bevy_mod_openxr::{ helper_traits::{ToQuat, ToVec3}, resources::{OxrFrameState, OxrInstance, Pipelined}, session::OxrSession, - spaces::{update_space_transforms, OxrSpaceExt, OxrSpaceLocationFlags, OxrSpaceSyncSet}, + spaces::{ OxrSpaceLocationFlags, OxrSpaceSyncSet}, }; use bevy_mod_xr::{ session::{session_available, session_running, XrSessionCreated, XrTrackingRoot}, - spaces::{XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace}, + spaces::{XrPrimaryReferenceSpace, XrReferenceSpace}, types::XrPose, }; use openxr::Posef; @@ -86,8 +85,8 @@ impl Plugin for TrackingUtilitiesPlugin { // .in_set(OxrSpaceSyncSet) // .run_if(session_running), // ) - app.add_systems(PreUpdate, update_left_grip.after(update_space_transforms)); - app.add_systems(PreUpdate, update_right_grip.after(update_space_transforms)); + app.add_systems(PreUpdate, update_left_grip.after(OxrSpaceSyncSet)); + app.add_systems(PreUpdate, update_right_grip.after(OxrSpaceSyncSet)); } } From 5c0a68019d28bc5526b40131900695d355f3ec27 Mon Sep 17 00:00:00 2001 From: ForTehLose Date: Tue, 3 Sep 2024 22:10:18 -0400 Subject: [PATCH 13/13] removed uneeded redirections --- crates/bevy_xr_utils/src/tracking_utils.rs | 46 ++++------------------ 1 file changed, 8 insertions(+), 38 deletions(-) diff --git a/crates/bevy_xr_utils/src/tracking_utils.rs b/crates/bevy_xr_utils/src/tracking_utils.rs index fc7dbed..cd75dce 100644 --- a/crates/bevy_xr_utils/src/tracking_utils.rs +++ b/crates/bevy_xr_utils/src/tracking_utils.rs @@ -1,4 +1,3 @@ - use bevy::prelude::*; use bevy_mod_openxr::{ action_binding::{OxrSendActionBindings, OxrSuggestActionBinding}, @@ -7,7 +6,7 @@ use bevy_mod_openxr::{ helper_traits::{ToQuat, ToVec3}, resources::{OxrFrameState, OxrInstance, Pipelined}, session::OxrSession, - spaces::{ OxrSpaceLocationFlags, OxrSpaceSyncSet}, + spaces::{OxrSpaceLocationFlags, OxrSpaceSyncSet}, }; use bevy_mod_xr::{ session::{session_available, session_running, XrSessionCreated, XrTrackingRoot}, @@ -55,16 +54,11 @@ impl Plugin for TrackingUtilitiesPlugin { app.add_systems(PreUpdate, update_view.after(update_head_transforms)); //local floor transforms - //internal app.add_systems( PreUpdate, update_local_floor_transforms.after(update_head_transforms), ); - //external - app.add_systems( - PreUpdate, - update_local_floor.after(update_local_floor_transforms), - ); + //bindings app.add_systems(OxrSendActionBindings, suggest_action_bindings); //sync actions @@ -78,13 +72,7 @@ impl Plugin for TrackingUtilitiesPlugin { app.add_systems(XrSessionCreated, attach_set); //create actions app.add_systems(Startup, create_actions.run_if(session_available)); - //left grip - // .add_systems( - // PreUpdate, - // update_space_transforms - // .in_set(OxrSpaceSyncSet) - // .run_if(session_running), - // ) + app.add_systems(PreUpdate, update_left_grip.after(OxrSpaceSyncSet)); app.add_systems(PreUpdate, update_right_grip.after(OxrSpaceSyncSet)); } @@ -157,12 +145,9 @@ fn update_view( } //local floor -#[derive(Component)] -struct LocalFloor; -//internal fn update_local_floor_transforms( - mut head_space: Query<&mut Transform, (With, Without)>, - mut local_floor: Query<&mut Transform, (With, Without)>, + mut head_space: Query<&mut Transform, (With, Without)>, + mut local_floor: Query<&mut Transform, (With, Without)>, ) { let head_transform = head_space.get_single_mut(); match head_transform { @@ -180,21 +165,6 @@ fn update_local_floor_transforms( Err(_) => (), } } -//external -fn update_local_floor( - mut local_floor: Query<&mut Transform, (With, Without)>, - mut tracked_floor: Query<&mut Transform, (With, Without)>, -) { - let head_transform = local_floor.get_single_mut(); - match head_transform { - Ok(head) => { - for (mut transform) in &mut tracked_floor { - *transform = head.clone(); - } - } - Err(_) => (), - } -} //left grip #[derive(Component)] @@ -255,7 +225,7 @@ fn spawn_tracking_rig( let head = cmds .spawn((SpatialBundle::default(), HeadXRSpace(head_space))) .id(); - let local_floor = cmds.spawn((SpatialBundle::default(), LocalFloor)).id(); + // let local_floor = cmds.spawn((SpatialBundle::default(), LocalFloor)).id(); let left_space = session .create_action_space(&actions.left, openxr::Path::NULL, XrPose::IDENTITY) @@ -271,11 +241,11 @@ fn spawn_tracking_rig( .id(); cmds.entity(root.single()) - .push_children(&[head, local_floor, left, right]); + .push_children(&[head, left, right]); } //bindings -//TODO figure out how to make these better +//TODO figure out how to make these better, specifically not be controller specific fn suggest_action_bindings( actions: Res, mut bindings: EventWriter,