vr locomotion and camera using vr view

Cargo.lock

···
 ]
 
 [[package]]
+name = "bevy_xr_utils"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f82cd353262258aae6048ccad3544b8a978a301d9eb954d66efef6dccc91dfa9"
+dependencies = [
+ "bevy_app",
+ "bevy_color",
+ "bevy_derive",
+ "bevy_ecs",
+ "bevy_gizmos",
+ "bevy_log",
+ "bevy_math",
+ "bevy_mod_openxr",
+ "bevy_mod_xr",
+ "bevy_transform",
+ "openxr",
+ "openxr_mndx_xdev_space",
+]
+
+[[package]]
 name = "bindgen"
 version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "bevy",
  "bevy_mod_openxr",
  "bevy_mod_xr",
+ "bevy_xr_utils",
  "cpal 0.16.0",
  "dotenvy",
  "felix-assets",
···
  "cmake",
  "libc",
  "mint",
+]
+
+[[package]]
+name = "openxr_mndx_xdev_space"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc03c3948dceb287224eaa9079a5d4f690e91b43a2385da6c686edf0f850408a"
+dependencies = [
+ "openxr",
 ]
 
 [[package]]

assets/src/felix/mod.rs

···
 pub fn load( path: &'static str ) -> anyhow::Result<Vec<BevyObject>>{
   // TODO: Material loading
   // TODO: UV Loading
+  // TODO: Flat normals
+  // TODO: Live updates directly from blender?
 
   let mut objs = vec![];
 

client/Cargo.toml

···
 bevy_mod_openxr = "0.4.0"
 openxr = "0.19.0"
 bevy_mod_xr = "0.4.0"
+bevy_xr_utils = "0.4.0"

client/src/components/debug_camera.rs

···
 use std::f32::consts::PI;
 
 use bevy::{ input::mouse::MouseMotion, prelude::* };
-use bevy_mod_xr::session::XrState;
+use bevy_mod_openxr::{helper_traits::ToQuat, resources::OxrViews};
+use bevy_mod_xr::session::{XrState, XrTrackingRoot};
 use felix_audio::voice::microphone::VoiceChatMicrophone;
 
 use crate::net::connection::Connection;
···
   }
 }
 
