Switching all coordinate transformations to be explicit about rig-loc…

…al space vs floor-offset-relative-space.

UnityProjects/MRTKDevTemplate/Assets/Scripts/SampleSceneHandMenu.cs

@@ -68,7 +68,7 @@ private void Awake()
         /// </summary>
         public void SetHandRaysActive(bool value)
         {
-            var handRays = PlayspaceUtilities.ReferenceTransform.GetComponentsInChildren<MRTKRayInteractor>(true);
+            var handRays = PlayspaceUtilities.Origin.GetComponentsInChildren<MRTKRayInteractor>(true);
 
             foreach (var interactor in handRays)
             {
@@ -81,7 +81,7 @@ public void SetHandRaysActive(bool value)
         /// </summary>
         public void SetGazePinchActive(bool value)
         {
-            var gazePinchInteractors = PlayspaceUtilities.ReferenceTransform.GetComponentsInChildren<GazePinchInteractor>(true);
+            var gazePinchInteractors = PlayspaceUtilities.Origin.GetComponentsInChildren<GazePinchInteractor>(true);
 
             foreach (var interactor in gazePinchInteractors)
             {

com.microsoft.mrtk.input/Interactors/GazePinch/GazePinchInteractor.cs

@@ -230,7 +230,7 @@ private void ComputeAttachTransform(IXRSelectInteractable interactable)
             if (DevicePoseSource != null && DevicePoseSource.TryGetPose(out Pose devicePose) &&
                    PinchPoseSource != null && PinchPoseSource.TryGetPose(out Pose pinchPose))
             {
-                rotationToApply = PlayspaceUtilities.ReferenceTransform.rotation * devicePose.rotation;
+                rotationToApply = PlayspaceUtilities.OriginOffsetTransform.rotation * devicePose.rotation;
                 if (hasSelection && interactable != null)
                 {
                     var pinchCentroid = GetPinchCentroid(interactable);

com.microsoft.mrtk.input/Simulation/Devices/SimulatedController.cs

@@ -94,12 +94,12 @@ internal class SimulatedController : IDisposable
         /// <summary>
         /// Returns the current position, in worldspace, of the simulated controller.
         /// </summary>
-        public Vector3 WorldPosition => PlayspaceUtilities.ReferenceTransform.TransformPoint(simulatedControllerState.devicePosition);
+        public Vector3 WorldPosition => PlayspaceUtilities.OriginOffsetTransform.TransformPoint(simulatedControllerState.devicePosition);
 
         /// <summary>
         /// Returns the current rotation, in worldspace, of the simulated controller.
         /// </summary>
-        public Quaternion WorldRotation => PlayspaceUtilities.ReferenceTransform.rotation * simulatedControllerState.deviceRotation;
+        public Quaternion WorldRotation => PlayspaceUtilities.OriginOffsetTransform.rotation * simulatedControllerState.deviceRotation;
 
         /// <summary>
         /// Returns the position of the index finger joint on the simulated device,
@@ -512,8 +512,8 @@ private void SetWorldPose(
         {
             using (SetWorldPosePerfMarker.Auto())
             {
-                Vector3 rigLocalPosition = PlayspaceUtilities.ReferenceTransform.InverseTransformPoint(position);
-                Quaternion rigLocalRotation = Quaternion.Inverse(PlayspaceUtilities.ReferenceTransform.rotation) * rotation;
+                Vector3 rigLocalPosition = PlayspaceUtilities.OriginOffsetTransform.InverseTransformPoint(position);
+                Quaternion rigLocalRotation = Quaternion.Inverse(PlayspaceUtilities.OriginOffsetTransform.rotation) * rotation;
                 SetRigLocalPose(rigLocalPosition, rigLocalRotation, rotationMode, shouldUseRayVector);
             }
         }
@@ -544,7 +544,7 @@ private void SetRigLocalPose(
                 if (rotationMode == ControllerRotationMode.FaceCamera)
                 {
                     Quaternion worldLookAtCamera = Quaternion.LookRotation(Camera.main.transform.position - position);
-                    Quaternion rigLocalLookAtCamera = Quaternion.Inverse(PlayspaceUtilities.ReferenceTransform.rotation) * worldLookAtCamera;
+                    Quaternion rigLocalLookAtCamera = Quaternion.Inverse(PlayspaceUtilities.OriginOffsetTransform.rotation) * worldLookAtCamera;
                     simulatedControllerState.deviceRotation = Smoothing.SmoothTo(
                         simulatedControllerState.deviceRotation,
                         rigLocalLookAtCamera,
@@ -554,7 +554,7 @@ private void SetRigLocalPose(
                 else if (rotationMode == ControllerRotationMode.CameraAligned)
                 {
                     Quaternion worldCameraForward = Quaternion.LookRotation(Camera.main.transform.forward);
-                    Quaternion rigLocalCameraForward = Quaternion.Inverse(PlayspaceUtilities.ReferenceTransform.rotation) * worldCameraForward;
+                    Quaternion rigLocalCameraForward = Quaternion.Inverse(PlayspaceUtilities.OriginOffsetTransform.rotation) * worldCameraForward;
                     simulatedControllerState.deviceRotation = Smoothing.SmoothTo(
                         simulatedControllerState.deviceRotation,
                         rigLocalCameraForward,
@@ -572,10 +572,10 @@ private void SetRigLocalPose(
                 {
                     // If prompted to use the ray vector, this is pose is calculated by simulating a hand ray initialized at the device pose.
                     // This occurs when the simulation mode is set to ArticulatedHand
-                    handRay.Update(PlayspaceUtilities.ReferenceTransform.TransformPoint(simulatedControllerState.devicePosition), -palmPose.Up, Camera.main.transform, Handedness);
+                    handRay.Update(PlayspaceUtilities.OriginOffsetTransform.TransformPoint(simulatedControllerState.devicePosition), -palmPose.Up, Camera.main.transform, Handedness);
                     Ray ray = handRay.Ray;
-                    simulatedControllerState.pointerPosition = PlayspaceUtilities.ReferenceTransform.InverseTransformPoint(ray.origin);
-                    simulatedControllerState.pointerRotation = Quaternion.Inverse(PlayspaceUtilities.ReferenceTransform.rotation) * Quaternion.LookRotation(ray.direction);
+                    simulatedControllerState.pointerPosition = PlayspaceUtilities.OriginOffsetTransform.InverseTransformPoint(ray.origin);
+                    simulatedControllerState.pointerRotation = Quaternion.Inverse(PlayspaceUtilities.OriginOffsetTransform.rotation) * Quaternion.LookRotation(ray.direction);
                 }
                 else
                 {

com.microsoft.mrtk.input/Simulation/Devices/SimulatedHMD.cs

@@ -136,7 +136,7 @@ public void Update(
                     moveDelta;
 
                 simulatedHmdState.trackingState = (int)(InputTrackingState.Position | InputTrackingState.Rotation);
-                simulatedHmdState.centerEyePosition += Quaternion.Inverse(PlayspaceUtilities.ReferenceTransform.rotation) * Camera.main.transform.rotation * (smoothedMoveDelta * moveSpeed);
+                simulatedHmdState.centerEyePosition += Quaternion.Inverse(PlayspaceUtilities.OriginOffsetTransform.rotation) * Camera.main.transform.rotation * (smoothedMoveDelta * moveSpeed);
                 simulatedHmdState.devicePosition = simulatedHmdState.centerEyePosition;
 
                 cameraRotation += rotationDelta * rotationSensitivity;

com.microsoft.mrtk.input/Subsystems/Hands/OpenXRHandsSubsystem.cs

@@ -96,7 +96,9 @@ public override bool TryGetJoint(TrackedHandJoint joint, out HandJointPose pose)
                             return false;
                         }
 
-                        Transform playspaceTransform = PlayspaceUtilities.ReferenceTransform;
+                        // Here, we use the origin transform (rather than the offset transform)
+                        // as joints are reported in rig-local space.
+                        Transform playspaceTransform = PlayspaceUtilities.OriginTransform;
                         if (playspaceTransform == null)
                         {
                             pose = handJoints[index];
@@ -141,7 +143,9 @@ private void TryCalculateEntireHand()
                     // Null checks against Unity objects can be expensive, especially when you do
                     // it 52 times per frame (26 hand joints across 2 hands). Instead, we manage
                     // the playspace transformation internally for hand joints.
-                    Transform playspaceTransform = PlayspaceUtilities.ReferenceTransform;
+                    // Here, we use the origin transform (rather than the offset transform)
+                        // as joints are reported in rig-local space.
+                    Transform playspaceTransform = PlayspaceUtilities.OriginTransform;
                     if (playspaceTransform == null)
                     {
                         return;

com.microsoft.mrtk.input/Subsystems/Hands/XRSDKHandsSubsystem.cs

@@ -95,7 +95,9 @@ public override bool TryGetJoint(TrackedHandJoint joint, out HandJointPose pose)
                             return false;
                         }
 
-                        Transform playspaceTransform = PlayspaceUtilities.ReferenceTransform;
+                        // Here, we use the origin transform (rather than the offset transform)
+                        // as joints are reported in rig-local space.
+                        Transform playspaceTransform = PlayspaceUtilities.OriginTransform;
                         if (playspaceTransform == null)
                         {
                             pose = handJoints[HandsUtils.ConvertToIndex(joint)];
@@ -200,7 +202,9 @@ private void TryCalculateEntireHand()
                     // Null checks against Unity objects can be expensive, especially when you do
                     // it 52 times per frame (26 hand joints across 2 hands). Instead, we manage
                     // the playspace transformation internally for hand joints.
-                    Transform playspaceTransform = PlayspaceUtilities.ReferenceTransform;
+                    // Here, we use the origin transform (rather than the offset transform)
+                    // as joints are reported in rig-local space.
+                    Transform playspaceTransform = PlayspaceUtilities.OriginTransform;
                     if (playspaceTransform == null)
                     {
                         return;

com.microsoft.mrtk.input/Subsystems/SyntheticHands/SyntheticHandsSubsystem.cs

@@ -333,7 +333,9 @@ private void TryCalculateEntireHand()
                     // Null checks against Unity objects can be expensive, especially when you do
                     // it 52 times per frame (26 hand joints across 2 hands). Instead, we manage
                     // the playspace transformation internally for hand joints.
-                    Transform playspaceTransform = PlayspaceUtilities.ReferenceTransform;
+                    // Here, we use the origin transform (rather than the offset transform)
+                    // as joints are reported in rig-local space.
+                    Transform playspaceTransform = PlayspaceUtilities.OriginTransform;
                     if (playspaceTransform == null)
                     {
                         return;

com.microsoft.mrtk.input/Utilities/PoseSource/InputActionPoseSource.cs

@@ -38,9 +38,10 @@ public bool TryGetPose(out Pose pose)
                 && rotationAction != null && rotationAction.controls.Count != 0
                 && ((InputTrackingState)trackingStateAction.ReadValue<int>() & (InputTrackingState.Position | InputTrackingState.Rotation)) != 0)
             {
-                // Transform the pose into worldspace, as input actions are returned in rig space
-                pose.position = PlayspaceUtilities.ReferenceTransform.TransformPoint(positionAction.ReadValue<Vector3>());
-                pose.rotation = PlayspaceUtilities.ReferenceTransform.rotation * rotationAction.ReadValue<Quaternion>();
+                // Transform the pose into worldspace, as input actions are returned
+                // in floor-offset-relative coordinates.
+                pose.position = PlayspaceUtilities.OriginOffsetTransform.TransformPoint(positionAction.ReadValue<Vector3>());
+                pose.rotation = PlayspaceUtilities.OriginOffsetTransform.rotation * rotationAction.ReadValue<Quaternion>();
 
                 return true;
             }

com.microsoft.mrtk.input/Utilities/PoseSource/PolyfillHandRayPoseSource.cs

@@ -47,9 +47,9 @@ public override bool TryGetPose(out Pose pose)
                 Ray ray = handRay.Ray;
 
                 // controllerState is in rig-local space, our ray generator works in worldspace!
-                pose.position = PlayspaceUtilities.ReferenceTransform.InverseTransformPoint(ray.origin);
-                pose.rotation = Quaternion.LookRotation(PlayspaceUtilities.ReferenceTransform.InverseTransformVector(ray.direction),
-                                                                   PlayspaceUtilities.ReferenceTransform.InverseTransformVector(palm.Up));
+                pose.position = PlayspaceUtilities.CameraFloorOffsetObject.InverseTransformPoint(ray.origin);
+                pose.rotation = Quaternion.LookRotation(PlayspaceUtilities.CameraFloorOffsetObject.InverseTransformVector(ray.direction),
+                                                                   PlayspaceUtilities.CameraFloorOffsetObject.InverseTransformVector(palm.Up));
             }
             else
             {