Merge pull request #159 from Schmarni-Dev/create_xr_hands

add CI and move more hand related things into bevy_mod_xr

.github/workflows/ci.yaml

@@ -0,0 +1,67 @@
+name: CI
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+
+
+  check_linux:
+    name: Check Ubuntu
+    runs-on: ubuntu-latest
+
+    env:
+      CARGO_TERM_COLOR: always
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install bevy dependencies
+        run: |
+          sudo apt-get update && sudo apt-get install -y \
+            g++ pkg-config libx11-dev libasound2-dev libudev-dev libopenxr-loader1 libopenxr-dev
+
+      - name: Cache cargo dependencies
+        uses: Swatinem/rust-cache@v2
+
+      - name: check
+        run: cargo check --all --all-targets
+  check_windows:
+    name: Check Windows
+    runs-on: windows-latest
+
+    env:
+      CARGO_TERM_COLOR: always
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Cache cargo dependencies
+        uses: Swatinem/rust-cache@v2
+
+      - name: check
+        run: cargo check --all --all-targets
+
+  check_wasm:
+    name: Check Wasm
+    runs-on: ubuntu-latest
+
+    env:
+      CARGO_TERM_COLOR: always
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Cache cargo dependencies
+        uses: Swatinem/rust-cache@v2
+
+      - name: install wasm toolchain
+        run: rustup toolchain install stable --profile minimal --target wasm32-unknown-unknown --no-self-update
+
+      - run: cargo check --target wasm32-unknown-unknown -p bevy_mod_xr
+      - run: cargo check --target wasm32-unknown-unknown -p bevy_mod_openxr
+      - run: cargo check --target wasm32-unknown-unknown -p bevy_mod_webxr
+      - run: cargo check --target wasm32-unknown-unknown -p bevy_xr_utils

crates/bevy_openxr/Cargo.toml

@@ -43,3 +43,7 @@ wgpu = { version = "0.20", features = ["vulkan-portability"] }
 openxr = { version = "0.18.0", features = ["mint", "static"] }
 winapi = { version = "0.3.9", optional = true }
 d3d12 = { version = "0.20", features = ["libloading"], optional = true }
+
+[lints.clippy]
+too_many_arguments = "allow"
+type_complexity = "allow"

crates/bevy_openxr/src/openxr/features/handtracking.rs

@@ -1,6 +1,9 @@
 use bevy::prelude::*;
