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

chore: update to rust edition 2024

Browse Source 
Signed-off-by: Schmarni <marnistromer@gmail.com>
This commit is contained in:
Schmarni
2025-10-19 17:14:35 +02:00
parent 258bd0448d
commit 0a98204124
5 changed files with 62 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@@ -1,6 +1,6 @@
[workspace.package]
version = "0.3.0"
edition = "2021"
edition = "2024"
description = "Community crate for XR in Bevy"
repository = "https://github.com/awtterpip/bevy_oxr"
license = "MIT/Apache-2.0"

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

@@ -207,16 +207,16 @@ unsafe impl GraphicsExt for openxr::Vulkan {
system_id,
};
let mut out = sys::Session::NULL;
cvt((instance.fp().create_session)(
cvt(unsafe { (instance.fp().create_session)(
instance.as_raw(),
&info,
&mut out,
))?;
Ok(openxr::Session::from_raw(
) })?;
Ok(unsafe { openxr::Session::from_raw(
instance.clone(),
out,
Box::new(()),
))
) })
}
fn init_fallback_graphics(

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

@@ -1,15 +1,15 @@
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::sync::atomic::Ordering;
use bevy_app::App;
use bevy_app::Plugin;
use bevy_ecs::message::MessageWriter;
use bevy_ecs::message::Messages;
use bevy_ecs::resource::Resource;
use bevy_ecs::schedule::IntoScheduleConfigs as _;
use bevy_ecs::schedule::SystemCondition as _;
use bevy_ecs::schedule::common_conditions::on_message;
use bevy_ecs::schedule::common_conditions::resource_exists;
use bevy_ecs::schedule::IntoScheduleConfigs as _;
use bevy_ecs::system::Commands;
use bevy_ecs::system::Local;
use bevy_ecs::system::Res;
@@ -22,6 +22,12 @@ use bevy_log::info;
use bevy_log::warn;
use bevy_math::UVec2;
use bevy_mod_xr::session::*;
use bevy_render::ExtractSchedule;
use bevy_render::MainWorld;
use bevy_render::Render;
use bevy_render::RenderApp;
use bevy_render::RenderDebugFlags;
use bevy_render::RenderPlugin;
use bevy_render::extract_resource::ExtractResourcePlugin;
use bevy_render::renderer::RenderAdapter;
use bevy_render::renderer::RenderAdapterInfo;
@@ -30,12 +36,6 @@ use bevy_render::renderer::RenderInstance;
use bevy_render::renderer::RenderQueue;
use bevy_render::renderer::WgpuWrapper;
use bevy_render::settings::RenderCreation;
use bevy_render::ExtractSchedule;
use bevy_render::MainWorld;
use bevy_render::Render;
use bevy_render::RenderApp;
use bevy_render::RenderDebugFlags;
use bevy_render::RenderPlugin;
#[cfg(feature = "window_support")]
use bevy_winit::UpdateMode;
#[cfg(feature = "window_support")]
@@ -185,8 +185,8 @@ impl Plugin for OxrInitPlugin {
}
Err(e) => {
error!("Failed to initialize openxr: {e}");
if let Some(cfg) = cfg {
if let Ok(WgpuGraphics(device, queue, adapter_info, adapter, wgpu_instance)) =
if let Some(cfg) = cfg
&& let Ok(WgpuGraphics(device, queue, adapter_info, adapter, wgpu_instance)) =
graphics_match!(
cfg.fallback_backend;
_ => Api::init_fallback_graphics(&self.app_info ,&cfg)
@@ -194,21 +194,20 @@ impl Plugin for OxrInitPlugin {
.inspect_err(|err| {
error!("Failed to initialize custom fallback graphics: {err}")
})
{
app.add_plugins(RenderPlugin {
render_creation: RenderCreation::manual(
device.into(),
RenderQueue(Arc::new(WgpuWrapper::new(queue))),
RenderAdapterInfo(WgpuWrapper::new(adapter_info)),
RenderAdapter(Arc::new(WgpuWrapper::new(adapter))),
RenderInstance(Arc::new(WgpuWrapper::new(wgpu_instance))),
),
synchronous_pipeline_compilation: self.synchronous_pipeline_compilation,
debug_flags: self.render_debug_flags,
})
.insert_resource(XrState::Unavailable);
return;
}
{
app.add_plugins(RenderPlugin {
render_creation: RenderCreation::manual(
device.into(),
RenderQueue(Arc::new(WgpuWrapper::new(queue))),
RenderAdapterInfo(WgpuWrapper::new(adapter_info)),
RenderAdapter(Arc::new(WgpuWrapper::new(adapter))),
RenderInstance(Arc::new(WgpuWrapper::new(wgpu_instance))),
),
synchronous_pipeline_compilation: self.synchronous_pipeline_compilation,
debug_flags: self.render_debug_flags,
})
.insert_resource(XrState::Unavailable);
return;
}
app.add_plugins(RenderPlugin::default())
.insert_resource(XrState::Unavailable);

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

@@ -1,8 +1,8 @@
use bevy_derive::{Deref, DerefMut};
use bevy_ecs::resource::Resource;
use bevy_log::error;
use bevy_math::UVec2;
use bevy_render::extract_resource::ExtractResource;
use bevy_log::error;
use crate::error::OxrError;
use crate::graphics::*;
@@ -144,7 +144,7 @@ impl OxrInstance {
graphics_match!(
info.0;
info => {
let (session, frame_waiter, frame_stream) = Api::create_session(self,system_id, &info,chain)?;
let (session, frame_waiter, frame_stream) = unsafe { Api::create_session(self,system_id, &info,chain)? };
Ok((session.into(), OxrFrameWaiter(frame_waiter), OxrFrameStream(Api::wrap(frame_stream))))
}
)
@@ -192,15 +192,14 @@ impl OxrFrameStream {
let mut new_layers = vec![];
for (i, layer) in layers.iter().enumerate() {
if let Some(swapchain) = layer.swapchain() {
if !swapchain.0.using_graphics::<Api>() {
error!(
"Composition layer {i} is using graphics api '{}', expected graphics api '{}'. Excluding layer from frame submission.",
swapchain.0.graphics_name(),
std::any::type_name::<Api>(),
);
continue;
}
if let Some(swapchain) = layer.swapchain()
&& !swapchain.0.using_graphics::<Api>() {
error!(
"Composition layer {i} is using graphics api '{}', expected graphics api '{}'. Excluding layer from frame submission.",
swapchain.0.graphics_name(),
std::any::type_name::<Api>(),
);
continue;
}
new_layers.push(unsafe {
#[allow(clippy::missing_transmute_annotations)]

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

@@ -1,9 +1,12 @@
use bevy_app::{App, Plugin, PreUpdate, Startup};
use bevy_ecs::{
component::Component, message::MessageReader, schedule::IntoScheduleConfigs as _, system::{Query, Res, ResMut}
component::Component,
message::MessageReader,
schedule::IntoScheduleConfigs as _,
system::{Query, Res, ResMut},
};
use bevy_log::{error, info};
use bevy_log::warn;
use bevy_log::{error, info};
use bevy_math::Isometry3d;
use bevy_mod_xr::{
session::{XrFirst, XrHandleEvents},
@@ -15,8 +18,8 @@ use bevy_mod_xr::{
use bevy_platform::collections::hash_set::HashSet;
use bevy_transform::components::Transform;
use openxr::{
sys, HandJointLocation, HandJointLocations, HandJointVelocities, HandJointVelocity,
ReferenceSpaceType, SpaceLocationFlags, SpaceVelocityFlags, HAND_JOINT_COUNT,
HAND_JOINT_COUNT, HandJointLocation, HandJointLocations, HandJointVelocities,
HandJointVelocity, ReferenceSpaceType, SpaceLocationFlags, SpaceVelocityFlags, sys,
};
use std::{mem::MaybeUninit, ptr, sync::Mutex};
@@ -95,10 +98,12 @@ unsafe extern "system" fn patched_destroy_space(space: openxr::sys::Space) -> op
.unwrap()
.contains(&space.into_raw())
{
OXR_ORIGINAL_DESTOY_SPACE
.lock()
.unwrap()
.expect("has to be initialized")(space)
unsafe {
OXR_ORIGINAL_DESTOY_SPACE
.lock()
.unwrap()
.expect("has to be initialized")(space)
}
} else {
info!("Inject Worked, not destroying space");
openxr::sys::Result::SUCCESS
@@ -581,11 +586,7 @@ unsafe impl OxrSpaceExt for XrSpace {
}
fn cvt(x: sys::Result) -> openxr::Result<sys::Result> {
if x.into_raw() >= 0 {
Ok(x)
} else {
Err(x)
}
if x.into_raw() >= 0 { Ok(x) } else { Err(x) }
}
#[allow(clippy::obfuscated_if_else)]
unsafe fn create_view(flags: openxr::ViewStateFlags, raw: &MaybeUninit<sys::View>) -> openxr::View {
@@ -595,31 +596,31 @@ unsafe fn create_view(flags: openxr::ViewStateFlags, raw: &MaybeUninit<sys::View
pose: openxr::Posef {
orientation: flags
.contains(sys::ViewStateFlags::ORIENTATION_VALID)
.then(|| *ptr::addr_of!((*ptr).pose.orientation))
.then(|| unsafe { *ptr::addr_of!((*ptr).pose.orientation) })
.unwrap_or_default(),
position: flags
.contains(sys::ViewStateFlags::POSITION_VALID)
.then(|| *ptr::addr_of!((*ptr).pose.position))
.then(|| unsafe { *ptr::addr_of!((*ptr).pose.position) })
.unwrap_or_default(),
},
fov: *ptr::addr_of!((*ptr).fov),
fov: unsafe { *ptr::addr_of!((*ptr).fov) },
}
}
#[allow(clippy::obfuscated_if_else)]
unsafe fn create_space_location(raw: &MaybeUninit<sys::SpaceLocation>) -> openxr::SpaceLocation {
// Applications *must* not read invalid parts of a pose, i.e. they may be uninitialized
let ptr = raw.as_ptr();
let flags = *ptr::addr_of!((*ptr).location_flags);
let flags = unsafe { *ptr::addr_of!((*ptr).location_flags) };
openxr::SpaceLocation {
location_flags: flags,
pose: openxr::Posef {
orientation: flags
.contains(sys::SpaceLocationFlags::ORIENTATION_VALID)
.then(|| *ptr::addr_of!((*ptr).pose.orientation))
.then(|| unsafe { *ptr::addr_of!((*ptr).pose.orientation) })
.unwrap_or_default(),
position: flags
.contains(sys::SpaceLocationFlags::POSITION_VALID)
.then(|| *ptr::addr_of!((*ptr).pose.position))
.then(|| unsafe { *ptr::addr_of!((*ptr).pose.position) })
.unwrap_or_default(),
},
}
@@ -628,16 +629,16 @@ unsafe fn create_space_location(raw: &MaybeUninit<sys::SpaceLocation>) -> openxr
unsafe fn create_space_velocity(raw: &MaybeUninit<sys::SpaceVelocity>) -> openxr::SpaceVelocity {
// Applications *must* not read invalid velocities, i.e. they may be uninitialized
let ptr = raw.as_ptr();
let flags = *ptr::addr_of!((*ptr).velocity_flags);
let flags = unsafe { *ptr::addr_of!((*ptr).velocity_flags) };
openxr::SpaceVelocity {
velocity_flags: flags,
linear_velocity: flags
.contains(sys::SpaceVelocityFlags::LINEAR_VALID)
.then(|| *ptr::addr_of!((*ptr).linear_velocity))
.then(|| unsafe { *ptr::addr_of!((*ptr).linear_velocity) })
.unwrap_or_default(),
angular_velocity: flags
.contains(sys::SpaceVelocityFlags::ANGULAR_VALID)
.then(|| *ptr::addr_of!((*ptr).angular_velocity))
.then(|| unsafe { *ptr::addr_of!((*ptr).angular_velocity) })
.unwrap_or_default(),
}
}