Merge pull request #9425 from microsoft/releases/2.6.0

Merge Releases/2.6.0 -> mrtk_release

Author: keveleigh

.gitignore

@@ -105,6 +105,8 @@ MSBuildForUnity.Common.props
 *.msb4u.sln.meta
 Dependencies*
 Nuget.config*
+*.obj
+*.bin
 
 # =========== #
 # Other files #

Assets/MRTK/Core/Attributes/MixedRealityControllerAttribute.cs

@@ -15,7 +15,7 @@ namespace Microsoft.MixedReality.Toolkit.Input
     /// <summary>
     /// Attach to a controller device class to make it show up in the controller mapping profile.
     /// </summary>
-    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
     public class MixedRealityControllerAttribute : Attribute
     {
         /// <summary>

Assets/MRTK/Core/Attributes/MixedRealityServiceProfileAttribute.cs

@@ -22,7 +22,7 @@ public MixedRealityServiceProfileAttribute(Type requiredType, Type excludedType
         public MixedRealityServiceProfileAttribute(Type[] requiredTypes, Type[] excludedTypes = null)
         {
             RequiredTypes = requiredTypes;
-            ExcludedTypes = excludedTypes != null ? excludedTypes : new Type[0];
+            ExcludedTypes = excludedTypes ?? (new Type[0]);
         }
 
         public Type[] RequiredTypes { get; private set; }

Assets/MRTK/Core/Definitions/BoundarySystem/InscribedRectangle.cs

@@ -27,12 +27,12 @@ public class InscribedRectangle
         /// <summary>
         /// Angles to use for fitting the rectangle within the boundary.
         /// </summary>
-        private static readonly float[] fitAngles = { 0, 15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165 };
+        private static readonly float[] FitAngles = { 0, 15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165 };
 
         /// <summary>
         /// Aspect ratios used when fitting rectangles within the boundary.
         /// </summary>
-        private static float[] aspectRatios = {
+        private static readonly float[] AspectRatios = {
                 1.0f, 1.5f, 2.0f, 2.5f, 3.0f, 3.5f, 4.0f, 4.5f,
                 5.0f, 5.5f, 6, 6.5f, 7, 7.5f, 8.0f, 8.5f, 9.0f,
                 9.5f, 10.0f, 10.5f, 11.0f, 11.5f, 12.0f, 12.5f,
@@ -80,8 +80,7 @@ public class InscribedRectangle
         /// <param name="geometryEdges">The boundary geometry.</param>
         /// <param name="randomSeed">Random number generator seed.</param>
         /// <remarks>
-        /// For the most reproducible results, use the same randomSeed value 
-        /// each time this method is called.
+        /// For the most reproducible results, use the same randomSeed value each time this method is called.
         /// </remarks>
         public InscribedRectangle(Edge[] geometryEdges, int randomSeed)
         {
@@ -148,7 +147,7 @@ public InscribedRectangle(Edge[] geometryEdges, int randomSeed)
                 }
             }
 
-            for (int angleIndex = 0; angleIndex < fitAngles.Length; angleIndex++)
+            for (int angleIndex = 0; angleIndex < FitAngles.Length; angleIndex++)
             {
                 for (int pointIndex = 0; pointIndex < startingPoints.Length; pointIndex++)
                 {
@@ -157,7 +156,7 @@ public InscribedRectangle(Edge[] geometryEdges, int randomSeed)
                     Vector2 leftCollisionPoint;
                     Vector2 rightCollisionPoint;
 
-                    float angleRadians = MathUtilities.DegreesToRadians(fitAngles[angleIndex]);
+                    float angleRadians = MathUtilities.DegreesToRadians(FitAngles[angleIndex]);
 
                     // Find the collision point of a cross through the given point at the given angle.
                     // Note, we are ignoring the return value as we are checking each point's validity
@@ -192,7 +191,7 @@ public InscribedRectangle(Edge[] geometryEdges, int randomSeed)
                             out newHeight))
                         {
                             Center = verticalMidpoint;
-                            Angle = fitAngles[angleIndex];
+                            Angle = FitAngles[angleIndex];
                             Width = newWidth;
                             Height = newHeight;
                         }
@@ -216,7 +215,7 @@ public InscribedRectangle(Edge[] geometryEdges, int randomSeed)
                             out newHeight))
                         {
                             Center = horizontalMidpoint;
-                            Angle = fitAngles[angleIndex];
+                            Angle = FitAngles[angleIndex];
                             Width = newWidth;
                             Height = newHeight;
                         }
@@ -510,19 +509,19 @@ private bool TryFixMaximumRectangle(
 
             // For each aspect ratio we do a binary search to find the maximum rectangle that fits, 
             // though once we start increasing our area by minimumHeightGain we call it good enough.
-            for (int i = 0; i < aspectRatios.Length; i++)
+            for (int i = 0; i < AspectRatios.Length; i++)
             {
                 // The height is limited by the width. If a height would make our width exceed maxWidth, it can't be used
-                float searchHeightUpperBound = Mathf.Max(maxHeight, maxWidth / aspectRatios[i]);
+                float searchHeightUpperBound = Mathf.Max(maxHeight, maxWidth / AspectRatios[i]);
 
                 // Set to the min height that will out perform our previous area at the given aspect ratio. This is 0 the first time.
                 // Derived from biggestAreaSoFar=height*(height*aspectRatio)
-                float searchHeightLowerBound = Mathf.Sqrt(Mathf.Max((width * height), minArea) / aspectRatios[i]);
+                float searchHeightLowerBound = Mathf.Sqrt(Mathf.Max((width * height), minArea) / AspectRatios[i]);
 
                 // If the lowest value needed to outperform the previous best is greater than our max, 
                 // this aspect ratio can't outperform what we've already calculated.
                 if ((searchHeightLowerBound > searchHeightUpperBound) ||
-                    (searchHeightLowerBound * aspectRatios[i] > maxWidth))
+                    (searchHeightLowerBound * AspectRatios[i] > maxWidth))
                 {
                     continue;
                 }
@@ -536,16 +535,16 @@ private bool TryFixMaximumRectangle(
                     if (CheckRectangleFit(geometryEdges,
                         centerPoint,
                         angleRadians,
-                        aspectRatios[i] * currentTestingHeight,
+                        AspectRatios[i] * currentTestingHeight,
                         currentTestingHeight))
                     {
                         // Binary search up-ward
                         // If the rectangle will fit, increase the lower bounds of our binary search
                         searchHeightLowerBound = currentTestingHeight;
 
-                        width = currentTestingHeight * aspectRatios[i];
+                        width = currentTestingHeight * AspectRatios[i];
                         height = currentTestingHeight;
-                        aspectRatio = aspectRatios[i];
+                        aspectRatio = AspectRatios[i];
                         currentTestingHeight = (searchHeightUpperBound + currentTestingHeight) * 0.5f;
                     }
                     else

Assets/MRTK/Core/Definitions/BoundarySystem/MixedRealityBoundaryVisualizationProfile.cs

@@ -12,7 +12,7 @@ namespace Microsoft.MixedReality.Toolkit.Boundary
     /// </summary>
     [CreateAssetMenu(menuName = "Mixed Reality Toolkit/Profiles/Mixed Reality Boundary Visualization Profile", fileName = "MixedRealityBoundaryVisualizationProfile", order = (int)CreateProfileMenuItemIndices.BoundaryVisualization)]
     [MixedRealityServiceProfile(typeof(IMixedRealityBoundarySystem))]
-    [HelpURL("https://microsoft.github.io/MixedRealityToolkit-Unity/Documentation/Boundary/BoundarySystemGettingStarted.html")]
+    [HelpURL("https://docs.microsoft.com/windows/mixed-reality/mrtk-unity/features/boundary/boundary-system-getting-started")]
     public class MixedRealityBoundaryVisualizationProfile : BaseMixedRealityProfile
     {
         [SerializeField]

Assets/MRTK/Core/Definitions/CameraSystem/MixedRealityCameraProfile.cs

@@ -16,7 +16,7 @@ namespace Microsoft.MixedReality.Toolkit
     /// </summary>
     [CreateAssetMenu(menuName = "Mixed Reality Toolkit/Profiles/Mixed Reality Camera Profile", fileName = "MixedRealityCameraProfile", order = (int)CreateProfileMenuItemIndices.Camera)]
     [MixedRealityServiceProfile(typeof(IMixedRealityCameraSystem))]
-    [HelpURL("https://microsoft.github.io/MixedRealityToolkit-Unity/Documentation/MixedRealityConfigurationGuide.html#camera")]
+    [HelpURL("https://docs.microsoft.com/windows/mixed-reality/mrtk-unity/configuration/mixed-reality-configuration-guide#camera")]
     public class MixedRealityCameraProfile : BaseMixedRealityProfile
     {
         [SerializeField]

…iders/Hands/ArticulatedHandDefinition.cs …ons/Devices/ArticulatedHandDefinition.csAssets/MRTK/Core/Providers/Hands/ArticulatedHandDefinition.cs renamed to Assets/MRTK/Core/Definitions/Devices/ArticulatedHandDefinition.cs Assets/MRTK/Core/Providers/Hands/ArticulatedHandDefinition.cs renamed to Assets/MRTK/Core/Definitions/Devices/ArticulatedHandDefinition.cs

@@ -11,16 +11,22 @@ namespace Microsoft.MixedReality.Toolkit.Input
     /// <summary>
     /// Defines the interactions and data that an articulated hand can provide.
     /// </summary>
-    public class ArticulatedHandDefinition
+    public class ArticulatedHandDefinition : BaseInputSourceDefinition
     {
-        public ArticulatedHandDefinition(IMixedRealityInputSource source, Handedness handedness)
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="source">The input source backing this definition instance. Used for raising events.</param>
+        /// <param name="handedness">The handedness that this definition instance represents.</param>
+        public ArticulatedHandDefinition(IMixedRealityInputSource source, Handedness handedness) : base(handedness)
         {
-            inputSource = source;
-            this.handedness = handedness;
+            InputSource = source;
         }
 
-        protected readonly IMixedRealityInputSource inputSource;
-        protected readonly Handedness handedness;
+        /// <summary>
+        /// The input source backing this definition instance.
+        /// </summary>
+        protected IMixedRealityInputSource InputSource { get; }
 
         private readonly float cursorBeamBackwardTolerance = 0.5f;
         private readonly float cursorBeamUpTolerance = 0.8f;
@@ -86,13 +92,32 @@ public float ExitPinchDistance
         /// The articulated hands default interactions.
         /// </summary>
         /// <remarks>A single interaction mapping works for both left and right articulated hands.</remarks>
-        public MixedRealityInteractionMapping[] DefaultInteractions => new[]
+        [System.Obsolete("Call GetDefaultMappings(Handedness) instead.")]
+        public MixedRealityInteractionMapping[] DefaultInteractions
         {
-            new MixedRealityInteractionMapping(0, "Spatial Pointer", AxisType.SixDof, DeviceInputType.SpatialPointer),
-            new MixedRealityInteractionMapping(1, "Spatial Grip", AxisType.SixDof, DeviceInputType.SpatialGrip),
-            new MixedRealityInteractionMapping(2, "Select", AxisType.Digital, DeviceInputType.Select),
-            new MixedRealityInteractionMapping(3, "Grab", AxisType.SingleAxis, DeviceInputType.TriggerPress),
-            new MixedRealityInteractionMapping(4, "Index Finger Pose", AxisType.SixDof, DeviceInputType.IndexFinger)
+            get
+            {
+                MixedRealityInteractionMapping[] defaultInteractions = new MixedRealityInteractionMapping[DefaultMappings.Length];
+                for (int i = 0; i < DefaultMappings.Length; i++)
+                {
+                    defaultInteractions[i] = new MixedRealityInteractionMapping((uint)i, DefaultMappings[i]);
+                }
+                return defaultInteractions;
+            }
+        }
+
+        /// <summary>
+        /// The articulated hands default interactions.
+        /// </summary>
+        /// <remarks>A single interaction mapping works for both left and right articulated hands.</remarks>
+        protected override MixedRealityInputActionMapping[] DefaultMappings => new[]
+        {
+            new MixedRealityInputActionMapping("Spatial Pointer", AxisType.SixDof, DeviceInputType.SpatialPointer),
+            new MixedRealityInputActionMapping("Spatial Grip", AxisType.SixDof, DeviceInputType.SpatialGrip),
+            new MixedRealityInputActionMapping("Select", AxisType.Digital, DeviceInputType.Select),
+            new MixedRealityInputActionMapping("Grab", AxisType.SingleAxis, DeviceInputType.TriggerPress),
+            new MixedRealityInputActionMapping("Index Finger Pose", AxisType.SixDof, DeviceInputType.IndexFinger),
+            new MixedRealityInputActionMapping("Teleport Pose", AxisType.DualAxis, DeviceInputType.ThumbStick),
         };
 
         /// <summary>
@@ -122,11 +147,34 @@ public bool IsInPointingPose
                         }
                     }
                 }
-                return true;
+                return !IsInTeleportPose;
             }
         }
 
-        private static readonly ProfilerMarker UpdateHandJointsPerfMarker = new ProfilerMarker("[MRTK] ArticulatedHandDefinition.UpdateHandJoints");
+        /// <summary>
+        /// Calculates whether the current pose is the one to start a teleport action
+        /// </summary>
+        protected bool IsInTeleportPose
+        {
+            get
+            {
+                if (!unityJointPoses.TryGetValue(TrackedHandJoint.Palm, out var palmPose)) return false;
+
+                Camera mainCamera = CameraCache.Main;
+
+                if (mainCamera == null)
+                {
+                    return false;
+                }
+
+                Transform cameraTransform = mainCamera.transform;
+
+                // We check if the palm up is roughly in line with the camera up
+                return Vector3.Dot(-palmPose.Up, cameraTransform.up) > 0.6f
+                       // Thumb must be extended, and middle must be grabbing
+                       && !isThumbGrabbing && isMiddleGrabbing;
+            }
+        }
 
         /// <summary>
         /// Calculates whether the current the current joint pose is selecting (air tap gesture).
@@ -159,6 +207,12 @@ public bool IsPinching
             }
         }
 
