XRTK · FejZa · Oct 25, 2021 · Oct 24, 2021 · Oct 24, 2021 · Oct 24, 2021
@@ -110,8 +110,8 @@ protected override void OnEnable()
                     {
                         if (MixedRealityToolkit.TryGetSystem<IMixedRealityCameraSystem>(out var cameraSystem))
                         {
-                            var playspace = cameraSystem.MainCameraRig.PlayspaceTransform;
-                            Debug.Assert(playspace != null);
+                            var rig = cameraSystem.MainCameraRig.RigTransform;
+                            Debug.Assert(rig != null);
                         }
 
                         MixedRealityToolkit.Instance.ActiveProfile = rootProfile;

@@ -188,7 +188,7 @@ public InscribedRectangle(Edge[] geometryEdges, int randomSeed)
 
                         // Calculate the midpoint between the top and bottom collision points.
                         Vector2 verticalMidpoint = new Vector2((aX + bX) * 0.5f, (aY + bY) * 0.5f);
-                        if (TryFixMaximumRectangle(
+                        if (TryFitMaximumRectangle(
                             geometryEdges,
                             verticalMidpoint,
                             angleRadians,
@@ -213,7 +213,7 @@ public InscribedRectangle(Edge[] geometryEdges, int randomSeed)
                         // Calculate the midpoint between the left and right collision points.
                         var horizontalMidpoint = new Vector2((aX + bX) * 0.5f, (aY + bY) * 0.5f);
 
-                        if (TryFixMaximumRectangle(
+                        if (TryFitMaximumRectangle(
                             geometryEdges,
                             horizontalMidpoint,
                             angleRadians,
@@ -426,7 +426,7 @@ private static bool CheckRectangleFit(Edge[] geometryEdges, Vector2 centerPoint,
         /// True if a rectangle with an area greater than or equal to minArea was able to be fit
         /// within the geometry at centerPoint.
         /// </returns>
-        private static bool TryFixMaximumRectangle(
+        private static bool TryFitMaximumRectangle(
             Edge[] geometryEdges,
             Vector2 centerPoint,
             float angleRadians,
@@ -518,4 +518,4 @@ private static bool TryFixMaximumRectangle(
             return (aspectRatio > 0.0f);
         }
     }
-}
+}
@@ -89,7 +89,7 @@ public HandData(MixedRealityPose rootPose, MixedRealityPose[] jointPoses)
         public float GripStrength { get; set; }
 
         /// <summary>
-        /// The hand's pointer pose, relative to <see cref="Interfaces.CameraSystem.IMixedRealityCameraRig.PlayspaceTransform"/>.
+        /// The hand's pointer pose, relative to <see cref="Interfaces.CameraSystem.IMixedRealityCameraRig.RigTransform"/>.
         /// </summary>
         public MixedRealityPose PointerPose { get; set; }
 
@@ -102,7 +102,7 @@ public HandData(MixedRealityPose rootPose, MixedRealityPose[] jointPoses)
 
         /// <summary>
         /// The hands root pose. <see cref="Joints"/> poses are relative to the root pose.
-        /// The root pose itself is relative to <see cref="Interfaces.CameraSystem.IMixedRealityCameraRig.PlayspaceTransform"/>.
+        /// The root pose itself is relative to <see cref="Interfaces.CameraSystem.IMixedRealityCameraRig.RigTransform"/>.
         /// </summary>
         public MixedRealityPose RootPose { get; set; }
 

@@ -24,8 +24,8 @@ public enum TrackedObjectType
         /// </summary>
         Body,
         /// <summary>
-        /// Calculates position and orientation based on the <see cref="IMixedRealityCameraRig.PlayspaceTransform"/>
+        /// Calculates position and orientation based on the <see cref="IMixedRealityCameraRig.RigTransform"/>
         /// </summary>
-        Playspace,
+        Rig
     }
-}
+}
@@ -7,7 +7,7 @@
 namespace XRTK.Interfaces.CameraSystem
 {
     /// <summary>
-    /// This interface is to be implemented by a <see cref="MonoBehaviour"/> and attached to the playspace root object.
+    /// This interface is to be implemented by a <see cref="MonoBehaviour"/> and attached to the rig root object.
     /// </summary>
     public interface IMixedRealityCameraRig
     {
@@ -17,11 +17,11 @@ public interface IMixedRealityCameraRig
         GameObject GameObject { get; }
 
         /// <summary>
-        /// The root playspace transform that serves as the root of the camera rig.<para/>
+        /// The root rig transform.<para/>
         /// This transform serves as a virtual representation of the physical space.<para/>
         /// All physical objects that have digital twins will use this frame of reference to synchronize their transform data.
         /// </summary>
-        Transform PlayspaceTransform { get; }
+        Transform RigTransform { get; }
 
         /// <summary>
         /// The player's head transform where the <see cref="Camera"/> is located.
@@ -47,4 +47,4 @@ public interface IMixedRealityCameraRig
         /// </remarks>
         Transform BodyTransform { get; }
     }
-}
+}
@@ -148,8 +148,15 @@ public override void Initialize()
 
             if (CameraRig == null)
             {
-                // TODO Currently we always get the main camera. Should we provide a tag to search for alts?
-                CameraRig = CameraCache.Main.gameObject.EnsureComponent(cameraRigType) as IMixedRealityCameraRig;
+                if (CameraCache.Main.transform.parent.IsNull())
+                {
+                    CameraRig = CameraCache.Main.gameObject.EnsureComponent(cameraRigType) as IMixedRealityCameraRig;
+                }
+                else
+                {
+                    CameraRig = CameraCache.Main.transform.parent.gameObject.EnsureComponent(cameraRigType) as IMixedRealityCameraRig;
+                }
+
                 Debug.Assert(CameraRig != null);
             }
 
@@ -265,9 +272,9 @@ public override void Disable()
                 cameraTransform.rotation = Quaternion.identity;
             }
 
-            if (CameraRig.PlayspaceTransform != null)
+            if (CameraRig.RigTransform != null)
             {
-                CameraRig.PlayspaceTransform.gameObject.Destroy();
+                CameraRig.RigTransform.gameObject.Destroy();
             }
 
             if (CameraRig is Component component &&
@@ -444,13 +451,13 @@ protected virtual void ApplySettingsForTransparentDisplay()
         }
 
         /// <summary>
-        /// Resets the <see cref="IMixedRealityCameraRig.PlayspaceTransform"/>, <see cref="IMixedRealityCameraRig.CameraTransform"/>,
+        /// Resets the <see cref="IMixedRealityCameraRig.RigTransform"/>, <see cref="IMixedRealityCameraRig.CameraTransform"/>,
         /// and <see cref="IMixedRealityCameraRig.BodyTransform&
10000
quot;/> poses.
         /// </summary>
         protected virtual void ResetRigTransforms()
         {
-            CameraRig.PlayspaceTransform.position = Vector3.zero;
-            CameraRig.PlayspaceTransform.rotation = Quaternion.identity;
+            CameraRig.RigTransform.position = Vector3.zero;
+            CameraRig.RigTransform.rotation = Quaternion.identity;
 
             // If the camera is a 2d camera then we can adjust the camera's height to match the head height.
             CameraRig.CameraTransform.position = IsStereoscopic ? Vector3.zero : new Vector3(0f, HeadHeight, 0f);
@@ -461,7 +468,7 @@ protected virtual void ResetRigTransforms()
         }
 
         /// <summary>
-        /// Called each <see cref="LateUpdate"/> to sync the <see cref="IMixedRealityCameraRig.PlayspaceTransform"/>,
+        /// Called each <see cref="LateUpdate"/> to sync the <see cref="IMixedRealityCameraRig.RigTransform"/>,
         /// <see cref="IMixedRealityCameraRig.CameraTransform"/>, and <see cref="IMixedRealityCameraRig.BodyTransform"/> poses.
         /// </summary>
         protected virtual void SyncRigTransforms()

@@ -176,10 +176,10 @@ private IMixedRealityPointer[] AssignControllerMappings(MixedRealityInteractionM
                 for (int j = 0; j < interactionProfile.PointerProfiles.Length; j++)
                 {
                     var pointerProfile = interactionProfile.PointerProfiles[j];
-                    var playspaceTransform = MixedRealityToolkit.TryGetSystem<IMixedRealityCameraSystem>(out var cameraSystem)
-                        ? cameraSystem.MainCameraRig.PlayspaceTransform
+                    var rigTransform = MixedRealityToolkit.TryGetSystem<IMixedRealityCameraSystem>(out var cameraSystem)
+                        ? cameraSystem.MainCameraRig.RigTransform
                         : CameraCache.Main.transform.parent;
-                    var pointerObject = Object.Instantiate(pointerProfile.PointerPrefab, playspaceTransform);
+                    var pointerObject = Object.Instantiate(pointerProfile.PointerPrefab, rigTransform);
                     var pointer = pointerObject.GetComponent<IMixedRealityPointer>();
 
                     if (pointer != null)
@@ -229,11 +229,11 @@ public void TryRenderControllerModel(bool useAlternatePoseAction = false)
             // If we've got a controller model, then place it in the scene and get/attach the visualizer.
             if (!controllerModel.IsNull())
             {
-                var playspaceTransform = MixedRealityToolkit.TryGetSystem<IMixedRealityCameraSystem>(out var cameraSystem)
-                    ? cameraSystem.MainCameraRig.PlayspaceTransform
+                var rigTransform = MixedRealityToolkit.TryGetSystem<IMixedRealityCameraSystem>(out var cameraSystem)
+                    ? cameraSystem.MainCameraRig.RigTransform
                     : CameraCache.Main.transform.parent;
 
-                var controllerObject = Object.Instantiate(controllerModel, playspaceTransform);
+                var controllerObject = Object.Instantiate(controllerModel, rigTransform);
                 Debug.Assert(controllerObject != null);
                 controllerObject.name = $"{GetType().Name}_Visualization";
                 Visualizer = controllerObject.GetComponent<IMixedRealityControllerVisualizer>();
@@ -270,4 +270,4 @@ void SetupController(IMixedRealityControllerVisualizer visualizer)
             }
         }
     }
-}
+}
@@ -137,14 +137,14 @@ private HandData UpdateIsPointing(HandData handData)
         {
             if (handData.TrackingState == TrackingState.Tracked && !PlatformProvidesIsPointing)
             {
-                var playspaceTransform = CameraSystem != null
-                    ? CameraSystem.MainCameraRig.PlayspaceTransform
+                var rigTransform = CameraSystem != null
+                    ? CameraSystem.MainCameraRig.RigTransform
                     : CameraCache.Main.transform.parent;
                 var localPalmPose = handData.Joints[(int)TrackedHandJoint.Palm];
                 var worldPalmPose = new MixedRealityPose
                 {
                     Position = handData.RootPose.Position + handData.RootPose.Rotation * localPalmPose.Position,
-                    Rotation = playspaceTransform.rotation * handData.RootPose.Rotation * localPalmPose.Rotation
+                    Rotation = rigTransform.rotation * handData.RootPose.Rotation * localPalmPose.Rotation
                 };
 
                 // We check if the palm forward is roughly in line with the camera lookAt.
@@ -184,4 +184,4 @@ private HandData UpdatePointerPose(HandData handData)
             return handData;
         }
     }
-}
+}
@@ -126,17 +126,17 @@ private static IMixedRealityCameraSystem CameraSystem
         public string TrackedPoseId { get; private set; }
 
         /// <summary>
