Avii/bevy_oxr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #163 from Schmarni-Dev/0.15rc

Browse Source 
update to bevy 0.15
This commit is contained in:
Schmarni
2025-01-01 22:37:46 +01:00
committed by GitHub
parent 901b9bc446 336c40d555
commit 03a97f4c12
39 changed files with 1448 additions and 1321 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1528
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

9
Cargo.toml
View File

@@ -10,10 +10,17 @@ resolver = "2"
members = ["crates/*", "crates/bevy_openxr/examples/android"]
[workspace.dependencies]
bevy = { version = "0.14.0", default-features = false, features = [
bevy = { version = "0.15", default-features = false, features = [
"bevy_render",
"bevy_core_pipeline",
"bevy_winit",
"bevy_pbr",
"x11",
] }
bevy_mod_xr.path = "crates/bevy_xr"
bevy_mod_openxr.path = "crates/bevy_openxr"
bevy_xr_utils.path = "crates/bevy_xr_utils"
openxr = "0.19.0"
thiserror = "2.0.3"
wgpu = "23"
wgpu-hal = "23"

24
crates/bevy_openxr/Cargo.toml
View File

@@ -10,11 +10,11 @@ keywords = ["gamedev", "bevy", "Xr", "Vr", "OpenXR"]
[features]
default = ["vulkan", "d3d12", "passthrough"]
vulkan = ["dep:ash"]
d3d12 = ["wgpu/dx12", "wgpu-hal/dx12", "dep:winapi", "dep:d3d12"]
d3d12 = ["wgpu/dx12", "wgpu-hal/dx12", "dep:winapi"]
passthrough = []
[dev-dependencies]
bevy_xr_utils.path = "../bevy_xr_utils"
bevy_xr_utils.workspace = true
bevy = { workspace = true, default-features = true }
[target.'cfg(target_os = "android")'.dependencies]
@@ -27,22 +27,20 @@ bevy.workspace = true
# all other dependencies are placed under this since on wasm, this crate is completely empty
[target.'cfg(not(target_family = "wasm"))'.dependencies]
openxr = "0.18.0"
thiserror = "1.0.57"
wgpu = "0.20"
wgpu-hal = "0.21"
bevy_mod_xr = { path = "../bevy_xr", version = "0.1.0" }
ash = { version = "0.37.3", optional = true }
bevy_mod_xr.workspace = true
openxr.workspace = true
thiserror.workspace = true
wgpu.workspace = true
wgpu-hal.workspace = true
ash = { version = "0.38", optional = true }
[target.'cfg(target_family = "unix")'.dependencies]
openxr = { version = "0.18.0", features = ["mint"] }
wgpu = { version = "0.20", features = ["vulkan-portability"] }
openxr = { workspace = true, features = ["mint"] }
wgpu = { workspace = true, features = ["vulkan-portability"] }
[target.'cfg(target_family = "windows")'.dependencies]
openxr = { version = "0.18.0", features = ["mint", "static"] }
openxr = { workspace=true, features = ["mint", "static"] }
winapi = { version = "0.3.9", optional = true }
d3d12 = { version = "0.20", features = ["libloading"], optional = true }
[lints.clippy]
too_many_arguments = "allow"

57
crates/bevy_openxr/examples/3d_scene.rs
View File

@@ -1,13 +1,25 @@
//! A simple 3D scene with light shining over a cube sitting on a plane.
use bevy::prelude::*;
use bevy_mod_openxr::add_xr_plugins;
use bevy::{prelude::*, render::pipelined_rendering::PipelinedRenderingPlugin};
use bevy_mod_openxr::{add_xr_plugins, init::OxrInitPlugin};
use openxr::EnvironmentBlendMode;
fn main() {
App::new()
.add_plugins(add_xr_plugins(DefaultPlugins))
.add_plugins(
add_xr_plugins(DefaultPlugins.build().disable::<PipelinedRenderingPlugin>()).set(
OxrInitPlugin {
blend_modes: Some(vec![
EnvironmentBlendMode::ALPHA_BLEND,
EnvironmentBlendMode::ADDITIVE,
]),
..Default::default()
},
),
)
.add_plugins(bevy_xr_utils::hand_gizmos::HandGizmosPlugin)
.add_systems(Startup, setup)
.insert_resource(ClearColor(Color::NONE))
.run();
}
@@ -18,30 +30,27 @@ fn setup(
mut materials: ResMut<Assets<StandardMaterial>>,
) {
// circular base
commands.spawn(PbrBundle {
mesh: meshes.add(Circle::new(4.0)),
material: materials.add(Color::WHITE),
transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Circle::new(4.0))),
MeshMaterial3d(materials.add(Color::WHITE)),
Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
));
// cube
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
material: materials.add(Color::srgb_u8(124, 144, 255)),
transform: Transform::from_xyz(0.0, 0.5, 0.0),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
Transform::from_xyz(0.0, 0.5, 0.0),
));
// light
commands.spawn(PointLightBundle {
point_light: PointLight {
commands.spawn((
PointLight {
shadows_enabled: true,
..default()
},
transform: Transform::from_xyz(4.0, 8.0, 4.0),
..default()
});
commands.spawn(Camera3dBundle {
transform: Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
..default()
});
Transform::from_xyz(4.0, 8.0, 4.0),
));
commands.spawn((
Camera3d::default(),
Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
));
}

32
crates/bevy_openxr/examples/actions.rs
View File

@@ -34,24 +34,22 @@ fn setup_scene(
mut materials: ResMut<Assets<StandardMaterial>>,
) {
// circular base
commands.spawn(PbrBundle {
mesh: meshes.add(Circle::new(4.0)),
material: materials.add(Color::WHITE),
transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Circle::new(4.0))),
MeshMaterial3d(materials.add(Color::WHITE)),
Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
));
// cube
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
material: materials.add(Color::srgb_u8(124, 144, 255)),
transform: Transform::from_xyz(0.0, 0.5, 0.0),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
Transform::from_xyz(0.0, 0.5, 0.0),
));
commands.spawn(Camera3dBundle {
transform: Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
..default()
});
commands.spawn((
Camera3d::default(),
Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
));
}
#[derive(Component)]
@@ -145,7 +143,7 @@ fn handle_flight_input(
let locomotion_vector = reference_quat.mul_vec3(input_vector);
root_position.translation +=
locomotion_vector * speed * time.delta_seconds();
locomotion_vector * speed * time.delta_secs();
}
None => return,
}

4
crates/bevy_openxr/examples/android/Cargo.toml
View File

@@ -7,9 +7,9 @@ publish = false
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
bevy_mod_openxr.path = "../.."
bevy_mod_openxr.workspace = true
bevy = { workspace = true, default-features = true }
bevy_xr_utils.path = "../../../bevy_xr_utils"
bevy_xr_utils.workspace = true
[build-dependencies]
reqwest = { version = "0.12", features = ["blocking"] }

33
crates/bevy_openxr/examples/android/src/lib.rs
View File

@@ -21,8 +21,8 @@ fn main() {
synchronous_pipeline_compilation: default(),
}))
.add_plugins(bevy_xr_utils::hand_gizmos::HandGizmosPlugin)
.insert_resource(Msaa::Off)
.add_systems(Startup, setup)
.add_systems(Update, modify_msaa)
.insert_resource(AmbientLight {
color: Default::default(),
brightness: 500.0,
@@ -31,6 +31,15 @@ fn main() {
.run();
}
#[derive(Component)]
struct MsaaModified;
fn modify_msaa(cams: Query<Entity, (With<Camera>, Without<MsaaModified>)>, mut commands: Commands) {
for cam in &cams {
commands.entity(cam).insert(Msaa::Off).insert(MsaaModified);
}
}
/// set up a simple 3D scene
fn setup(
mut commands: Commands,
@@ -40,19 +49,17 @@ fn setup(
let mut white: StandardMaterial = Color::WHITE.into();
white.unlit = true;
// circular base
commands.spawn(PbrBundle {
mesh: meshes.add(Circle::new(4.0)),
material: materials.add(white),
transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Circle::new(4.0))),
MeshMaterial3d(materials.add(white)),
Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
));
let mut cube_mat: StandardMaterial = Color::srgb_u8(124, 144, 255).into();
cube_mat.unlit = true;
// cube
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
material: materials.add(cube_mat),
transform: Transform::from_xyz(0.0, 0.5, 0.0),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
MeshMaterial3d(materials.add(cube_mat)),
Transform::from_xyz(0.0, 0.5, 0.0),
));
}

78
crates/bevy_openxr/examples/overlay.rs
View File