+        private bool isIndexGrabbing;
+        private bool isMiddleGrabbing;
+        private bool isThumbGrabbing;
+
+        private static readonly ProfilerMarker UpdateHandJointsPerfMarker = new ProfilerMarker("[MRTK] ArticulatedHandDefinition.UpdateHandJoints");
+
         /// <summary>
         /// Updates the current hand joints with new data.
         /// </summary>
@@ -168,7 +222,7 @@ public void UpdateHandJoints(Dictionary<TrackedHandJoint, MixedRealityPose> join
             using (UpdateHandJointsPerfMarker.Auto())
             {
                 unityJointPoses = jointPoses;
-                CoreServices.InputSystem?.RaiseHandJointsUpdated(inputSource, handedness, unityJointPoses);
+                CoreServices.InputSystem?.RaiseHandJointsUpdated(InputSource, Handedness, unityJointPoses);
             }
         }
 
@@ -191,10 +245,72 @@ public void UpdateCurrentIndexPose(MixedRealityInteractionMapping interactionMap
                     if (interactionMapping.Changed)
                     {
                         // Raise input system event if it's enabled
-                        CoreServices.InputSystem?.RaisePoseInputChanged(inputSource, handedness, interactionMapping.MixedRealityInputAction, currentIndexPose);
+                        CoreServices.InputSystem?.RaisePoseInputChanged(InputSource, Handedness, interactionMapping.MixedRealityInputAction, currentIndexPose);
                     }
                 }
             }
         }