-        /// The hand's pointer pose in playspace.
+        /// The hand's pointer pose in the camera rig's local coordinate space.
         /// </summary>
         private MixedRealityPose SpatialPointerPose { get; set; }
 
         /// <summary>
-        /// The hand's index finger tip pose in playspace.
+        /// The hand's index finger tip pose in the camera rig's local coordinate space.
         /// </summary>
         private MixedRealityPose IndexFingerTipPose { get; set; }
 
         /// <summary>
-        /// The hand's grip pose in playspace.
+        /// The hand's grip pose in the camera rig's local coordinate space.
         /// </summary>
         private MixedRealityPose GripPose { get; set; }
 
@@ -799,8 +799,8 @@ public bool TryGetJointPose(TrackedHandJoint joint, out MixedRealityPose pose, S
                 // Translate to world space.
                 if (CameraSystem != null)
                 {
-                    pose.Position = CameraSystem.MainCameraRig.PlayspaceTransform.TransformPoint(pose.Position);
-                    pose.Rotation = CameraSystem.MainCameraRig.PlayspaceTransform.rotation * pose.Rotation;
+                    pose.Position = CameraSystem.MainCameraRig.RigTransform.TransformPoint(pose.Position);
+                    pose.Rotation = CameraSystem.MainCameraRig.RigTransform.rotation * pose.Rotation;
                 }
 
                 return lastHandRootPose != MixedRealityPose.ZeroIdentity;

@@ -205,13 +205,13 @@ private HandData UpdatePoseFrame()
             var position = PlayerCamera.ScreenToWorldPoint(ScreenPosition + JitterOffset);
 
             // At this point we know the hand's root pose in world space and
-            // need to translate to playspace.
+            // need to translate to the camera rig's local coordinate space.
             var rootPose = new MixedRealityPose(position, rotation);
-            var playspaceTransform = CameraSystem != null
-                ? CameraSystem.MainCameraRig.PlayspaceTransform
+            var rigTransform = CameraSystem != null
+                ? CameraSystem.MainCameraRig.RigTransform
                 : CameraCache.Main.transform.parent;
-            rootPose.Position = playspaceTransform.InverseTransformPoint(rootPose.Position);
-            rootPose.Rotation = Quaternion.Inverse(playspaceTransform.rotation) * playspaceTransform.rotation * rootPose.Rotation;
+            rootPose.Position = rigTransform.InverseTransformPoint(rootPose.Position);
+            rootPose.Rotation = Quaternion.Inverse(rigTransform.rotation) * rigTransform.rotation * rootPose.Rotation;
 
             // Compute joint poses relative to root pose.
             var jointPoses = ComputeJointPoses(Pose, handedness);
@@ -287,4 +287,4 @@ public void ResetConverter()
             }
         }
     }