-use bevy_mod_xr::hands::{HandBone, HandBoneRadius};
+use bevy_mod_xr::hands::{
-use bevy_mod_xr::hands::{LeftHand, RightHand, XrHandBoneEntities, HAND_JOINT_COUNT};
+    spawn_hand_bones, HandBone, HandBoneRadius, HandSide, SpawnHandTracker,
+    SpawnHandTrackerCommandExecutor,
+};
+use bevy_mod_xr::hands::{LeftHand, RightHand, XrHandBoneEntities};
 use bevy_mod_xr::session::{XrPreDestroySession, XrSessionCreated, XrTrackingRoot};
 use bevy_mod_xr::spaces::{
     XrPrimaryReferenceSpace, XrReferenceSpace, XrSpaceLocationFlags, XrSpaceVelocityFlags,
@@ -9,11 +12,11 @@ use bevy_mod_xr::spaces::{
 use openxr::{SpaceLocationFlags, SpaceVelocityFlags};
 
 use crate::helper_traits::ToVec3;
-use crate::openxr_session_running;
 use crate::resources::OxrFrameState;
 use crate::resources::Pipelined;
 use crate::session::OxrSession;
 use crate::spaces::{OxrSpaceLocationFlags, OxrSpaceVelocityFlags};
+use crate::{openxr_session_available, openxr_session_running};
 
 pub struct HandTrackingPlugin {
     default_hands: bool,
@@ -33,79 +36,72 @@ impl Plugin for HandTrackingPlugin {
             app.add_systems(XrPreDestroySession, clean_up_default_hands)
                 .add_systems(XrSessionCreated, spawn_default_hands);
         }
+        app.add_systems(Startup, set_spawn_executor.run_if(openxr_session_available));
     }
 }
 
-pub fn spawn_hand_bones<T: Bundle + Clone>(
+fn set_spawn_executor(mut cmds: Commands) {
-    cmds: &mut Commands,
+    cmds.insert_resource(SpawnHandTrackerCommandExecutor(handle_tracker_spawn))
-    bundle: T,
-) -> [Entity; HAND_JOINT_COUNT] {
-    let mut bones: [Entity; HAND_JOINT_COUNT] = [Entity::PLACEHOLDER; HAND_JOINT_COUNT];
-    // screw you clippy, i don't see a better way to init this array
-    #[allow(clippy::needless_range_loop)]
-    for bone in HandBone::get_all_bones().into_iter() {
-        bones[bone as usize] = cmds
-            .spawn((
-                SpatialBundle::default(),
-                bone,
-                HandBoneRadius(0.0),
-                OxrSpaceLocationFlags(openxr::SpaceLocationFlags::default()),
-                XrSpaceLocationFlags::default(),
-            ))
-            .insert(bundle.clone())
-            .id();
-    }
-    bones
 }
 
-fn spawn_default_hands(
+fn handle_tracker_spawn(world: &mut World, tracker: Entity, side: HandSide) {
-    mut cmds: Commands,
+    let Some(session) = world.get_resource_mut::<OxrSession>() else {
-    session: Res<OxrSession>,
+        error!("unable to get session while creating hand tracker");
-    root: Query<Entity, With<XrTrackingRoot>>,
+        return;
-) {
+    };
-    debug!("spawning default hands");
+    debug!("spawning hand");
+    let oxr_tracker = match session.create_hand_tracker(match side {
+        HandSide::Left => openxr::HandEXT::LEFT,
+        HandSide::Right => openxr::HandEXT::RIGHT,
+    }) {
+        Ok(t) => t,
+        Err(openxr::sys::Result::ERROR_EXTENSION_NOT_PRESENT) => {
+            warn!("Handtracking Extension not loaded, Unable to create Handtracker!");
+            return;
+        }
+        Err(err) => {
+            warn!("Error while creating Handtracker: {}", err.to_string());
+            return;
+        }
+    };
+
+    world
+        .entity_mut(tracker)
+        .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 hand creation");
+        error!("unable to get tracking root, skipping handtracker creation");
         return;
     };
-    let tracker_left = match session.create_hand_tracker(openxr::HandEXT::LEFT) {
+    debug!("spawning default hands");
-        Ok(t) => t,
+    let left_bones = spawn_hand_bones(&mut cmds, |_| {
-        Err(openxr::sys::Result::ERROR_EXTENSION_NOT_PRESENT) => {
+        (
-            warn!("Handtracking Extension not loaded, Unable to create Handtracker!");
+            DefaultHandBone,
-            return;
+            LeftHand,
-        }
+            OxrSpaceLocationFlags(openxr::SpaceLocationFlags::default()),
-        Err(err) => {
+        )
-            warn!("Error while creating Handtracker: {}", err.to_string());
+    });
-            return;
+    let right_bones = spawn_hand_bones(&mut cmds, |_| {
-        }
+        (
-    };
+            DefaultHandBone,
-    let tracker_right = match session.create_hand_tracker(openxr::HandEXT::RIGHT) {
+            RightHand,
-        Ok(t) => t,
+            OxrSpaceLocationFlags(openxr::SpaceLocationFlags::default()),
-        Err(openxr::sys::Result::ERROR_EXTENSION_NOT_PRESENT) => {
+        )
-            warn!("Handtracking Extension not loaded, Unable to create Handtracker!");
+    });
-            return;
-        }
-        Err(err) => {
-            warn!("Error while creating Handtracker: {}", err.to_string());
-            return;
-        }
-    };
-    let left_bones = spawn_hand_bones(&mut cmds, (DefaultHandBone, LeftHand));
-    let right_bones = spawn_hand_bones(&mut cmds, (DefaultHandBone, RightHand));
     cmds.entity(root).push_children(&left_bones);
     cmds.entity(root).push_children(&right_bones);
-    cmds.spawn((
+    cmds.push(SpawnHandTracker {
-        DefaultHandTracker,
+        joints: XrHandBoneEntities(left_bones),
-        OxrHandTracker(tracker_left),
+        tracker_bundle: DefaultHandTracker,
-        XrHandBoneEntities(left_bones),
+        side: HandSide::Left,
-        LeftHand,
+    });
-    ));
+    cmds.push(SpawnHandTracker {
-    cmds.spawn((
+        joints: XrHandBoneEntities(right_bones),
-        DefaultHandTracker,
+        tracker_bundle: DefaultHandTracker,
-        OxrHandTracker(tracker_right),
+        side: HandSide::Right,
-        XrHandBoneEntities(right_bones),
+    });
-        RightHand,
-    ));
 }
 
 #[derive(Component, Clone, Copy)]

crates/bevy_webxr/Cargo.toml

@@ -17,3 +17,7 @@ wgpu = "0.19.3"
 wgpu-hal = "0.19.3"
 
 bevy_mod_xr = { path = "../bevy_xr", version = "0.1.0-rc1" }
+
+[lints.clippy]
+too_many_arguments = "allow"
+type_complexity = "allow"

crates/bevy_xr/Cargo.toml

@@ -11,3 +11,7 @@ keywords = ["gamedev", "bevy", "Xr", "Vr"]
 
 [dependencies]
 bevy.workspace = true
+
+[lints.clippy]
+too_many_arguments = "allow"
+type_complexity = "allow"

crates/bevy_xr/src/hands.rs

@@ -1,16 +1,49 @@
 use bevy::{
-    ecs::{component::Component, entity::Entity},
+    ecs::{component::Component, entity::Entity, world::Command},
+    hierarchy::BuildWorldChildren,
+    log::{error, warn},
     math::bool,
-    prelude::{Deref, DerefMut},
+    prelude::{Bundle, Commands, Deref, DerefMut, Resource, SpatialBundle, With, World},
+};
+
+use crate::{
+    session:: XrTrackingRoot,
+    spaces::XrSpaceLocationFlags,
 };
 pub const HAND_JOINT_COUNT: usize = 26;
 
+pub fn spawn_hand_bones<T: Bundle>(
+    cmds: &mut Commands,
+    mut get_bundle: impl FnMut(HandBone) -> T,
+) -> [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
+}
+
+#[derive(Clone, Copy, Component, Debug)]
+pub enum HandSide {
+    Left,
+    Right,
+}
+
 #[derive(Clone, Copy, Component, Debug)]
 pub struct LeftHand;
 
 #[derive(Clone, Copy, Component, Debug)]
 pub struct RightHand;
 
+/// Hand Joint Entities orderd
 #[derive(Deref, DerefMut, Component, Clone, Copy)]
 pub struct XrHandBoneEntities(pub [Entity; HAND_JOINT_COUNT]);
 
@@ -141,3 +174,43 @@ impl HandBone {
         ]
     }
 }
