chore: update to rust edition 2024

Signed-off-by: Schmarni <marnistromer@gmail.com>

Cargo.toml

@@ -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"

crates/bevy_openxr/src/openxr/graphics/vulkan.rs

@@ -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(

crates/bevy_openxr/src/openxr/init.rs

@@ -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 Some(cfg) = cfg
-                    if let Ok(WgpuGraphics(device, queue, adapter_info, adapter, wgpu_instance)) =
+                    && let Ok(WgpuGraphics(device, queue, adapter_info, adapter, wgpu_instance)) =
                         graphics_match!(
                             cfg.fallback_backend;
                             _ => Api::init_fallback_graphics(&self.app_info ,&cfg)
@@ -209,7 +209,6 @@ impl Plugin for OxrInitPlugin {
                     .insert_resource(XrState::Unavailable);
                     return;
                 }
-                }
                 app.add_plugins(RenderPlugin::default())
                     .insert_resource(XrState::Unavailable);
             }

crates/bevy_openxr/src/openxr/resources.rs

@@ -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,8 +192,8 @@ impl OxrFrameStream {
                 let mut new_layers = vec![];
 
                 for (i, layer) in layers.iter().enumerate() {
-                    if let Some(swapchain) = layer.swapchain() {
+                    if let Some(swapchain) = layer.swapchain()
-                        if !swapchain.0.using_graphics::<Api>() {
+                        && !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(),
@@ -201,7 +201,6 @@ impl OxrFrameStream {
                         );
                         continue;
                     }
-                    }
                     new_layers.push(unsafe {
                         #[allow(clippy::missing_transmute_annotations)]
                         std::mem::transmute(layer.header())

crates/bevy_openxr/src/openxr/spaces.rs

@@ -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,
+    HAND_JOINT_COUNT, HandJointLocation, HandJointLocations, HandJointVelocities,
-    ReferenceSpaceType, SpaceLocationFlags, SpaceVelocityFlags, HAND_JOINT_COUNT,
+    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())
     {
+        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 {
+    if x.into_raw() >= 0 { Ok(x) } else { Err(x) }
-        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(),
     }
 }