-}
+}
@@ -68,19 +68,19 @@ public MixedRealityBoundarySystem(MixedRealityBoundaryProfile profile)
 
         private readonly Dictionary<BoundsCache, ProximityAlert> trackedObjects = new Dictionary<BoundsCache, ProximityAlert>(3);
 
-        private Transform playspaceTransform = null;
+        private Transform rigTransform = null;
 
-        private Transform PlayspaceTransform
+        private Transform RigTransform
         {
             get
             {
-                if (playspaceTransform == null)
+                if (rigTransform == null)
                 {
-                    playspaceTransform = MixedRealityToolkit.TryGetSystem<IMixedRealityCameraSystem>(out var cameraSystem)
-                       ? cameraSystem.MainCameraRig.PlayspaceTransform
+                    rigTransform = MixedRealityToolkit.TryGetSystem<IMixedRealityCameraSystem>(out var cameraSystem)
+                       ? cameraSystem.MainCameraRig.RigTransform
                        : CameraCache.Main.transform.parent;
                 }
-                return playspaceTransform;
+                return rigTransform;
             }
         }
 
@@ -98,7 +98,7 @@ private GameObject BoundarySystemVisualizationRoot
                 }
 
                 boundaryVisualizationRoot = new GameObject(nameof(BoundarySystemVisualizationRoot));
