interactions, and grabbables

examples/xr.rs

@@ -5,13 +5,13 @@ use bevy_openxr::input::XrInput;
 use bevy_openxr::resources::{XrFrameState, XrInstance, XrSession};
 use bevy_openxr::xr_input::debug_gizmos::OpenXrDebugRenderer;
 use bevy_openxr::xr_input::interactions::{
-    draw_interaction_gizmos, direct_interaction, XRDirectInteractor, XRInteractable,
+    interactions, draw_interaction_gizmos, update_interactable_states, InteractionEvent,
-    XRInteractableState, XRInteractorState, XRRayInteractor, ray_interaction,
+    XRDirectInteractor, XRInteractable, XRInteractableState, XRInteractorState, XRRayInteractor,
 };
 use bevy_openxr::xr_input::oculus_touch::OculusController;
 use bevy_openxr::xr_input::prototype_locomotion::{proto_locomotion, PrototypeLocomotionConfig};
 use bevy_openxr::xr_input::trackers::{
-    OpenXRController, OpenXRLeftController, OpenXRRightController, OpenXRTracker, AimPose,
+    AimPose, OpenXRController, OpenXRLeftController, OpenXRRightController, OpenXRTracker,
 };
 use bevy_openxr::xr_input::Hand;
 use bevy_openxr::DefaultXrPlugins;
@@ -29,10 +29,15 @@ fn main() {
         .add_systems(Update, proto_locomotion)
         .add_systems(Startup, spawn_controllers_example)
         .insert_resource(PrototypeLocomotionConfig::default())
-        .add_systems(Update, draw_interaction_gizmos)
+        .add_systems(
-        .add_systems(Update, direct_interaction)
+            Update,
-        .add_systems(Update, ray_interaction)
+            draw_interaction_gizmos.after(update_interactable_states),
+        )
+        .add_systems(Update, interactions)
         .add_systems(Update, prototype_interaction_input)
+        .add_systems(Update, update_interactable_states.after(interactions))
+        .add_systems(Update, update_grabbables.after(update_interactable_states))
+        .add_event::<InteractionEvent>()
         .run();
 }
 
@@ -85,6 +90,7 @@ fn setup(
         },
         XRInteractable,
         XRInteractableState::default(),
+        Grabbable,
     ));
 }
 