+
+        // Used to track the input that was last raised
+        private bool previousReadyToTeleport = false;
+
+        private IMixedRealityTeleportPointer teleportPointer;
+
+        private static readonly ProfilerMarker UpdateCurrentTeleportPosePerfMarker = new ProfilerMarker("[MRTK] ArticulatedHandDefinition.UpdateCurrentTeleportPose");
+
+        public void UpdateCurrentTeleportPose(MixedRealityInteractionMapping interactionMapping)
+        {
+            using (UpdateCurrentTeleportPosePerfMarker.Auto())
+            {
+                // Check if we're focus locked or near something interactive to avoid teleporting unintentionally.
+                bool anyPointersLockedWithHand = false;
+                for (int i = 0; i < InputSource?.Pointers?.Length; i++)
+                {
+                    IMixedRealityPointer mixedRealityPointer = InputSource.Pointers[i];
+                    if (mixedRealityPointer.IsNull()) continue;
+                    if (mixedRealityPointer is IMixedRealityNearPointer nearPointer)
+                    {
+                        anyPointersLockedWithHand |= nearPointer.IsNearObject;
+                    }
+                    anyPointersLockedWithHand |= mixedRealityPointer.IsFocusLocked;
+
+                    // If official teleport mode and we have a teleport pointer registered, we get the input action to trigger it.
+                    if (teleportPointer == null && mixedRealityPointer is IMixedRealityTeleportPointer pointer)
+                    {
+                        teleportPointer = pointer;
+                    }
+                }
+
+                // We close middle finger to signal spider-man gesture, and as being ready for teleport
+                isIndexGrabbing = HandPoseUtils.IsIndexGrabbing(Handedness);
+                isMiddleGrabbing = HandPoseUtils.IsMiddleGrabbing(Handedness);
+                isThumbGrabbing = HandPoseUtils.IsThumbGrabbing(Handedness);
+                bool isReadyForTeleport = !anyPointersLockedWithHand && IsInTeleportPose;
+
+                // Tracks the input vector that should be sent out based on the gesture that is made
+                Vector2 stickInput = (isReadyForTeleport && !isIndexGrabbing) ? Vector2.up : Vector2.zero;
+
+                // The teleport event needs to be canceled if we have not completed the teleport motion and we were previously ready to teleport, but for some reason we
+                // are no longer doing the ready to teleport gesture
+                bool teleportCanceled = previousReadyToTeleport && !isReadyForTeleport && !isIndexGrabbing;
+                if (teleportCanceled && teleportPointer != null)
+                {
+                    CoreServices.TeleportSystem?.RaiseTeleportCanceled(teleportPointer, null);
+                    previousReadyToTeleport = isReadyForTeleport;
+                    return;
+                }
+
+                // Update the interaction data source
+                interactionMapping.Vector2Data = stickInput;
+
+                // If our value changed raise it
+                if (interactionMapping.Changed)
+                {
+                    CoreServices.InputSystem?.RaisePositionInputChanged(InputSource, Handedness, interactionMapping.MixedRealityInputAction, stickInput);
+                }
+
+                previousReadyToTeleport = isReadyForTeleport;
+            }
+        }
     }
 }