Feature/back strafing steps (#9697)

* support for back strafing on slopes or steps.

* Adding  "requiresStrafeHeight" to inspector

* style cleanup and minor code refactor

* added tests for backstrafe, fixed compiler complaints

* Address PR comments

* Update Assets/MRTK/SDK/Features/UX/Scripts/Pointers/TeleportPointer.cs

Co-authored-by: Kurtis <[email protected]>

* pr comment addressal

Co-authored-by: sabin george <[email protected]>
Co-authored-by: Kurtis <[email protected]>

Author: 3 people

Assets/MRTK/SDK/Editor/Inspectors/UX/Pointers/TeleportPointerInspector.cs

@@ -18,6 +18,9 @@ public class TeleportPointerInspector : LinePointerInspector
         private SerializedProperty rotationAmount;
         private SerializedProperty backStrafeActivationAngle;
         private SerializedProperty strafeAmount;
+        private SerializedProperty checkForFloorOnStrafe;
+        private SerializedProperty adjustHeightOnStrafe;
+        private SerializedProperty maxHeightChangeOnStrafe;
         private SerializedProperty upDirectionThreshold;
         private SerializedProperty lineColorHotSpot;
         private SerializedProperty validLayers;
@@ -42,11 +45,13 @@ protected override void OnEnable()
             rotationAmount = serializedObject.FindProperty("rotationAmount");
             backStrafeActivationAngle = serializedObject.FindProperty("backStrafeActivationAngle");
             strafeAmount = serializedObject.FindProperty("strafeAmount");
+            checkForFloorOnStrafe = serializedObject.FindProperty("checkForFloorOnStrafe");
+            adjustHeightOnStrafe = serializedObject.FindProperty("adjustHeightOnStrafe");
+            maxHeightChangeOnStrafe = serializedObject.FindProperty("maxHeightChangeOnStrafe");
             upDirectionThreshold = serializedObject.FindProperty("upDirectionThreshold");
             lineColorHotSpot = serializedObject.FindProperty("LineColorHotSpot");
             validLayers = serializedObject.FindProperty("ValidLayers");
             invalidLayers = serializedObject.FindProperty("InvalidLayers");
-
             pointerAudioSource = serializedObject.FindProperty("pointerAudioSource");
             teleportRequestedClip = serializedObject.FindProperty("teleportRequestedClip");
             teleportCompletedClip = serializedObject.FindProperty("teleportCompletedClip");
@@ -71,6 +76,12 @@ public override void OnInspectorGUI()
                 EditorGUILayout.PropertyField(rotationAmount);
                 EditorGUILayout.PropertyField(backStrafeActivationAngle);
                 EditorGUILayout.PropertyField(strafeAmount);
+                EditorGUILayout.PropertyField(checkForFloorOnStrafe);
+                if (checkForFloorOnStrafe.boolValue)
+                {
+                    EditorGUILayout.PropertyField(adjustHeightOnStrafe);
+                    EditorGUILayout.PropertyField(maxHeightChangeOnStrafe);
+                }
                 EditorGUILayout.PropertyField(upDirectionThreshold);
                 EditorGUILayout.PropertyField(lineColorHotSpot);
                 EditorGUILayout.PropertyField(validLayers);

Assets/MRTK/SDK/Features/UX/Scripts/Pointers/TeleportPointer.cs

@@ -5,10 +5,12 @@
 using Microsoft.MixedReality.Toolkit.Physics;
 using Microsoft.MixedReality.Toolkit.Utilities;
 using System;
+using System.Runtime.CompilerServices;
 using Unity.Profiling;
 using UnityEngine;
 using UnityPhysics = UnityEngine.Physics;
 
+[assembly: InternalsVisibleTo("Microsoft.MixedReality.Toolkit.Tests.PlayModeTests")]
 namespace Microsoft.MixedReality.Toolkit.Teleport
 {
     /// <summary>
@@ -85,7 +87,20 @@ public bool TeleportHotSpotCursorVisibility
 
         [SerializeField]
         [Tooltip("The distance to move the camera when the strafe is activated")]
-        private float strafeAmount = 0.25f;
+        internal float strafeAmount = 0.25f;
+        
+        [SerializeField]
+        [Tooltip("Whether or not a strafe checks that there is a floor beneath the user's origin on strafe")]
+        internal bool checkForFloorOnStrafe = false;
+
+        [SerializeField]
+        [Tooltip("Whether or not the user's y-position can move during a strafe")]
+        internal bool adjustHeightOnStrafe = false;
+
+
+        [SerializeField]
+        [Tooltip("The detection range for a floor on strafe, as well as the max amount that a user's y-position can change on strafe")]
+        internal float maxHeightChangeOnStrafe = 0.5f;
 
         [SerializeField]
         [Range(0f, 1f)]
@@ -231,6 +246,58 @@ protected Gradient GetLineGradient(TeleportSurfaceResult targetResult)
             }
         }
 