@@ -95,7 +101,6 @@ fn spawn_controllers_example(mut commands: Commands) {
         OpenXRController,
         OpenXRTracker,
         SpatialBundle::default(),
-        XRDirectInteractor,
         XRRayInteractor,
         AimPose(Transform::default()),
         XRInteractorState::default(),
@@ -128,7 +133,7 @@ fn prototype_interaction_input(
     mut left_interactor_query: Query<
         (&mut XRInteractorState),
         (
-            With<XRDirectInteractor>,
+            With<XRRayInteractor>,
             With<OpenXRLeftController>,
             Without<OpenXRRightController>,
         ),
@@ -155,3 +160,41 @@ fn prototype_interaction_input(
         *right_state = XRInteractorState::Idle;
     }
 }
+
+#[derive(Component)]
+pub struct Grabbable;
+
+pub fn update_grabbables(
+    mut events: EventReader<InteractionEvent>,
+    mut grabbable_query: Query<(&mut Transform, With<Grabbable>, Without<XRDirectInteractor>)>,
+    interactor_query: Query<(&GlobalTransform, With<XRDirectInteractor>, Without<Grabbable>)>,
+) {
+    //so basically the idea is to try all the events?
+    for event in events.read() {
+        info!("some event");
+        match grabbable_query.get_mut(event.interactable) {
+            Ok(mut grabbable_transform) => {
+                info!("we got a grabbable");
+                //now we need the location of our interactor
+                match interactor_query.get(event.interactor) {
+                    Ok(interactor_transform) => {
+                        info!("its a direct interactor?");
+                        info!(
+                            "before gT: {:?}, iT: {:?}",
+                            grabbable_transform, interactor_transform
+                        );
+                        *grabbable_transform.0 = interactor_transform.0.compute_transform();
+                        info!(
+                            "after gT: {:?}, iT: {:?}",
+                            grabbable_transform, interactor_transform
+                        );
+                    }
+                    Err(_) => info!("not a direct interactor"),
+                }
+            }
+            Err(_) => {
+                info!("not a grabbable?")
+            }
+        }
+    }
+}

src/xr_input/interactions.rs

@@ -1,7 +1,8 @@
 use std::f32::consts::PI;
 
 use bevy::prelude::{
-    info, Color, Component, Gizmos, GlobalTransform, Quat, Query, Transform, Vec3, With, Without,
+    info, Color, Component, Entity, Event, EventReader, EventWriter, Gizmos, GlobalTransform, Quat,
+    Query, Transform, Vec3, With, Without,
 };
 
 use super::trackers::{AimPose, OpenXRTrackingRoot};
@@ -12,7 +13,7 @@ pub struct XRDirectInteractor;
 #[derive(Component)]
 pub struct XRRayInteractor;
 
-#[derive(Component)]
+#[derive(Component, Clone, Copy)]
 pub enum XRInteractableState {
     Idle,
     Hover,
@@ -110,46 +111,113 @@ pub fn draw_interaction_gizmos(
     }
 }
 
-pub fn direct_interaction(
+#[derive(Event)]
+pub struct InteractionEvent {
+    pub interactor: Entity,
+    pub interactable: Entity,
+    pub interactable_state: XRInteractableState,
+}
+
+pub fn interactions(
     mut interactable_query: Query<
-        (&GlobalTransform, &mut XRInteractableState),
+        (&GlobalTransform, &mut XRInteractableState, Entity),
         (With<XRInteractable>, Without<XRDirectInteractor>),
     >,
     interactor_query: Query<
-        (&GlobalTransform, &XRInteractorState),
+        (
-        (With<XRDirectInteractor>, Without<XRInteractable>),
+            &GlobalTransform,
+            &XRInteractorState,
+            Entity,
+            Option<&XRDirectInteractor>,
+            Option<&XRRayInteractor>,
+            Option<&AimPose>,
+        ),
+        (Without<XRInteractable>),
     >,
+    tracking_root_query: Query<(&mut Transform, With<OpenXRTrackingRoot>)>,
+    mut writer: EventWriter<InteractionEvent>,
 ) {
-    for (xr_interactable_global_transform, mut state) in interactable_query.iter_mut() {
+    for (xr_interactable_global_transform, mut state, interactable_entity) in
+        interactable_query.iter_mut()
+    {
         let mut hovered = false;
-        let mut selected = false;
+        for (interactor_global_transform, interactor_state, interactor_entity, direct, ray, aim) in
-        for (interactor_global_transform, interactor_state) in interactor_query.iter() {
+            interactor_query.iter()
-            //check for sphere overlaps
+        {
-            let size = 0.1;
+            match direct {
-            if interactor_global_transform
+                Some(_) => {
-                .compute_transform()
+                    //check for sphere overlaps
-                .translation
+                    let size = 0.1;
-                .distance_squared(
+                    if interactor_global_transform
-                    xr_interactable_global_transform
                         .compute_transform()
-                        .translation,
+                        .translation
-                )
+                        .distance_squared(
-                < (size * size) * 2.0
+                            xr_interactable_global_transform
-            {
+                                .compute_transform()
-                //check for selections first
+                                .translation,
-                match interactor_state {
+                        )
-                    XRInteractorState::Idle => hovered = true,
+                        < (size * size) * 2.0
-                    XRInteractorState::Selecting => {
+                    {
-                        selected = true;
+                        //check for selections first
+                        match interactor_state {
+                            XRInteractorState::Idle => hovered = true,
+                            XRInteractorState::Selecting => {
+                                //welp now I gota actually make things do stuff lol
+                                let event = InteractionEvent {
+                                    interactor: interactor_entity,
+                                    interactable: interactable_entity,
+                                    interactable_state: XRInteractableState::Select,
+                                };
+                                writer.send(event);
+                            }
+                        }
                     }
                 }
+                None => (),
+            }
+            match ray {
+                Some(_) => {
+                    //check for ray-sphere intersection
+                    let sphere_transform = xr_interactable_global_transform.compute_transform();
+                    let center = sphere_transform.translation;
+                    let radius: f32 = 0.1;
+                    //I hate this but the aim pose needs the root for now
+                    let root = tracking_root_query.get_single().unwrap().0;
+                    match aim {
+                        Some(aim) => {
+                            let ray_origin =
+                                root.translation + root.rotation.mul_vec3(aim.0.translation);
+                            let ray_dir = root.rotation.mul_vec3(aim.0.forward());
+
+                            if ray_sphere_intersection(
+                                center,
+                                radius,
+                                ray_origin,
+                                ray_dir.normalize_or_zero(),
+                            ) {
+                                //check for selections first
+                                match interactor_state {
+                                    XRInteractorState::Idle => hovered = true,
+                                    XRInteractorState::Selecting => {
+                                        //welp now I gota actually make things do stuff lol
+                                        let event = InteractionEvent {
+                                            interactor: interactor_entity,
+                                            interactable: interactable_entity,
+                                            interactable_state: XRInteractableState::Select,
+                                        };
+                                        writer.send(event);
+                                    }
+                                }
+                            }
+                        }
+                        None => info!("no aim pose"),
+                    }
+                }
+                None => (),
             }
         }
-        //check what we found
+        //still hate this
-        //also i dont like this
+        if hovered {
-        if selected {
-            *state = XRInteractableState::Select;
-        } else if hovered {
             *state = XRInteractableState::Hover;
         } else {
             *state = XRInteractableState::Idle;
@@ -157,58 +225,18 @@ pub fn direct_interaction(
     }
 }
 
-pub fn ray_interaction(
+pub fn update_interactable_states(
-    mut interactable_query: Query<
+    mut events: EventReader<InteractionEvent>,
-        (&GlobalTransform, &mut XRInteractableState),
+    mut interactable_query: Query<(Entity, &mut XRInteractableState), (With<XRInteractable>)>,
-        (With<XRInteractable>, Without<XRDirectInteractor>),
-    >,
-    interactor_query: Query<
-        (&GlobalTransform, &XRInteractorState, Option<&AimPose>),
-        (With<XRRayInteractor>, Without<XRInteractable>),
-    >,
-    tracking_root_query: Query<(&mut Transform, With<OpenXRTrackingRoot>)>,
 ) {
-    for (xr_interactable_global_transform, mut state) in interactable_query.iter_mut() {
+    for event in events.read() {
-        let mut hovered = false;
+        //lets change the state?
-        let mut selected = false;
+        match interactable_query.get_mut(event.interactable) {
-        for (interactor_global_transform, interactor_state, aim) in interactor_query.iter() {
+            Ok((_entity, mut entity_state)) => {
-            //check for ray-sphere intersection
+                *entity_state = event.interactable_state;
-            let sphere_transform = xr_interactable_global_transform.compute_transform();
+            }
-            let center = sphere_transform.translation;
+            Err(_) => {
-            let radius: f32 = 0.1;
-            //I hate this but the aim pose needs the root for now
-            let root = tracking_root_query.get_single().unwrap().0;
-            match aim {
-                Some(aim) => {
-                    let ray_origin = root.translation + root.rotation.mul_vec3(aim.0.translation);
-                    let ray_dir = root.rotation.mul_vec3(aim.0.forward());
-
-                    if ray_sphere_intersection(
-                        center,
-                        radius,
-                        ray_origin,
-                        ray_dir.normalize_or_zero(),
-                    ) {
-                        //check for selections first
-                        match interactor_state {
-                            XRInteractorState::Idle => hovered = true,
-                            XRInteractorState::Selecting => {
-                                selected = true;
-                            }
-                        }
-                    }
-                }
-                None => info!("no aim pose"),
             }
-        }
-        //check what we found
-        //also i dont like this
-        if selected {
-            *state = XRInteractableState::Select;
-        } else if hovered {
-            *state = XRInteractableState::Hover;
-        } else {
-            *state = XRInteractableState::Idle;
         }
     }
 }