@@ -1,10 +1,11 @@
//! A simple 3D scene with light shining over a cube sitting on a plane.
use bevy::prelude::*;
use bevy_mod_openxr::{add_xr_plugins, init::OxrInitPlugin, types::OxrExtensions};
use bevy_mod_xr::session::XrState;
// use openxr::EnvironmentBlendMode;
// use wgpu::TextureFormat;
use bevy_mod_openxr::{
add_xr_plugins, features::overlay::OxrOverlaySessionEvent, init::OxrInitPlugin,
types::OxrExtensions,
};
use openxr::EnvironmentBlendMode;
fn main() {
App::new()
@@ -12,32 +13,32 @@ fn main() {
exts: {
let mut exts = OxrExtensions::default();
exts.enable_hand_tracking();
exts.other.push("XR_EXTX_overlay\0".into());
exts.extx_overlay = true;
exts
},
// blend_modes: Some({
// let mut v = Vec::new();
// v.push(EnvironmentBlendMode::ALPHA_BLEND);
// v.push(EnvironmentBlendMode::ADDITIVE);
// v.push(EnvironmentBlendMode::OPAQUE);
// v
// }),
// formats: Some({
// let mut v = Vec::new();
// // v.push(TextureFormat::Rgba8Uint);
// v.push(TextureFormat::Rgba8Unorm);
// v.push(TextureFormat::Rgba8UnormSrgb);
// v
// }),
blend_modes: Some({
vec![
EnvironmentBlendMode::ALPHA_BLEND,
EnvironmentBlendMode::OPAQUE,
]
}),
..OxrInitPlugin::default()
}))
.insert_resource(ClearColor(Color::NONE))
.add_plugins(bevy_xr_utils::hand_gizmos::HandGizmosPlugin)
.add_systems(Startup, setup)
.add_systems(Update, handle_input)
.add_systems(Update, print_main_session_changes)
.run();
}
fn print_main_session_changes(mut events: EventReader<OxrOverlaySessionEvent>) {
for event in events.read() {
let OxrOverlaySessionEvent::MainSessionVisibilityChanged { visible, flags: _ } = event;
info!("main session visible: {visible}");
}
}
fn handle_input(
keys: Res<ButtonInput<KeyCode>>,
mut end: EventWriter<bevy_mod_xr::session::XrEndSessionEvent>,
@@ -45,7 +46,6 @@ fn handle_input(
mut begin: EventWriter<bevy_mod_xr::session::XrBeginSessionEvent>,
mut create: EventWriter<bevy_mod_xr::session::XrCreateSessionEvent>,
mut request_exit: EventWriter<bevy_mod_xr::session::XrRequestExitEvent>,
state: Res<XrState>,
) {
if keys.just_pressed(KeyCode::KeyE) {
info!("sending end");
@@ -67,9 +67,6 @@ fn handle_input(
info!("sending request exit");
request_exit.send_default();
}
if keys.just_pressed(KeyCode::KeyI) {
info!("current state: {:?}", *state);
}
}
/// set up a simple 3D scene
@@ -78,31 +75,22 @@ fn setup(
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
// circular base
// commands.spawn(PbrBundle {
// mesh: meshes.add(Circle::new(4.0)),
// material: materials.add(Color::WHITE),
// transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
// ..default()
// });
// cube
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
material: materials.add(Color::srgb_u8(124, 144, 255)),
transform: Transform::from_xyz(0.0, 2.5, 0.0),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
Transform::from_xyz(0.0, 2.5, 0.0),
));
// light
commands.spawn(PointLightBundle {
point_light: PointLight {
commands.spawn((
PointLight {
shadows_enabled: true,
..default()
},
transform: Transform::from_xyz(4.0, 8.0, 4.0),
..default()
});
commands.spawn(Camera3dBundle {
transform: Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
..default()
});
Transform::from_xyz(4.0, 8.0, 4.0),
));
commands.spawn((
Camera3d::default(),
Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
));
}

87
crates/bevy_openxr/examples/raw_actions.rs
View File

@@ -5,15 +5,14 @@ use bevy_mod_openxr::{
action_binding::{OxrSendActionBindings, OxrSuggestActionBinding},
action_set_attaching::OxrAttachActionSet,
action_set_syncing::{OxrActionSetSyncSet, OxrSyncActionSet},
add_xr_plugins,
add_xr_plugins, openxr_session_running,
resources::OxrInstance,
session::OxrSession,
spaces::OxrSpaceExt,
};
use bevy_mod_xr::{
session::{session_available, session_running, XrSessionCreated, XrTrackingRoot},
session::{session_available, XrSessionCreated},
spaces::XrSpace,
types::XrPose,
};
use openxr::Posef;
@@ -26,7 +25,7 @@ fn main() {
PreUpdate,
sync_actions
.before(OxrActionSetSyncSet)
.run_if(session_running),
.run_if(openxr_session_running),
);
app.add_systems(OxrSendActionBindings, suggest_action_bindings);
app.add_systems(Startup, create_actions.run_if(session_available));
@@ -55,32 +54,29 @@ fn setup(
mut materials: ResMut<Assets<StandardMaterial>>,
) {
// circular base
commands.spawn(PbrBundle {
mesh: meshes.add(Circle::new(4.0)),
material: materials.add(Color::WHITE),
transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Circle::new(4.0))),
MeshMaterial3d(materials.add(Color::WHITE)),
Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
));
// cube
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
material: materials.add(Color::srgb_u8(124, 144, 255)),
transform: Transform::from_xyz(0.0, 0.5, 0.0),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
Transform::from_xyz(0.0, 0.5, 0.0),
));
// light
commands.spawn(PointLightBundle {
point_light: PointLight {
commands.spawn((
PointLight {
shadows_enabled: true,
..default()
},
transform: Transform::from_xyz(4.0, 8.0, 4.0),
..default()
});
commands.spawn(Camera3dBundle {
transform: Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
..default()
});
Transform::from_xyz(4.0, 8.0, 4.0),
));
commands.spawn((
Camera3d::default(),
Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
));
}
fn suggest_action_bindings(
actions: Res<ControllerActions>,
@@ -112,7 +108,6 @@ fn create_actions(instance: Res<OxrInstance>, mut cmds: Commands) {
fn spawn_hands(
actions: Res<ControllerActions>,
mut cmds: Commands,
root: Query<Entity, With<XrTrackingRoot>>,
session: Res<OxrSession>,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
@@ -130,34 +125,20 @@ fn spawn_hands(
.unwrap(),
);
let right_space = session
.create_action_space(&actions.right, openxr::Path::NULL, XrPose::IDENTITY)
.create_action_space(&actions.right, openxr::Path::NULL, Isometry3d::IDENTITY)
.unwrap();
let left = cmds
.spawn((
PbrBundle {
mesh: meshes.add(Cuboid::new(0.1, 0.1, 0.05)),
material: materials.add(Color::srgb_u8(124, 144, 255)),
transform: Transform::from_xyz(0.0, 0.5, 0.0),
..default()
},
left_space,
Controller,
))
.id();
let right = cmds
.spawn((
PbrBundle {
mesh: meshes.add(Cuboid::new(0.1, 0.1, 0.05)),
material: materials.add(Color::srgb_u8(124, 144, 255)),
transform: Transform::from_xyz(0.0, 0.5, 0.0),
..default()
},
right_space,
Controller,
))
.id();
cmds.entity(root.single()).push_children(&[left, right]);
cmds.spawn((
Mesh3d(meshes.add(Cuboid::new(0.1, 0.1, 0.05))),
MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
left_space,
Controller,
));
cmds.spawn((
Mesh3d(meshes.add(Cuboid::new(0.1, 0.1, 0.05))),
MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
right_space,
Controller,
));
}
#[derive(Component)]

41
crates/bevy_openxr/examples/sessions.rs
View File

@@ -1,12 +1,19 @@
//! A simple 3D scene with light shining over a cube sitting on a plane.
use bevy::prelude::*;
use bevy_mod_openxr::add_xr_plugins;
use bevy_mod_openxr::{add_xr_plugins, init::OxrInitPlugin};
use bevy_mod_xr::session::{XrSessionPlugin, XrState};
fn main() {
App::new()
.add_plugins(add_xr_plugins(DefaultPlugins).set(XrSessionPlugin { auto_handle: true }))
.add_plugins(
add_xr_plugins(DefaultPlugins)
.set(XrSessionPlugin { auto_handle: true })
.set(OxrInitPlugin {
blend_modes: Some(vec![openxr::EnvironmentBlendMode::OPAQUE]),
..Default::default()
}),
)
.add_plugins(bevy_xr_utils::hand_gizmos::HandGizmosPlugin)
.add_systems(Startup, setup)
.add_systems(Update, handle_input)
@@ -55,21 +62,19 @@ fn setup(
mut materials: ResMut<Assets<StandardMaterial>>,
) {
// circular base
commands.spawn(PbrBundle {
mesh: meshes.add(Circle::new(4.0)),
material: materials.add(Color::WHITE),
transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Circle::new(4.0))),
MeshMaterial3d(materials.add(Color::WHITE)),
Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
));
// cube
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
material: materials.add(Color::srgb_u8(124, 144, 255)),
transform: Transform::from_xyz(0.0, 0.5, 0.0),
..default()
});
commands.spawn(Camera3dBundle {
transform: Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
Transform::from_xyz(0.0, 0.5, 0.0),
));
commands.spawn((
Camera3d::default(),
Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
));
}

121
crates/bevy_openxr/examples/tracking_utils.rs
View File

@@ -2,7 +2,7 @@
use bevy::prelude::*;
use bevy_mod_openxr::{action_binding::OxrSendActionBindings, add_xr_plugins};
use bevy_mod_xr::session::XrSessionCreated;
use bevy_mod_xr::session::{XrSessionCreated, XrTracker};
use bevy_xr_utils::tracking_utils::{
suggest_action_bindings, TrackingUtilitiesPlugin, XrTrackedLeftGrip, XrTrackedLocalFloor, XrTrackedRightGrip, XrTrackedStage, XrTrackedView
};
@@ -30,25 +30,23 @@ fn setup(
mut materials: ResMut<Assets<StandardMaterial>>,
) {
// circular base
commands.spawn(PbrBundle {
mesh: meshes.add(Circle::new(4.0)),
material: materials.add(Color::WHITE),
transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Circle::new(4.0))),
MeshMaterial3d(materials.add(Color::WHITE)),
Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
));
// light
commands.spawn(PointLightBundle {
point_light: PointLight {
commands.spawn((
PointLight {
shadows_enabled: true,
..default()
},
transform: Transform::from_xyz(4.0, 8.0, 4.0),
..default()
});
commands.spawn(Camera3dBundle {
transform: Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
..default()
});
Transform::from_xyz(4.0, 8.0, 4.0),
));
commands.spawn((
Camera3d::default(),
Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
));
}
fn spawn_hands(
@@ -56,65 +54,42 @@ fn spawn_hands(
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
let left = cmds
.spawn((
PbrBundle {
mesh: meshes.add(Cuboid::new(0.1, 0.1, 0.05)),
material: materials.add(Color::srgb_u8(124, 144, 255)),
transform: Transform::from_xyz(0.0, 0.5, 0.0),
..default()
},
XrTrackedLeftGrip,
))
.id();
let bundle = (
PbrBundle {
mesh: meshes.add(Cuboid::new(0.1, 0.1, 0.05)),
material: materials.add(Color::srgb_u8(124, 144, 255)),
transform: Transform::from_xyz(0.0, 0.5, 0.0),
..default()
},
cmds.spawn((
Mesh3d(meshes.add(Cuboid::new(0.1, 0.1, 0.05))),
MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
Transform::from_xyz(0.0, 0.5, 0.0),
XrTrackedLeftGrip,
XrTracker,
));
cmds.spawn((
Mesh3d(meshes.add(Cuboid::new(0.1, 0.1, 0.05))),
MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
Transform::from_xyz(0.0, 0.5, 0.0),
XrTrackedRightGrip,
);
let right = cmds.spawn(bundle).id();
XrTracker,
));
//head
let head = cmds
.spawn((
PbrBundle {
mesh: meshes.add(Cuboid::new(0.2, 0.2, 0.2)),
material: materials.add(Color::srgb_u8(255, 144, 144)),
transform: Transform::from_xyz(0.0, 0.0, 0.0),
..default()
},
XrTrackedView,
))
.id();
cmds.spawn((
Mesh3d(meshes.add(Cuboid::new(0.2, 0.2, 0.2))),
MeshMaterial3d(materials.add(Color::srgb_u8(255, 144, 144))),
Transform::from_xyz(0.0, 0.0, 0.0),
XrTrackedView,
XrTracker,
));
//local_floor emulated
let local_floor = cmds
.spawn((
PbrBundle {
mesh: meshes.add(Cuboid::new(0.5, 0.1, 0.5)),
material: materials.add(Color::srgb_u8(144, 255, 144)),
transform: Transform::from_xyz(0.0, 0.0, 0.0),
..default()
},
XrTrackedLocalFloor,
))
.id();
cmds.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,
));
let stage = cmds
.spawn((
PbrBundle {
mesh: meshes.add(Cuboid::new(0.5, 0.1, 0.5)),
material: materials.add(Color::srgb_u8(144, 255, 255)),
transform: Transform::from_xyz(0.0, 0.0, 0.0),
..default()
},
XrTrackedStage,
))
.id();
cmds.entity(stage)
.push_children(&[left, right, head, local_floor]);
cmds.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,
));
}

