326 lines
12 KiB
Rust
326 lines
12 KiB
Rust
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::trackers::{
|
|
OpenXRController, OpenXRLeftController, OpenXRRightController, OpenXRTracker,
|
|
OpenXRTrackingRoot,
|
|
};
|
|
use bevy_openxr::xr_input::{Hand, QuatConv, Vec3Conv};
|
|
use bevy_openxr::DefaultXrPlugins;
|
|
|
|
fn main() {
|
|
color_eyre::install().unwrap();
|
|
|
|
info!("Running `openxr-6dof` skill");
|
|
App::new()
|
|
.add_plugins(DefaultXrPlugins)
|
|
.add_plugins(OpenXrDebugRenderer) //new debug renderer adds gizmos to
|
|
.add_plugins(LogDiagnosticsPlugin::default())
|
|
.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();
|
|
}
|
|
|
|
/// set up a simple 3D scene
|
|
fn setup(
|
|
mut commands: Commands,
|
|
mut meshes: ResMut<Assets<Mesh>>,
|
|
mut materials: ResMut<Assets<StandardMaterial>>,
|
|
) {
|
|
// plane
|
|
commands.spawn(PbrBundle {
|
|
mesh: meshes.add(shape::Plane::from_size(5.0).into()),
|
|
material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
|
|
..default()
|
|
});
|
|
// cube
|
|
commands.spawn(PbrBundle {
|
|
mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
|
|
material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
|
|
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 {
|
|
intensity: 1500.0,
|
|
shadows_enabled: true,
|
|
..default()
|
|
},
|
|
transform: Transform::from_xyz(4.0, 8.0, 4.0),
|
|
..default()
|
|
});
|
|
// camera
|
|
commands.spawn((Camera3dBundle {
|
|
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>>,
|
|
) {
|
|
//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<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"),
|
|
}
|
|
}
|