+pub fn vr_locomotion( // TODO: Move locomotion to controllers instead of keyboard
+  views: ResMut<OxrViews>,
+  mut position_query: Query<&mut Transform, With<XrTrackingRoot>>,
+  keys: Res<ButtonInput<KeyCode>>,
+  xr_state: Res<XrState>,
+  time: Res<Time>
+){
+  if *xr_state == XrState::Running{
+    let mut delta_time = time.delta_secs();
+    if keys.pressed(KeyCode::ShiftLeft){ delta_time *= 2.0; }
+
+    let mut transform = position_query.single_mut().unwrap();
+    let view = views.first().unwrap();
+
+    let cam = view.pose.orientation.to_quat();
+
+    if keys.pressed(KeyCode::KeyW){
+      let mut dir = cam * -Vec3::Z * delta_time;
+      dir.y = 0.0;
+
+      transform.translation += dir;
+    } else if keys.pressed(KeyCode::KeyS){
+      let mut dir = cam * Vec3::Z * delta_time;
+      dir.y = 0.0;
+
+      transform.translation += dir;
+    }
+
+    if keys.pressed(KeyCode::KeyA){
+      let mut dir = cam * -Vec3::X * delta_time;
+      dir.y = 0.0;
+
+      transform.translation += dir;
+    } else if keys.pressed(KeyCode::KeyD){
+      let mut dir = cam * Vec3::X * delta_time;
+      dir.y = 0.0;
+
+      transform.translation += dir;
+    }
+  }
+}
+
 pub fn update(
   mut query: Query<(&mut DebugCamera, &mut Transform)>,
-
   time: Res<Time>,
 
   keys: Res<ButtonInput<KeyCode>>,
···
   xr_state: Res<XrState>
 ){
   let net_manager = networking.single().unwrap();
+  let xr_state = xr_state.into_inner();
 
-  let mut delta_time = time.delta_secs();
-  if keys.pressed(KeyCode::ShiftLeft){ delta_time *= 2.0; }
+  let ( mut debug, mut transform ) = query.single_mut().unwrap();
 
-  let ( mut debug, mut transform ) = query.single_mut().unwrap();
+  if *xr_state != XrState::Running{
+    let mut delta_time = time.delta_secs();
+    if keys.pressed(KeyCode::ShiftLeft){ delta_time *= 2.0; }
 
-  for ev in mouse_motion.read(){
-    if mouse_buttons.pressed(MouseButton::Right){
-      debug.pitch -= ev.delta.y * delta_time * 0.1;
-      debug.yaw -= ev.delta.x * delta_time * 0.1;
+    for ev in mouse_motion.read(){
+      if mouse_buttons.pressed(MouseButton::Right){
+        debug.pitch -= ev.delta.y * delta_time * 0.1;
+        debug.yaw -= ev.delta.x * delta_time * 0.1;
+      }
     }
-  }
 
-  transform.rotation = Quat::from_euler(EulerRot::YXZ, debug.yaw, debug.pitch, 0.0);
+    transform.rotation = Quat::from_euler(EulerRot::YXZ, debug.yaw, debug.pitch, 0.0);
 
-  if keys.pressed(KeyCode::KeyW){
-    let dir = transform.forward();
-    transform.translation += dir * delta_time;
-  } else if keys.pressed(KeyCode::KeyS){
-    let dir = -transform.forward();
-    transform.translation += dir * delta_time;
-  }
+    if keys.pressed(KeyCode::KeyW){
+      let dir = transform.forward();
+      transform.translation += dir * delta_time;
+    } else if keys.pressed(KeyCode::KeyS){
+      let dir = -transform.forward();
+      transform.translation += dir * delta_time;
+    }
 
-  if keys.pressed(KeyCode::KeyA){
-    let dir = transform.left();
-    transform.translation += dir * delta_time;
-  } else if keys.pressed(KeyCode::KeyD){
-    let dir = -transform.left();
-    transform.translation += dir * delta_time;
-  }
+    if keys.pressed(KeyCode::KeyA){
+      let dir = transform.left();
+      transform.translation += dir * delta_time;
+    } else if keys.pressed(KeyCode::KeyD){
+      let dir = -transform.left();
+      transform.translation += dir * delta_time;
+    }
 
-  if keys.pressed(KeyCode::KeyE){
-    let dir = transform.up();
-    transform.translation += dir * delta_time;
-  } else if keys.pressed(KeyCode::KeyQ){
-    let dir = -transform.up();
-    transform.translation += dir * delta_time;
+    if keys.pressed(KeyCode::KeyE){
+      let dir = transform.up();
+      transform.translation += dir * delta_time;
+    } else if keys.pressed(KeyCode::KeyQ){
+      let dir = -transform.up();
+      transform.translation += dir * delta_time;
+    }
   }
 
   let mut remote_rms = "".to_owned();
···
     transform.rotation.z,
     transform.rotation.w,
 
-    xr_state.into_inner()
+    xr_state
   );
 }
 

client/src/main.rs

···
 
 use bevy::{app::{App, FixedUpdate, Startup, Update}, ecs::system::Commands, prelude::*, render::pipelined_rendering::PipelinedRenderingPlugin};
 use bevy_mod_openxr::{add_xr_plugins, resources::OxrSessionConfig};
-use bevy_mod_xr::session::{XrSessionCreated, XrSessionPlugin};
+use bevy_mod_xr::session::{XrSessionCreated, XrSessionPlugin, XrState};
+use bevy_xr_utils::tracking_utils::TrackingUtilitiesPlugin;
 use felix_audio::{FelixAudio, voice};
-use openxr::EnvironmentBlendMode;
 
 use crate::{components::{debug_camera, network_interface, remote_player}, setup::setup};
 
···
 
 fn main() {
   if let Err(err) = dotenvy::dotenv(){ println!("[WARN] .ENV failed loading {:#?}", err); }
+  let try_use_vr = env::var("DONT_USE_VR").is_err();
 
-  App::new()
-    .add_plugins((
+  let mut app = App::new();
+
+  if try_use_vr{
+    app.add_plugins((
       add_xr_plugins(
         DefaultPlugins
           .build()
           .disable::<PipelinedRenderingPlugin>(),
       ).set(XrSessionPlugin { auto_handle: true }),
-      FelixAudio
+      TrackingUtilitiesPlugin
     ))
     .insert_resource(OxrSessionConfig {
-      blend_mode_preference: vec![
-        EnvironmentBlendMode::ALPHA_BLEND,
-        EnvironmentBlendMode::ADDITIVE,
-        EnvironmentBlendMode::OPAQUE
-      ],
       ..Default::default()
     })
-    .add_systems(XrSessionCreated, || { println!("[INFO] Started VR") })
-    .add_systems(Startup, setup)
-    .add_systems(Startup, move | mut commands: Commands |{
-      let addr = env::var("HOST").unwrap().to_socket_addrs().unwrap().nth(0).unwrap();
+    .add_systems(XrSessionCreated, || { println!("[INFO] Started VR") });
+  } else{
+    app
+      .add_plugins(DefaultPlugins)
+      .insert_resource(XrState::Unavailable);
+  }
+
+  app.add_plugins(FelixAudio)
+  .add_systems(Startup, setup)
+  .add_systems(Startup, move | mut commands: Commands |{
+    let addr = env::var("HOST").unwrap().to_socket_addrs().unwrap().nth(0).unwrap();
+
+    let ( comp, voice ) = net::handle_net(addr.clone()).expect("Network Module Failed");
+    commands.spawn(comp);
 
-      let ( comp, voice ) = net::handle_net(addr.clone()).expect("Network Module Failed");
-      commands.spawn(comp);
+    match voice::init_microphone(addr, voice){
+      Ok(voice) => { commands.spawn(voice); },
+      Err(err) => println!("[WARN] Failed to start microphone: {}", err)
+    }
+  })
+  .add_systems(Update, debug_camera::update)
+  .add_systems(Update, debug_camera::vr_locomotion)
+  .add_systems(Startup, debug_camera::setup)
+  .add_systems(Update, remote_player::update)
+  .add_systems(FixedUpdate, network_interface::fixed_update);
 
-      match voice::init_microphone(addr, voice){
-        Ok(voice) => { commands.spawn(voice); },
-        Err(err) => println!("[WARN] Failed to start microphone: {}", err)
-      }
-    })
-    .add_systems(Update, debug_camera::update)
-    .add_systems(Startup, debug_camera::setup)
-    .add_systems(Update, remote_player::update)
-    .add_systems(FixedUpdate, network_interface::fixed_update)
-    .run();
-}
+  app.run();
+}

client/src/setup.rs

···
 use bevy::prelude::*;
+use bevy_mod_xr::session::XrTracker;
+use bevy_xr_utils::tracking_utils::{XrTrackedLocalFloor, XrTrackedStage, XrTrackedView};
 use felix_assets::{BevyObjectData, BevyObjectLightDataType};
 use felix_audio::FelixAudioListener;
 
···
     DebugCamera::default(), // TODO: Build a proper player controller
     Camera3d::default(),
     Transform::from_xyz(0.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
-    FelixAudioListener
+    FelixAudioListener,
+    XrTracker,
+    XrTrackedView
+  ));
+
+  commands.spawn((
+    Mesh3d(meshes.add(Cuboid::new(0.5, 0.1, 0.5))),
+    MeshMaterial3d(materials.add(Color::srgb_u8(144, 255, 144))),
+    Transform::from_xyz(0.0, 0.0, 0.0),
+    XrTrackedLocalFloor,
+    XrTracker,
+  ));
+
+  commands.spawn((
+    Mesh3d(meshes.add(Cuboid::new(0.5, 0.1, 0.5))),
+    MeshMaterial3d(materials.add(Color::srgb_u8(144, 255, 255))),
+    Transform::from_xyz(0.0, 0.0, 0.0),
+    XrTrackedStage,
+    XrTracker,
   ));
 
   let gos = felix_assets::load("/home/phaze/Documents/rindo.flx").unwrap();