74
crates/bevy_openxr/examples/transform_utils.rs
View File

@@ -41,52 +41,46 @@ fn setup(
mut materials: ResMut<Assets<StandardMaterial>>,
) {
// circular base
commands.spawn(PbrBundle {
mesh: meshes.add(Circle::new(4.0)),
material: materials.add(Color::WHITE),
transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Circle::new(4.0))),
MeshMaterial3d(materials.add(Color::WHITE)),
Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
));
// red cube
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
material: materials.add(Color::srgb_u8(252, 44, 3)),
transform: Transform::from_xyz(4.0, 0.5, 0.0).with_scale(Vec3::splat(0.5)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
MeshMaterial3d(materials.add(Color::srgb_u8(252, 44, 3))),
Transform::from_xyz(4.0, 0.5, 0.0).with_scale(Vec3::splat(0.5)),
));
// blue cube
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
material: materials.add(Color::srgb_u8(3, 28, 252)),
transform: Transform::from_xyz(-4.0, 0.5, 0.0).with_scale(Vec3::splat(0.5)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
MeshMaterial3d(materials.add(Color::srgb_u8(3, 28, 252))),
Transform::from_xyz(-4.0, 0.5, 0.0).with_scale(Vec3::splat(0.5)),
));
// green cube
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
material: materials.add(Color::srgb_u8(3, 252, 32)),
transform: Transform::from_xyz(0.0, 0.5, 4.0).with_scale(Vec3::splat(0.5)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
MeshMaterial3d(materials.add(Color::srgb_u8(3, 252, 32))),
Transform::from_xyz(0.0, 0.5, 4.0).with_scale(Vec3::splat(0.5)),
));
// white cube
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
material: materials.add(Color::srgb_u8(250, 250, 250)),
transform: Transform::from_xyz(0.0, 0.5, -4.0).with_scale(Vec3::splat(0.5)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
MeshMaterial3d(materials.add(Color::srgb_u8(250, 250, 250))),
Transform::from_xyz(0.0, 0.5, -4.0).with_scale(Vec3::splat(0.5)),
));
// black cube
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
material: materials.add(Color::srgb_u8(0, 0, 0)),
transform: Transform::from_xyz(0.0, 0.1, 0.0).with_scale(Vec3::splat(0.2)),
..default()
});
commands.spawn((
Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
MeshMaterial3d(materials.add(Color::srgb_u8(0, 0, 0))),
Transform::from_xyz(0.0, 0.1, 0.0).with_scale(Vec3::splat(0.2)),
));
commands.spawn(Camera3dBundle {
transform: Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
..default()
});
commands.spawn((
Camera3d::default(),
Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
));
}
#[derive(Component)]

4
crates/bevy_openxr/src/openxr/action_binding.rs
View File

