From 263168fc26d392219e0a4c1b71734656c7a0074f Mon Sep 17 00:00:00 2001
From: Jay Christy <fortehlose@gmail.com>
Date: Tue, 19 Sep 2023 16:18:20 -0400
Subject: [PATCH 01/10] first attempt at locomotion

---
 examples/xr.rs               | 38 ++++++++++++++++++++++++++++++++++++
 src/xr_input/debug_gizmos.rs | 32 +++++++++++++++++++++++-------
 src/xr_input/mod.rs          | 18 ++++++++++++-----
 src/xr_input/xr_camera.rs    |  1 +
 4 files changed, 77 insertions(+), 12 deletions(-)

diff --git a/examples/xr.rs b/examples/xr.rs
index 35d766ad..f6459ee3 100644
--- a/examples/xr.rs
+++ b/examples/xr.rs
@@ -1,7 +1,11 @@
 use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
 use bevy::prelude::*;
 use bevy::transform::components::Transform;
+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::oculus_touch::OculusController;
+use bevy_openxr::xr_input::{Hand, TrackingRoot};
 use bevy_openxr::DefaultXrPlugins;
 
 fn main() {
@@ -14,6 +18,7 @@ fn main() {
         .add_plugins(LogDiagnosticsPlugin::default())
         .add_plugins(FrameTimeDiagnosticsPlugin)
         .add_systems(Startup, setup)
+        .add_systems(Update, proto_locomotion)
         .run();
 }
 
@@ -36,6 +41,13 @@ fn setup(
         transform: Transform::from_xyz(0.0, 0.5, 0.0),
         ..default()
     });
+        // cube
+        commands.spawn(PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
+            material: materials.add(Color::rgb(0.8, 0.0, 0.0).into()),
+            transform: Transform::from_xyz(0.0, 0.5, 1.0),
+            ..default()
+        });
     // light
     commands.spawn(PointLightBundle {
         point_light: PointLight {
@@ -52,3 +64,29 @@ fn setup(
         ..default()
     },));
 }