+
+/// Use by a backend to run custom logic when spawning a hand tracker
+#[derive(Resource)]
+pub struct SpawnHandTrackerCommandExecutor(pub fn(&mut World, Entity, HandSide));
+
+/// `tracker_bundle` is inserted after the backend specific code is run
+pub struct SpawnHandTracker<B: Bundle> {
+    pub joints: XrHandBoneEntities,
+    pub tracker_bundle: B,
+    pub side: HandSide,
+}
+
+impl<B: Bundle> Command for SpawnHandTracker<B> {
+    fn apply(self, world: &mut bevy::prelude::World) {
+        let Some(executor) = world.remove_resource::<SpawnHandTrackerCommandExecutor>() else {
+            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(LeftHand),
+        };
+        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) {
+            tracker.insert(self.side);
+            tracker.insert(self.tracker_bundle);
+        }
+        world.insert_resource(executor);
+    }
+}

crates/bevy_xr_utils/Cargo.toml

@@ -15,3 +15,7 @@ bevy_mod_openxr = { path = "../bevy_openxr", version = "0.1.0-rc1" }
 
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
 openxr = "0.18.0"
+
+[lints.clippy]
+too_many_arguments = "allow"
+type_complexity = "allow"

crates/bevy_xr_utils/src/lib.rs

@@ -1,4 +1,3 @@
-// use bevy::prelude::*;
 pub mod hand_gizmos;
 #[cfg(not(target_family = "wasm"))]
 pub mod tracking_utils;

crates/bevy_xr_utils/src/tracking_utils.rs