@@ -16,7 +16,7 @@ impl Plugin for OxrActionBindingPlugin {
app.add_event::<OxrSuggestActionBinding>();
app.add_systems(
Update,
run_action_binding_sugestion.run_if(on_event::<XrSessionCreatedEvent>()),
run_action_binding_sugestion.run_if(on_event::<XrSessionCreatedEvent>),
);
}
}
@@ -25,7 +25,7 @@ impl Plugin for OxrActionBindingPlugin {
// Event to allow requesting binding suggestion for new actions
pub(crate) fn run_action_binding_sugestion(world: &mut World) {
world.run_schedule(OxrSendActionBindings);
world.run_system_once(bind_actions);
_ = world.run_system_once(bind_actions);
}
fn bind_actions(instance: Res<OxrInstance>, mut actions: EventReader<OxrSuggestActionBinding>) {

2
crates/bevy_openxr/src/openxr/action_set_attaching.rs
View File

@@ -8,7 +8,7 @@ impl Plugin for OxrActionAttachingPlugin {
app.add_systems(
PostUpdate,
attach_sets
.run_if(on_event::<XrSessionCreatedEvent>())
.run_if(on_event::<XrSessionCreatedEvent>)
.after(run_action_binding_sugestion),
);
}

1
crates/bevy_openxr/src/openxr/action_set_syncing.rs
View File

@@ -22,7 +22,6 @@ fn sync_sets(session: Res<OxrSession>, mut events: EventReader<OxrSyncActionSet>
.map(|v| &v.0)
.map(openxr::ActiveActionSet::new)
.collect::<Vec<_>>();
if sets.is_empty() {
return;
}

27
crates/bevy_openxr/src/openxr/exts.rs
View File

@@ -1,4 +1,7 @@
use bevy::{ecs::system::Resource, prelude::{Deref, DerefMut}};
use bevy::{
ecs::system::Resource,
prelude::{Deref, DerefMut},
};
use openxr::ExtensionSet;
#[derive(Clone, Debug, Eq, PartialEq, Deref, DerefMut, Resource)]
@@ -29,6 +32,10 @@ impl OxrExtensions {
self.0.ext_hand_tracking = false;
self
}
pub fn enable_extx_overlay(&mut self) -> &mut Self {
self.0.extx_overlay = true;
self
}
/// returns true if all of the extensions enabled are also available in `available_exts`
pub fn is_available(&self, available_exts: &OxrExtensions) -> bool {
self.clone() & available_exts.clone() == *self
@@ -192,6 +199,8 @@ macro_rules! impl_ext {
ext_local_floor,
ext_hand_tracking_data_source,
ext_plane_detection,
ext_future,
ext_user_presence,
fb_composition_layer_image_layout,
fb_composition_layer_alpha_blend,
#[cfg(target_os = "android")]
@@ -234,6 +243,7 @@ macro_rules! impl_ext {
fb_composition_layer_depth_test,
fb_spatial_entity_storage_batch,
fb_spatial_entity_user,
fb_face_tracking2,
htc_vive_cosmos_controller_interaction,
htc_facial_tracking,
htc_vive_focus3_controller_interaction,
@@ -241,6 +251,7 @@ macro_rules! impl_ext {
htc_vive_wrist_tracker_interaction,
htc_passthrough,
htc_foveation,
htc_anchor,
huawei_controller_interaction,
#[cfg(target_os = "android")]
khr_android_thread_settings,
@@ -272,6 +283,8 @@ macro_rules! impl_ext {
khr_composition_layer_equirect2,
khr_binding_modification,
khr_swapchain_usage_input_attachment_bit,
khr_locate_spaces,
khr_maintenance1,
meta_foveation_eye_tracked,
meta_local_dimming,
meta_passthrough_preferences,
@@ -279,11 +292,18 @@ macro_rules! impl_ext {
meta_vulkan_swapchain_create_info,
meta_performance_metrics,
meta_headset_id,
meta_recommended_layer_resolution,
meta_passthrough_color_lut,
meta_spatial_entity_mesh,
meta_automatic_layer_filter,
meta_touch_controller_plus,
meta_environment_depth,
ml_ml2_controller_interaction,
ml_frame_end_info,
ml_global_dimmer,
ml_compat,
ml_marker_understanding,
ml_localization_map,
ml_user_calibration,
mnd_headless,
mnd_swapchain_usage_input_attachment_bit,
@@ -315,7 +335,12 @@ macro_rules! impl_ext {
varjo_environment_depth_estimation,
varjo_marker_tracking,
varjo_view_offset,
varjo_xr4_controller_interaction,
yvr_controller_interaction,
extx_overlay,
mndx_egl_enable,
mndx_force_feedback_curl,
htcx_vive_tracker_interaction,
}
)*

20
crates/bevy_openxr/src/openxr/features/handtracking.rs
View File

@@ -1,10 +1,10 @@
use bevy::prelude::*;
use bevy_mod_xr::hands::{
spawn_hand_bones, HandBone, HandBoneRadius, HandSide, SpawnHandTracker,
SpawnHandTrackerCommandExecutor,
spawn_hand_bones, HandBone, HandSide, SpawnHandTracker, SpawnHandTrackerCommandExecutor,
XrHandBoneRadius,
};
use bevy_mod_xr::hands::{LeftHand, RightHand, XrHandBoneEntities};
use bevy_mod_xr::session::{XrPreDestroySession, XrSessionCreated, XrTrackingRoot};
use bevy_mod_xr::session::{XrPreDestroySession, XrSessionCreated};
use bevy_mod_xr::spaces::{
XrPrimaryReferenceSpace, XrReferenceSpace, XrSpaceLocationFlags, XrSpaceVelocityFlags,
XrVelocity,
@@ -70,11 +70,7 @@ fn handle_tracker_spawn(world: &mut World, tracker: Entity, side: HandSide) {
.insert(OxrHandTracker(oxr_tracker));
}
fn spawn_default_hands(mut cmds: Commands, root: Query<Entity, With<XrTrackingRoot>>) {
let Ok(root) = root.get_single() else {
error!("unable to get tracking root, skipping handtracker creation");
return;
};
fn spawn_default_hands(mut cmds: Commands) {
debug!("spawning default hands");
let left_bones = spawn_hand_bones(&mut cmds, |_| {
(
@@ -90,14 +86,12 @@ fn spawn_default_hands(mut cmds: Commands, root: Query<Entity, With<XrTrackingRo
OxrSpaceLocationFlags(openxr::SpaceLocationFlags::default()),
)
});
cmds.entity(root).push_children(&left_bones);
cmds.entity(root).push_children(&right_bones);
cmds.push(SpawnHandTracker {
cmds.queue(SpawnHandTracker {
joints: XrHandBoneEntities(left_bones),
tracker_bundle: DefaultHandTracker,
side: HandSide::Left,
});
cmds.push(SpawnHandTracker {
cmds.queue(SpawnHandTracker {
joints: XrHandBoneEntities(right_bones),
tracker_bundle: DefaultHandTracker,
side: HandSide::Right,
@@ -134,7 +128,7 @@ fn locate_hands(
session: Res<OxrSession>,
mut bone_query: Query<(
&HandBone,
&mut HandBoneRadius,
&mut XrHandBoneRadius,
&mut Transform,
Option<&mut XrVelocity>,
&mut OxrSpaceLocationFlags,

2
crates/bevy_openxr/src/openxr/features/overlay.rs
View File

@@ -55,7 +55,7 @@ fn add_overlay_info_to_chain(
exts: Res<OxrEnabledExtensions>,
settings: Res<OxrOverlaySettings>,
) {
if exts.other.contains(&"XR_EXTX_overlay\0".to_string()) {
if exts.extx_overlay {
chain.push(OxrSessionCreateInfoOverlay::new(
settings.flags,
settings.session_layer_placement,

31
crates/bevy_openxr/src/openxr/graphics.rs
View File

@@ -1,5 +1,5 @@
#[cfg(all(feature = "d3d12", windows))]
mod d3d12;
// #[cfg(all(feature = "d3d12", windows))]
// mod d3d12;
#[cfg(feature = "vulkan")]
pub mod vulkan;
@@ -8,7 +8,10 @@ use std::any::TypeId;
use bevy::math::UVec2;
use openxr::{FrameStream, FrameWaiter, Session};
use crate::{session::OxrSessionCreateNextChain, types::{AppInfo, OxrExtensions, Result, WgpuGraphics}};
use crate::{
session::OxrSessionCreateNextChain,
types::{AppInfo, OxrExtensions, Result, WgpuGraphics},
};
/// This is an extension trait to the [`Graphics`](openxr::Graphics) trait and is how the graphics API should be interacted with.
pub unsafe trait GraphicsExt: openxr::Graphics {
@@ -37,7 +40,7 @@ pub unsafe trait GraphicsExt: openxr::Graphics {
instance: &openxr::Instance,
system_id: openxr::SystemId,
) -> Result<(WgpuGraphics, Self::SessionCreateInfo)>;
unsafe fn create_session(
unsafe fn create_session(
instance: &openxr::Instance,
system_id: openxr::SystemId,
info: &Self::SessionCreateInfo,
@@ -74,8 +77,8 @@ impl GraphicsBackend {
const ALL: &'static [Self] = &[
#[cfg(feature = "vulkan")]
Self::Vulkan(()),
#[cfg(all(feature = "d3d12", windows))]
Self::D3D12(()),
// #[cfg(all(feature = "d3d12", windows))]
// Self::D3D12(()),
];
pub fn available_backends(exts: &OxrExtensions) -> Vec<Self> {
@@ -103,8 +106,8 @@ impl GraphicsBackend {
pub enum GraphicsWrap<T: GraphicsType> {
#[cfg(feature = "vulkan")]
Vulkan(T::Inner<openxr::Vulkan>),
#[cfg(all(feature = "d3d12", windows))]
D3D12(T::Inner<openxr::D3D12>),
// #[cfg(all(feature = "d3d12", windows))]
// D3D12(T::Inner<openxr::D3D12>),
}
impl<T: GraphicsType> GraphicsWrap<T> {
@@ -173,12 +176,12 @@ macro_rules! graphics_match {
type Api = openxr::Vulkan;
graphics_match!(@arm_impl Vulkan; $expr $(=> $($return)*)?)
},
#[cfg(all(feature = "d3d12", windows))]
$crate::graphics::GraphicsWrap::D3D12($var) => {
#[allow(unused)]
type Api = openxr::D3D12;
graphics_match!(@arm_impl D3D12; $expr $(=> $($return)*)?)
},
// #[cfg(all(feature = "d3d12", windows))]
// $crate::graphics::GraphicsWrap::D3D12($var) => {
// #[allow(unused)]
// type Api = openxr::D3D12;
// graphics_match!(@arm_impl D3D12; $expr $(=> $($return)*)?)
// },
}
};

60
crates/bevy_openxr/src/openxr/graphics/vulkan.rs
View File

@@ -21,7 +21,7 @@ const VK_TARGET_VERSION_ASH: u32 = ash::vk::make_api_version(
0,
VK_TARGET_VERSION.major() as u32,
VK_TARGET_VERSION.minor() as u32,
VK_TARGET_VERSION.patch() as u32,
VK_TARGET_VERSION.patch(),
);
unsafe impl GraphicsExt for openxr::Vulkan {
@@ -63,7 +63,7 @@ unsafe impl GraphicsExt for openxr::Vulkan {
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: format,
format,
usage: wgpu_hal::TextureUses::COLOR_TARGET | wgpu_hal::TextureUses::COPY_DST,
memory_flags: wgpu_hal::MemoryFlags::empty(),
view_formats: vec![],
@@ -84,7 +84,7 @@ unsafe impl GraphicsExt for openxr::Vulkan {
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: format,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
},
@@ -113,20 +113,20 @@ unsafe impl GraphicsExt for openxr::Vulkan {
let flags = wgpu::InstanceFlags::empty();
let extensions =
<Vulkan as Api>::Instance::desired_extensions(&vk_entry, VK_TARGET_VERSION_ASH, flags)?;
let device_extensions = vec![
ash::extensions::khr::Swapchain::name(),
ash::extensions::khr::DrawIndirectCount::name(),
#[cfg(target_os = "android")]
ash::extensions::khr::TimelineSemaphore::name(),
ash::vk::KhrImagelessFramebufferFn::name(),
ash::vk::KhrImageFormatListFn::name(),
let device_extensions = [
ash::khr::swapchain::NAME,
ash::khr::draw_indirect_count::NAME,
// #[cfg(target_os = "android")]
ash::khr::timeline_semaphore::NAME,
ash::khr::imageless_framebuffer::NAME,
ash::khr::image_format_list::NAME,
];
let vk_instance = unsafe {
let extensions_cchar: Vec<_> = extensions.iter().map(|s| s.as_ptr()).collect();
let app_name = CString::new(app_info.name.clone().into_owned())?;
let vk_app_info = ash::vk::ApplicationInfo::builder()
let vk_app_info = ash::vk::ApplicationInfo::default()
.application_name(&app_name)
.application_version(1)
.engine_name(&app_name)
@@ -136,8 +136,9 @@ unsafe impl GraphicsExt for openxr::Vulkan {
let vk_instance = instance
.create_vulkan_instance(
system_id,
#[allow(clippy::missing_transmute_annotations)]
std::mem::transmute(vk_entry.static_fn().get_instance_proc_addr),
&ash::vk::InstanceCreateInfo::builder()
&ash::vk::InstanceCreateInfo::default()
.application_info(&vk_app_info)
.enabled_extension_names(&extensions_cchar) as *const _
as *const _,
@@ -181,7 +182,7 @@ unsafe impl GraphicsExt for openxr::Vulkan {
extensions,
flags,
false,
Some(Box::new(())),
None,
)?
};
@@ -205,26 +206,26 @@ unsafe impl GraphicsExt for openxr::Vulkan {
.adapter
.physical_device_features(&enabled_extensions, wgpu_features);
let family_index = 0;
let family_info = ash::vk::DeviceQueueCreateInfo::builder()
let family_info = ash::vk::DeviceQueueCreateInfo::default()
.queue_family_index(family_index)
.queue_priorities(&[1.0])
.build();
.queue_priorities(&[1.0]);
let family_infos = [family_info];
let mut physical_device_multiview_features = ash::vk::PhysicalDeviceMultiviewFeatures {
multiview: ash::vk::TRUE,
..Default::default()
};
let info = enabled_phd_features
.add_to_device_create_builder(
ash::vk::DeviceCreateInfo::builder()
.add_to_device_create(
ash::vk::DeviceCreateInfo::default()
.queue_create_infos(&family_infos)
.push_next(&mut ash::vk::PhysicalDeviceMultiviewFeatures {
multiview: ash::vk::TRUE,
..Default::default()
}),
.push_next(&mut physical_device_multiview_features),
)
.enabled_extension_names(&extensions_cchar)
.build();
.enabled_extension_names(&extensions_cchar);
let vk_device = unsafe {
let vk_device = instance
.create_vulkan_device(
system_id,
#[allow(clippy::missing_transmute_annotations)]
std::mem::transmute(vk_entry.static_fn().get_instance_proc_addr),
vk_physical_device.as_raw() as _,
&info as *const _ as *const _,
@@ -241,9 +242,10 @@ unsafe impl GraphicsExt for openxr::Vulkan {
let wgpu_open_device = unsafe {
wgpu_exposed_adapter.adapter.device_from_raw(
vk_device,
true,
None,
&enabled_extensions,
wgpu_features,
&wgpu::MemoryHints::Performance,
family_info.queue_family_index,
0,
)
@@ -273,6 +275,7 @@ unsafe impl GraphicsExt for openxr::Vulkan {
max_push_constant_size: 4,
..Default::default()
},
memory_hints: wgpu::MemoryHints::Performance,
},
None,
)
@@ -320,7 +323,7 @@ unsafe impl GraphicsExt for openxr::Vulkan {
ty: sys::SessionCreateInfo::TYPE,
next: &binding as *const _ as *const _,
create_flags: Default::default(),
system_id: system_id,
system_id,
};
let mut out = sys::Session::NULL;
cvt((instance.fp().create_session)(
@@ -379,7 +382,7 @@ fn vulkan_to_wgpu(format: ash::vk::Format) -> Option<wgpu::TextureFormat> {
F::R8G8B8A8_SINT => Tf::Rgba8Sint,
F::A2B10G10R10_UINT_PACK32 => Tf::Rgb10a2Uint,
F::A2B10G10R10_UNORM_PACK32 => Tf::Rgb10a2Unorm,
F::B10G11R11_UFLOAT_PACK32 => Tf::Rg11b10Float,
F::B10G11R11_UFLOAT_PACK32 => Tf::Rg11b10Ufloat,
F::R32G32_UINT => Tf::Rg32Uint,
F::R32G32_SINT => Tf::Rg32Sint,
F::R32G32_SFLOAT => Tf::Rg32Float,
@@ -630,7 +633,7 @@ fn wgpu_to_vulkan(format: wgpu::TextureFormat) -> Option<ash::vk::Format> {
Tf::Rgba8Sint => F::R8G8B8A8_SINT,
Tf::Rgb10a2Uint => F::A2B10G10R10_UINT_PACK32,
Tf::Rgb10a2Unorm => F::A2B10G10R10_UNORM_PACK32,
Tf::Rg11b10Float => F::B10G11R11_UFLOAT_PACK32,
Tf::Rg11b10Ufloat => F::B10G11R11_UFLOAT_PACK32,
Tf::Rg32Uint => F::R32G32_UINT,
Tf::Rg32Sint => F::R32G32_SINT,
Tf::Rg32Float => F::R32G32_SFLOAT,
@@ -724,4 +727,3 @@ fn wgpu_to_vulkan(format: wgpu::TextureFormat) -> Option<ash::vk::Format> {
},
})
}

26
crates/bevy_openxr/src/openxr/helper_traits.rs
View File

@@ -1,5 +1,4 @@
use bevy::prelude::*;
use bevy_mod_xr::types::XrPose;
use bevy::{math::Vec3A, prelude::*};
pub trait ToPosef {
fn to_posef(&self) -> openxr::Posef;
@@ -7,8 +6,8 @@ pub trait ToPosef {
pub trait ToTransform {
fn to_transform(&self) -> Transform;
}
pub trait ToXrPose {
fn to_xr_pose(&self) -> XrPose;
pub trait ToIsometry3d {
fn to_xr_pose(&self) -> Isometry3d;
}
pub trait ToQuaternionf {
fn to_quaternionf(&self) -> openxr::Quaternionf;
@@ -42,15 +41,15 @@ impl ToTransform for openxr::Posef {
.with_rotation(self.orientation.to_quat())
}
}
impl ToXrPose for openxr::Posef {
fn to_xr_pose(&self) -> XrPose {
XrPose {
translation: self.position.to_vec3(),
impl ToIsometry3d for openxr::Posef {
fn to_xr_pose(&self) -> Isometry3d {
Isometry3d {
translation: self.position.to_vec3().into(),
rotation: self.orientation.to_quat(),
}
}
}
impl ToPosef for XrPose {
impl ToPosef for Isometry3d {
fn to_posef(&self) -> openxr::Posef {
openxr::Posef {
orientation: self.rotation.to_quaternionf(),
@@ -90,6 +89,15 @@ impl ToVector3f for Vec3 {
}
}
}
impl ToVector3f for Vec3A {
fn to_vector3f(&self) -> openxr::Vector3f {
openxr::Vector3f {
x: self.x,
y: self.y,
z: self.z,
}
}
}
impl ToVec3 for openxr::Vector3f {
fn to_vec3(&self) -> Vec3 {
Vec3 {

26
crates/bevy_openxr/src/openxr/init.rs
View File

@@ -113,7 +113,7 @@ impl Plugin for OxrInitPlugin {
(
create_xr_session
.run_if(state_equals(XrState::Available))
.run_if(on_event::<XrCreateSessionEvent>()),
.run_if(on_event::<XrCreateSessionEvent>),
(
destroy_xr_session,
(|v: Res<XrDestroySessionRender>| {
@@ -122,16 +122,16 @@ impl Plugin for OxrInitPlugin {
}),
)
.run_if(state_matches!(XrState::Exiting { .. }))
.run_if(on_event::<XrDestroySessionEvent>()),
.run_if(on_event::<XrDestroySessionEvent>),
begin_xr_session
.run_if(state_equals(XrState::Ready))
.run_if(on_event::<XrBeginSessionEvent>()),
.run_if(on_event::<XrBeginSessionEvent>),
end_xr_session
.run_if(state_equals(XrState::Stopping))
.run_if(on_event::<XrEndSessionEvent>()),
.run_if(on_event::<XrEndSessionEvent>),
request_exit_xr_session
.run_if(session_created)
.run_if(on_event::<XrRequestExitEvent>()),
.run_if(on_event::<XrRequestExitEvent>),
)
.in_set(XrHandleEvents::SessionStateUpdateEvents),
)
@@ -146,9 +146,6 @@ impl Plugin for OxrInitPlugin {
.insert_non_send_resource(session_create_info)
.init_non_send_resource::<OxrSessionCreateNextChain>();
app.world_mut()
.spawn((SpatialBundle::default(), XrTrackingRoot));
app.world_mut()
.resource_mut::<Events<XrStateChanged>>()
.send(XrStateChanged(XrState::Available));
@@ -178,7 +175,7 @@ impl Plugin for OxrInitPlugin {
})
.run_if(
resource_exists::<XrDestroySessionRender>
.and_then(|v: Res<XrDestroySessionRender>| v.0.load(Ordering::Relaxed)),
.and(|v: Res<XrDestroySessionRender>| v.0.load(Ordering::Relaxed)),
)
.chain(),
);
@@ -467,7 +464,7 @@ pub fn create_xr_session(world: &mut World) {
let system_id = world.resource::<OxrSystemId>();
match init_xr_session(
device.wgpu_device(),
&instance,
instance,
**system_id,
&mut chain,
create_info.clone(),
@@ -475,8 +472,8 @@ pub fn create_xr_session(world: &mut World) {
Ok((session, frame_waiter, frame_stream, swapchain, images, graphics_info)) => {
world.insert_resource(session.clone());
world.insert_resource(frame_waiter);
world.insert_resource(images.clone());
world.insert_resource(graphics_info.clone());
world.insert_resource(images);
world.insert_resource(graphics_info);
world.insert_resource(OxrRenderResources {
session,
frame_stream,
@@ -511,12 +508,13 @@ pub fn begin_xr_session(
world: &mut World,
// session: Res<OxrSession>, mut session_started: ResMut<OxrSessionStarted>
) {
let _span = info_span!("xr_begin_session");
let _span = debug_span!("xr_begin_session").entered();
world
.get_resource::<OxrSession>()
.unwrap()
.begin(openxr::ViewConfigurationType::PRIMARY_STEREO)
.expect("Failed to begin session");
drop(_span);
world.get_resource_mut::<OxrSessionStarted>().unwrap().0 = true;
world.run_schedule(XrPostSessionBegin);
}
@@ -527,7 +525,7 @@ pub fn end_xr_session(
) {
// Maybe this could be an event?
world.run_schedule(XrPreSessionEnd);
let _span = info_span!("xr_end_session");
let _span = debug_span!("xr_end_session").entered();
world
.get_resource::<OxrSession>()
.unwrap()

14
crates/bevy_openxr/src/openxr/layer_builder.rs
View File

@@ -37,14 +37,14 @@ impl LayerProvider for ProjectionLayer {
Some(Box::new(
CompositionLayerProjection::new()
.layer_flags(CompositionLayerFlags::BLEND_TEXTURE_SOURCE_ALPHA)
.space(&stage)
.space(stage)
.views(&[
CompositionLayerProjectionView::new()
.pose(openxr_views.0[0].pose)
.fov(openxr_views.0[0].fov)
.sub_image(
SwapchainSubImage::new()
.swapchain(&swapchain)
.swapchain(swapchain)
.image_array_index(0)
.image_rect(rect),
),
@@ -53,7 +53,7 @@ impl LayerProvider for ProjectionLayer {
.fov(openxr_views.0[1].fov)
.sub_image(
SwapchainSubImage::new()
.swapchain(&swapchain)
.swapchain(swapchain)
.image_array_index(1)
.image_rect(rect),
),
@@ -235,9 +235,15 @@ impl<'a> Default for CompositionLayerProjection<'a> {
pub struct CompositionLayerPassthrough {
inner: sys::CompositionLayerPassthroughFB,
}
impl Default for CompositionLayerPassthrough {
fn default() -> Self {
Self::new()
}
}
impl CompositionLayerPassthrough {
#[inline]
pub fn new() -> Self {
pub const fn new() -> Self {
Self {
inner: openxr::sys::CompositionLayerPassthroughFB {
ty: openxr::sys::CompositionLayerPassthroughFB::TYPE,

4
crates/bevy_openxr/src/openxr/mod.rs
View File

@@ -60,8 +60,8 @@ pub fn add_xr_plugins<G: PluginGroup>(plugins: G) -> PluginGroupBuilder {
.build()
.disable::<RenderPlugin>()
// .disable::<PipelinedRenderingPlugin>()
.add_before::<RenderPlugin, _>(XrSessionPlugin { auto_handle: true })
.add_before::<RenderPlugin, _>(OxrInitPlugin::default())
.add_before::<RenderPlugin>(XrSessionPlugin { auto_handle: true })
.add_before::<RenderPlugin>(OxrInitPlugin::default())
.add(OxrEventsPlugin)
.add(OxrReferenceSpacePlugin::default())
.add(OxrRenderPlugin)

13
crates/bevy_openxr/src/openxr/poll_events.rs
View File

@@ -19,7 +19,7 @@ impl Plugin for OxrEventsPlugin {
}
/// Polls any OpenXR events and handles them accordingly
pub fn poll_events(world: &mut World) {
let _span = info_span!("xr_poll_events");
let _span = debug_span!("xr_poll_events").entered();
let instance = world.resource::<OxrInstance>().clone();
let handlers = world.remove_resource::<OxrEventHandlers>().unwrap();
let mut buffer = EventDataBuffer::default();
@@ -45,15 +45,16 @@ use super::{openxr_session_available, resources::OxrInstance};
pub struct OxrEventHandlers {
pub handlers: Vec<OxrEventHandler>,
}
pub type OxrEventHandler = SystemId<OxrEvent, ()>;
pub type OxrEventHandler = SystemId<In<OxrEvent>, ()>;
pub struct OxrEvent {
event: Rc<RefCell<Option<Event<'static>>>>,
}
impl OxrEvent {
pub(crate) fn new<'a>(event: Rc<RefCell<Option<Event<'a>>>>) -> Self {
pub(crate) fn new(event: Rc<RefCell<Option<Event<'_>>>>) -> Self {
Self {
#[allow(clippy::missing_transmute_annotations)]
event: unsafe { mem::transmute(event) },
}
}
@@ -63,19 +64,19 @@ impl OxrEvent {
/// don't Store the [Event] anywhere!!
#[allow(clippy::needless_lifetimes)]
pub unsafe fn get<'a>(&'a self) -> Option<Event<'a>> {
self.event.borrow().clone()
*self.event.borrow()
}
}
pub trait OxrEventHandlerExt {
fn add_oxr_event_handler<M>(
&mut self,
system: impl IntoSystem<OxrEvent, (), M> + 'static,
system: impl IntoSystem<In<OxrEvent>, (), M> + 'static,
) -> &mut Self;
}
impl OxrEventHandlerExt for App {
fn add_oxr_event_handler<M>(
&mut self,
system: impl IntoSystem<OxrEvent, (), M> + 'static,
system: impl IntoSystem<In<OxrEvent>, (), M> + 'static,
) -> &mut Self {
self.init_resource::<OxrEventHandlers>();
let id = self.register_system(system);

53
crates/bevy_openxr/src/openxr/render.rs
View File

@@ -1,5 +1,4 @@
use bevy::{
ecs::query::QuerySingleError,
prelude::*,
render::{
camera::{ManualTextureView, ManualTextureViewHandle, ManualTextureViews, RenderTarget},
@@ -11,10 +10,8 @@ use bevy::{
transform::TransformSystem,
};
use bevy_mod_xr::{
camera::{XrCamera, XrCameraBundle, XrProjection},
session::{
XrFirst, XrHandleEvents, XrPreDestroySession, XrRenderSet, XrRootTransform, XrTrackingRoot,
},
camera::{XrCamera, XrProjection},
session::{XrFirst, XrHandleEvents, XrPreDestroySession, XrRenderSet, XrRootTransform},
spaces::XrPrimaryReferenceSpace,
};
use openxr::ViewStateFlags;
@@ -34,10 +31,6 @@ impl Plugin for OxrRenderPlugin {
fn build(&self, app: &mut App) {
if app.is_plugin_added::<PipelinedRenderingPlugin>() {
app.init_resource::<Pipelined>();
// if let Some(sub_app) = app.remove_sub_app(RenderExtractApp) {
// app.insert_sub_app(RenderExtractApp, SubApp::new(sub_app.app, update_rendering));
// }
}
app.add_plugins((
@@ -140,43 +133,26 @@ pub fn init_views(
graphics_info: Res<OxrGraphicsInfo>,
mut manual_texture_views: ResMut<ManualTextureViews>,
swapchain_images: Res<OxrSwapchainImages>,
root: Query<Entity, With<XrTrackingRoot>>,
mut commands: Commands,
) {
let _span = info_span!("xr_init_views");
let temp_tex = swapchain_images.first().unwrap();
// this for loop is to easily add support for quad or mono views in the future.
for index in 0..2 {
info!("{}", graphics_info.resolution);
let _span = debug_span!("xr_init_view").entered();
info!("XrCamera resolution: {}", graphics_info.resolution);
let view_handle =
add_texture_view(&mut manual_texture_views, temp_tex, &graphics_info, index);
let cam = commands
.spawn((XrCameraBundle {
camera: Camera {
target: RenderTarget::TextureView(view_handle),
..Default::default()
},
view: XrCamera(index),
commands.spawn((
Camera {
target: RenderTarget::TextureView(view_handle),
..Default::default()
},))
.id();
match root.get_single() {
Ok(root) => {
commands.entity(root).add_child(cam);
}
Err(QuerySingleError::NoEntities(_)) => {
warn!("No XrTrackingRoot!");
}
Err(QuerySingleError::MultipleEntities(_)) => {
warn!("Multiple XrTrackingRoots! this is not allowed");
}
}
},
XrCamera(index),
));
}
}
pub fn wait_frame(mut frame_waiter: ResMut<OxrFrameWaiter>, mut commands: Commands) {
let _span = info_span!("xr_wait_frame");
let state = frame_waiter.wait().expect("Failed to wait frame");
commands.insert_resource(OxrFrameState(state));
}
@@ -385,11 +361,11 @@ pub fn insert_texture_views(
mut manual_texture_views: ResMut<ManualTextureViews>,
graphics_info: Res<OxrGraphicsInfo>,
) {
let _span = info_span!("xr_insert_texture_views");
let index = swapchain.acquire_image().expect("Failed to acquire image");
let image = &swapchain_images[index as usize];
for i in 0..2 {
let _span = debug_span!("xr_insert_texture_view").entered();
add_texture_view(&mut manual_texture_views, image, &graphics_info, i);
}
}
@@ -423,23 +399,21 @@ pub fn add_texture_view(
}
pub fn begin_frame(mut frame_stream: ResMut<OxrFrameStream>) {
let _span = info_span!("xr_begin_frame");
frame_stream.begin().expect("Failed to begin frame");
}
pub fn release_image(mut swapchain: ResMut<OxrSwapchain>) {
let _span = info_span!("xr_release_image");
#[cfg(target_os = "android")]
{
let ctx = ndk_context::android_context();
let vm = unsafe { jni::JavaVM::from_raw(ctx.vm().cast()) }.unwrap();
let env = vm.attach_current_thread_as_daemon();
}
let _span = debug_span!("xr_release_image").entered();
swapchain.release_image().unwrap();
}
pub fn end_frame(world: &mut World) {
let _span = info_span!("xr_end_frame");
#[cfg(target_os = "android")]
{
let ctx = ndk_context::android_context();
@@ -449,6 +423,7 @@ pub fn end_frame(world: &mut World) {
world.resource_scope::<OxrFrameStream, ()>(|world, mut frame_stream| {
let mut layers = vec![];
let frame_state = world.resource::<OxrFrameState>();
let _span = debug_span!("get layers").entered();
if frame_state.should_render {
for layer in world.resource::<OxrRenderLayers>().iter() {
if let Some(layer) = layer.get(world) {
@@ -456,7 +431,9 @@ pub fn end_frame(world: &mut World) {
}
}
}
drop(_span);
let layers: Vec<_> = layers.iter().map(Box::as_ref).collect();
let _span = debug_span!("xr_end_frame").entered();
if let Err(e) = frame_stream.end(
frame_state.predicted_display_time,
world.resource::<OxrGraphicsInfo>().blend_mode,

10
crates/bevy_openxr/src/openxr/resources.rs
View File

@@ -43,6 +43,7 @@ impl OxrEntry {
application_version: app_info.version.to_u32(),
engine_name: "Bevy",
engine_version: Version::BEVY.to_u32(),
api_version: openxr::Version::new(1, 1, 36),
},
&required_exts.into(),
layers,
@@ -108,7 +109,7 @@ impl OxrInstance {
graphics_match!(
self.1;
_ => {
let (graphics, session_info) = Api::init_graphics(&self.2, &self, system_id)?;
let (graphics, session_info) = Api::init_graphics(&self.2, self, system_id)?;
Ok((graphics, SessionCreateInfo(Api::wrap(session_info))))
}
@@ -185,7 +186,7 @@ impl OxrFrameStream {
stream => {
let mut new_layers = vec![];
for (i, layer) in layers.into_iter().enumerate() {
for (i, layer) in layers.iter().enumerate() {
if let Some(swapchain) = layer.swapchain() {
if !swapchain.0.using_graphics::<Api>() {
error!(
@@ -196,7 +197,10 @@ impl OxrFrameStream {
continue;
}
}
new_layers.push(unsafe { std::mem::transmute(layer.header()) });
new_layers.push(unsafe {
#[allow(clippy::missing_transmute_annotations)]
std::mem::transmute(layer.header())
});
}
Ok(stream.end(display_time, environment_blend_mode, new_layers.as_slice())?)

28
crates/bevy_openxr/src/openxr/spaces.rs
View File

@@ -7,7 +7,6 @@ use bevy_mod_xr::{
XrDestroySpace, XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace, XrSpaceLocationFlags,
XrSpaceVelocityFlags, XrVelocity,
},
types::XrPose,
};
use openxr::{
sys, HandJointLocation, HandJointLocations, HandJointVelocities, HandJointVelocity,
@@ -51,28 +50,11 @@ impl Plugin for OxrSpatialPlugin {
.in_set(OxrSpaceSyncSet)
.run_if(openxr_session_running),
)
.observe(add_location_flags)
.observe(add_velocity_flags);
.register_required_components::<XrSpaceLocationFlags, OxrSpaceLocationFlags>()
.register_required_components::<XrSpaceVelocityFlags, OxrSpaceVelocityFlags>();
}
}
fn add_velocity_flags(event: Trigger<OnAdd, XrVelocity>, mut cmds: Commands) {
if event.entity() == Entity::PLACEHOLDER {
error!("called add_location_flags observer without entity");
return;
}
cmds.entity(event.entity())
.insert(OxrSpaceLocationFlags(openxr::SpaceLocationFlags::default()));
}
fn add_location_flags(event: Trigger<OnAdd, XrSpace>, mut cmds: Commands) {
if event.entity() == Entity::PLACEHOLDER {
error!("called add_location_flags observer without entity");
return;
}
cmds.entity(event.entity())
.insert(OxrSpaceLocationFlags(openxr::SpaceLocationFlags::default()));
}
fn destroy_space_event(instance: Res<OxrInstance>, mut events: EventReader<XrDestroySpace>) {
for space in events.read() {
match instance.destroy_space(space.0) {
@@ -119,7 +101,7 @@ unsafe extern "system" fn patched_destroy_space(space: openxr::sys::Space) -> op
}
}
#[derive(Clone, Copy, Component)]
#[derive(Clone, Copy, Component, Default)]
pub struct OxrSpaceLocationFlags(pub openxr::SpaceLocationFlags);
impl OxrSpaceLocationFlags {
pub fn pos_valid(&self) -> bool {
@@ -135,7 +117,7 @@ impl OxrSpaceLocationFlags {
self.0.contains(SpaceLocationFlags::ORIENTATION_TRACKED)
}
}
#[derive(Clone, Copy, Component)]
#[derive(Clone, Copy, Component, Default)]
pub struct OxrSpaceVelocityFlags(pub openxr::SpaceVelocityFlags);
impl OxrSpaceVelocityFlags {
pub fn linear_valid(&self) -> bool {
@@ -231,7 +213,7 @@ impl OxrSession {
&self,
action: &openxr::Action<T>,
subaction_path: openxr::Path,
pose_in_space: XrPose,
pose_in_space: Isometry3d,
) -> openxr::Result<XrSpace> {
let info = sys::ActionSpaceCreateInfo {
ty: sys::ActionSpaceCreateInfo::TYPE,

2
crates/bevy_openxr/src/openxr/types.rs
View File

@@ -24,7 +24,7 @@ pub struct Version(pub u8, pub u8, pub u16);
impl Version {
/// Bevy's version number
pub const BEVY: Self = Self(0, 13, 0);
pub const BEVY: Self = Self(0, 15, 0);
pub const fn to_u32(self) -> u32 {
let major = (self.0 as u32) << 24;

8
crates/bevy_webxr/Cargo.toml
View File

@@ -12,11 +12,11 @@ bevy.workspace = true
# all dependencies are placed under this since on anything but wasm, this crate is completely empty
[target.'cfg(target_family = "wasm")'.dependencies]
thiserror = "1.0.57"
wgpu = "0.19.3"
wgpu-hal = "0.19.3"
thiserror.workspace = true
wgpu.workspace = true
wgpu-hal.workspace = true
bevy_mod_xr = { path = "../bevy_xr", version = "0.1.0-rc1" }
bevy_mod_xr.workspace = true
[lints.clippy]
too_many_arguments = "allow"

4
crates/bevy_xr/src/actions.rs
View File

@@ -94,11 +94,11 @@ impl<A: Action<ActionType = bool>> ActionState<A> {
}
pub fn just_pressed(&self) -> bool {
self.previous_state == false && self.current_state == true
!self.previous_state && self.current_state
}
pub fn just_released(&self) -> bool {
self.previous_state == true && self.current_state == false
self.previous_state && !self.current_state
}
pub fn press(&mut self) {

80
crates/bevy_xr/src/camera.rs
View File

@@ -1,25 +1,24 @@
use core::panic;
use bevy::app::{App, Plugin, PostUpdate};
use bevy::core_pipeline::core_3d::graph::Core3d;
use bevy::core_pipeline::core_3d::Camera3d;
use bevy::core_pipeline::tonemapping::{DebandDither, Tonemapping};
use bevy::ecs::bundle::Bundle;
use bevy::ecs::component::Component;
use bevy::ecs::component::{Component, StorageType};
use bevy::ecs::reflect::ReflectComponent;
use bevy::ecs::schedule::IntoSystemConfigs;
use bevy::math::{Mat4, Vec3A};
use bevy::pbr::{build_directional_light_cascades, clear_directional_light_cascades, SimulationLightSystems};
use bevy::pbr::{
build_directional_light_cascades, clear_directional_light_cascades, SimulationLightSystems,
};
use bevy::prelude::Projection;
use bevy::reflect::std_traits::ReflectDefault;
use bevy::reflect::Reflect;
use bevy::render::camera::{
Camera, CameraMainTextureUsages, CameraProjection, CameraProjectionPlugin, CameraRenderGraph,
Exposure,
};
use bevy::render::camera::{CameraProjection, CameraProjectionPlugin};
use bevy::render::extract_component::{ExtractComponent, ExtractComponentPlugin};
use bevy::render::primitives::Frustum;
use bevy::render::view::{update_frusta, ColorGrading, VisibilitySystems, VisibleEntities};
use bevy::transform::components::{GlobalTransform, Transform};
use bevy::render::view::{update_frusta, VisibilitySystems};
use bevy::transform::TransformSystem;
use crate::session::XrTracker;
pub struct XrCameraPlugin;
impl Plugin for XrCameraPlugin {
@@ -44,12 +43,21 @@ impl Plugin for XrCameraPlugin {
}
}
#[derive(Debug, Clone, Component, Reflect, ExtractComponent)]
#[derive(Debug, Clone, Reflect, ExtractComponent)]
#[reflect(Component, Default)]
pub struct XrProjection {
pub projection_matrix: Mat4,
pub near: f32,
}
impl Component for XrProjection {
const STORAGE_TYPE: StorageType = StorageType::Table;
fn register_component_hooks(hooks: &mut bevy::ecs::component::ComponentHooks) {
hooks.on_add(|mut world, entity, _| {
world.commands().entity(entity).remove::<Projection>();
});
}
}
impl Default for XrProjection {
fn default() -> Self {
@@ -62,16 +70,15 @@ impl Default for XrProjection {
/// Marker component for an XR view. It is the backends responsibility to update this.
#[derive(Clone, Copy, Component, ExtractComponent, Debug, Default)]
#[require(Camera3d, XrProjection, XrTracker)]
pub struct XrCamera(pub u32);
impl CameraProjection for XrProjection {
fn update(&mut self, _width: f32, _height: f32) {}
fn far(&self) -> f32 {
let far = self.projection_matrix.to_cols_array()[14]
/ (self.projection_matrix.to_cols_array()[10] + 1.0);
far
self.projection_matrix.to_cols_array()[14]
/ (self.projection_matrix.to_cols_array()[10] + 1.0)
}
// TODO calculate this properly
@@ -99,43 +106,8 @@ impl CameraProjection for XrProjection {
fn get_clip_from_view(&self) -> Mat4 {
self.projection_matrix
}
}
#[derive(Bundle)]
pub struct XrCameraBundle {
pub camera: Camera,
pub camera_render_graph: CameraRenderGraph,
pub projection: XrProjection,
pub visible_entities: VisibleEntities,
pub frustum: Frustum,
pub transform: Transform,
pub global_transform: GlobalTransform,
pub camera_3d: Camera3d,
pub tonemapping: Tonemapping,
pub dither: DebandDither,
pub color_grading: ColorGrading,
pub exposure: Exposure,
pub main_texture_usages: CameraMainTextureUsages,
pub view: XrCamera,
}
impl Default for XrCameraBundle {
fn default() -> Self {
Self {
camera_render_graph: CameraRenderGraph::new(Core3d),
camera: Default::default(),
projection: Default::default(),
visible_entities: Default::default(),
frustum: Default::default(),
transform: Default::default(),
global_transform: Default::default(),
camera_3d: Default::default(),
tonemapping: Default::default(),
color_grading: Default::default(),
exposure: Default::default(),
main_texture_usages: Default::default(),
dither: DebandDither::Enabled,
view: XrCamera(0),
}
fn get_clip_from_view_for_sub(&self, _sub_view: &bevy::render::camera::SubCameraView) -> Mat4 {
panic!("sub view not supported for xr camera");
}
}

45
crates/bevy_xr/src/hands.rs
View File

@@ -1,15 +1,11 @@
use bevy::{
ecs::{component::Component, entity::Entity, world::Command},
hierarchy::BuildWorldChildren,
log::{error, warn},
log::warn,
math::bool,
prelude::{Bundle, Commands, Deref, DerefMut, Resource, SpatialBundle, With, World},
prelude::{Bundle, Commands, Deref, DerefMut, Resource, Transform, Visibility, World},
};
use crate::{
session:: XrTrackingRoot,
spaces::XrSpaceLocationFlags,
};
use crate::{session::XrTracker, spaces::XrSpaceLocationFlags};
pub const HAND_JOINT_COUNT: usize = 26;
pub fn spawn_hand_bones<T: Bundle>(
@@ -18,15 +14,7 @@ pub fn spawn_hand_bones<T: Bundle>(
) -> [Entity; HAND_JOINT_COUNT] {
let mut bones: [Entity; HAND_JOINT_COUNT] = [Entity::PLACEHOLDER; HAND_JOINT_COUNT];
for bone in HandBone::get_all_bones().into_iter() {
bones[bone as usize] = cmds
.spawn((
SpatialBundle::default(),
bone,
HandBoneRadius(0.0),
XrSpaceLocationFlags::default(),
))
.insert((get_bundle)(bone))
.id();
bones[bone as usize] = cmds.spawn((bone, (get_bundle)(bone))).id();
}
bones
}
@@ -48,11 +36,18 @@ pub struct RightHand;
pub struct XrHandBoneEntities(pub [Entity; HAND_JOINT_COUNT]);
#[repr(transparent)]
#[derive(Clone, Copy, Component, Debug, DerefMut, Deref)]
pub struct HandBoneRadius(pub f32);
#[derive(Clone, Copy, Component, Debug, DerefMut, Deref, Default)]
pub struct XrHandBoneRadius(pub f32);
#[repr(u8)]
#[derive(Clone, Copy, Component, Debug)]
#[require(
XrSpaceLocationFlags,
XrHandBoneRadius,
Transform,
Visibility,
XrTracker
)]
pub enum HandBone {
Palm = 0,
Wrist = 1,
@@ -192,22 +187,14 @@ impl<B: Bundle> Command for SpawnHandTracker<B> {
warn!("no SpawnHandTracker executor defined, skipping handtracker creation");
return;
};
let Ok(root) = world
.query_filtered::<Entity, With<XrTrackingRoot>>()
.get_single(world)
else {
error!("unable to get tracking root, skipping handtracker creation");
return;
};
let mut tracker = world.spawn(self.joints);
match &self.side {
HandSide::Left => tracker.insert(LeftHand),
HandSide::Right => tracker.insert(RightHand),
HandSide::Left => tracker.insert((XrTracker, LeftHand)),
HandSide::Right => tracker.insert((XrTracker, RightHand)),
};
let tracker = tracker.id();
world.entity_mut(root).push_children(&[tracker]);
executor.0(world, tracker, self.side);
if let Some(mut tracker) = world.get_entity_mut(tracker) {
if let Ok(mut tracker) = world.get_entity_mut(tracker) {
tracker.insert(self.side);
tracker.insert(self.tracker_bundle);
}

34
crates/bevy_xr/src/session.rs
View File

@@ -1,7 +1,9 @@
use std::convert::identity;
use std::sync::atomic::AtomicBool;
use std::sync::Arc;
use bevy::app::{AppExit, MainScheduleOrder};
use bevy::ecs::component::StorageType;
use bevy::ecs::schedule::ScheduleLabel;
use bevy::prelude::*;
use bevy::render::extract_resource::{ExtractResource, ExtractResourcePlugin};
@@ -84,7 +86,33 @@ pub struct XrRootTransform(pub GlobalTransform);
/// Component used to specify the entity we should use as the tracking root.
#[derive(Component)]
#[require(Transform, Visibility)]
pub struct XrTrackingRoot;
#[derive(Resource)]
struct TrackingRootRes(Entity);
/// Makes the entity a child of the XrTrackingRoot if the entity has no parent
#[derive(Clone, Copy, Hash, PartialEq, Eq, Reflect, Debug, Default)]
pub struct XrTracker;
impl Component for XrTracker {
const STORAGE_TYPE: StorageType = StorageType::SparseSet;
fn register_component_hooks(hooks: &mut bevy::ecs::component::ComponentHooks) {
hooks.on_add(|mut world, entity, _| {
if world
.entity(entity)
.get_components::<Has<Parent>>()
.is_some_and(identity)
{
return;
}
let Some(root) = world.get_resource::<TrackingRootRes>().map(|r| r.0) else {
return;
};
world.commands().entity(root).add_child(entity);
});
}
}
pub struct XrSessionPlugin {
pub auto_handle: bool,
@@ -121,10 +149,12 @@ impl Plugin for XrSessionPlugin {
.add_systems(
XrFirst,
exits_session_on_app_exit
.run_if(on_event::<AppExit>())
.run_if(on_event::<AppExit>)
.run_if(session_created)
.in_set(XrHandleEvents::ExitEvents),
);
let root = app.world_mut().spawn(XrTrackingRoot).id();
app.world_mut().insert_resource(TrackingRootRes(root));
app.world_mut()
.resource_mut::<MainScheduleOrder>()
.labels
@@ -153,7 +183,7 @@ impl Plugin for XrSessionPlugin {
XrFirst,
exits_session_on_app_exit
.before(XrHandleEvents::ExitEvents)
.run_if(on_event::<AppExit>().and_then(session_running)),
.run_if(on_event::<AppExit>.and(session_running)),
);
let render_app = app.sub_app_mut(RenderApp);

34
crates/bevy_xr/src/spaces.rs
View File

@@ -1,15 +1,18 @@
use bevy::{
ecs::component::StorageType,
prelude::*,
render::{extract_component::ExtractComponent, extract_resource::ExtractResource},
};
use crate::session::XrTracker;
/// Any Spaces will be invalid after the owning session exits
#[repr(transparent)]
#[derive(Clone, Copy, Hash, PartialEq, Eq, Reflect, Debug, ExtractComponent)]
#[derive(Component, Clone, Copy, Hash, PartialEq, Eq, Reflect, Debug, ExtractComponent)]
#[require(XrSpaceLocationFlags, Transform, Visibility, XrTracker)]
pub struct XrSpace(u64);
#[derive(Clone, Copy, Reflect, Debug, ExtractComponent, Default)]
#[derive(Component, Clone, Copy, Reflect, Debug, ExtractComponent, Default)]
#[require(XrSpaceVelocityFlags)]
pub struct XrVelocity {
/// Velocity of a space relative to it's reference space
pub linear: Vec3,
@@ -69,28 +72,3 @@ impl XrSpace {
self.0
}
}
impl Component for XrSpace {
const STORAGE_TYPE: StorageType = StorageType::Table;
fn register_component_hooks(hooks: &mut bevy::ecs::component::ComponentHooks) {
hooks.on_add(|mut world, entity, _| {
world
.commands()
.entity(entity)
.insert(XrSpaceLocationFlags::default());
});
}
}
impl Component for XrVelocity {
const STORAGE_TYPE: StorageType = StorageType::Table;
fn register_component_hooks(hooks: &mut bevy::ecs::component::ComponentHooks) {
hooks.on_add(|mut world, entity, _| {
world
.commands()
.entity(entity)
.insert(XrSpaceVelocityFlags::default());
});
}
}

28
crates/bevy_xr/src/types.rs
View File

@@ -1,26 +1,4 @@
use bevy::{
math::{Quat, Vec3},
reflect::Reflect,
transform::components::Transform,
};
use bevy::math::Isometry3d;
#[derive(Clone, Copy, PartialEq, Reflect, Debug)]
pub struct XrPose {
pub translation: Vec3,
pub rotation: Quat,
}
impl Default for XrPose {
fn default() -> Self {
Self::IDENTITY
}
}
impl XrPose {
pub const IDENTITY: XrPose = XrPose {
translation: Vec3::ZERO,
rotation: Quat::IDENTITY,
};
pub const fn to_transform(self) -> Transform {
Transform::from_translation(self.translation).with_rotation(self.rotation)
}
}
#[deprecated = "Use Isometry3d instead"]
pub type XrPose = Isometry3d;

6
crates/bevy_xr_utils/Cargo.toml
View File

@@ -10,11 +10,11 @@ description = "utils for bevy_mod_xr and bevy_mod_openxr"
[dependencies]
bevy = { workspace = true, features = ["bevy_gizmos"] }
bevy_mod_xr = { path = "../bevy_xr", version = "0.1.0" }
bevy_mod_openxr = { path = "../bevy_openxr", version = "0.1.0" }
bevy_mod_xr.workspace = true
bevy_mod_openxr.workspace = true
[target.'cfg(not(target_family = "wasm"))'.dependencies]
openxr = "0.18.0"
openxr.workspace = true
[lints.clippy]
too_many_arguments = "allow"

22
crates/bevy_xr_utils/src/hand_gizmos.rs
View File

@@ -1,6 +1,7 @@
use bevy::color::palettes::css;
use bevy::{prelude::*, transform::TransformSystem};
use bevy_mod_xr::hands::{HandBone, HandBoneRadius};
use bevy_mod_xr::hands::{HandBone, XrHandBoneRadius};
use bevy_mod_xr::spaces::XrSpaceLocationFlags;
pub struct HandGizmosPlugin;
impl Plugin for HandGizmosPlugin {
fn build(&self, app: &mut App) {
@@ -12,11 +13,24 @@ impl Plugin for HandGizmosPlugin {
}
fn draw_hand_gizmos(
mut gizmos: Gizmos,
query: Query<(&GlobalTransform, &HandBone, &HandBoneRadius)>,
query: Query<(
&GlobalTransform,
&HandBone,
&XrHandBoneRadius,
&XrSpaceLocationFlags,
)>,
) {
for (transform, bone, radius) in &query {
for (transform, bone, radius, flags) in &query {
if (!flags.position_tracked) || (!flags.rotation_tracked) {
continue;
}
let pose = transform.compute_transform();
gizmos.sphere(pose.translation, pose.rotation, **radius, gizmo_color(bone));
let pose = Isometry3d {
translation: pose.translation.into(),
rotation: pose.rotation,
};
gizmos.sphere(pose, **radius, gizmo_color(bone));
gizmos.axes(pose, **radius);
}
}

97
crates/bevy_xr_utils/src/tracking_utils.rs
View File

@@ -1,11 +1,17 @@
use bevy::prelude::*;
use bevy_mod_openxr::{
action_binding::{OxrSendActionBindings, OxrSuggestActionBinding}, action_set_attaching::OxrAttachActionSet, action_set_syncing::{OxrActionSetSyncSet, OxrSyncActionSet}, helper_traits::{ToQuat, ToVec3}, openxr_session_available, openxr_session_running, resources::{OxrFrameState, OxrInstance, Pipelined}, session::OxrSession, spaces::{OxrSpaceLocationFlags, OxrSpaceSyncSet}
action_binding::OxrSuggestActionBinding,
action_set_attaching::OxrAttachActionSet,
action_set_syncing::{OxrActionSetSyncSet, OxrSyncActionSet},
helper_traits::{ToQuat, ToVec3},
openxr_session_available, openxr_session_running,
resources::{OxrFrameState, OxrInstance, Pipelined},
session::OxrSession,
spaces::{OxrSpaceLocationFlags, OxrSpaceSyncSet},
};
use bevy_mod_xr::{
session::{session_available, session_running, XrSessionCreated, XrTrackingRoot},
session::{XrSessionCreated, XrTracker, XrTrackingRoot},
spaces::{XrPrimaryReferenceSpace, XrReferenceSpace},
types::XrPose,
};
use openxr::Posef;
@@ -74,17 +80,13 @@ impl Plugin for TrackingUtilitiesPlugin {
//stage
fn update_stage(
mut root_query: Query<&mut Transform, (With<XrTrackingRoot>, Without<XrTrackedStage>)>,
root_query: Query<&Transform, (With<XrTrackingRoot>, Without<XrTrackedStage>)>,
mut stage_query: Query<&mut Transform, (With<XrTrackedStage>, Without<XrTrackingRoot>)>,
) {
let tracking_root_transform = root_query.get_single_mut();
match tracking_root_transform {
Ok(root) => {
for (mut transform) in &mut stage_query {
*transform = root.clone();
}
if let Ok(root) = root_query.get_single() {
for mut transform in &mut stage_query {
*transform = *root;
}
Err(_) => (),
}
}
@@ -128,13 +130,10 @@ fn update_view(
mut view_query: Query<&mut Transform, (With<XrTrackedView>, Without<HeadXRSpace>)>,
) {
let head_transform = head_query.get_single_mut();
match head_transform {
Ok(root) => {
for (mut transform) in &mut view_query {
*transform = root.clone();
}
if let Ok(root) = head_transform {
for mut transform in &mut view_query {
*transform = *root;
}
Err(_) => (),
}
}
@@ -144,19 +143,16 @@ fn update_local_floor_transforms(
mut local_floor: Query<&mut Transform, (With<XrTrackedLocalFloor>, Without<HeadXRSpace>)>,
) {
let head_transform = head_space.get_single_mut();
match head_transform {
Ok(head) => {
let mut calc_floor = head.clone();
calc_floor.translation.y = 0.0;
//TODO: use yaw
let (y, x, z) = calc_floor.rotation.to_euler(EulerRot::YXZ);
let new_rot = Quat::from_rotation_y(y);
calc_floor.rotation = new_rot;
for (mut transform) in &mut local_floor {
*transform = calc_floor;
}
if let Ok(head) = head_transform {
let mut calc_floor = *head;
calc_floor.translation.y = 0.0;
//TODO: use yaw
let (y, _, _) = calc_floor.rotation.to_euler(EulerRot::YXZ);
let new_rot = Quat::from_rotation_y(y);
calc_floor.rotation = new_rot;
for mut transform in &mut local_floor {
*transform = calc_floor;
}
Err(_) => (),
}
}
@@ -169,13 +165,10 @@ fn update_left_grip(
mut tracked_left_grip: Query<&mut Transform, (With<XrTrackedLeftGrip>, Without<LeftGrip>)>,
) {
let head_transform = left_grip.get_single_mut();
match head_transform {
Ok(head) => {
for (mut transform) in &mut tracked_left_grip {
*transform = head.clone();
}
if let Ok(head) = head_transform {
for mut transform in &mut tracked_left_grip {
*transform = *head;
}
Err(_) => (),
}
}
@@ -188,13 +181,10 @@ fn update_right_grip(
mut tracked_right_grip: Query<&mut Transform, (With<XrTrackedRightGrip>, Without<RightGrip>)>,
) {
let head_transform = right_grip.get_single_mut();
match head_transform {
Ok(head) => {
for (mut transform) in &mut tracked_right_grip {
*transform = head.clone();
}
if let Ok(head) = head_transform {
for mut transform in &mut tracked_right_grip {
*transform = *head;
}
Err(_) => (),
}
}
@@ -209,33 +199,28 @@ pub struct ControllerActions {
fn spawn_tracking_rig(
actions: Res<ControllerActions>,
mut cmds: Commands,
root: Query<Entity, With<XrTrackingRoot>>,
session: Res<OxrSession>,
) {
//head
let head_space = session
.create_reference_space(openxr::ReferenceSpaceType::VIEW, Transform::IDENTITY)
.unwrap();
let head = cmds
.spawn((SpatialBundle::default(), HeadXRSpace(head_space)))
.id();
cmds.spawn((
Transform::default(),
Visibility::default(),
XrTracker,
HeadXRSpace(head_space),
));
// let local_floor = cmds.spawn((SpatialBundle::default(), LocalFloor)).id();
let left_space = session
.create_action_space(&actions.left, openxr::Path::NULL, XrPose::IDENTITY)
.create_action_space(&actions.left, openxr::Path::NULL, Isometry3d::IDENTITY)
.unwrap();
let right_space = session
.create_action_space(&actions.right, openxr::Path::NULL, XrPose::IDENTITY)
.create_action_space(&actions.right, openxr::Path::NULL, Isometry3d::IDENTITY)
.unwrap();
let left = cmds
.spawn((SpatialBundle::default(), left_space, LeftGrip))
.id();
let right = cmds
.spawn((SpatialBundle::default(), right_space, RightGrip))
.id();
cmds.entity(root.single())
.push_children(&[head, left, right]);
cmds.spawn((left_space, LeftGrip));
cmds.spawn((right_space, RightGrip));
}
//bindings