fix(vr): an untracked held hand still reads as lost

Review: keeping the last pose hid tracking loss from support, visuals and the
refit. The hand now keeps the reported (untracked) pose and only skips placing
the item. Physics guard reuses GripPose::is_tracked; stale comments fixed.

Author: tommy-xr

shock2vr/src/hand_glove.rs

@@ -185,7 +185,8 @@ impl GloveRenderer {
         })
     }
 
-    /// `posed_joints` in authored units (world scale 1), as grips are fitted.
+    /// The glove's 26 skin joints posed with `pose`, in calibrated hand space
+    /// at authored size (world scale 1), as grips are fitted.
     fn authored_joints(
         &mut self,
         pose: &Pose,

shock2vr/src/interaction.rs

@@ -3694,17 +3694,19 @@ mod tests {
         for _ in 0..3 {
             let effects = interaction.update(&context(&world, &physics, &input));
             assert_eq!(interaction.right_hand.get_held_entity(), Some(entity));
-            for effect in effects {
-                if let VirtualHandEffect::SetPositionRotation {
-                    position, rotation, ..
-                } = effect
-                {
-                    assert!(
-                        GripPose { position, rotation }.is_tracked(),
-                        "{position:?} {rotation:?}"
-                    );
-                }
-            }
+            assert!(
+                !effects.iter().any(|e| matches!(
+                    e,
+                    VirtualHandEffect::SetPositionRotation { entity_id, .. } if *entity_id == entity
+                )),
+                "the item is not placed"
+            );
+            // `fit_held_items` reads this pose: still lost, so it places nothing.
+            let pose = GripPose {
+                position: interaction.right_hand.get_position(),
+                rotation: interaction.right_hand.get_rotation(),
+            };
+            assert!(!pose.is_tracked());
         }
     }
 

shock2vr/src/interaction/pose_tool.rs

@@ -460,7 +460,7 @@ impl GripPoseTool {
             .map_or(self.hand_pose.position, |(item, _)| item.position)
     }
 
-    /// Draws the bench (item, posed gloves, their spheres) as turned. The
+    /// Draws the bench (item and posed gloves) as turned. The
     /// tool works in the unturned bench, so captures stay relative to the
     /// item.
     pub fn turn_matrix(&self) -> Matrix4<f32> {

shock2vr/src/physics/mod.rs

@@ -4114,21 +4114,12 @@ impl PhysicsWorld {
         // A zero quaternion (an untracked Quest controller) or a non-finite
         // pose would normalize to NaN and panic parry's broad-phase rebuild;
         // the body keeps its last pose instead.
-        let finite = [
-            position.x,
-            position.y,
-            position.z,
-            rotation.s,
-            rotation.v.x,
-            rotation.v.y,
-            rotation.v.z,
-        ]
-        .into_iter()
-        .all(f32::is_finite);
-        let Some(rotation) = crate::util::tracked_rotation(rotation).filter(|_| finite) else {
+        let pose = crate::vr_support::GripPose { position, rotation };
+        if !pose.is_tracked() {
             tracing::warn!("[physics] ignored non-finite pose {position:?} {rotation:?}");
             return;
-        };
+        }
+        let rotation = rotation.normalize();
         let nquat = nalgebra::geometry::Quaternion::new(
             rotation.s,
             rotation.v.x,

shock2vr/src/virtual_hand.rs

@@ -436,16 +436,17 @@ impl VirtualHand {
             HandState::Grabbing { entity_id } => {
                 // See what we're hitting
                 let mut msgs = Vec::new();
+                let tracked = crate::vr_support::GripPose {
+                    position: input_hand.position,
+                    rotation: input_hand.rotation,
+                }
+                .is_tracked();
 
                 // A held download also collects on trigger, through the same
                 // drop a release takes. Never from an untracked fallback pose.
                 let trigger_collects = prev.trigger_value < 0.5
                     && input_hand.trigger_value > 0.5
-                    && crate::vr_support::GripPose {
-                        position: input_hand.position,
-                        rotation: input_hand.rotation,
-                    }
-                    .is_tracked()
+                    && tracked
                     && crate::scripts::script_util::is_download_pickup(world, entity_id);
 
                 // If we're holding onto something, but not grabbing, we can drop it
@@ -521,17 +522,8 @@ impl VirtualHand {
                     }
 
                     // A set-down controller (Quest: the zero quaternion)
-                    // leaves the item, and the hand, where they last were.
-                    let tracked = crate::vr_support::GripPose {
-                        position: input_hand.position,
-                        rotation: input_hand.rotation,
-                    }
-                    .is_tracked();
-                    let (hand_position, hand_rotation) = if tracked {
-                        (hand_position, hand_rotation)
-                    } else {
-                        (prev.position, prev.rotation)
-                    };
+                    // leaves the item where it is. The hand keeps that pose,
+                    // so tracking checks downstream still see it lost.
                     if tracked {
                         msgs.push(VirtualHandEffect::SetPositionRotation {
                             entity_id,
@@ -1978,12 +1970,14 @@ mod tests {
                 .any(|e| matches!(e, VirtualHandEffect::SetPositionRotation { .. })),
             "the item is not moved"
         );
-        assert_eq!(
-            hand.get_rotation(),
-            held.get_rotation(),
-            "the hand keeps its last pose"
+        assert!(
+            !crate::vr_support::GripPose {
+                position: hand.get_position(),
+                rotation: hand.get_rotation(),
+            }
+            .is_tracked(),
+            "the hand still reads as lost, so the refit places nothing either"
         );
-        assert_eq!(hand.get_position(), held.get_position());
     }
 
     #[test]