@@ -1,12 +1,6 @@
 use bevy::prelude::*;
 use bevy_mod_openxr::{
-    action_binding::{OxrSendActionBindings, OxrSuggestActionBinding},
+    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_set_attaching::OxrAttachActionSet,
-    action_set_syncing::{OxrActionSetSyncSet, OxrSyncActionSet},
-    helper_traits::{ToQuat, ToVec3},
-    resources::{OxrFrameState, OxrInstance, Pipelined},
-    session::OxrSession,
-    spaces::{OxrSpaceLocationFlags, OxrSpaceSyncSet},
 };
 use bevy_mod_xr::{
     session::{session_available, session_running, XrSessionCreated, XrTrackingRoot},
@@ -48,7 +42,7 @@ impl Plugin for TrackingUtilitiesPlugin {
             PreUpdate,
             update_head_transforms
                 .in_set(OxrSpaceSyncSet)
-                .run_if(session_running),
+                .run_if(openxr_session_running),
         );
         //external
         app.add_systems(PreUpdate, update_view.after(update_head_transforms));
@@ -66,12 +60,12 @@ impl Plugin for TrackingUtilitiesPlugin {
             PreUpdate,
             sync_actions
                 .before(OxrActionSetSyncSet)
-                .run_if(session_running),
+                .run_if(openxr_session_running),
         );
         //attach sets
         app.add_systems(XrSessionCreated, attach_set);
         //create actions
-        app.add_systems(Startup, create_actions.run_if(session_available));
+        app.add_systems(Startup, create_actions.run_if(openxr_session_available));
 
         app.add_systems(PreUpdate, update_left_grip.after(OxrSpaceSyncSet));
         app.add_systems(PreUpdate, update_right_grip.after(OxrSpaceSyncSet));

crates/bevy_xr_utils/src/xr_utils_actions.rs

@@ -55,11 +55,13 @@
 //!
 use bevy::prelude::*;
 use bevy_mod_openxr::{
-    action_binding::OxrSuggestActionBinding, action_set_attaching::OxrAttachActionSet,
+    action_binding::OxrSuggestActionBinding,
-    action_set_syncing::OxrActionSetSyncSet, action_set_syncing::OxrSyncActionSet,
+    action_set_attaching::OxrAttachActionSet,
-    resources::OxrInstance, session::OxrSession,
+    action_set_syncing::{OxrActionSetSyncSet, OxrSyncActionSet},
+    openxr_session_available, openxr_session_running,
+    resources::OxrInstance,
+    session::OxrSession,
 };
-use bevy_mod_xr::session::{session_available, session_running};
 use openxr::{Path, Vector2f};
 
 use std::borrow::Cow;
@@ -69,37 +71,40 @@ impl Plugin for XRUtilsActionsPlugin {
     fn build(&self, app: &mut App) {
         app.configure_sets(
             Startup,
-            XRUtilsActionSystemSet::CreateEvents.run_if(session_available),
+            XRUtilsActionSystemSet::CreateEvents.run_if(openxr_session_available),
         );
         app.configure_sets(
             PreUpdate,
-            XRUtilsActionSystemSet::SyncActionStates.run_if(session_running),
+            XRUtilsActionSystemSet::SyncActionStates.run_if(openxr_session_running),
         );
         app.add_systems(
             Startup,
             create_openxr_events
                 .in_set(XRUtilsActionSystemSet::CreateEvents)
-                .run_if(session_available),
+                .run_if(openxr_session_available),
+        );
+        app.add_systems(
+            Update,
+            sync_active_action_sets.run_if(openxr_session_running),
         );
-        app.add_systems(Update, sync_active_action_sets.run_if(session_running));
         app.add_systems(
             PreUpdate,
             sync_and_update_action_states_f32
-                .run_if(session_running)
+                .run_if(openxr_session_running)
                 .in_set(XRUtilsActionSystemSet::SyncActionStates)
                 .after(OxrActionSetSyncSet),
         );
         app.add_systems(
             PreUpdate,
             sync_and_update_action_states_bool
-                .run_if(session_running)
+                .run_if(openxr_session_running)
                 .in_set(XRUtilsActionSystemSet::SyncActionStates)
                 .after(OxrActionSetSyncSet),
         );
         app.add_systems(
             PreUpdate,
             sync_and_update_action_states_vector
-                .run_if(session_running)
+                .run_if(openxr_session_running)
                 .in_set(XRUtilsActionSystemSet::SyncActionStates)
                 .after(OxrActionSetSyncSet),
         );