fix(grip): xreview - locked index keeps a curl grip's trigger pose, lock change clears its refusal, shared snapshot_fingers and with_fingers

Author: tommy-xr

shock2vr/src/interaction.rs

@@ -1822,8 +1822,7 @@ impl VrInteraction {
             return false;
         }
         let personal = crate::world_scale::WorldScale::active().personal();
-        let captured = tool.with_locked(&current.fingers, fitted.fit.bones);
-        let fingers = pose_tool::slot_fingers(tool.slot, &current.fingers, captured);
+        let fingers = tool.snapshot_fingers(&current.fingers, fitted.fit.bones);
         let places = tool.places();
         let (grip, hand_pose) = if !places {
             // Fingers only: the wrist and item stay where the grip has them.
@@ -2103,8 +2102,9 @@ impl VrInteraction {
         };
         let profile = self.support_profiles.get(&held.model);
         let posed = glove.ok_or("degenerate_joints").and_then(|(glove, bones)| {
+            let profile = profile.ok_or("invalid_support_pose")?;
             // Locked fingers keep the support pose's.
-            let bones = profile.map_or(bones, |profile| tool.with_locked(&profile.fingers, bones));
+            let bones = tool.with_locked(&profile.fingers, bones);
             let pose = SupportProfile::captured_pose(
                 [Handedness::Left, Handedness::Right][tool.hand],
                 model,
@@ -2118,9 +2118,9 @@ impl VrInteraction {
                 },
             )
             .ok_or("degenerate_joints")?;
-            self.support_profiles
-                .get(&held.model)
-                .is_some_and(|profile| profile.with_pose(&pose).is_valid())
+            profile
+                .with_pose(&pose)
+                .is_valid()
                 .then_some(pose)
                 .ok_or("invalid_support_pose")
         });

shock2vr/src/interaction/pose_tool.rs

@@ -563,7 +563,8 @@ impl GripPoseTool {
         if self.slot != Slot::Trigger {
             Err("trigger slot only".to_owned())
         } else if self.locks[1] {
-            Err("index locked".to_owned())
+            // The Trigger slot's only finger.
+            Err(self.all_locked().replace('_', " "))
         } else {
             Ok(())
         }
@@ -572,6 +573,14 @@ impl GripPoseTool {
     /// Lock or unlock finger `finger` (0 thumb .. 4 little).
     pub fn toggle_lock(&mut self, finger: usize) {
         self.locks[finger] = !self.locks[finger];
+        // A snapshot refused for locks is stale once they change.
+        if self
+            .capture_failure
+            .as_deref()
+            .is_some_and(|reason| reason.ends_with("_locked"))
+        {
+            self.capture_failure = None;
+        }
     }
 
     /// Whether a snapshot can set anything, or why not (a capture failure
@@ -592,6 +601,26 @@ impl GripPoseTool {
         crate::vr_grip::with_fingers(&tracked, &stored, self.locks)
     }
 
+    /// The fingers a primary snapshot of `tracked` stores over `stored`:
+    /// the slot's (`slot_fingers`), locked ones as stored.
+    pub fn snapshot_fingers(&self, stored: &FingerPose, tracked: FingerBones) -> FingerPose {
+        match slot_fingers(self.slot, stored, self.with_locked(stored, tracked)) {
+            // A locked index keeps its rest, so a curl grip's trigger pose
+            // still pairs with it: kept, as a bone grip's is.
+            FingerPose::Bones {
+                bones,
+                trigger_bones: None,
+            } if self.locks[1] && stored.has_trigger_pose() => FingerPose::Bones {
+                trigger_bones: Some(crate::vr_grip::with_index(
+                    &bones,
+                    &stored.at(1.0).rest_bones(),
+                )),
+                bones,
+            },
+            fingers => fingers,
+        }
+    }
+
     /// A primary snapshot places the glove where the tracked hand is: a rest
     /// one with the placement not kept (a trigger one always keeps it).
     pub fn places(&self) -> bool {
@@ -619,8 +648,7 @@ impl GripPoseTool {
         let stored =
             stored.filter(|_| index == self.posing() && (kept || self.locks.contains(&true)))?;
         let at = if kept { self.hand_pose } else { glove.palm() };
-        let fingers = self.with_locked(stored, glove.fit.bones);
-        Some((at, slot_fingers(self.slot, stored, fingers)))
+        Some((at, self.snapshot_fingers(stored, glove.fit.bones)))
     }
 
     /// The trigger value the posed glove is drawn at: test hold's controller
@@ -1948,6 +1976,41 @@ mod tests {
         );
     }
 
+    /// A curl grip's trigger pose survives a rest snapshot while the index is
+    /// locked (the rest index it pairs with is kept); unlocked, it goes.
+    #[test]
+    fn a_locked_index_keeps_a_curl_grips_trigger_pose_through_a_rest_snapshot() {
+        use crate::vr_grip::with_index;
+        let mut tool = posing_tool();
+        let stored = FingerPose::curls([0.2; 5]).with_trigger_index(0.6);
+        let tracked = FingerPose::curls([0.9; 5]).rest_bones();
+        assert!(!tool.snapshot_fingers(&stored, tracked).has_trigger_pose());
+        tool.toggle_lock(1);
+        let FingerPose::Bones {
+            bones,
+            trigger_bones,
+        } = tool.snapshot_fingers(&stored, tracked)
+        else {
+            panic!("a snapshot is bones");
+        };
+        assert_eq!(
+            trigger_bones,
+            Some(with_index(&bones, &stored.at(1.0).rest_bones()))
+        );
+    }
+
+    /// A snapshot refused for locks stops saying so once they change.
+    #[test]
+    fn changing_a_lock_clears_a_lock_refusal() {
+        let mut tool = posing_tool();
+        tool.capture_failure = Some("index_locked".to_owned());
+        tool.toggle_lock(1);
+        assert_eq!(tool.capture_failure, None);
+        tool.capture_failure = Some("window_short".to_owned());
+        tool.toggle_lock(1);
+        assert_eq!(tool.capture_failure.as_deref(), Some("window_short"));
+    }
+
     #[test]
     fn a_rest_snapshot_captures_the_placement_until_toggled_on_a_primary_grip() {
         let mut tool = posing_tool();

shock2vr/src/vr_grip.rs

@@ -1280,15 +1280,11 @@ impl GripSurface {
                     let rest = moved_fingers(bones, &amounts, &open, &fist);
                     FingerPose::Bones {
                         bones: rest,
-                        trigger_bones: trigger_bones.map(|mut pulled| {
+                        trigger_bones: trigger_bones.map(|pulled| {
                             let behind =
                                 fingers[1] && bones_to_curls(&pulled)[1] < bones_to_curls(&rest)[1];
-                            for f in (0..5).filter(|&f| follows(f) || (f == 1 && behind)) {
-                                for i in FINGER_BONES[f].clone() {
-                                    pulled[i] = rest[i];
-                                }
-                            }
-                            pulled
+                            let take = std::array::from_fn(|f| follows(f) || (f == 1 && behind));
+                            with_fingers(&pulled, &rest, take)
                         }),
                     }
                 }

tools/dark_explorer/src/grip_editor.rs

@@ -59,7 +59,7 @@ impl CurlPoseEditor {
             ui.label("Lock:");
             for (name, lock) in FINGER_NAMES.into_iter().zip(self.locks.iter_mut()) {
                 ui.checkbox(lock, name)
-                    .on_hover_text("Keep this finger as it is while editing the others");
+                    .on_hover_text("Keep this finger: its sliders, presets and Tighten skip it");
             }
         });
         if let FingerPose::Bones { .. } = fingers {