use linked openxr

Cargo.lock

@@ -2198,7 +2198,7 @@ dependencies = [
 [[package]]
 name = "ovr_overlay"
 version = "0.0.0"
-source = "git+https://github.com/galister/ovr_overlay_oyasumi#43a825d12bc86e225df5eaac8da9b3fd4880f9f1"
+source = "git+https://github.com/galister/ovr_overlay_oyasumi#9d8a3f4017024e79b6ec7fa518b97df401bf259c"
 dependencies = [
  "byteorder",
  "derive_more",
@@ -2213,7 +2213,7 @@ dependencies = [
 [[package]]
 name = "ovr_overlay_sys"
 version = "0.0.0"
-source = "git+https://github.com/galister/ovr_overlay_oyasumi#43a825d12bc86e225df5eaac8da9b3fd4880f9f1"
+source = "git+https://github.com/galister/ovr_overlay_oyasumi#9d8a3f4017024e79b6ec7fa518b97df401bf259c"
 dependencies = [
  "autocxx",
  "autocxx-build",
@@ -3722,7 +3722,7 @@ dependencies = [
 
 [[package]]
 name = "wlx-overlay-s"
-version = "0.2.4"
+version = "0.2.6"
 dependencies = [
  "anyhow",
  "ash",

Cargo.toml

@@ -4,7 +4,7 @@ debug = true
 
 [package]
 name = "wlx-overlay-s"
-version = "0.2.4"
+version = "0.2.6"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

src/backend/openvr/lines.rs

@@ -5,6 +5,7 @@ use std::sync::Arc;
 use glam::{Affine3A, Vec3, Vec3A, Vec4};
 use idmap::IdMap;
 use ovr_overlay::overlay::OverlayManager;
+use ovr_overlay::sys::ETrackingUniverseOrigin;
 use vulkano::command_buffer::CommandBufferUsage;
 use vulkano::format::Format;
 use vulkano::image::view::ImageView;
@@ -141,6 +142,7 @@ impl LinePool {
 
     pub fn update(
         &mut self,
+        universe: ETrackingUniverseOrigin,
         overlay: &mut OverlayManager,
         app: &mut AppState,
     ) -> anyhow::Result<()> {
@@ -152,7 +154,7 @@ impl LinePool {
                     data.state.dirty = false;
                 }
 
-                data.upload_transform(overlay);
+                data.upload_transform(universe.clone(), overlay);
                 data.upload_color(overlay);
             }
         }

src/backend/openvr/mod.rs

@@ -219,9 +219,11 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
             }
         }
 
+        let universe = playspace.get_universe();
+
         state.input_state.pre_update();
         input_source.update(
-            playspace.get_universe(),
+            universe.clone(),
             &mut input_mgr,
             &mut system_mgr,
             &mut state,
@@ -258,7 +260,7 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
             }
         }
 
-        lines.update(&mut overlay_mgr, &mut state)?;
+        lines.update(universe.clone(), &mut overlay_mgr, &mut state)?;
 
         for o in overlays.iter_mut() {
             o.after_input(&mut overlay_mgr, &mut state)?;
@@ -281,7 +283,7 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
 
         overlays
             .iter_mut()
-            .for_each(|o| o.after_render(&mut overlay_mgr, &state.graphics));
+            .for_each(|o| o.after_render(universe.clone(), &mut overlay_mgr, &state.graphics));
 
         // chaperone
 

src/backend/openvr/overlay.rs

@@ -79,10 +79,15 @@ impl OverlayData<OpenVrOverlayData> {
         Ok(())
     }
 
-    pub(super) fn after_render(&mut self, overlay: &mut OverlayManager, graphics: &WlxGraphics) {
+    pub(super) fn after_render(
+        &mut self,
+        universe: ETrackingUniverseOrigin,
+        overlay: &mut OverlayManager,
+        graphics: &WlxGraphics,
+    ) {
         if self.data.visible {
             if self.state.dirty {
-                self.upload_transform(overlay);
+                self.upload_transform(universe, overlay);
                 self.upload_alpha(overlay);
                 self.state.dirty = false;
             }
@@ -185,7 +190,11 @@ impl OverlayData<OpenVrOverlayData> {
         }
     }
 
-    pub(super) fn upload_transform(&self, overlay: &mut OverlayManager) {
+    pub(super) fn upload_transform(
+        &self,
+        universe: ETrackingUniverseOrigin,
+        overlay: &mut OverlayManager,
+    ) {
         let Some(handle) = self.data.handle else {
             log::debug!("{}: No overlay handle", self.state.name);
             return;
@@ -193,11 +202,7 @@ impl OverlayData<OpenVrOverlayData> {
 
         let transform = Matrix3x4::from_affine(&self.state.transform);
 
-        if let Err(e) = overlay.set_transform_absolute(
-            handle,
-            ETrackingUniverseOrigin::TrackingUniverseStanding,
-            &transform,
-        ) {
+        if let Err(e) = overlay.set_transform_absolute(handle, universe, &transform) {
             log::error!(
                 "{}: Failed to set overlay transform: {}",
                 self.state.name,

src/backend/openvr/playspace.rs

@@ -46,21 +46,26 @@ impl PlayspaceMover {
                 return;
             }
 
-            let new_hand =
-                state.input_state.pointers[data.hand].raw_pose.translation + data.pose.translation;
-            let relative_pos = data.pose.transform_vector3a(new_hand - data.hand_pos);
+            let new_hand = data
+                .pose
+                .transform_point3a(state.input_state.pointers[data.hand].raw_pose.translation);
+            let relative_pos = new_hand - data.hand_pos;
 
             if relative_pos.length_squared() > 1000.0 {
                 log::warn!("Space drag too fast, ignoring");
                 return;
             }
 
+            let overlay_offset = data.pose.inverse().transform_vector3a(relative_pos);
+
             overlays.iter_mut().for_each(|overlay| {
                 if overlay.state.grabbable {
                     overlay.state.dirty = true;
-                    overlay.state.transform.translation -= relative_pos;
+                    overlay.state.transform.translation -= overlay_offset;
                 }
             });
+            chaperone_mgr.revert_working_copy();
+            apply_chaperone_offset(overlay_offset, chaperone_mgr);
 
             data.pose.translation += relative_pos;
             data.hand_pos = new_hand;
@@ -74,7 +79,7 @@ impl PlayspaceMover {
                         log::warn!("Can't space drag - failed to get zero pose");
                         return;
                     };
-                    let hand_pos = pointer.raw_pose.translation + mat.translation;
+                    let hand_pos = mat.transform_point3a(pointer.raw_pose.translation);
                     self.last = Some(DragData {
                         pose: mat,
                         hand: i,
@@ -170,3 +175,17 @@ fn set_working_copy(
         _ => chaperone_mgr.set_working_seated_zero_pose_to_raw_tracking_pose(&mat),
     };
 }
+
+fn apply_chaperone_offset(offset: Vec3A, chaperone_mgr: &mut ChaperoneSetupManager) {
+    let mut quads = chaperone_mgr.get_working_collision_bounds_info();
+    quads.iter_mut().for_each(|quad| {
+        quad.vCorners.iter_mut().for_each(|corner| {
+            corner.v[0] += offset.x;
+            if corner.v[1] != 0.0 {
+                corner.v[1] += offset.y;
+            }
+            corner.v[2] += offset.z;
+        });
+    });
+    chaperone_mgr.set_working_collision_bounds_info(&mut quads);
+}

src/backend/openxr/helpers.rs

@@ -4,9 +4,7 @@ use openxr as xr;
 use xr::OverlaySessionCreateFlagsEXTX;
 
 pub(super) fn init_xr() -> Result<(xr::Instance, xr::SystemId), anyhow::Error> {
-    let Ok(entry) = (unsafe { xr::Entry::load() }) else {
-        bail!("OpenXR Loader not found.");
-    };
+    let entry = xr::Entry::linked();
 
     let Ok(available_extensions) = entry.enumerate_extensions() else {
         bail!("Failed to enumerate OpenXR extensions.");