+        /// <summary>
+        /// check if a backstrafe is possible on a valid platform regarding the possible strafe height given
+        /// </summary>
+        /// <param name="newPosition">the new position relative to backstrafe position</param>
+        /// <param name="hitStrafePosition">actual position the strafe raycast hits</param>
+        /// <returns>if there is a valid layer one can backstrafe on</returns>
+        internal bool CheckPossibleBackStep(Vector3 newPosition, out Vector3 hitStrafePosition)
+        {
+            var raycastProvider = CoreServices.InputSystem.RaycastProvider;
+            Vector3 strafeOrigin = new Vector3(newPosition.x, MixedRealityPlayspace.Position.y + maxHeightChangeOnStrafe, newPosition.z);
+            Vector3 strafeTerminus = strafeOrigin + (Vector3.down * maxHeightChangeOnStrafe * 2f);
+
+            RayStep rayStep = new RayStep(strafeOrigin, strafeTerminus);
+            LayerMask[] layerMasks =  new LayerMask[] { ValidLayers };
+
+            // check are we hiting a floor plane or step above the current MixedRealityPlayspace.Position
+            if (!raycastProvider.IsNull() && raycastProvider.Raycast(rayStep, layerMasks, false, out var hitInfo))
+            {
+                hitStrafePosition = hitInfo.point;
+                return true;
+            }
+
+            hitStrafePosition = Vector3.zero;
+            return false;
+        }
+
+        /// <summary>
+        /// Performs a strafe in the opposite direction of the camera's forward direction
+        /// </summary>
+        internal void PerformStrafe()
+        {
+            canMove = false;
+            var height = MixedRealityPlayspace.Position.y;
+            var newPosition = -CameraCache.Main.transform.forward * strafeAmount + MixedRealityPlayspace.Position;
+
+            newPosition.y = height;
+            bool isValidStrafe = true;
+            if (checkForFloorOnStrafe)
+            {
+                isValidStrafe = CheckPossibleBackStep(newPosition, out var strafeHitPosition);
+                if (adjustHeightOnStrafe)
+                {
+                    newPosition = strafeHitPosition;
+                }
+            }
+
+            if (isValidStrafe)
+            {
+                MixedRealityPlayspace.Position = newPosition;
+            }
+        }
+
         #region IMixedRealityPointer Implementation
 
         /// <inheritdoc />
@@ -469,11 +536,7 @@ public override void OnInputChanged(InputEventData<Vector2> eventData)
                                     // Check to make sure we're still under our activation threshold.
                                     if (offsetStrafeAngle > 0 && offsetStrafeAngle <= backStrafeActivationAngle)
                                     {
-                                        canMove = false;
-                                        var height = MixedRealityPlayspace.Position.y;
-                                        var newPosition = -CameraCache.Main.transform.forward * strafeAmount + MixedRealityPlayspace.Position;
-                                        newPosition.y = height;
-                                        MixedRealityPlayspace.Position = newPosition;
+                                        PerformStrafe();
                                     }
                                 }
                             }

Assets/MRTK/Tests/PlayModeTests/PointerBehaviorTests.cs

@@ -357,6 +357,57 @@ public IEnumerator TestTeleportLayers()
 
         }
 
+        /// <summary>
+        /// Tests strafing with the teleport pointer
+        /// </summary>
+        [UnityTest]
+        public IEnumerator TestTeleportStrafe()
+        {
+            var iss = PlayModeTestUtilities.GetInputSimulationService();
+
+            // Create a floor and make sure it's below the camera
+            var floor = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            floor.transform.position = -0.5f * Vector3.up;
+
+            // Bring out the right hand and set it to the teleport gesture
+            TestUtilities.PlayspaceToOriginLookingForward();
+            Vector3 initialPosition = MixedRealityPlayspace.Position;
+
+            TestHand rightHand = new TestHand(Handedness.Right);
+
+            // Make sure the hand is in front of the camera
+            yield return rightHand.Show(Vector3.forward * 0.6f);
+            rightHand.SetRotation(Quaternion.identity);
+
+            TeleportPointer teleportPointer = rightHand.GetPointer<TeleportPointer>();
+            teleportPointer.PerformStrafe();
+            TestUtilities.AssertAboutEqual(MixedRealityPlayspace.Position, initialPosition - Vector3.forward * teleportPointer.strafeAmount, "Did not strafe to the expected position");
+
+            teleportPointer.checkForFloorOnStrafe = true;
+            teleportPointer.adjustHeightOnStrafe = true;
+            teleportPointer.strafeAmount = 1.0f;
+            teleportPointer.maxHeightChangeOnStrafe = 0.5f;
+
+            TestUtilities.PlayspaceToOriginLookingForward();
+            teleportPointer.PerformStrafe();
+            TestUtilities.AssertAboutEqual(MixedRealityPlayspace.Position, initialPosition, "Performed an invalid strafe");
+
+            var floor2 = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            floor2.transform.position = new Vector3(0,-0.25f,-1.0f);
+            yield return PlayModeTestUtilities.WaitForInputSystemUpdate();
+            
+            TestUtilities.PlayspaceToOriginLookingForward();
+            teleportPointer.PerformStrafe();
+            TestUtilities.AssertAboutEqual(MixedRealityPlayspace.Position, initialPosition + new Vector3(0, 0.25f, -teleportPointer.strafeAmount), "Height did not change on strafe");
+
+            floor2.transform.position = new Vector3(0, -0.75f, -1.0f);
+            yield return PlayModeTestUtilities.WaitForInputSystemUpdate();
+
+            TestUtilities.PlayspaceToOriginLookingForward();
+            teleportPointer.PerformStrafe();
+            TestUtilities.AssertAboutEqual(MixedRealityPlayspace.Position, initialPosition + new Vector3(0, -0.25f, -teleportPointer.strafeAmount), "Height did not change on strafe");
+        }
+
         /// <summary>
         /// Tests that rays can be turned on and off
         /// </summary>