-                boundaryVisualizationRoot.transform.SetParent(PlayspaceTransform, false);
+                boundaryVisualizationRoot.transform.SetParent(RigTransform, false);
 
                 return boundaryVisualizationRoot;
             }
@@ -184,7 +184,7 @@ private GameObject FloorVisualization
                     return floorVisualization;
                 }
 
-                var position = PlayspaceTransform.position;
+                var position = RigTransform.position;
 
                 // Render the floor.
                 floorVisualization = GameObject.CreatePrimitive(PrimitiveType.Cube);
@@ -577,7 +577,7 @@ public bool IsInsideBoundary(Vector3 position, Space referenceSpace = Space.Worl
             // Handle the user teleporting (boundary moves with them).
             if (referenceSpace == Space.World)
             {
-                position = PlayspaceTransform.InverseTransformPoint(position);
+                position = RigTransform.InverseTransformPoint(position);
             }
 
             if (position.y < 0 ||
@@ -605,7 +605,7 @@ public bool TryGetRectangularBoundsParams(out Vector2 center, out float angle, o
             }
 
             // Handle the user teleporting (boundary moves with them).
-            var transformedCenter = PlayspaceTransform.TransformPoint(new Vector3(rectangularBounds.Center.x, 0f, rectangularBounds.Center.y));
+            var transformedCenter = RigTransform.TransformPoint(new Vector3(rectangularBounds.Center.x, 0f, rectangularBounds.Center.y));
 
             center = new Vector2(transformedCenter.x, transformedCenter.z);
             angle = rectangularBounds.Angle;