Release v0.2.5

Cargo.lock

@@ -2198,7 +2198,7 @@ dependencies = [
 [[package]]
 name = "ovr_overlay"
 version = "0.0.0"
-source = "git+https://github.com/galister/ovr_overlay_oyasumi#376e817f9bf6438a486fbbfc6cf6ac2b8ff8ae36"
+source = "git+https://github.com/galister/ovr_overlay_oyasumi#43a825d12bc86e225df5eaac8da9b3fd4880f9f1"
 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#376e817f9bf6438a486fbbfc6cf6ac2b8ff8ae36"
+source = "git+https://github.com/galister/ovr_overlay_oyasumi#43a825d12bc86e225df5eaac8da9b3fd4880f9f1"
 dependencies = [
  "autocxx",
  "autocxx-build",
@@ -3722,7 +3722,7 @@ dependencies = [
 
 [[package]]
 name = "wlx-overlay-s"
-version = "0.2.3"
+version = "0.2.5"
 dependencies = [
  "anyhow",
  "ash",

Cargo.toml

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

src/backend/input.rs

@@ -159,6 +159,7 @@ impl Default for InteractionState {
 pub struct Pointer {
     pub idx: usize,
     pub pose: Affine3A,
+    pub raw_pose: Affine3A,
     pub now: PointerState,
     pub before: PointerState,
     pub last_click: Instant,
@@ -171,6 +172,7 @@ impl Pointer {
         Self {
             idx,
             pose: Affine3A::IDENTITY,
+            raw_pose: Affine3A::IDENTITY,
             now: Default::default(),
             before: Default::default(),
             last_click: Instant::now(),

src/backend/openvr/input.rs

@@ -56,6 +56,7 @@ pub(super) struct OpenVrInputSource {
 
 pub(super) struct OpenVrHandSource {
     has_pose: bool,
+    device: Option<TrackedDeviceIndex>,
     input_hnd: InputValueHandle,
     pose_hnd: ActionHandle,
     haptics_hnd: ActionHandle,
@@ -91,6 +92,7 @@ impl OpenVrInputSource {
 
         let hands: [OpenVrHandSource; 2] = array::from_fn(|i| OpenVrHandSource {
             has_pose: false,
+            device: None,
             input_hnd: input_hnd[i],
             pose_hnd: pose_hnd[i],
             haptics_hnd: haptics_hnd[i],
@@ -124,6 +126,7 @@ impl OpenVrInputSource {
 
     pub fn update(
         &mut self,
+        universe: ETrackingUniverseOrigin,
         input: &mut InputManager,
         system: &mut SystemManager,
         app: &mut AppState,
@@ -138,12 +141,19 @@ impl OpenVrInputSource {
 
         let _ = input.update_actions(&mut [aas]);
 
-        let universe = ETrackingUniverseOrigin::TrackingUniverseStanding;
+        let devices = system.get_device_to_absolute_tracking_pose(universe.clone(), 0.005);
+        app.input_state.hmd = devices[0].mDeviceToAbsoluteTracking.to_affine();
 
         for i in 0..2 {
             let hand = &mut self.hands[i];
             let app_hand = &mut app.input_state.pointers[i];
 
+            if let Some(device) = hand.device {
+                app_hand.raw_pose = devices[device.0 as usize]
+                    .mDeviceToAbsoluteTracking
+                    .to_affine();
+            }
+
             hand.has_pose = false;
 
             let _ = input
@@ -198,14 +208,10 @@ impl OpenVrInputSource {
                 .map(|x| x.0.y)
                 .unwrap_or(0.0);
         }
-
-        let devices = system.get_device_to_absolute_tracking_pose(universe, 0.005);
-        app.input_state.hmd = devices[0].mDeviceToAbsoluteTracking.to_affine();
     }
 
     pub fn update_devices(&mut self, system: &mut SystemManager, app: &mut AppState) {
         app.input_state.devices.clear();
-
         for idx in 0..TrackedDeviceIndex::MAX {
             let device = TrackedDeviceIndex::new(idx as _).unwrap(); // safe
             if !system.is_tracked_device_connected(device) {
@@ -220,9 +226,11 @@ impl OpenVrInputSource {
                     let role = system.get_controller_role_for_tracked_device_index(device);
                     match role {
                         ETrackedControllerRole::TrackedControllerRole_LeftHand => {
+                            self.hands[0].device = Some(device);
                             TrackedDeviceRole::LeftHand
                         }
                         ETrackedControllerRole::TrackedControllerRole_RightHand => {
+                            self.hands[1].device = Some(device);
                             TrackedDeviceRole::RightHand
                         }
                         _ => continue,

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

@@ -100,8 +100,8 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
     notifications.run_dbus();
     notifications.run_udp();
 
-    let mut space_mover = playspace::PlayspaceMover::new();
-    space_mover.playspace_changed(&mut compositor_mgr, &mut chaperone_mgr);
+    let mut playspace = playspace::PlayspaceMover::new();
+    playspace.playspace_changed(&mut compositor_mgr, &mut chaperone_mgr);
 
     #[cfg(feature = "osc")]
     let mut osc_sender =
@@ -126,7 +126,9 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
 
     let watch_id = overlays.get_by_name(WATCH_NAME).unwrap().state.id; // want panic
 
-    let frame_time = (1000.0 / refresh_rate).floor() * 0.001;
+    // want at least half refresh rate
+    let frame_timeout = 2 * (1000.0 / refresh_rate).floor() as u32;
+
     let mut next_device_update = Instant::now();
     let mut due_tasks = VecDeque::with_capacity(4);
 
@@ -134,6 +136,8 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
     let pointer_lines = [lines.allocate(), lines.allocate()];
 
     'main_loop: loop {
+        let _ = overlay_mgr.wait_frame_sync(frame_timeout);
+
         if !running.load(Ordering::Relaxed) {
             log::warn!("Received shutdown signal.");
             break 'main_loop;
@@ -155,7 +159,7 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
                 EVREventType::VREvent_SeatedZeroPoseReset
                 | EVREventType::VREvent_StandingZeroPoseReset
                 | EVREventType::VREvent_ChaperoneUniverseHasChanged => {
-                    space_mover.playspace_changed(&mut compositor_mgr, &mut chaperone_mgr);
+                    playspace.playspace_changed(&mut compositor_mgr, &mut chaperone_mgr);
                 }
                 _ => {}
             }
@@ -206,17 +210,24 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
                         let _ = adjust_gain(&mut settings_mgr, channel, value);
                     }
                     SystemTask::FixFloor => {
-                        space_mover.fix_floor(&mut chaperone_mgr, &state.input_state);
+                        playspace.fix_floor(&mut chaperone_mgr, &state.input_state);
                     }
                     SystemTask::ResetPlayspace => {
-                        space_mover.reset_offset(&mut chaperone_mgr);
+                        playspace.reset_offset(&mut chaperone_mgr);
                     }
                 },
             }
         }
 
+        let universe = playspace.get_universe();
+
         state.input_state.pre_update();
-        input_source.update(&mut input_mgr, &mut system_mgr, &mut state);
+        input_source.update(
+            universe.clone(),
+            &mut input_mgr,
+            &mut system_mgr,
+            &mut state,
+        );
         state.input_state.post_update();
 
         if state
@@ -233,7 +244,7 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
             .for_each(|o| o.state.auto_movement(&mut state));
 
         watch_fade(&mut state, overlays.mut_by_id(watch_id).unwrap()); // want panic
-        space_mover.update(&mut chaperone_mgr, &mut overlays, &state);
+        playspace.update(&mut chaperone_mgr, &mut overlays, &state);
 
         let lengths_haptics = interact(&mut overlays, &mut state);
         for (idx, (len, haptics)) in lengths_haptics.iter().enumerate() {
@@ -249,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)?;
@@ -272,22 +283,13 @@ 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
 
         // close font handles?
 
         state.hid_provider.on_new_frame();
-
-        let mut seconds_since_vsync = 0f32;
-        std::thread::sleep(Duration::from_secs_f32(
-            if system_mgr.get_time_since_last_vsync(&mut seconds_since_vsync, &mut 0u64) {
-                (frame_time - seconds_since_vsync).max(0.0)
-            } else {
-                frame_time
-            },
-        ));
     }
 
     log::warn!("OpenVR shutdown");

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

@@ -14,7 +14,6 @@ use super::{helpers::Affine3AConvert, overlay::OpenVrOverlayData};
 
 struct DragData {
     pose: Affine3A,
-    pose_inverse: Affine3A,
     hand: usize,
     hand_pos: Vec3A,
 }
@@ -46,24 +45,28 @@ impl PlayspaceMover {
                 log::info!("End space drag");
                 return;
             }
-            let new_hand = state.input_state.pointers[data.hand].pose.translation;
-            let new_hand_local = new_hand;
 
-            let relative_pos = data.pose.transform_vector3a(new_hand_local - data.hand_pos);
-            log::info!("Space drag: {:?}", relative_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;
+            }
 
             overlays.iter_mut().for_each(|overlay| {
                 if overlay.state.grabbable {
                     overlay.state.dirty = true;
-                    overlay.state.transform.translation += relative_pos * -1.0;
+                    overlay.state.transform.translation -= relative_pos;
                 }
             });
 
-            let mut mat = data.pose.clone();
-            mat.translation += relative_pos;
-            //data.hand_pos = data.pose.inverse().transform_point3a(new_hand);
+            data.pose.translation += relative_pos;
+            data.hand_pos = new_hand;
 
-            set_working_copy(&universe, chaperone_mgr, &mat);
+            set_working_copy(&universe, chaperone_mgr, &data.pose);
             chaperone_mgr.commit_working_copy(EChaperoneConfigFile::EChaperoneConfigFile_Live);
         } else {
             for (i, pointer) in state.input_state.pointers.iter().enumerate() {
@@ -72,11 +75,9 @@ impl PlayspaceMover {
                         log::warn!("Can't space drag - failed to get zero pose");
                         return;
                     };
-                    let pose_inverse = mat.inverse();
-                    let hand_pos = pointer.pose.translation;
+                    let hand_pos = mat.transform_point3a(pointer.raw_pose.translation);
                     self.last = Some(DragData {
                         pose: mat,
-                        pose_inverse,
                         hand: i,
                         hand_pos,
                     });
@@ -129,6 +130,10 @@ impl PlayspaceMover {
             self.last = None;
         }
     }
+
+    pub fn get_universe(&self) -> ETrackingUniverseOrigin {
+        self.universe.clone()
+    }
 }
 
 fn universe_str(universe: &ETrackingUniverseOrigin) -> &'static str {