+
+fn proto_locomotion(
+    time: Res<Time>,
+    mut tracking_root_query: Query<(&mut Transform, With<TrackingRoot>)>,
+    oculus_controller: Res<OculusController>,
+    frame_state: Res<XrFrameState>,
+    xr_input: Res<XrInput>,
+    instance: Res<XrInstance>,
+    session: Res<XrSession>,
+) {
+    //lock frame
+    let frame_state = *frame_state.lock().unwrap();
+    //get controller
+    let controller = oculus_controller.get_ref(&instance, &session, &frame_state, &xr_input);
+    let root = tracking_root_query.get_single_mut();
+    match root {
+        Ok(mut position) => {
+            //do work here?
+            let stick = controller.thumbstick(Hand::Left);
+            let input = Vec3::new(stick.x, 0.0, -stick.y);
+            let speed = 1.0;
+            position.0.translation += input * speed * time.delta_seconds()
+        }
+        Err(_) => info!("too many tracking roots"),
+    }
+}
diff --git a/src/xr_input/debug_gizmos.rs b/src/xr_input/debug_gizmos.rs
index 4e96e2cb..9f5fea60 100644
--- a/src/xr_input/debug_gizmos.rs
+++ b/src/xr_input/debug_gizmos.rs
@@ -1,4 +1,6 @@
-use bevy::prelude::{Color, Gizmos, Plugin, Quat, Res, Transform, Update, Vec2, Vec3};
+use bevy::prelude::{
+    info, Color, Gizmos, Plugin, Quat, Query, Res, Transform, Update, Vec2, Vec3, With, PreUpdate,
+};
 
 use crate::{
     input::XrInput,
@@ -7,7 +9,7 @@ use crate::{
 
 use crate::xr_input::{
     oculus_touch::{OculusController, OculusControllerRef},
-    Hand, QuatConv, Vec3Conv,
+    Hand, QuatConv, TrackingRoot, Vec3Conv,
 };
 
 /// add debug renderer for controllers
@@ -27,17 +29,33 @@ pub fn draw_gizmos(
     xr_input: Res<XrInput>,
     instance: Res<XrInstance>,
     session: Res<XrSession>,
+    tracking_root_query: Query<(&mut Transform, With<TrackingRoot>)>,
 ) {
     //lock frame
     let frame_state = *frame_state.lock().unwrap();
     //get controller
     let controller = oculus_controller.get_ref(&instance, &session, &frame_state, &xr_input);
+    //tracking root?
+    let mut tracking_position = Vec3::ZERO;
+    let root = tracking_root_query.get_single();
+    match root {
+        Ok(position) => {
+            gizmos.circle(position.0.translation, Vec3::Y, 0.2, Color::RED);
+            tracking_position = position.0.translation;
+        }
+        Err(_) => info!("too many tracking roots"),
+    }
     //draw the hands
-    draw_hand_gizmo(&mut gizmos, &controller, Hand::Right);
-    draw_hand_gizmo(&mut gizmos, &controller, Hand::Left);
+    draw_hand_gizmo(&mut gizmos, &controller, Hand::Right, tracking_position);
+    draw_hand_gizmo(&mut gizmos, &controller, Hand::Left, tracking_position);
 }
 
-fn draw_hand_gizmo(gizmos: &mut Gizmos, controller: &OculusControllerRef<'_>, hand: Hand) {
+fn draw_hand_gizmo(
+    gizmos: &mut Gizmos,
+    controller: &OculusControllerRef<'_>,
+    hand: Hand,
+    tracking_root: Vec3,
+) {
     match hand {
         Hand::Left => {
             //get left controller
@@ -51,7 +69,7 @@ fn draw_hand_gizmo(gizmos: &mut Gizmos, controller: &OculusControllerRef<'_>, ha
             let grip_quat_offset = Quat::from_rotation_x(-1.4);
             let face_quat_offset = Quat::from_rotation_x(1.05);
 
-            let controller_vec3 = left_controller.0.pose.position.to_vec3();
+            let controller_vec3 = left_controller.0.pose.position.to_vec3() + tracking_root;
             let controller_quat = left_controller.0.pose.orientation.to_quat();
             let face_quat = controller_quat.mul_quat(face_quat_offset);
             let face_quat_normal = face_quat.mul_vec3(Vec3::Z);
@@ -158,7 +176,7 @@ fn draw_hand_gizmo(gizmos: &mut Gizmos, controller: &OculusControllerRef<'_>, ha
             let grip_quat_offset = Quat::from_rotation_x(-1.4);
             let face_quat_offset = Quat::from_rotation_x(1.05);
 
-            let controller_vec3 = right_controller.0.pose.position.to_vec3();
+            let controller_vec3 = right_controller.0.pose.position.to_vec3() + tracking_root;
             let controller_quat = right_controller.0.pose.orientation.to_quat();
             let face_quat = controller_quat.mul_quat(face_quat_offset);
             let face_quat_normal = face_quat.mul_vec3(Vec3::Z);
diff --git a/src/xr_input/mod.rs b/src/xr_input/mod.rs
index 70fd1f90..d7cf8a64 100644
--- a/src/xr_input/mod.rs
+++ b/src/xr_input/mod.rs
@@ -10,11 +10,11 @@ use crate::xr_input::oculus_touch::{setup_oculus_controller, ActionSets};
 use crate::xr_input::xr_camera::{xr_camera_head_sync, Eye, XRProjection, XrCameraBundle};
 use bevy::app::{App, PostUpdate, Startup};
 use bevy::log::warn;
-use bevy::prelude::IntoSystemConfigs;
-use bevy::prelude::{Commands, Plugin, PreUpdate, Quat, Res, Vec3};
+use bevy::prelude::{default, Commands, Component, Plugin, PreUpdate, Quat, Res, Vec3};
+use bevy::prelude::{BuildChildren, IntoSystemConfigs};
 use bevy::render::camera::CameraProjectionPlugin;
 use bevy::render::view::{update_frusta, VisibilitySystems};
-use bevy::transform::TransformSystem;
+use bevy::transform::{TransformBundle, TransformSystem};
 
 #[derive(Copy, Clone)]
 pub struct OpenXrInput {
@@ -25,6 +25,10 @@ pub enum Hand {
     Left,
     Right,
 }
+
+#[derive(Component)]
+pub struct TrackingRoot;
+
 impl OpenXrInput {
     pub fn new(controller_type: XrControllerType) -> Self {
         Self { controller_type }
@@ -52,8 +56,12 @@ impl Plugin for OpenXrInput {
 }
 
 fn setup_xr_cameras(mut commands: Commands) {
-    commands.spawn(XrCameraBundle::new(Eye::Right));
-    commands.spawn(XrCameraBundle::new(Eye::Left));
+    //this needs to do the whole xr tracking volume not just cameras
+    //get the root?
+    let tracking_root = commands.spawn((TransformBundle { ..default() }, TrackingRoot)).id();
+    let right = commands.spawn(XrCameraBundle::new(Eye::Right)).id();
+    let left = commands.spawn(XrCameraBundle::new(Eye::Left)).id();
+    commands.entity(tracking_root).push_children(&[right, left]);
 }
 
 fn action_set_system(action_sets: Res<ActionSets>, session: Res<XrSession>) {
diff --git a/src/xr_input/xr_camera.rs b/src/xr_input/xr_camera.rs
index fbd2a901..8c04eb9c 100644
--- a/src/xr_input/xr_camera.rs
+++ b/src/xr_input/xr_camera.rs
@@ -46,6 +46,7 @@ pub enum XrCameraType {
     Xr(Eye),
     Flatscreen,
 }
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
 pub enum Eye {
     Left = 0,

From 6925f81f099dce084f4ac8e91720d9ca9c98caeb Mon Sep 17 00:00:00 2001
From: Jay Christy <fortehlose@gmail.com>
Date: Tue, 19 Sep 2023 23:13:23 -0400
Subject: [PATCH 02/10] it lives

---
 src/xr_input/debug_gizmos.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/xr_input/debug_gizmos.rs b/src/xr_input/debug_gizmos.rs
index 9f5fea60..454cb80b 100644
--- a/src/xr_input/debug_gizmos.rs
+++ b/src/xr_input/debug_gizmos.rs
@@ -1,6 +1,4 @@
-use bevy::prelude::{
-    info, Color, Gizmos, Plugin, Quat, Query, Res, Transform, Update, Vec2, Vec3, With, PreUpdate,
-};
+use bevy::prelude::{Color, Gizmos, Plugin, Quat, Query, Res, Transform, Update, Vec2, Vec3, With, info};
 
 use crate::{
     input::XrInput,

From 9043ebeb4d06427e0fea91832d6228d15dfced23 Mon Sep 17 00:00:00 2001
From: Jay Christy <fortehlose@gmail.com>
Date: Tue, 19 Sep 2023 23:13:37 -0400
Subject: [PATCH 03/10] first pass i think

---
 examples/xr.rs | 50 +++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 39 insertions(+), 11 deletions(-)

diff --git a/examples/xr.rs b/examples/xr.rs
index f6459ee3..64ae62a7 100644
--- a/examples/xr.rs
+++ b/examples/xr.rs
@@ -2,10 +2,10 @@ use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
 use bevy::prelude::*;
 use bevy::transform::components::Transform;
 use bevy_openxr::input::XrInput;
-use bevy_openxr::resources::{XrFrameState, XrInstance, XrSession};
+use bevy_openxr::resources::{XrFrameState, XrInstance, XrSession, XrViews};
 use bevy_openxr::xr_input::debug_gizmos::OpenXrDebugRenderer;
 use bevy_openxr::xr_input::oculus_touch::OculusController;
-use bevy_openxr::xr_input::{Hand, TrackingRoot};
+use bevy_openxr::xr_input::{Hand, QuatConv, TrackingRoot};
 use bevy_openxr::DefaultXrPlugins;
 
 fn main() {
@@ -41,13 +41,13 @@ fn setup(
         transform: Transform::from_xyz(0.0, 0.5, 0.0),
         ..default()
     });
-        // cube
-        commands.spawn(PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
-            material: materials.add(Color::rgb(0.8, 0.0, 0.0).into()),
-            transform: Transform::from_xyz(0.0, 0.5, 1.0),
-            ..default()
-        });
+    // cube
+    commands.spawn(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
+        material: materials.add(Color::rgb(0.8, 0.0, 0.0).into()),
+        transform: Transform::from_xyz(0.0, 0.5, 1.0),
+        ..default()
+    });
     // light
     commands.spawn(PointLightBundle {
         point_light: PointLight {
@@ -65,6 +65,11 @@ fn setup(
     },));
 }
 
+pub enum LocomotionType {
+    Head,
+    Hand,
+}
+
 fn proto_locomotion(
     time: Res<Time>,
     mut tracking_root_query: Query<(&mut Transform, With<TrackingRoot>)>,
@@ -73,6 +78,7 @@ fn proto_locomotion(
     xr_input: Res<XrInput>,
     instance: Res<XrInstance>,
     session: Res<XrSession>,
+    views: ResMut<XrViews>,
 ) {
     //lock frame
     let frame_state = *frame_state.lock().unwrap();
@@ -81,11 +87,33 @@ fn proto_locomotion(
     let root = tracking_root_query.get_single_mut();
     match root {
         Ok(mut position) => {
-            //do work here?
+            //get the stick input and do some maths
             let stick = controller.thumbstick(Hand::Left);
             let input = Vec3::new(stick.x, 0.0, -stick.y);
             let speed = 1.0;
-            position.0.translation += input * speed * time.delta_seconds()
+            //now the question is how do we do hmd based locomotion
+            //or controller based for that matter
+            let locomotion_type = LocomotionType::Hand;
+            let mut reference_quat = Quat::IDENTITY;
+            match locomotion_type {
+                LocomotionType::Head => {
+                    let v = views.lock().unwrap();
+                    let views = v.get(0);
+                    match views {
+                        Some(view) => {
+                            reference_quat = view.pose.orientation.to_quat();
+                        }
+                        None => return,
+                    }
+                }
+                LocomotionType::Hand => {
+                    let grip = controller.grip_space(Hand::Left);
+                    reference_quat = grip.0.pose.orientation.to_quat();
+                }
+            }
+            let mut locomotion_vec = reference_quat.mul_vec3(input);
+            locomotion_vec.y = 0.0;
+            position.0.translation += locomotion_vec * speed * time.delta_seconds()
         }
         Err(_) => info!("too many tracking roots"),
     }

From 0476736f5c82d53c4bb8294be35379671a0d462b Mon Sep 17 00:00:00 2001
From: Jay Christy <fortehlose@gmail.com>
Date: Wed, 20 Sep 2023 11:42:23 -0400
Subject: [PATCH 04/10] proto smooth rotation

---
 examples/xr.rs               | 65 +++++++++++++++++++++++++++++++++---
 src/xr_input/debug_gizmos.rs | 44 ++++++++++++++++++------
 2 files changed, 93 insertions(+), 16 deletions(-)

diff --git a/examples/xr.rs b/examples/xr.rs
index 64ae62a7..2ea58d5b 100644
--- a/examples/xr.rs
+++ b/examples/xr.rs
@@ -1,11 +1,14 @@
+use std::f32::consts::PI;
+
 use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
+use bevy::prelude::Gizmos;
 use bevy::prelude::*;
 use bevy::transform::components::Transform;
 use bevy_openxr::input::XrInput;
 use bevy_openxr::resources::{XrFrameState, XrInstance, XrSession, XrViews};
 use bevy_openxr::xr_input::debug_gizmos::OpenXrDebugRenderer;
 use bevy_openxr::xr_input::oculus_touch::OculusController;
-use bevy_openxr::xr_input::{Hand, QuatConv, TrackingRoot};
+use bevy_openxr::xr_input::{Hand, QuatConv, TrackingRoot, Vec3Conv};
 use bevy_openxr::DefaultXrPlugins;
 
 fn main() {
@@ -70,6 +73,11 @@ pub enum LocomotionType {
     Hand,
 }
 
+pub enum RotationType {
+    Smooth,
+    Snap,
+}
+
 fn proto_locomotion(
     time: Res<Time>,
     mut tracking_root_query: Query<(&mut Transform, With<TrackingRoot>)>,
@@ -79,6 +87,7 @@ fn proto_locomotion(
     instance: Res<XrInstance>,
     session: Res<XrSession>,
     views: ResMut<XrViews>,
+    mut gizmos: Gizmos,
 ) {
     //lock frame
     let frame_state = *frame_state.lock().unwrap();
@@ -93,7 +102,7 @@ fn proto_locomotion(
             let speed = 1.0;
             //now the question is how do we do hmd based locomotion
             //or controller based for that matter
-            let locomotion_type = LocomotionType::Hand;
+            let locomotion_type = LocomotionType::Head;
             let mut reference_quat = Quat::IDENTITY;
             match locomotion_type {
                 LocomotionType::Head => {
@@ -101,19 +110,65 @@ fn proto_locomotion(
                     let views = v.get(0);
                     match views {
                         Some(view) => {
-                            reference_quat = view.pose.orientation.to_quat();
+                            reference_quat = view
+                                .pose
+                                .orientation
+                                .to_quat()
+                                .mul_quat(position.0.rotation);
                         }
                         None => return,
                     }
                 }
                 LocomotionType::Hand => {
                     let grip = controller.grip_space(Hand::Left);
-                    reference_quat = grip.0.pose.orientation.to_quat();
+                    reference_quat = grip
+                        .0
+                        .pose
+                        .orientation
+                        .to_quat()
+                        .mul_quat(position.0.rotation); //TODO add root tracking quat to this so we simulate the global rotation
                 }
             }
             let mut locomotion_vec = reference_quat.mul_vec3(input);
             locomotion_vec.y = 0.0;
-            position.0.translation += locomotion_vec * speed * time.delta_seconds()
+            position.0.translation += locomotion_vec * speed * time.delta_seconds();
+
+            //now time for rotation
+            let snap_angle = 45.0;
+            let smooth_rotation_speed = 0.5 * PI;
+            let rotation_setting = RotationType::Smooth;
+            match rotation_setting {
+                RotationType::Smooth => {
+                    //once again with the math
+                    let control_stick = controller.thumbstick(Hand::Right);
+                    let rot_input = -control_stick.x; //why is this negative i dont know
+                    if rot_input.abs() <= 0.2 {
+                        //return;
+                    }
+                    let smoth_rot = Quat::from_rotation_y(
+                        rot_input * smooth_rotation_speed * time.delta_seconds(),
+                    );
+                    //apply rotation
+                    let v = views.lock().unwrap();
+                    let views = v.get(0);
+                    let views = v.get(0);
+                    match views {
+                        Some(view) => {
+                            let mut hmd_translation = view.pose.position.to_vec3();
+                            hmd_translation.y = 0.0;
+                            let local = position.0.translation;
+                            let global = position.0.rotation.mul_vec3(hmd_translation) + local;
+                            gizmos.circle(global, Vec3::Y, 0.1, Color::GREEN);
+                            position.0.rotate_around(global, smoth_rot);
+                        }
+                        None => return,
+                    }
+                }
+                RotationType::Snap => {
+                    //yup even more math i cant remember
+                    todo!();
+                }
+            }
         }
         Err(_) => info!("too many tracking roots"),
     }
diff --git a/src/xr_input/debug_gizmos.rs b/src/xr_input/debug_gizmos.rs
index 454cb80b..0ebde4a1 100644
--- a/src/xr_input/debug_gizmos.rs
+++ b/src/xr_input/debug_gizmos.rs
@@ -1,4 +1,6 @@
-use bevy::prelude::{Color, Gizmos, Plugin, Quat, Query, Res, Transform, Update, Vec2, Vec3, With, info};
+use bevy::prelude::{
+    info, Color, Gizmos, Plugin, Quat, Query, Res, Transform, Update, Vec2, Vec3, With,
+};
 
 use crate::{
     input::XrInput,
@@ -34,25 +36,35 @@ pub fn draw_gizmos(
     //get controller
     let controller = oculus_controller.get_ref(&instance, &session, &frame_state, &xr_input);
     //tracking root?
-    let mut tracking_position = Vec3::ZERO;
+    let mut tracking_transform = &Transform::IDENTITY;
     let root = tracking_root_query.get_single();
     match root {
         Ok(position) => {
-            gizmos.circle(position.0.translation, Vec3::Y, 0.2, Color::RED);
-            tracking_position = position.0.translation;
+            gizmos.circle(
+                position.0.translation
+                    + Vec3 {
+                        x: 0.0,
+                        y: 0.01,
+                        z: 0.0,
+                    },
+                Vec3::Y,
+                0.2,
+                Color::RED,
+            );
+            tracking_transform = position.0;
         }
         Err(_) => info!("too many tracking roots"),
     }
     //draw the hands
-    draw_hand_gizmo(&mut gizmos, &controller, Hand::Right, tracking_position);
-    draw_hand_gizmo(&mut gizmos, &controller, Hand::Left, tracking_position);
+    draw_hand_gizmo(&mut gizmos, &controller, Hand::Right, tracking_transform);
+    draw_hand_gizmo(&mut gizmos, &controller, Hand::Left, tracking_transform);
 }
 
 fn draw_hand_gizmo(
     gizmos: &mut Gizmos,
     controller: &OculusControllerRef<'_>,
     hand: Hand,
-    tracking_root: Vec3,
+    tracking_root: &Transform,
 ) {
     match hand {
         Hand::Left => {
@@ -67,8 +79,13 @@ fn draw_hand_gizmo(
             let grip_quat_offset = Quat::from_rotation_x(-1.4);
             let face_quat_offset = Quat::from_rotation_x(1.05);
 
-            let controller_vec3 = left_controller.0.pose.position.to_vec3() + tracking_root;
-            let controller_quat = left_controller.0.pose.orientation.to_quat();
+            let controller_vec3 = tracking_root
+                .rotation
+                .mul_vec3(left_controller.0.pose.position.to_vec3())
+                + tracking_root.translation;
+            let controller_quat = tracking_root
+                .rotation
+                .mul_quat(left_controller.0.pose.orientation.to_quat());
             let face_quat = controller_quat.mul_quat(face_quat_offset);
             let face_quat_normal = face_quat.mul_vec3(Vec3::Z);
 
@@ -174,8 +191,13 @@ fn draw_hand_gizmo(
             let grip_quat_offset = Quat::from_rotation_x(-1.4);
             let face_quat_offset = Quat::from_rotation_x(1.05);
 
-            let controller_vec3 = right_controller.0.pose.position.to_vec3() + tracking_root;
-            let controller_quat = right_controller.0.pose.orientation.to_quat();
+            let controller_vec3 = tracking_root
+                .rotation
+                .mul_vec3(right_controller.0.pose.position.to_vec3())
+                + tracking_root.translation;
+            let controller_quat = tracking_root
+                .rotation
+                .mul_quat(right_controller.0.pose.orientation.to_quat());
             let face_quat = controller_quat.mul_quat(face_quat_offset);
             let face_quat_normal = face_quat.mul_vec3(Vec3::Z);
 

From 11328f72edf7fdf474999191488721dad6d255a3 Mon Sep 17 00:00:00 2001
From: Jay Christy <fortehlose@gmail.com>
Date: Wed, 20 Sep 2023 12:46:09 -0400
Subject: [PATCH 05/10] first pass at snap rotation

---
 examples/xr.rs | 59 +++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 54 insertions(+), 5 deletions(-)

diff --git a/examples/xr.rs b/examples/xr.rs
index 2ea58d5b..d6bbb417 100644
--- a/examples/xr.rs
+++ b/examples/xr.rs
@@ -1,4 +1,5 @@
 use std::f32::consts::PI;
+use std::time::Duration;
 
 use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
 use bevy::prelude::Gizmos;
@@ -66,6 +67,10 @@ fn setup(
         transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
         ..default()
     },));
+
+    commands.insert_resource(RotationTimer {
+        timer: Timer::from_seconds(1.0, TimerMode::Once),
+    })
 }
 
 pub enum LocomotionType {
@@ -78,6 +83,11 @@ pub enum RotationType {
     Snap,
 }
 
+#[derive(Resource)]
+struct RotationTimer {
+    timer: Timer,
+}
+
 fn proto_locomotion(
     time: Res<Time>,
     mut tracking_root_query: Query<(&mut Transform, With<TrackingRoot>)>,
@@ -88,6 +98,7 @@ fn proto_locomotion(
     session: Res<XrSession>,
     views: ResMut<XrViews>,
     mut gizmos: Gizmos,
+    mut rotation_timer: Option<ResMut<RotationTimer>>,
 ) {
     //lock frame
     let frame_state = *frame_state.lock().unwrap();
@@ -134,16 +145,16 @@ fn proto_locomotion(
             position.0.translation += locomotion_vec * speed * time.delta_seconds();
 
             //now time for rotation
-            let snap_angle = 45.0;
+            let snap_angle = 45.0 * (PI / 180.0);
             let smooth_rotation_speed = 0.5 * PI;
-            let rotation_setting = RotationType::Smooth;
+            let rotation_setting = RotationType::Snap;
             match rotation_setting {
                 RotationType::Smooth => {
                     //once again with the math
                     let control_stick = controller.thumbstick(Hand::Right);
-                    let rot_input = -control_stick.x; //why is this negative i dont know
+                    let rot_input = control_stick.x; //why is this negative i dont know
                     if rot_input.abs() <= 0.2 {
-                        //return;
+                        return;
                     }
                     let smoth_rot = Quat::from_rotation_y(
                         rot_input * smooth_rotation_speed * time.delta_seconds(),
@@ -166,7 +177,45 @@ fn proto_locomotion(
                 }
                 RotationType::Snap => {
                     //yup even more math i cant remember
-                    todo!();
+
+                    //get timer
+                    match rotation_timer {
+                        Some(mut timer) => {
+                            //tick the timer
+                            timer.timer.tick(time.delta());
+                            if timer.timer.finished() {
+                                //now we can snap turn?
+                                //once again with the math
+                                let control_stick = controller.thumbstick(Hand::Right);
+                                let rot_input = -control_stick.x;
+                                if rot_input.abs() <= 0.5 {
+                                    return;
+                                }
+                                let dir: f32 = match rot_input > 0.0 {
+                                    true => 1.0,
+                                    false => -1.0,
+                                };
+                                let smoth_rot = Quat::from_rotation_y(snap_angle * dir);
+                                //apply rotation
+                                let v = views.lock().unwrap();
+                                let views = v.get(0);
+                                match views {
+                                    Some(view) => {
+                                        let mut hmd_translation = view.pose.position.to_vec3();
+                                        hmd_translation.y = 0.0;
+                                        let local = position.0.translation;
+                                        let global =
+                                            position.0.rotation.mul_vec3(hmd_translation) + local;
+                                        gizmos.circle(global, Vec3::Y, 0.1, Color::GREEN);
+                                        position.0.rotate_around(global, smoth_rot);
+                                    }
+                                    None => return,
+                                }
+                                timer.timer.reset();
+                            }
+                        }
+                        None => info!("didnt init the rotation timer"),
+                    }
                 }
             }
         }

From 9e69777a45c81c98d9053ee821aadea692ce1f14 Mon Sep 17 00:00:00 2001
From: Jay Christy <fortehlose@gmail.com>
Date: Thu, 21 Sep 2023 13:16:00 -0400
Subject: [PATCH 06/10] pinned to working version for now

---
 Cargo.toml | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 84e1f119..58c51010 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,7 +10,9 @@ linked = ["openxr/linked", "openxr/static"]
 [dependencies]
 anyhow = "1.0.75"
 ash = "0.37.3"
-bevy = { git = "https://github.com/awtterpip/bevy", default-features = false, features = ["bevy_render"] }
+bevy = { git = "https://github.com/awtterpip/bevy", default-features = false, features = [
+    "bevy_render",
+], rev = "ac28b11797c0a85b431ee4940c6afa434f712f7a" }
 openxr = { version = "0.17.1", features = ["mint"] }
 mint = "0.5.9"
 wgpu = "0.16.0"
@@ -18,7 +20,7 @@ wgpu-core = { version = "0.16.0", features = ["vulkan"] }
 wgpu-hal = "0.16.0"
 
 [dev-dependencies]
-bevy = { git = "https://github.com/awtterpip/bevy" }
+bevy = { git = "https://github.com/awtterpip/bevy", rev = "ac28b11797c0a85b431ee4940c6afa434f712f7a" }
 color-eyre = "0.6.2"
 
 [[example]]
@@ -26,4 +28,4 @@ name = "xr"
 path = "examples/xr.rs"
 
 [profile.release]
-debug = true
\ No newline at end of file
+debug = true

From 8cea603cb57a5ae3162288bb5e9612b691eff040 Mon Sep 17 00:00:00 2001
From: Jay Christy <fortehlose@gmail.com>
Date: Sun, 24 Sep 2023 01:34:20 -0400
Subject: [PATCH 07/10] added tracker markers and change detection

---
 examples/xr.rs               | 111 +++++++++++++++++++++++++++++++++--
 src/xr_input/debug_gizmos.rs |  57 ++++++++++--------
 src/xr_input/mod.rs          |  22 ++++---
 src/xr_input/trackers.rs     |  18 ++++++
 src/xr_input/xr_camera.rs    |   1 +
 5 files changed, 172 insertions(+), 37 deletions(-)
 create mode 100644 src/xr_input/trackers.rs

diff --git a/examples/xr.rs b/examples/xr.rs
index d6bbb417..8b52c8db 100644
--- a/examples/xr.rs
+++ b/examples/xr.rs
@@ -9,7 +9,11 @@ use bevy_openxr::input::XrInput;
 use bevy_openxr::resources::{XrFrameState, XrInstance, XrSession, XrViews};
 use bevy_openxr::xr_input::debug_gizmos::OpenXrDebugRenderer;
 use bevy_openxr::xr_input::oculus_touch::OculusController;
-use bevy_openxr::xr_input::{Hand, QuatConv, TrackingRoot, Vec3Conv};
+use bevy_openxr::xr_input::trackers::{
+    OpenXRController, OpenXRLeftController, OpenXRRightController, OpenXRTracker,
+    OpenXRTrackingRoot,
+};
+use bevy_openxr::xr_input::{Hand, QuatConv, Vec3Conv};
 use bevy_openxr::DefaultXrPlugins;
 
 fn main() {
@@ -23,6 +27,9 @@ fn main() {
         .add_plugins(FrameTimeDiagnosticsPlugin)
         .add_systems(Startup, setup)
         .add_systems(Update, proto_locomotion)
+        .add_systems(Startup, spawn_controllers)
+        .add_systems(Update, update_hands)
+        .add_systems(Update, adopt_open_xr_trackers)
         .run();
 }
 
@@ -88,9 +95,106 @@ struct RotationTimer {
     timer: Timer,
 }
 
+fn spawn_controllers(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    //left hand
+    commands.spawn((
+        OpenXRLeftController,
+        OpenXRController,
+        OpenXRTracker,
+        // SpatialBundle::default(),
+        PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
+            material: materials.add(Color::RED.into()),
+            transform: Transform::from_xyz(0.0, 0.5, 1.0),
+            ..default()
+        },
+    ));
+    //right hand
+    commands.spawn((
+        OpenXRRightController,
+        OpenXRController,
+        OpenXRTracker,
+        // SpatialBundle::default(),
+        PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
+            material: materials.add(Color::BLUE.into()),
+            transform: Transform::from_xyz(0.0, 0.5, 1.0),
+            ..default()
+        },
+    ));
+}
+
+fn update_hands(
+    oculus_controller: Res<OculusController>,
+    mut left_controller_query: Query<(
+        &mut Transform,
+        With<OpenXRLeftController>,
+        Without<OpenXRRightController>,
+    )>,
+    mut right_controller_query: Query<(
+        &mut Transform,
+        With<OpenXRRightController>,
+        Without<OpenXRLeftController>,
+    )>,
+    frame_state: Res<XrFrameState>,
+    instance: Res<XrInstance>,
+    xr_input: Res<XrInput>,
+    session: Res<XrSession>,
+) {
+    //lock dat frame?
+    let frame_state = *frame_state.lock().unwrap();
+    //get controller
+    let controller = oculus_controller.get_ref(&instance, &session, &frame_state, &xr_input);
+    //get left controller
+    let left = controller.grip_space(Hand::Left);
+    let left_postion = left.0.pose.position.to_vec3();
+
+    left_controller_query
+        .get_single_mut()
+        .unwrap()
+        .0
+        .translation = left_postion;
+
+    left_controller_query.get_single_mut().unwrap().0.rotation = left.0.pose.orientation.to_quat();
+    //get right controller
+    let right = controller.grip_space(Hand::Right);
+    let right_postion = right.0.pose.position.to_vec3();
+
+    right_controller_query
+        .get_single_mut()
+        .unwrap()
+        .0
+        .translation = right_postion;
+
+    right_controller_query.get_single_mut().unwrap().0.rotation =
+        right.0.pose.orientation.to_quat();
+}
+
+fn adopt_open_xr_trackers(
+    query: Query<(Entity), Added<OpenXRTracker>>,
+    mut commands: Commands,
+    tracking_root_query: Query<(Entity, With<OpenXRTrackingRoot>)>,
+) {
+    let root = tracking_root_query.get_single();
+    match root {
+        Ok(thing) => {
+            // info!("root is");
+            for tracker in query.iter() {
+                info!("we got a new tracker");
+                commands.entity(thing.0).add_child(tracker);
+            }
+        }
+        Err(_) => info!("root isnt spawned yet?"),
+    }
+}
+
 fn proto_locomotion(
     time: Res<Time>,
-    mut tracking_root_query: Query<(&mut Transform, With<TrackingRoot>)>,
+    mut tracking_root_query: Query<(&mut Transform, With<OpenXRTrackingRoot>)>,
     oculus_controller: Res<OculusController>,
     frame_state: Res<XrFrameState>,
     xr_input: Res<XrInput>,
@@ -162,7 +266,6 @@ fn proto_locomotion(
                     //apply rotation
                     let v = views.lock().unwrap();
                     let views = v.get(0);
-                    let views = v.get(0);
                     match views {
                         Some(view) => {
                             let mut hmd_translation = view.pose.position.to_vec3();
@@ -176,8 +279,6 @@ fn proto_locomotion(
                     }
                 }
                 RotationType::Snap => {
-                    //yup even more math i cant remember
-
                     //get timer
                     match rotation_timer {
                         Some(mut timer) => {
diff --git a/src/xr_input/debug_gizmos.rs b/src/xr_input/debug_gizmos.rs
index 0ebde4a1..5724bc67 100644
--- a/src/xr_input/debug_gizmos.rs
+++ b/src/xr_input/debug_gizmos.rs
@@ -1,5 +1,6 @@
 use bevy::prelude::{
-    info, Color, Gizmos, Plugin, Quat, Query, Res, Transform, Update, Vec2, Vec3, With,
+    info, Color, Gizmos, GlobalTransform, Plugin, Quat, Query, Res, Transform, Update, Vec2, Vec3,
+    With, Without,
 };
 
 use crate::{
@@ -9,9 +10,11 @@ use crate::{
 
 use crate::xr_input::{
     oculus_touch::{OculusController, OculusControllerRef},
-    Hand, QuatConv, TrackingRoot, Vec3Conv,
+    Hand, QuatConv, Vec3Conv,
 };
 
+use super::trackers::{OpenXRLeftController, OpenXRRightController, OpenXRTrackingRoot};
+
 /// add debug renderer for controllers
 #[derive(Default)]
 pub struct OpenXrDebugRenderer;
@@ -29,7 +32,19 @@ pub fn draw_gizmos(
     xr_input: Res<XrInput>,
     instance: Res<XrInstance>,
     session: Res<XrSession>,
-    tracking_root_query: Query<(&mut Transform, With<TrackingRoot>)>,
+    tracking_root_query: Query<(&mut Transform, With<OpenXRTrackingRoot>)>,
+    left_controller_query: Query<(
+        &GlobalTransform,
+        With<OpenXRLeftController>,
+        Without<OpenXRRightController>,
+        Without<OpenXRTrackingRoot>,
+    )>,
+    right_controller_query: Query<(
+        &GlobalTransform,
+        With<OpenXRRightController>,
+        Without<OpenXRLeftController>,
+        Without<OpenXRTrackingRoot>,
+    )>,
 ) {
     //lock frame
     let frame_state = *frame_state.lock().unwrap();
@@ -56,21 +71,21 @@ pub fn draw_gizmos(
         Err(_) => info!("too many tracking roots"),
     }
     //draw the hands
-    draw_hand_gizmo(&mut gizmos, &controller, Hand::Right, tracking_transform);
-    draw_hand_gizmo(&mut gizmos, &controller, Hand::Left, tracking_transform);
+    let left_transform = left_controller_query.get_single().unwrap().0;
+    let right_transform = right_controller_query.get_single().unwrap().0;
+
+    draw_hand_gizmo(&mut gizmos, &controller, Hand::Right, right_transform);
+    draw_hand_gizmo(&mut gizmos, &controller, Hand::Left, left_transform);
 }
 
 fn draw_hand_gizmo(
     gizmos: &mut Gizmos,
     controller: &OculusControllerRef<'_>,
     hand: Hand,
-    tracking_root: &Transform,
+    hand_transform: &GlobalTransform,
 ) {
     match hand {
         Hand::Left => {
-            //get left controller
-            let left_controller = controller.grip_space(Hand::Left);
-
             let left_color = Color::YELLOW_GREEN;
             let off_color = Color::BLUE;
             let touch_color = Color::GREEN;
@@ -78,14 +93,9 @@ fn draw_hand_gizmo(
 
             let grip_quat_offset = Quat::from_rotation_x(-1.4);
             let face_quat_offset = Quat::from_rotation_x(1.05);
-
-            let controller_vec3 = tracking_root
-                .rotation
-                .mul_vec3(left_controller.0.pose.position.to_vec3())
-                + tracking_root.translation;
-            let controller_quat = tracking_root
-                .rotation
-                .mul_quat(left_controller.0.pose.orientation.to_quat());
+            let trans = hand_transform.compute_transform();
+            let controller_vec3 = trans.translation;
+            let controller_quat = trans.rotation;
             let face_quat = controller_quat.mul_quat(face_quat_offset);
             let face_quat_normal = face_quat.mul_vec3(Vec3::Z);
 
@@ -182,7 +192,6 @@ fn draw_hand_gizmo(
         }
         Hand::Right => {
             //get right controller
-            let right_controller = controller.grip_space(Hand::Right);
             let right_color = Color::YELLOW_GREEN;
             let off_color = Color::BLUE;
             let touch_color = Color::GREEN;
@@ -191,16 +200,14 @@ fn draw_hand_gizmo(
             let grip_quat_offset = Quat::from_rotation_x(-1.4);
             let face_quat_offset = Quat::from_rotation_x(1.05);
 
-            let controller_vec3 = tracking_root
-                .rotation
-                .mul_vec3(right_controller.0.pose.position.to_vec3())
-                + tracking_root.translation;
-            let controller_quat = tracking_root
-                .rotation
-                .mul_quat(right_controller.0.pose.orientation.to_quat());
+            let trans = hand_transform.compute_transform();
+            let controller_vec3 = trans.translation;
+            let controller_quat = trans.rotation;
             let face_quat = controller_quat.mul_quat(face_quat_offset);
             let face_quat_normal = face_quat.mul_vec3(Vec3::Z);
 
+            let squeeze = controller.squeeze(Hand::Right);
+            //info!("{:?}", squeeze);
             //grip
             gizmos.rect(
                 controller_vec3,
diff --git a/src/xr_input/mod.rs b/src/xr_input/mod.rs
index d7cf8a64..3ca062e0 100644
--- a/src/xr_input/mod.rs
+++ b/src/xr_input/mod.rs
@@ -1,6 +1,7 @@
 pub mod controllers;
 pub mod debug_gizmos;
 pub mod oculus_touch;
+pub mod trackers;
 pub mod xr_camera;
 
 use crate::resources::XrSession;
@@ -10,12 +11,16 @@ use crate::xr_input::oculus_touch::{setup_oculus_controller, ActionSets};
 use crate::xr_input::xr_camera::{xr_camera_head_sync, Eye, XRProjection, XrCameraBundle};
 use bevy::app::{App, PostUpdate, Startup};
 use bevy::log::warn;
-use bevy::prelude::{default, Commands, Component, Plugin, PreUpdate, Quat, Res, Vec3};
+use bevy::prelude::{
+    default, Commands, Component, Plugin, PreUpdate, Quat, Res, SpatialBundle, Vec3,
+};
 use bevy::prelude::{BuildChildren, IntoSystemConfigs};
 use bevy::render::camera::CameraProjectionPlugin;
 use bevy::render::view::{update_frusta, VisibilitySystems};
 use bevy::transform::{TransformBundle, TransformSystem};
 
+use self::trackers::{OpenXRLeftEye, OpenXRRightEye, OpenXRTrackingRoot};
+
 #[derive(Copy, Clone)]
 pub struct OpenXrInput {
     pub controller_type: XrControllerType,
@@ -26,9 +31,6 @@ pub enum Hand {
     Right,
 }
 
-#[derive(Component)]
-pub struct TrackingRoot;
-
 impl OpenXrInput {
     pub fn new(controller_type: XrControllerType) -> Self {
         Self { controller_type }
@@ -58,9 +60,15 @@ impl Plugin for OpenXrInput {
 fn setup_xr_cameras(mut commands: Commands) {
     //this needs to do the whole xr tracking volume not just cameras
     //get the root?
-    let tracking_root = commands.spawn((TransformBundle { ..default() }, TrackingRoot)).id();
-    let right = commands.spawn(XrCameraBundle::new(Eye::Right)).id();
-    let left = commands.spawn(XrCameraBundle::new(Eye::Left)).id();
+    let tracking_root = commands
+        .spawn((SpatialBundle::default(), OpenXRTrackingRoot))
+        .id();
+    let right = commands
+        .spawn((XrCameraBundle::new(Eye::Right), OpenXRRightEye))
+        .id();
+    let left = commands
+        .spawn((XrCameraBundle::new(Eye::Left), OpenXRLeftEye))
+        .id();
     commands.entity(tracking_root).push_children(&[right, left]);
 }
 
diff --git a/src/xr_input/trackers.rs b/src/xr_input/trackers.rs
new file mode 100644
index 00000000..781ffa01
--- /dev/null
+++ b/src/xr_input/trackers.rs
@@ -0,0 +1,18 @@
+use bevy::prelude::Component;
+
+#[derive(Component)]
+pub struct OpenXRTrackingRoot;
+#[derive(Component)]
+pub struct OpenXRTracker;
+#[derive(Component)]
+pub struct OpenXRLeftEye;
+#[derive(Component)]
+pub struct OpenXRRightEye;
+#[derive(Component)]
+pub struct OpenXRHMD;
+#[derive(Component)]
+pub struct OpenXRLeftController;
+#[derive(Component)]
+pub struct OpenXRRightController;
+#[derive(Component)]
+pub struct OpenXRController;
diff --git a/src/xr_input/xr_camera.rs b/src/xr_input/xr_camera.rs
index 8c04eb9c..50edeaa5 100644
--- a/src/xr_input/xr_camera.rs
+++ b/src/xr_input/xr_camera.rs
@@ -223,6 +223,7 @@ pub fn xr_camera_head_sync(
     mut query: Query<(&mut Transform, &XrCameraType, &mut XRProjection)>,
 ) {
     let mut f = || -> Option<()> {
+        //TODO calculate HMD position
         for (mut transform, camera_type, mut xr_projection) in query.iter_mut() {
             let view_idx = match camera_type {
                 XrCameraType::Xr(eye) => *eye as usize,

From 85dc35ab531e7c3129b8398e4709a6c643a1af24 Mon Sep 17 00:00:00 2001
From: Jay Christy <fortehlose@gmail.com>
Date: Sun, 24 Sep 2023 15:25:50 -0400
Subject: [PATCH 08/10] made proto_locomotion used a config resource

---
 examples/xr.rs                       | 211 +++------------------------
 src/xr_input/mod.rs                  |   1 +
 src/xr_input/prototype_locomotion.rs | 188 ++++++++++++++++++++++++
 src/xr_input/trackers.rs             |  20 ++-
 4 files changed, 229 insertions(+), 191 deletions(-)
 create mode 100644 src/xr_input/prototype_locomotion.rs

diff --git a/examples/xr.rs b/examples/xr.rs
index 8b52c8db..1514de8f 100644
--- a/examples/xr.rs
+++ b/examples/xr.rs
@@ -9,9 +9,10 @@ use bevy_openxr::input::XrInput;
 use bevy_openxr::resources::{XrFrameState, XrInstance, XrSession, XrViews};
 use bevy_openxr::xr_input::debug_gizmos::OpenXrDebugRenderer;
 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,
-    OpenXRTrackingRoot,
+    OpenXRTrackingRoot, adopt_open_xr_trackers,
 };
 use bevy_openxr::xr_input::{Hand, QuatConv, Vec3Conv};
 use bevy_openxr::DefaultXrPlugins;
@@ -27,9 +28,10 @@ fn main() {
         .add_plugins(FrameTimeDiagnosticsPlugin)
         .add_systems(Startup, setup)
         .add_systems(Update, proto_locomotion)
-        .add_systems(Startup, spawn_controllers)
-        .add_systems(Update, update_hands)
+        .add_systems(Startup, spawn_controllers_example)
+        .add_systems(Update, update_open_xr_controllers)
         .add_systems(Update, adopt_open_xr_trackers)
+        .insert_resource(PrototypeLocomotionConfig::default())
         .run();
 }
 
@@ -74,61 +76,38 @@ fn setup(
         transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
         ..default()
     },));
-
-    commands.insert_resource(RotationTimer {
-        timer: Timer::from_seconds(1.0, TimerMode::Once),
-    })
-}
-
-pub enum LocomotionType {
-    Head,
-    Hand,
-}
-
-pub enum RotationType {
-    Smooth,
-    Snap,
-}
-
-#[derive(Resource)]
-struct RotationTimer {
-    timer: Timer,
 }
 
-fn spawn_controllers(
-    mut commands: Commands,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
-) {
+fn spawn_controllers_example(mut commands: Commands) {
     //left hand
     commands.spawn((
         OpenXRLeftController,
         OpenXRController,
         OpenXRTracker,
-        // SpatialBundle::default(),
-        PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
-            material: materials.add(Color::RED.into()),
-            transform: Transform::from_xyz(0.0, 0.5, 1.0),
-            ..default()
-        },
+        SpatialBundle::default(),
+        // PbrBundle {
+        //     mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
+        //     material: materials.add(Color::RED.into()),
+        //     transform: Transform::from_xyz(0.0, 0.5, 1.0),
+        //     ..default()
+        // },
     ));
     //right hand
     commands.spawn((
         OpenXRRightController,
         OpenXRController,
         OpenXRTracker,
-        // SpatialBundle::default(),
-        PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
-            material: materials.add(Color::BLUE.into()),
-            transform: Transform::from_xyz(0.0, 0.5, 1.0),
-            ..default()
-        },
+        SpatialBundle::default(),
+        // PbrBundle {
+        //     mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
+        //     material: materials.add(Color::BLUE.into()),
+        //     transform: Transform::from_xyz(0.0, 0.5, 1.0),
+        //     ..default()
+        // },
     ));
 }
 
-fn update_hands(
+fn update_open_xr_controllers(
     oculus_controller: Res<OculusController>,
     mut left_controller_query: Query<(
         &mut Transform,
@@ -174,152 +153,4 @@ fn update_hands(
         right.0.pose.orientation.to_quat();
 }
 
-fn adopt_open_xr_trackers(
-    query: Query<(Entity), Added<OpenXRTracker>>,
-    mut commands: Commands,
-    tracking_root_query: Query<(Entity, With<OpenXRTrackingRoot>)>,
-) {
-    let root = tracking_root_query.get_single();
-    match root {
-        Ok(thing) => {
-            // info!("root is");
-            for tracker in query.iter() {
-                info!("we got a new tracker");
-                commands.entity(thing.0).add_child(tracker);
-            }
-        }
-        Err(_) => info!("root isnt spawned yet?"),
-    }
-}
-
-fn proto_locomotion(
-    time: Res<Time>,
-    mut tracking_root_query: Query<(&mut Transform, With<OpenXRTrackingRoot>)>,
-    oculus_controller: Res<OculusController>,
-    frame_state: Res<XrFrameState>,
-    xr_input: Res<XrInput>,
-    instance: Res<XrInstance>,
-    session: Res<XrSession>,
-    views: ResMut<XrViews>,
-    mut gizmos: Gizmos,
-    mut rotation_timer: Option<ResMut<RotationTimer>>,
-) {
-    //lock frame
-    let frame_state = *frame_state.lock().unwrap();
-    //get controller
-    let controller = oculus_controller.get_ref(&instance, &session, &frame_state, &xr_input);
-    let root = tracking_root_query.get_single_mut();
-    match root {
-        Ok(mut position) => {
-            //get the stick input and do some maths
-            let stick = controller.thumbstick(Hand::Left);
-            let input = Vec3::new(stick.x, 0.0, -stick.y);
-            let speed = 1.0;
-            //now the question is how do we do hmd based locomotion
-            //or controller based for that matter
-            let locomotion_type = LocomotionType::Head;
-            let mut reference_quat = Quat::IDENTITY;
-            match locomotion_type {
-                LocomotionType::Head => {
-                    let v = views.lock().unwrap();
-                    let views = v.get(0);
-                    match views {
-                        Some(view) => {
-                            reference_quat = view
-                                .pose
-                                .orientation
-                                .to_quat()
-                                .mul_quat(position.0.rotation);
-                        }
-                        None => return,
-                    }
-                }
-                LocomotionType::Hand => {
-                    let grip = controller.grip_space(Hand::Left);
-                    reference_quat = grip
-                        .0
-                        .pose
-                        .orientation
-                        .to_quat()
-                        .mul_quat(position.0.rotation); //TODO add root tracking quat to this so we simulate the global rotation
-                }
-            }
-            let mut locomotion_vec = reference_quat.mul_vec3(input);
-            locomotion_vec.y = 0.0;
-            position.0.translation += locomotion_vec * speed * time.delta_seconds();
 
-            //now time for rotation
-            let snap_angle = 45.0 * (PI / 180.0);
-            let smooth_rotation_speed = 0.5 * PI;
-            let rotation_setting = RotationType::Snap;
-            match rotation_setting {
-                RotationType::Smooth => {
-                    //once again with the math
-                    let control_stick = controller.thumbstick(Hand::Right);
-                    let rot_input = control_stick.x; //why is this negative i dont know
-                    if rot_input.abs() <= 0.2 {
-                        return;
-                    }
-                    let smoth_rot = Quat::from_rotation_y(
-                        rot_input * smooth_rotation_speed * time.delta_seconds(),
-                    );
-                    //apply rotation
-                    let v = views.lock().unwrap();
-                    let views = v.get(0);
-                    match views {
-                        Some(view) => {
-                            let mut hmd_translation = view.pose.position.to_vec3();
-                            hmd_translation.y = 0.0;
-                            let local = position.0.translation;
-                            let global = position.0.rotation.mul_vec3(hmd_translation) + local;
-                            gizmos.circle(global, Vec3::Y, 0.1, Color::GREEN);
-                            position.0.rotate_around(global, smoth_rot);
-                        }
-                        None => return,
-                    }
-                }
-                RotationType::Snap => {
-                    //get timer
-                    match rotation_timer {
-                        Some(mut timer) => {
-                            //tick the timer
-                            timer.timer.tick(time.delta());
-                            if timer.timer.finished() {
-                                //now we can snap turn?
-                                //once again with the math
-                                let control_stick = controller.thumbstick(Hand::Right);
-                                let rot_input = -control_stick.x;
-                                if rot_input.abs() <= 0.5 {
-                                    return;
-                                }
-                                let dir: f32 = match rot_input > 0.0 {
-                                    true => 1.0,
-                                    false => -1.0,
-                                };
-                                let smoth_rot = Quat::from_rotation_y(snap_angle * dir);
-                                //apply rotation
-                                let v = views.lock().unwrap();
-                                let views = v.get(0);
-                                match views {
-                                    Some(view) => {
-                                        let mut hmd_translation = view.pose.position.to_vec3();
-                                        hmd_translation.y = 0.0;
-                                        let local = position.0.translation;
-                                        let global =
-                                            position.0.rotation.mul_vec3(hmd_translation) + local;
-                                        gizmos.circle(global, Vec3::Y, 0.1, Color::GREEN);
-                                        position.0.rotate_around(global, smoth_rot);
-                                    }
-                                    None => return,
-                                }
-                                timer.timer.reset();
-                            }
-                        }
-                        None => info!("didnt init the rotation timer"),
-                    }
-                }
-            }
-        }
-        Err(_) => info!("too many tracking roots"),
-    }
-}
diff --git a/src/xr_input/mod.rs b/src/xr_input/mod.rs
index 3ca062e0..e853ab38 100644
--- a/src/xr_input/mod.rs
+++ b/src/xr_input/mod.rs
@@ -2,6 +2,7 @@ pub mod controllers;
 pub mod debug_gizmos;
 pub mod oculus_touch;
 pub mod trackers;
+pub mod prototype_locomotion;
 pub mod xr_camera;
 
 use crate::resources::XrSession;
diff --git a/src/xr_input/prototype_locomotion.rs b/src/xr_input/prototype_locomotion.rs
new file mode 100644
index 00000000..615f9fd5
--- /dev/null
+++ b/src/xr_input/prototype_locomotion.rs
@@ -0,0 +1,188 @@
+use std::f32::consts::PI;
+
+use bevy::{
+    prelude::*,
+    time::{Time, Timer, TimerMode},
+};
+
+use crate::{
+    input::XrInput,
+    resources::{XrFrameState, XrInstance, XrSession, XrViews},
+};
+
+use super::{
+    oculus_touch::OculusController, trackers::OpenXRTrackingRoot, Hand, QuatConv, Vec3Conv,
+};
+
+pub enum LocomotionType {
+    Head,
+    Hand,
+}
+
+pub enum RotationType {
+    Smooth,
+    Snap,
+}
+
+#[derive(Resource)]
+pub struct RotationTimer {
+    pub timer: Timer,
+}
+
+#[derive(Resource)]
+pub struct PrototypeLocomotionConfig {
+    pub locomotion_type: LocomotionType,
+    pub locomotion_speed: f32,
+    pub rotation_type: RotationType,
+    pub snap_angle: f32,
+    pub smooth_rotation_speed: f32,
+    pub rotation_stick_deadzone: f32,
+    pub rotation_timer: RotationTimer,
+}
+
+impl Default for PrototypeLocomotionConfig {
+    fn default() -> Self {
+        Self {
+            locomotion_type: LocomotionType::Hand,
+            locomotion_speed: 1.0,
+            rotation_type: RotationType::Smooth,
+            snap_angle: 45.0 * (PI / 180.0),
+            smooth_rotation_speed: 0.5 * PI,
+            rotation_stick_deadzone: 0.2,
+            rotation_timer: RotationTimer {
+                timer: Timer::from_seconds(1.0, TimerMode::Once),
+            },
+        }
+    }
+}
+
+pub fn proto_locomotion(
+    time: Res<Time>,
+    mut tracking_root_query: Query<(&mut Transform, With<OpenXRTrackingRoot>)>,
+    oculus_controller: Res<OculusController>,
+    frame_state: Res<XrFrameState>,
+    xr_input: Res<XrInput>,
+    instance: Res<XrInstance>,
+    session: Res<XrSession>,
+    views: ResMut<XrViews>,
+    mut gizmos: Gizmos,
+    config_option: Option<ResMut<PrototypeLocomotionConfig>>,
+) {
+    match config_option {
+        Some(_) => (),
+        None => {
+            info!("no locomotion config");
+            return;
+        }
+    }
+    //i hate this but im too tired to think
+    let mut config = config_option.unwrap();
+    //lock frame
+    let frame_state = *frame_state.lock().unwrap();
+    //get controller
+    let controller = oculus_controller.get_ref(&instance, &session, &frame_state, &xr_input);
+    let root = tracking_root_query.get_single_mut();
+    match root {
+        Ok(mut position) => {
+            //get the stick input and do some maths
+            let stick = controller.thumbstick(Hand::Left);
+            let input = Vec3::new(stick.x, 0.0, -stick.y);
+
+            let mut reference_quat = Quat::IDENTITY;
+            match config.locomotion_type {
+                LocomotionType::Head => {
+                    let v = views.lock().unwrap();
+                    let views = v.get(0);
+                    match views {
+                        Some(view) => {
+                            reference_quat = view
+                                .pose
+                                .orientation
+                                .to_quat()
+                                .mul_quat(position.0.rotation);
+                        }
+                        None => return,
+                    }
+                }
+                LocomotionType::Hand => {
+                    let grip = controller.grip_space(Hand::Left);
+                    reference_quat = grip
+                        .0
+                        .pose
+                        .orientation
+                        .to_quat()
+                        .mul_quat(position.0.rotation);
+                }
+            }
+            //TODO: do this correctly as just removing the y from the resultant vec3 isnt correct, but works well enough for now
+            let mut locomotion_vec = reference_quat.mul_vec3(input);
+            locomotion_vec.y = 0.0;
+            position.0.translation +=
+                locomotion_vec * config.locomotion_speed * time.delta_seconds();
+
+            //now time for rotation
+
+            match config.rotation_type {
+                RotationType::Smooth => {
+                    //once again with the math
+                    let control_stick = controller.thumbstick(Hand::Right);
+                    let rot_input = -control_stick.x; //why is this negative i dont know
+                    if rot_input.abs() <= config.rotation_stick_deadzone {
+                        return;
+                    }
+                    let smoth_rot = Quat::from_rotation_y(
+                        rot_input * config.smooth_rotation_speed * time.delta_seconds(),
+                    );
+                    //apply rotation
+                    let v = views.lock().unwrap();
+                    let views = v.get(0);
+                    match views {
+                        Some(view) => {
+                            let mut hmd_translation = view.pose.position.to_vec3();
+                            hmd_translation.y = 0.0;
+                            let local = position.0.translation;
+                            let global = position.0.rotation.mul_vec3(hmd_translation) + local;
+                            gizmos.circle(global, Vec3::Y, 0.1, Color::GREEN);
+                            position.0.rotate_around(global, smoth_rot);
+                        }
+                        None => return,
+                    }
+                }
+                RotationType::Snap => {
+                    //tick the timer
+                    config.rotation_timer.timer.tick(time.delta());
+                    if config.rotation_timer.timer.finished() {
+                        //now we can snap turn?
+                        //once again with the math
+                        let control_stick = controller.thumbstick(Hand::Right);
+                        let rot_input = -control_stick.x;
+                        if rot_input.abs() <= config.rotation_stick_deadzone {
+                            return;
+                        }
+                        let dir: f32 = match rot_input > 0.0 {
+                            true => 1.0,
+                            false => -1.0,
+                        };
+                        let smoth_rot = Quat::from_rotation_y(config.snap_angle * dir);
+                        //apply rotation
+                        let v = views.lock().unwrap();
+                        let views = v.get(0);
+                        match views {
+                            Some(view) => {
+                                let mut hmd_translation = view.pose.position.to_vec3();
+                                hmd_translation.y = 0.0;
+                                let local = position.0.translation;
+                                let global = position.0.rotation.mul_vec3(hmd_translation) + local;
+                                gizmos.circle(global, Vec3::Y, 0.1, Color::GREEN);
+                                position.0.rotate_around(global, smoth_rot);
+                            }
+                            None => return,
+                        }
+                        config.rotation_timer.timer.reset();
+                    }
+                }
+            }
+        }
+        Err(_) => info!("too many tracking roots"),
+    }
+}
diff --git a/src/xr_input/trackers.rs b/src/xr_input/trackers.rs
index 781ffa01..6d442487 100644
--- a/src/xr_input/trackers.rs
+++ b/src/xr_input/trackers.rs
@@ -1,4 +1,4 @@
-use bevy::prelude::Component;
+use bevy::prelude::{info, Added, BuildChildren, Commands, Component, Entity, Query, With};
 
 #[derive(Component)]
 pub struct OpenXRTrackingRoot;
@@ -16,3 +16,21 @@ pub struct OpenXRLeftController;
 pub struct OpenXRRightController;
 #[derive(Component)]
 pub struct OpenXRController;
+
+pub fn adopt_open_xr_trackers(
+    query: Query<(Entity), Added<OpenXRTracker>>,
+    mut commands: Commands,
+    tracking_root_query: Query<(Entity, With<OpenXRTrackingRoot>)>,
+) {
+    let root = tracking_root_query.get_single();
+    match root {
+        Ok(thing) => {
+            // info!("root is");
+            for tracker in query.iter() {
+                info!("we got a new tracker");
+                commands.entity(thing.0).add_child(tracker);
+            }
+        }
+        Err(_) => info!("root isnt spawned yet?"),
+    }
+}

From 012a778c3520e5a2992e96fb9f17e1e3e2df3a46 Mon Sep 17 00:00:00 2001
From: Jay Christy <fortehlose@gmail.com>
Date: Sun, 24 Sep 2023 15:30:58 -0400
Subject: [PATCH 09/10] moved more stuff around

---
 examples/xr.rs           | 66 ++--------------------------------------
 src/xr_input/mod.rs      | 13 ++++++--
 src/xr_input/trackers.rs | 53 +++++++++++++++++++++++++++++++-
 3 files changed, 64 insertions(+), 68 deletions(-)

diff --git a/examples/xr.rs b/examples/xr.rs
index 1514de8f..344b8b24 100644
--- a/examples/xr.rs
+++ b/examples/xr.rs
@@ -11,8 +11,8 @@ use bevy_openxr::xr_input::debug_gizmos::OpenXrDebugRenderer;
 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,
-    OpenXRTrackingRoot, adopt_open_xr_trackers,
+    adopt_open_xr_trackers, OpenXRController, OpenXRLeftController, OpenXRRightController,
+    OpenXRTracker, OpenXRTrackingRoot,
 };
 use bevy_openxr::xr_input::{Hand, QuatConv, Vec3Conv};
 use bevy_openxr::DefaultXrPlugins;
@@ -29,8 +29,6 @@ fn main() {
         .add_systems(Startup, setup)
         .add_systems(Update, proto_locomotion)
         .add_systems(Startup, spawn_controllers_example)
-        .add_systems(Update, update_open_xr_controllers)
-        .add_systems(Update, adopt_open_xr_trackers)
         .insert_resource(PrototypeLocomotionConfig::default())
         .run();
 }
@@ -85,12 +83,6 @@ fn spawn_controllers_example(mut commands: Commands) {
         OpenXRController,
         OpenXRTracker,
         SpatialBundle::default(),
-        // PbrBundle {
-        //     mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
-        //     material: materials.add(Color::RED.into()),
-        //     transform: Transform::from_xyz(0.0, 0.5, 1.0),
-        //     ..default()
-        // },
     ));
     //right hand
     commands.spawn((
@@ -98,59 +90,5 @@ fn spawn_controllers_example(mut commands: Commands) {
         OpenXRController,
         OpenXRTracker,
         SpatialBundle::default(),
-        // PbrBundle {
-        //     mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
-        //     material: materials.add(Color::BLUE.into()),
-        //     transform: Transform::from_xyz(0.0, 0.5, 1.0),
-        //     ..default()
-        // },
     ));
 }
-
-fn update_open_xr_controllers(
-    oculus_controller: Res<OculusController>,
-    mut left_controller_query: Query<(
-        &mut Transform,
-        With<OpenXRLeftController>,
-        Without<OpenXRRightController>,
-    )>,
-    mut right_controller_query: Query<(
-        &mut Transform,
-        With<OpenXRRightController>,
-        Without<OpenXRLeftController>,
-    )>,
-    frame_state: Res<XrFrameState>,
-    instance: Res<XrInstance>,
-    xr_input: Res<XrInput>,
-    session: Res<XrSession>,
-) {
-    //lock dat frame?
-    let frame_state = *frame_state.lock().unwrap();
-    //get controller
-    let controller = oculus_controller.get_ref(&instance, &session, &frame_state, &xr_input);
-    //get left controller
-    let left = controller.grip_space(Hand::Left);
-    let left_postion = left.0.pose.position.to_vec3();
-
-    left_controller_query
-        .get_single_mut()
-        .unwrap()
-        .0
-        .translation = left_postion;
-
-    left_controller_query.get_single_mut().unwrap().0.rotation = left.0.pose.orientation.to_quat();
-    //get right controller
-    let right = controller.grip_space(Hand::Right);
-    let right_postion = right.0.pose.position.to_vec3();
-
-    right_controller_query
-        .get_single_mut()
-        .unwrap()
-        .0
-        .translation = right_postion;
-
-    right_controller_query.get_single_mut().unwrap().0.rotation =
-        right.0.pose.orientation.to_quat();
-}
-
-
diff --git a/src/xr_input/mod.rs b/src/xr_input/mod.rs
index e853ab38..05a04636 100644
--- a/src/xr_input/mod.rs
+++ b/src/xr_input/mod.rs
@@ -1,8 +1,8 @@
 pub mod controllers;
 pub mod debug_gizmos;
 pub mod oculus_touch;
-pub mod trackers;
 pub mod prototype_locomotion;
+pub mod trackers;
 pub mod xr_camera;
 
 use crate::resources::XrSession;
@@ -13,14 +13,17 @@ use crate::xr_input::xr_camera::{xr_camera_head_sync, Eye, XRProjection, XrCamer
 use bevy::app::{App, PostUpdate, Startup};
 use bevy::log::warn;
 use bevy::prelude::{
-    default, Commands, Component, Plugin, PreUpdate, Quat, Res, SpatialBundle, Vec3,
+    default, Commands, Component, Plugin, PreUpdate, Quat, Res, SpatialBundle, Update, Vec3,
 };
 use bevy::prelude::{BuildChildren, IntoSystemConfigs};
 use bevy::render::camera::CameraProjectionPlugin;
 use bevy::render::view::{update_frusta, VisibilitySystems};
 use bevy::transform::{TransformBundle, TransformSystem};
 
-use self::trackers::{OpenXRLeftEye, OpenXRRightEye, OpenXRTrackingRoot};
+use self::trackers::{
+    adopt_open_xr_trackers, update_open_xr_controllers, OpenXRLeftEye, OpenXRRightEye,
+    OpenXRTrackingRoot,
+};
 
 #[derive(Copy, Clone)]
 pub struct OpenXrInput {
@@ -46,8 +49,12 @@ impl Plugin for OpenXrInput {
                 app.add_systems(Startup, setup_oculus_controller);
             }
         }
+        //adopt any new trackers
+        app.add_systems(PreUpdate, adopt_open_xr_trackers);
         app.add_systems(PreUpdate, action_set_system);
         app.add_systems(PreUpdate, xr_camera_head_sync.after(xr_begin_frame));
+        //update controller trackers
+        app.add_systems(Update, update_open_xr_controllers);
         app.add_systems(
             PostUpdate,
             update_frusta::<XRProjection>
diff --git a/src/xr_input/trackers.rs b/src/xr_input/trackers.rs
index 6d442487..5da4541c 100644
--- a/src/xr_input/trackers.rs
+++ b/src/xr_input/trackers.rs
@@ -1,4 +1,8 @@
-use bevy::prelude::{info, Added, BuildChildren, Commands, Component, Entity, Query, With};
+use bevy::prelude::{info, Added, BuildChildren, Commands, Component, Entity, Query, With, Res, Transform, Without};
+
+use crate::{resources::{XrFrameState, XrInstance, XrSession}, input::XrInput};
+
+use super::{oculus_touch::OculusController, Hand, Vec3Conv, QuatConv};
 
 #[derive(Component)]
 pub struct OpenXRTrackingRoot;
@@ -34,3 +38,50 @@ pub fn adopt_open_xr_trackers(
         Err(_) => info!("root isnt spawned yet?"),
     }
 }
+
+pub fn update_open_xr_controllers(
+    oculus_controller: Res<OculusController>,
+    mut left_controller_query: Query<(
+        &mut Transform,
+        With<OpenXRLeftController>,
+        Without<OpenXRRightController>,
+    )>,
+    mut right_controller_query: Query<(
+        &mut Transform,
+        With<OpenXRRightController>,
+        Without<OpenXRLeftController>,
+    )>,
+    frame_state: Res<XrFrameState>,
+    instance: Res<XrInstance>,
+    xr_input: Res<XrInput>,
+    session: Res<XrSession>,
+) {
+    //lock dat frame?
+    let frame_state = *frame_state.lock().unwrap();
+    //get controller
+    let controller = oculus_controller.get_ref(&instance, &session, &frame_state, &xr_input);
+    //get left controller
+    let left = controller.grip_space(Hand::Left);
+    let left_postion = left.0.pose.position.to_vec3();
+
+    left_controller_query
+        .get_single_mut()
+        .unwrap()
+        .0
+        .translation = left_postion;
+
+    left_controller_query.get_single_mut().unwrap().0.rotation = left.0.pose.orientation.to_quat();
+    //get right controller
+    let right = controller.grip_space(Hand::Right);
+    let right_postion = right.0.pose.position.to_vec3();
+
+    right_controller_query
+        .get_single_mut()
+        .unwrap()
+        .0
+        .translation = right_postion;
+
+    right_controller_query.get_single_mut().unwrap().0.rotation =
+        right.0.pose.orientation.to_quat();
+}
+

From 6d5c1fa00f39aaf5ae68acde41430c41d514f3e0 Mon Sep 17 00:00:00 2001
From: Jay Christy <fortehlose@gmail.com>
Date: Sun, 24 Sep 2023 15:33:40 -0400
Subject: [PATCH 10/10] lite cleaning

---
 examples/xr.rs               | 11 +----------
 src/xr_input/debug_gizmos.rs |  2 +-
 src/xr_input/mod.rs          |  6 ++----
 src/xr_input/trackers.rs     |  2 +-
 4 files changed, 5 insertions(+), 16 deletions(-)

diff --git a/examples/xr.rs b/examples/xr.rs
index 344b8b24..548fe152 100644
--- a/examples/xr.rs
+++ b/examples/xr.rs
@@ -1,20 +1,11 @@
-use std::f32::consts::PI;
-use std::time::Duration;
-
 use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
-use bevy::prelude::Gizmos;
 use bevy::prelude::*;
 use bevy::transform::components::Transform;
-use bevy_openxr::input::XrInput;
-use bevy_openxr::resources::{XrFrameState, XrInstance, XrSession, XrViews};
 use bevy_openxr::xr_input::debug_gizmos::OpenXrDebugRenderer;
-use bevy_openxr::xr_input::oculus_touch::OculusController;
 use bevy_openxr::xr_input::prototype_locomotion::{proto_locomotion, PrototypeLocomotionConfig};
 use bevy_openxr::xr_input::trackers::{
-    adopt_open_xr_trackers, OpenXRController, OpenXRLeftController, OpenXRRightController,
-    OpenXRTracker, OpenXRTrackingRoot,
+    OpenXRController, OpenXRLeftController, OpenXRRightController, OpenXRTracker,
 };
-use bevy_openxr::xr_input::{Hand, QuatConv, Vec3Conv};
 use bevy_openxr::DefaultXrPlugins;
 
 fn main() {
diff --git a/src/xr_input/debug_gizmos.rs b/src/xr_input/debug_gizmos.rs
index 5724bc67..5d7432e8 100644
--- a/src/xr_input/debug_gizmos.rs
+++ b/src/xr_input/debug_gizmos.rs
@@ -10,7 +10,7 @@ use crate::{
 
 use crate::xr_input::{
     oculus_touch::{OculusController, OculusControllerRef},
-    Hand, QuatConv, Vec3Conv,
+    Hand,
 };
 
 use super::trackers::{OpenXRLeftController, OpenXRRightController, OpenXRTrackingRoot};
diff --git a/src/xr_input/mod.rs b/src/xr_input/mod.rs
index 05a04636..55e7c562 100644
--- a/src/xr_input/mod.rs
+++ b/src/xr_input/mod.rs
@@ -12,13 +12,11 @@ use crate::xr_input::oculus_touch::{setup_oculus_controller, ActionSets};
 use crate::xr_input::xr_camera::{xr_camera_head_sync, Eye, XRProjection, XrCameraBundle};
 use bevy::app::{App, PostUpdate, Startup};
 use bevy::log::warn;
-use bevy::prelude::{
-    default, Commands, Component, Plugin, PreUpdate, Quat, Res, SpatialBundle, Update, Vec3,
-};
 use bevy::prelude::{BuildChildren, IntoSystemConfigs};
+use bevy::prelude::{Commands, Plugin, PreUpdate, Quat, Res, SpatialBundle, Update, Vec3};
 use bevy::render::camera::CameraProjectionPlugin;
 use bevy::render::view::{update_frusta, VisibilitySystems};
-use bevy::transform::{TransformBundle, TransformSystem};
+use bevy::transform::TransformSystem;
 
 use self::trackers::{
     adopt_open_xr_trackers, update_open_xr_controllers, OpenXRLeftEye, OpenXRRightEye,
diff --git a/src/xr_input/trackers.rs b/src/xr_input/trackers.rs
index 5da4541c..f33e6ee5 100644
--- a/src/xr_input/trackers.rs
+++ b/src/xr_input/trackers.rs
@@ -1,4 +1,4 @@
-use bevy::prelude::{info, Added, BuildChildren, Commands, Component, Entity, Query, With, Res, Transform, Without};
+use bevy::prelude::{Added, BuildChildren, Commands, Entity, Query, With, Res, Transform, Without, Component, info};
 
 use crate::{resources::{XrFrameState, XrInstance, XrSession}, input::XrInput};