610 lines
21 KiB
Rust
610 lines
21 KiB
Rust
use bevy::{
|
|
diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
|
|
log::info,
|
|
prelude::{
|
|
*,
|
|
bevy_main, default, shape, App, Assets, Color, Commands, Component, Event, EventReader,
|
|
EventWriter, GlobalTransform, IntoSystemConfigs, IntoSystemSetConfigs, Mesh, PbrBundle,
|
|
PostUpdate, Query, Res, ResMut, Resource, SpatialBundle, StandardMaterial, Startup,
|
|
Transform, Update, With, Without,
|
|
},
|
|
time::{Time, Timer},
|
|
transform::TransformSystem,
|
|
};
|
|
use bevy_openxr::{
|
|
input::XrInput,
|
|
resources::{XrFrameState, XrInstance, XrSession},
|
|
xr_input::{
|
|
debug_gizmos::OpenXrDebugRenderer,
|
|
hand::{HandBone, HandInputDebugRenderer, HandResource, HandsResource, OpenXrHandInput},
|
|
interactions::{
|
|
draw_interaction_gizmos, draw_socket_gizmos, interactions, socket_interactions,
|
|
update_interactable_states, InteractionEvent, Touched, XRDirectInteractor,
|
|
XRInteractable, XRInteractableState, XRInteractorState, XRSelection,
|
|
},
|
|
oculus_touch::OculusController,
|
|
prototype_locomotion::{proto_locomotion, PrototypeLocomotionConfig},
|
|
trackers::{OpenXRController, OpenXRLeftController, OpenXRRightController, OpenXRTracker},
|
|
Hand,
|
|
},
|
|
DefaultXrPlugins,
|
|
};
|
|
|
|
mod setup;
|
|
use crate::setup::setup_scene;
|
|
use bevy_rapier3d::prelude::*;
|
|
|
|
#[bevy_main]
|
|
pub fn main() {
|
|
color_eyre::install().unwrap();
|
|
|
|
info!("Running bevy_openxr demo");
|
|
let mut app = App::new();
|
|
|
|
app
|
|
//lets get the usual diagnostic stuff added
|
|
.add_plugins(LogDiagnosticsPlugin::default())
|
|
.add_plugins(FrameTimeDiagnosticsPlugin)
|
|
//lets get the xr defaults added
|
|
.add_plugins(DefaultXrPlugins)
|
|
//lets add the debug renderer for the controllers
|
|
.add_plugins(OpenXrDebugRenderer)
|
|
//rapier goes here
|
|
.add_plugins(RapierPhysicsPlugin::<NoUserData>::default().with_default_system_setup(false))
|
|
.add_plugins(RapierDebugRenderPlugin::default())
|
|
//lets setup the starting scene
|
|
.add_systems(Startup, setup_scene)
|
|
.add_systems(Startup, spawn_controllers_example) //you need to spawn controllers or it crashes TODO:: Fix this
|
|
//add locomotion
|
|
.add_systems(Update, proto_locomotion)
|
|
.insert_resource(PrototypeLocomotionConfig::default())
|
|
//lets add the interaction systems
|
|
.add_event::<InteractionEvent>()
|
|
.add_systems(Update, prototype_interaction_input)
|
|
.add_systems(Update, interactions.before(update_interactable_states))
|
|
.add_systems(Update, update_interactable_states)
|
|
.add_systems(
|
|
Update,
|
|
socket_interactions.before(update_interactable_states),
|
|
)
|
|
//add the grabbable system
|
|
.add_systems(Update, update_grabbables.after(update_interactable_states))
|
|
//draw the interaction gizmos
|
|
.add_systems(
|
|
Update,
|
|
draw_interaction_gizmos.after(update_interactable_states),
|
|
)
|
|
.add_systems(Update, draw_socket_gizmos.after(update_interactable_states))
|
|
//add our cube spawning system
|
|
.add_event::<SpawnCubeRequest>()
|
|
.insert_resource(SpawnCubeTimer(Timer::from_seconds(
|
|
0.25,
|
|
bevy::time::TimerMode::Once,
|
|
)))
|
|
.add_systems(Update, request_cube_spawn)
|
|
.add_systems(Update, cube_spawner.after(request_cube_spawn))
|
|
//test capsule
|
|
.add_systems(Startup, spawn_capsule)
|
|
//physics hands
|
|
.add_plugins(OpenXrHandInput)
|
|
.add_plugins(HandInputDebugRenderer)
|
|
.add_systems(Startup, spawn_physics_hands)
|
|
.add_systems(Update, update_physics_hands);
|
|
|
|
//configure rapier sets
|
|
app.configure_sets(
|
|
PostUpdate,
|
|
(
|
|
PhysicsSet::SyncBackend,
|
|
PhysicsSet::StepSimulation,
|
|
PhysicsSet::Writeback,
|
|
)
|
|
.chain()
|
|
.before(TransformSystem::TransformPropagate),
|
|
);
|
|
//add rapier systems
|
|
app.add_systems(
|
|
PostUpdate,
|
|
(
|
|
RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::SyncBackend)
|
|
.in_set(PhysicsSet::SyncBackend),
|
|
(
|
|
RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::StepSimulation),
|
|
// despawn_one_box,
|
|
)
|
|
.in_set(PhysicsSet::StepSimulation),
|
|
RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::Writeback)
|
|
.in_set(PhysicsSet::Writeback),
|
|
),
|
|
);
|
|
|
|
app.run();
|
|
}
|
|
|
|
fn spawn_controllers_example(mut commands: Commands) {
|
|
//left hand
|
|
commands.spawn((
|
|
OpenXRLeftController,
|
|
OpenXRController,
|
|
OpenXRTracker,
|
|
SpatialBundle::default(),
|
|
XRDirectInteractor,
|
|
XRInteractorState::default(),
|
|
XRSelection::default(),
|
|
));
|
|
//right hand
|
|
commands.spawn((
|
|
OpenXRRightController,
|
|
OpenXRController,
|
|
OpenXRTracker,
|
|
SpatialBundle::default(),
|
|
XRDirectInteractor,
|
|
XRInteractorState::default(),
|
|
XRSelection::default(),
|
|
));
|
|
}
|
|
|
|
fn spawn_capsule(
|
|
mut commands: Commands,
|
|
mut meshes: ResMut<Assets<Mesh>>,
|
|
mut materials: ResMut<Assets<StandardMaterial>>,
|
|
) {
|
|
commands.spawn((
|
|
PbrBundle {
|
|
mesh: meshes.add(Mesh::from(shape::Capsule {
|
|
radius: 0.033,
|
|
depth: 0.115,
|
|
..default()
|
|
})),
|
|
material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
|
|
transform: Transform::from_xyz(0.0, 2.0, 0.0),
|
|
..default()
|
|
},
|
|
// Collider::capsule_y(0.0575, 0.034),
|
|
Collider::capsule(
|
|
Vec3 {
|
|
x: 0.0,
|
|
y: -0.0575,
|
|
z: 0.0,
|
|
},
|
|
Vec3 {
|
|
x: 0.0,
|
|
y: 0.0575,
|
|
z: 0.0,
|
|
},
|
|
0.034,
|
|
),
|
|
RigidBody::Dynamic,
|
|
));
|
|
}
|
|
|
|
#[derive(Component, PartialEq, Debug, Clone, Copy)]
|
|
pub enum PhysicsHandBone {
|
|
Palm,
|
|
Wrist,
|
|
ThumbMetacarpal,
|
|
ThumbProximal,
|
|
ThumbDistal,
|
|
ThumbTip,
|
|
IndexMetacarpal,
|
|
IndexProximal,
|
|
IndexIntermediate,
|
|
IndexDistal,
|
|
IndexTip,
|
|
MiddleMetacarpal,
|
|
MiddleProximal,
|
|
MiddleIntermediate,
|
|
MiddleDistal,
|
|
MiddleTip,
|
|
RingMetacarpal,
|
|
RingProximal,
|
|
RingIntermediate,
|
|
RingDistal,
|
|
RingTip,
|
|
LittleMetacarpal,
|
|
LittleProximal,
|
|
LittleIntermediate,
|
|
LittleDistal,
|
|
LittleTip,
|
|
}
|
|
#[derive(Component, PartialEq)]
|
|
pub enum BoneInitState {
|
|
True,
|
|
False,
|
|
}
|
|
|
|
fn spawn_physics_hands(mut commands: Commands) {
|
|
//here we go
|
|
let hands = [Hand::Left, Hand::Right];
|
|
let bones = [
|
|
PhysicsHandBone::Palm,
|
|
PhysicsHandBone::Wrist,
|
|
PhysicsHandBone::ThumbMetacarpal,
|
|
PhysicsHandBone::ThumbProximal,
|
|
PhysicsHandBone::ThumbDistal,
|
|
PhysicsHandBone::ThumbTip,
|
|
PhysicsHandBone::IndexMetacarpal,
|
|
PhysicsHandBone::IndexProximal,
|
|
PhysicsHandBone::IndexIntermediate,
|
|
PhysicsHandBone::IndexDistal,
|
|
PhysicsHandBone::IndexTip,
|
|
PhysicsHandBone::MiddleMetacarpal,
|
|
PhysicsHandBone::MiddleProximal,
|
|
PhysicsHandBone::MiddleIntermediate,
|
|
PhysicsHandBone::MiddleDistal,
|
|
PhysicsHandBone::MiddleTip,
|
|
PhysicsHandBone::RingMetacarpal,
|
|
PhysicsHandBone::RingProximal,
|
|
PhysicsHandBone::RingIntermediate,
|
|
PhysicsHandBone::RingDistal,
|
|
PhysicsHandBone::RingTip,
|
|
PhysicsHandBone::LittleMetacarpal,
|
|
PhysicsHandBone::LittleProximal,
|
|
PhysicsHandBone::LittleIntermediate,
|
|
PhysicsHandBone::LittleDistal,
|
|
PhysicsHandBone::LittleTip,
|
|
];
|
|
//lets just do the Right ThumbMetacarpal for now
|
|
//i dont understand the groups yet
|
|
let self_group = Group::GROUP_1;
|
|
let interaction_group = Group::ALL;
|
|
let radius = 0.010;
|
|
|
|
for hand in hands.iter() {
|
|
for bone in bones.iter() {
|
|
//spawn the thing
|
|
commands.spawn((
|
|
SpatialBundle::default(),
|
|
Collider::capsule(
|
|
Vec3 {
|
|
x: 0.0,
|
|
y: -0.0575,
|
|
z: 0.0,
|
|
},
|
|
Vec3 {
|
|
x: 0.0,
|
|
y: 0.0575,
|
|
z: 0.0,
|
|
},
|
|
radius,
|
|
),
|
|
RigidBody::KinematicPositionBased,
|
|
// CollisionGroups::new(self_group, interaction_group),
|
|
// SolverGroups::new(self_group, interaction_group),
|
|
bone.clone(),
|
|
BoneInitState::False,
|
|
hand.clone(),
|
|
));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn update_physics_hands(
|
|
hands_res: Option<Res<HandsResource>>,
|
|
mut bone_query: Query<(
|
|
&mut Transform,
|
|
&mut Collider,
|
|
&PhysicsHandBone,
|
|
&mut BoneInitState,
|
|
&Hand,
|
|
)>,
|
|
hand_query: Query<(&Transform, &HandBone, &Hand, Without<PhysicsHandBone>)>,
|
|
) {
|
|
//sanity check do we even have hands?
|
|
match hands_res {
|
|
Some(res) => {
|
|
//config stuff
|
|
let radius = 0.010;
|
|
for mut bone in bone_query.iter_mut() {
|
|
let hand_res = match bone.4 {
|
|
Hand::Left => res.left,
|
|
Hand::Right => res.right,
|
|
};
|
|
|
|
//lets just do the Right ThumbMetacarpal for now
|
|
let result = get_start_and_end_entities(hand_res, bone.2);
|
|
if let Some((start_entity, end_entity)) = result {
|
|
//now we need their transforms
|
|
let start_components = hand_query.get(start_entity);
|
|
let end_components = hand_query.get(end_entity);
|
|
let direction = end_components.unwrap().0.translation
|
|
- start_components.unwrap().0.translation;
|
|
if direction.length() < 0.001 {
|
|
//i hate this but we need to skip init if the length is zero
|
|
return;
|
|
}
|
|
|
|
match *bone.3 {
|
|
BoneInitState::True => {
|
|
//if we are init then we just move em?
|
|
*bone.0 = start_components
|
|
.unwrap()
|
|
.0
|
|
.clone()
|
|
.looking_at(end_components.unwrap().0.translation, Vec3::Y);
|
|
}
|
|
BoneInitState::False => {
|
|
//build a new collider?
|
|
*bone.1 = Collider::capsule(
|
|
Vec3::splat(0.0),
|
|
Vec3 {
|
|
x: 0.0,
|
|
y: 0.0,
|
|
z: -direction.length(),
|
|
},
|
|
radius,
|
|
);
|
|
*bone.3 = BoneInitState::True;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
None => info!("hand states resource not initialized yet"),
|
|
}
|
|
}
|
|
|
|
fn get_start_and_end_entities(
|
|
hand_res: HandResource,
|
|
bone: &PhysicsHandBone,
|
|
) -> Option<(Entity, Entity)> {
|
|
match bone {
|
|
PhysicsHandBone::Palm => return None,
|
|
PhysicsHandBone::Wrist => return None,
|
|
PhysicsHandBone::ThumbMetacarpal => {
|
|
return Some((hand_res.thumb.metacarpal, hand_res.thumb.proximal))
|
|
}
|
|
PhysicsHandBone::ThumbProximal => {
|
|
return Some((hand_res.thumb.proximal, hand_res.thumb.distal))
|
|
}
|
|
PhysicsHandBone::ThumbDistal => return Some((hand_res.thumb.distal, hand_res.thumb.tip)),
|
|
PhysicsHandBone::ThumbTip => return None,
|
|
PhysicsHandBone::IndexMetacarpal => {
|
|
return Some((hand_res.index.metacarpal, hand_res.index.proximal))
|
|
}
|
|
PhysicsHandBone::IndexProximal => {
|
|
return Some((hand_res.index.proximal, hand_res.index.intermediate))
|
|
}
|
|
PhysicsHandBone::IndexIntermediate => {
|
|
return Some((hand_res.index.intermediate, hand_res.index.distal))
|
|
}
|
|
PhysicsHandBone::IndexDistal => return Some((hand_res.index.distal, hand_res.index.tip)),
|
|
PhysicsHandBone::IndexTip => return None,
|
|
PhysicsHandBone::MiddleMetacarpal => {
|
|
return Some((hand_res.middle.metacarpal, hand_res.middle.proximal))
|
|
}
|
|
PhysicsHandBone::MiddleProximal => {
|
|
return Some((hand_res.middle.proximal, hand_res.middle.intermediate))
|
|
}
|
|
PhysicsHandBone::MiddleIntermediate => {
|
|
return Some((hand_res.middle.intermediate, hand_res.middle.distal))
|
|
}
|
|
PhysicsHandBone::MiddleDistal => {
|
|
return Some((hand_res.middle.distal, hand_res.middle.tip))
|
|
}
|
|
PhysicsHandBone::MiddleTip => return None,
|
|
PhysicsHandBone::RingMetacarpal => {
|
|
return Some((hand_res.ring.metacarpal, hand_res.ring.proximal))
|
|
}
|
|
PhysicsHandBone::RingProximal => {
|
|
return Some((hand_res.ring.proximal, hand_res.ring.intermediate))
|
|
}
|
|
PhysicsHandBone::RingIntermediate => {
|
|
return Some((hand_res.ring.intermediate, hand_res.ring.distal))
|
|
}
|
|
PhysicsHandBone::RingDistal => return Some((hand_res.ring.distal, hand_res.ring.tip)),
|
|
PhysicsHandBone::RingTip => return None,
|
|
PhysicsHandBone::LittleMetacarpal => {
|
|
return Some((hand_res.little.metacarpal, hand_res.little.proximal))
|
|
}
|
|
PhysicsHandBone::LittleProximal => {
|
|
return Some((hand_res.little.proximal, hand_res.little.intermediate))
|
|
}
|
|
PhysicsHandBone::LittleIntermediate => {
|
|
return Some((hand_res.little.intermediate, hand_res.little.distal))
|
|
}
|
|
PhysicsHandBone::LittleDistal => {
|
|
return Some((hand_res.little.distal, hand_res.little.tip))
|
|
}
|
|
PhysicsHandBone::LittleTip => return None,
|
|
};
|
|
}
|
|
|
|
fn get_hand_res(res: &Res<'_, HandsResource>, hand: Hand) -> HandResource {
|
|
match hand {
|
|
Hand::Left => res.left.clone(),
|
|
Hand::Right => res.right.clone(),
|
|
}
|
|
}
|
|
|
|
#[derive(Event, Default)]
|
|
pub struct SpawnCubeRequest;
|
|
|
|
#[derive(Resource)]
|
|
pub struct SpawnCubeTimer(Timer);
|
|
|
|
fn request_cube_spawn(
|
|
oculus_controller: Res<OculusController>,
|
|
frame_state: Res<XrFrameState>,
|
|
xr_input: Res<XrInput>,
|
|
instance: Res<XrInstance>,
|
|
session: Res<XrSession>,
|
|
mut writer: EventWriter<SpawnCubeRequest>,
|
|
time: Res<Time>,
|
|
mut timer: ResMut<SpawnCubeTimer>,
|
|
) {
|
|
timer.0.tick(time.delta());
|
|
if timer.0.finished() {
|
|
//lock frame
|
|
let frame_state = *frame_state.lock().unwrap();
|
|
//get controller
|
|
let controller = oculus_controller.get_ref(&instance, &session, &frame_state, &xr_input);
|
|
//get controller triggers
|
|
let left_main_button = controller.a_button();
|
|
if left_main_button {
|
|
writer.send(SpawnCubeRequest::default());
|
|
timer.0.reset();
|
|
}
|
|
let right_main_button = controller.x_button();
|
|
if right_main_button {
|
|
writer.send(SpawnCubeRequest::default());
|
|
timer.0.reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn cube_spawner(
|
|
mut commands: Commands,
|
|
mut meshes: ResMut<Assets<Mesh>>,
|
|
mut materials: ResMut<Assets<StandardMaterial>>,
|
|
mut events: EventReader<SpawnCubeRequest>,
|
|
) {
|
|
for request in events.iter() {
|
|
// 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, 1.0, 0.0),
|
|
..default()
|
|
},
|
|
RigidBody::Dynamic,
|
|
Collider::cuboid(0.05, 0.05, 0.05),
|
|
ColliderDebugColor(Color::hsl(220.0, 1.0, 0.3)),
|
|
XRInteractable,
|
|
XRInteractableState::default(),
|
|
Grabbable,
|
|
Touched(false),
|
|
));
|
|
}
|
|
}
|
|
|
|
//TODO: find a real place for this
|
|
fn prototype_interaction_input(
|
|
oculus_controller: Res<OculusController>,
|
|
frame_state: Res<XrFrameState>,
|
|
xr_input: Res<XrInput>,
|
|
instance: Res<XrInstance>,
|
|
session: Res<XrSession>,
|
|
mut right_interactor_query: Query<
|
|
(&mut XRInteractorState),
|
|
(
|
|
With<XRDirectInteractor>,
|
|
With<OpenXRRightController>,
|
|
Without<OpenXRLeftController>,
|
|
),
|
|
>,
|
|
mut left_interactor_query: Query<
|
|
(&mut XRInteractorState),
|
|
(
|
|
With<XRDirectInteractor>,
|
|
With<OpenXRLeftController>,
|
|
Without<OpenXRRightController>,
|
|
),
|
|
>,
|
|
) {
|
|
//lock frame
|
|
let frame_state = *frame_state.lock().unwrap();
|
|
//get controller
|
|
let controller = oculus_controller.get_ref(&instance, &session, &frame_state, &xr_input);
|
|
//get controller triggers
|
|
let left_trigger = controller.trigger(Hand::Left);
|
|
let right_trigger = controller.trigger(Hand::Right);
|
|
//get the interactors and do state stuff
|
|
let mut left_state = left_interactor_query.single_mut();
|
|
if left_trigger > 0.8 {
|
|
*left_state = XRInteractorState::Selecting;
|
|
} else {
|
|
*left_state = XRInteractorState::Idle;
|
|
}
|
|
let mut right_state = right_interactor_query.single_mut();
|
|
if right_trigger > 0.8 {
|
|
*right_state = XRInteractorState::Selecting;
|
|
} else {
|
|
*right_state = XRInteractorState::Idle;
|
|
}
|
|
}
|
|
|
|
#[derive(Component)]
|
|
pub struct Grabbable;
|
|
|
|
pub fn update_grabbables(
|
|
mut events: EventReader<InteractionEvent>,
|
|
mut grabbable_query: Query<(
|
|
Entity,
|
|
&mut Transform,
|
|
With<Grabbable>,
|
|
Without<XRDirectInteractor>,
|
|
Option<&mut RigidBody>,
|
|
)>,
|
|
mut interactor_query: Query<(
|
|
&GlobalTransform,
|
|
&XRInteractorState,
|
|
&mut XRSelection,
|
|
Without<Grabbable>,
|
|
)>,
|
|
) {
|
|
//so basically the idea is to try all the events?
|
|
for event in events.read() {
|
|
// info!("some event");
|
|
match grabbable_query.get_mut(event.interactable) {
|
|
Ok(mut grabbable_transform) => {
|
|
// info!("we got a grabbable");
|
|
//now we need the location of our interactor
|
|
match interactor_query.get_mut(event.interactor) {
|
|
Ok(mut interactor_transform) => {
|
|
match *interactor_transform.2 {
|
|
XRSelection::Empty => {
|
|
match interactor_transform.1 {
|
|
XRInteractorState::Idle => match grabbable_transform.4 {
|
|
Some(mut thing) => {
|
|
*thing = RigidBody::Dynamic;
|
|
*interactor_transform.2 = XRSelection::Empty;
|
|
}
|
|
None => (),
|
|
},
|
|
XRInteractorState::Selecting => {
|
|
// info!("its a direct interactor?");
|
|
match grabbable_transform.4 {
|
|
Some(mut thing) => {
|
|
*thing = RigidBody::KinematicPositionBased;
|
|
*interactor_transform.2 =
|
|
XRSelection::Full(grabbable_transform.0);
|
|
}
|
|
None => (),
|
|
}
|
|
*grabbable_transform.1 =
|
|
interactor_transform.0.compute_transform();
|
|
}
|
|
}
|
|
}
|
|
XRSelection::Full(ent) => {
|
|
info!("nah bro we holding something");
|
|
match grabbable_transform.0 == ent {
|
|
true => {
|
|
*grabbable_transform.1 =
|
|
interactor_transform.0.compute_transform();
|
|
}
|
|
false => {}
|
|
}
|
|
match interactor_transform.1 {
|
|
XRInteractorState::Idle => {
|
|
*interactor_transform.2 = XRSelection::Empty
|
|
}
|
|
XRInteractorState::Selecting => {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Err(_) => {
|
|
// info!("not a direct interactor")
|
|
}
|
|
}
|
|
}
|
|
Err(_) => {
|
|
// info!("not a grabbable?")
|
|
}
|
|
}
|
|
}
|
|
}
|