From 8807b5f92734249e7224340b511eaaab2db6eeed Mon Sep 17 00:00:00 2001 From: Jay Christy Date: Fri, 7 Jun 2024 13:58:05 -0400 Subject: [PATCH 1/2] working on examples of transform utilities --- .../bevy_openxr/examples/transform_utils.rs | 130 ++++++++++++++++++ crates/bevy_xr_utils/src/lib.rs | 1 + crates/bevy_xr_utils/src/transform_utils.rs | 59 ++++++++ 3 files changed, 190 insertions(+) create mode 100644 crates/bevy_openxr/examples/transform_utils.rs create mode 100644 crates/bevy_xr_utils/src/transform_utils.rs diff --git a/crates/bevy_openxr/examples/transform_utils.rs b/crates/bevy_openxr/examples/transform_utils.rs new file mode 100644 index 0000000..cb140f0 --- /dev/null +++ b/crates/bevy_openxr/examples/transform_utils.rs @@ -0,0 +1,130 @@ +//! A simple 3D scene with light shining over a cube sitting on a plane. + +use bevy::prelude::*; +use bevy_openxr::add_xr_plugins; +use bevy_xr_utils::xr_utils_actions::{ActiveSet, XRUtilsAction, XRUtilsActionSet, XRUtilsActionState, XRUtilsActionSystemSet, XRUtilsActionsPlugin, XRUtilsBinding}; +use bevy_xr_utils::transform_utils; + +fn main() { + App::new() + .add_plugins(add_xr_plugins(DefaultPlugins)) + .add_plugins(bevy_xr_utils::hand_gizmos::HandGizmosPlugin) + .add_plugins(transform_utils::TransformUtilitiesPlugin) + .add_systems(Startup, setup) + .add_plugins(XRUtilsActionsPlugin) + .add_systems( + Startup, + create_action_entities.before(XRUtilsActionSystemSet::CreateEvents), + ) + .add_systems( + Update, + read_action_with_marker_component.after(XRUtilsActionSystemSet::SyncActionStates), + ) + .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() + }); + // red cube + commands.spawn(PbrBundle { + mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)), + material: materials.add(Color::rgb_u8(252, 44, 3)), + transform: Transform::from_xyz(4.0, 0.5, 0.0).with_scale(Vec3::splat(0.5)), + ..default() + }); + // red cube + commands.spawn(PbrBundle { + mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)), + material: materials.add(Color::rgb_u8(3, 28, 252)), + transform: Transform::from_xyz(-4.0, 0.5, 0.0).with_scale(Vec3::splat(0.5)), + ..default() + }); + // green cube + commands.spawn(PbrBundle { + mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)), + material: materials.add(Color::rgb_u8(3, 252, 32)), + transform: Transform::from_xyz(0.0, 0.5, 4.0).with_scale(Vec3::splat(0.5)), + ..default() + }); + // white cube + commands.spawn(PbrBundle { + mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)), + material: materials.add(Color::rgb_u8(250, 250, 250)), + transform: Transform::from_xyz(0.0, 0.5, -4.0).with_scale(Vec3::splat(0.5)), + ..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(Component)] +pub struct FaceRedAction; + +fn create_action_entities(mut commands: Commands) { + //create a set + let set = commands + .spawn(( + XRUtilsActionSet { + name: "locomotion".into(), + pretty_name: "locomotion set".into(), + priority: u32::MIN, + }, + ActiveSet, //marker to indicate we want this synced + )) + .id(); + //create an action + let action = commands + .spawn(( + XRUtilsAction { + action_name: "face_red".into(), + localized_name: "face_red_localized".into(), + action_type: bevy_xr::actions::ActionType::Bool, + }, + FaceRedAction, //lets try a marker component + )) + .id(); + + //create a binding + let binding = commands + .spawn(XRUtilsBinding { + profile: "/interaction_profiles/valve/index_controller".into(), + binding: "/user/hand/left//input/a/click".into(), + }) + .id(); + + //add action to set, this isnt the best + //TODO look into a better system + commands.entity(action).add_child(binding); + commands.entity(set).add_child(action); +} + +fn read_action_with_marker_component( + mut action_query: Query<&XRUtilsActionState, With>, +) { + //now for the actual checking + for state in action_query.iter_mut() { + info!("action state is: {:?}", state); + } +} diff --git a/crates/bevy_xr_utils/src/lib.rs b/crates/bevy_xr_utils/src/lib.rs index 6a1a780..6db8e46 100644 --- a/crates/bevy_xr_utils/src/lib.rs +++ b/crates/bevy_xr_utils/src/lib.rs @@ -1,3 +1,4 @@ // use bevy::prelude::*; pub mod hand_gizmos; pub mod xr_utils_actions; +pub mod transform_utils; diff --git a/crates/bevy_xr_utils/src/transform_utils.rs b/crates/bevy_xr_utils/src/transform_utils.rs new file mode 100644 index 0000000..1b71e09 --- /dev/null +++ b/crates/bevy_xr_utils/src/transform_utils.rs @@ -0,0 +1,59 @@ +use bevy::prelude::*; +use bevy_openxr::{helper_traits::{ToQuat, ToVec3}, init::OxrTrackingRoot, resources::OxrViews}; + +pub struct TransformUtilitiesPlugin; + +impl Plugin for TransformUtilitiesPlugin { + fn build(&self, app: &mut App) { + app.add_event::(); + app.add_event::(); + app.add_systems(PostUpdate, handle_transform_events); + } +} + +//events +#[derive(Event, Debug)] +pub struct SnapToRotation(pub Quat); + +#[derive(Event, Debug)] +pub struct SnapToPosition(pub Vec3); + +pub fn handle_transform_events( + mut root_query: Query<&mut Transform, With>, + views: ResMut, + mut position_reader: EventReader, + mut rotation_reader: EventReader, +) { + let result = root_query.get_single_mut(); + match result { + Ok(mut root_transform) => { + //rotation first + let view = views.first(); + match view { + Some(view) => { + //get our parameters together + let mut view_translation = view.pose.position.to_vec3(); + let view_quat = view.pose.orientation.to_quat(); + let view_yaw = view_quat.to_euler(EulerRot::XYZ).1; + let science = Quat::from_axis_angle(*root_transform.up(), view_yaw); + let invert_science = science.inverse(); + view_translation.y = 0.0; //we want to do rotations around the same height as the root + let root_local = root_transform.translation; + let view_global = root_transform.rotation.mul_vec3(view_translation) + root_local; + //now set our rotation for every event, this does mean only the last event matters + for snap in rotation_reader.read() { + let rotation_quaternion = snap.0.mul_quat(invert_science); + root_transform.rotate_around(view_global, rotation_quaternion); + } + //position second + for position in position_reader.read() { + root_transform.translation = position.0; + } + + }, + None => debug!("error getting first view"), + } + } + Err(_) => debug!("error getting root transform"), + } +} From 8ecebb7d2cf8368789f54ed248b453e8dd7ba382 Mon Sep 17 00:00:00 2001 From: Jay Christy Date: Tue, 11 Jun 2024 13:17:16 -0400 Subject: [PATCH 2/2] added transform utils for snapping to position and rotation --- .../bevy_openxr/examples/transform_utils.rs | 101 +++++++++++++++--- .../bevy_openxr/src/openxr/action_binding.rs | 2 +- crates/bevy_xr_utils/src/transform_utils.rs | 52 +++++---- crates/bevy_xr_utils/src/xr_utils_actions.rs | 13 ++- 4 files changed, 127 insertions(+), 41 deletions(-) diff --git a/crates/bevy_openxr/examples/transform_utils.rs b/crates/bevy_openxr/examples/transform_utils.rs index cb140f0..04db5b6 100644 --- a/crates/bevy_openxr/examples/transform_utils.rs +++ b/crates/bevy_openxr/examples/transform_utils.rs @@ -1,9 +1,12 @@ -//! A simple 3D scene with light shining over a cube sitting on a plane. +//! A simple example of how to use the transform utils to set the players position and orientation use bevy::prelude::*; use bevy_openxr::add_xr_plugins; -use bevy_xr_utils::xr_utils_actions::{ActiveSet, XRUtilsAction, XRUtilsActionSet, XRUtilsActionState, XRUtilsActionSystemSet, XRUtilsActionsPlugin, XRUtilsBinding}; -use bevy_xr_utils::transform_utils; +use bevy_xr_utils::transform_utils::{self, SnapToPosition, SnapToRotation}; +use bevy_xr_utils::xr_utils_actions::{ + ActiveSet, XRUtilsAction, XRUtilsActionSet, XRUtilsActionState, XRUtilsActionSystemSet, + XRUtilsActionsPlugin, XRUtilsBinding, +}; fn main() { App::new() @@ -18,8 +21,16 @@ fn main() { ) .add_systems( Update, - read_action_with_marker_component.after(XRUtilsActionSystemSet::SyncActionStates), + send_look_at_red_cube_event.after(XRUtilsActionSystemSet::SyncActionStates), ) + .add_systems( + Update, + send_recenter.after(XRUtilsActionSystemSet::SyncActionStates), + ) + .insert_resource(AmbientLight { + color: Default::default(), + brightness: 500.0, + }) .run(); } @@ -43,7 +54,7 @@ fn setup( transform: Transform::from_xyz(4.0, 0.5, 0.0).with_scale(Vec3::splat(0.5)), ..default() }); - // red cube + // blue cube commands.spawn(PbrBundle { mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)), material: materials.add(Color::rgb_u8(3, 28, 252)), @@ -64,15 +75,14 @@ fn setup( transform: Transform::from_xyz(0.0, 0.5, -4.0).with_scale(Vec3::splat(0.5)), ..default() }); - // light - commands.spawn(PointLightBundle { - point_light: PointLight { - shadows_enabled: true, - ..default() - }, - transform: Transform::from_xyz(4.0, 8.0, 4.0), + // black cube + commands.spawn(PbrBundle { + mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)), + material: materials.add(Color::rgb_u8(0, 0, 0)), + transform: Transform::from_xyz(0.0, 0.1, 0.0).with_scale(Vec3::splat(0.2)), ..default() }); + commands.spawn(Camera3dBundle { transform: Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y), ..default() @@ -110,7 +120,31 @@ fn create_action_entities(mut commands: Commands) { let binding = commands .spawn(XRUtilsBinding { profile: "/interaction_profiles/valve/index_controller".into(), - binding: "/user/hand/left//input/a/click".into(), + binding: "/user/hand/left/input/a/click".into(), + }) + .id(); + + //add action to set, this isnt the best + //TODO look into a better system + commands.entity(action).add_child(binding); + commands.entity(set).add_child(action); + + let action = commands + .spawn(( + XRUtilsAction { + action_name: "center".into(), + localized_name: "center_localized".into(), + action_type: bevy_xr::actions::ActionType::Bool, + }, + Center, //lets try a marker component + )) + .id(); + + //create a binding + let binding = commands + .spawn(XRUtilsBinding { + profile: "/interaction_profiles/valve/index_controller".into(), + binding: "/user/hand/right/input/a/click".into(), }) .id(); @@ -120,11 +154,48 @@ fn create_action_entities(mut commands: Commands) { commands.entity(set).add_child(action); } -fn read_action_with_marker_component( +fn send_look_at_red_cube_event( mut action_query: Query<&XRUtilsActionState, With>, + mut event_writer: EventWriter, ) { //now for the actual checking for state in action_query.iter_mut() { - info!("action state is: {:?}", state); + match state { + XRUtilsActionState::Bool(state) => { + let send = state.current_state && state.changed_since_last_sync; + if send { + info!("send facing"); + let quat = Transform::default() + .looking_at(Transform::from_xyz(4.0, 0.0, 0.0).translation, Vec3::Y); //this is a transform facing the red cube from the center of the scene, you should use the HMD posision but I was lazy. + event_writer.send(SnapToRotation(quat.rotation)); + } + } + XRUtilsActionState::Float(_) => (), + XRUtilsActionState::Vector(_) => (), + } + } +} + +#[derive(Component)] +pub struct Center; + +fn send_recenter( + mut action_query: Query<&XRUtilsActionState, With
>, + mut event_writer: EventWriter, +) { + //now for the actual checking + for state in action_query.iter_mut() { + match state { + XRUtilsActionState::Bool(state) => { + let send = state.current_state && state.changed_since_last_sync; + if send { + let center = Transform::default().translation; + + event_writer.send(SnapToPosition(center)); + } + } + XRUtilsActionState::Float(_) => (), + XRUtilsActionState::Vector(_) => (), + } } } diff --git a/crates/bevy_openxr/src/openxr/action_binding.rs b/crates/bevy_openxr/src/openxr/action_binding.rs index 2d5af6d..192287d 100644 --- a/crates/bevy_openxr/src/openxr/action_binding.rs +++ b/crates/bevy_openxr/src/openxr/action_binding.rs @@ -14,7 +14,7 @@ impl Plugin for OxrActionBindingPlugin { app.add_schedule(Schedule::new(OxrSendActionBindings)); app.add_event::(); app.add_systems( - PostUpdate, + Update, run_action_binding_sugestion.run_if( |mut session_state: EventReader| { session_state diff --git a/crates/bevy_xr_utils/src/transform_utils.rs b/crates/bevy_xr_utils/src/transform_utils.rs index 1b71e09..21993b1 100644 --- a/crates/bevy_xr_utils/src/transform_utils.rs +++ b/crates/bevy_xr_utils/src/transform_utils.rs @@ -1,5 +1,10 @@ + use bevy::prelude::*; -use bevy_openxr::{helper_traits::{ToQuat, ToVec3}, init::OxrTrackingRoot, resources::OxrViews}; +use bevy_openxr::{ + helper_traits::{ToQuat, ToVec3}, + init::OxrTrackingRoot, + resources::OxrViews, +}; pub struct TransformUtilitiesPlugin; @@ -27,30 +32,37 @@ pub fn handle_transform_events( let result = root_query.get_single_mut(); match result { Ok(mut root_transform) => { - //rotation first let view = views.first(); match view { Some(view) => { - //get our parameters together + //we want the view translation with a height of zero for a few calculations let mut view_translation = view.pose.position.to_vec3(); - let view_quat = view.pose.orientation.to_quat(); - let view_yaw = view_quat.to_euler(EulerRot::XYZ).1; - let science = Quat::from_axis_angle(*root_transform.up(), view_yaw); - let invert_science = science.inverse(); - view_translation.y = 0.0; //we want to do rotations around the same height as the root - let root_local = root_transform.translation; - let view_global = root_transform.rotation.mul_vec3(view_translation) + root_local; - //now set our rotation for every event, this does mean only the last event matters - for snap in rotation_reader.read() { - let rotation_quaternion = snap.0.mul_quat(invert_science); - root_transform.rotate_around(view_global, rotation_quaternion); - } - //position second - for position in position_reader.read() { - root_transform.translation = position.0; - } + view_translation.y = 0.0; - }, + //position + for position in position_reader.read() { + root_transform.translation = position.0 - root_transform.rotation.mul_vec3(view_translation); + } + + //rotation + let root_local = root_transform.translation.clone(); + let hmd_global = root_transform.rotation.mul_vec3(view_translation) + root_local; + let view_rot = view.pose.orientation.to_quat(); + 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); + let up = Vec3::Y; + for rotation in rotation_reader.read() { + let (target_yaw, _pitch, _roll) = + rotation.0.normalize().to_euler(bevy::math::EulerRot::YXZ); + let diff_yaw = target_yaw - global_view_yaw; + + //build a rotation quat? + let rotation_quat = Quat::from_axis_angle(up, diff_yaw); + //apply rotation this works + root_transform.rotate_around(hmd_global, rotation_quat); + } + } None => debug!("error getting first view"), } } diff --git a/crates/bevy_xr_utils/src/xr_utils_actions.rs b/crates/bevy_xr_utils/src/xr_utils_actions.rs index ded0b19..2c45c1d 100644 --- a/crates/bevy_xr_utils/src/xr_utils_actions.rs +++ b/crates/bevy_xr_utils/src/xr_utils_actions.rs @@ -68,22 +68,28 @@ impl Plugin for XRUtilsActionsPlugin { Startup, create_openxr_events.in_set(XRUtilsActionSystemSet::CreateEvents), ); - app.add_systems(Update, sync_active_action_sets); + app.add_systems( + Update, + sync_active_action_sets.run_if(resource_exists::), + ); app.add_systems( Update, sync_and_update_action_states_f32 + .run_if(resource_exists::) .in_set(XRUtilsActionSystemSet::SyncActionStates) .after(sync_active_action_sets), ); app.add_systems( Update, sync_and_update_action_states_bool + .run_if(resource_exists::) .in_set(XRUtilsActionSystemSet::SyncActionStates) .after(sync_active_action_sets), ); app.add_systems( Update, sync_and_update_action_states_vector + .run_if(resource_exists::) .in_set(XRUtilsActionSystemSet::SyncActionStates) .after(sync_active_action_sets), ); @@ -248,7 +254,7 @@ fn sync_active_action_sets( .collect::>(); let sync = session.sync_actions(&active_sets[..]); match sync { - Ok(_) => info!("sync ok"), + Ok(_) => (), Err(_) => error!("sync error"), } } @@ -262,7 +268,6 @@ fn sync_and_update_action_states_f32( let state = reference.action.state(&session, Path::NULL); match state { Ok(s) => { - info!("we found a state"); let new_state = XRUtilsActionState::Float(ActionStateFloat { current_state: s.current_state, changed_since_last_sync: s.changed_since_last_sync, @@ -288,7 +293,6 @@ fn sync_and_update_action_states_bool( let state = reference.action.state(&session, Path::NULL); match state { Ok(s) => { - info!("we found a state"); let new_state = XRUtilsActionState::Bool(ActionStateBool { current_state: s.current_state, changed_since_last_sync: s.changed_since_last_sync, @@ -314,7 +318,6 @@ fn sync_and_update_action_states_vector( let state = reference.action.state(&session, Path::NULL); match state { Ok(s) => { - info!("we found a state"); let new_state = XRUtilsActionState::Vector(ActionStateVector { current_state: [s.current_state.x, s.current_state.y], changed_since_last_sync: s.changed_since_last_sync,