PokePointer and TouchableVolume fix for packed scenes and nested set-ups (#10531)

* Fix PokePointer hitting arbitrary colliders when touching volumes

For packed scenes the huge ray range used for Touchable volumes, regularly hits arbitrary colliders in the scene, instead of the actual touched object. Touchable volumes will now properly calculate the penetration distance into the object. Further PokePointer ray has been adjusted to only cast through the very touchable volume.

* Improve touch events for nested touchable volumes

* Add unit tests for the touchable volume raycasting and nesting

Co-authored-by: Julian Löhr <[email protected]>
Co-authored-by: RogPodge <[email protected]>

Author: 3 people

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

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 using Microsoft.MixedReality.Toolkit.Physics;
@@ -24,12 +24,6 @@ namespace Microsoft.MixedReality.Toolkit.Input
     [AddComponentMenu("Scripts/MRTK/SDK/PokePointer")]
     public class PokePointer : BaseControllerPointer, IMixedRealityNearPointer
     {
-        /// <summary>
-        /// If touchable volumes are larger than this size (meters), pointer will raise
-        /// touch up even when pointer is inside the volume
-        /// </summary>
-        private const int maximumTouchableVolumeSize = 1000;
-
         [SerializeField]
         [Tooltip("Maximum distance a which a touchable surface can be interacted with.")]
         protected float touchableDistance = 0.2f;
@@ -177,13 +171,20 @@ public override void OnPreSceneQuery()
                 if (newClosestTouchable != null)
                 {
                     // Build ray (poke from in front to the back of the pointer position)
-                    // We make a very long ray if we are touching a touchable volume to ensure that we actually
-                    // hit the volume when we are inside of the volume, which could be very large.
-                    var lengthOfPointerRay = newClosestTouchable is NearInteractionTouchableVolume ?
-                        maximumTouchableVolumeSize : touchableDistance;
-                    Vector3 start = Position + lengthOfPointerRay * closestNormal;
-                    Vector3 end = Position - lengthOfPointerRay * closestNormal;
-                    Rays[0].UpdateRayStep(ref start, ref end);
+                    NearInteractionTouchableVolume touchableVolume = newClosestTouchable as NearInteractionTouchableVolume;
+                    if (touchableVolume != null && (closestDistance < 0.0f))
+                    {
+                        // When we are inside of a volume, ensure that we actually hit it by placing the origin closely outside the volume.
+                        Vector3 start = Position + (-closestDistance * 1.01f) * closestNormal;
+                        Vector3 end = Position - touchableVolume.TouchableCollider.bounds.size.magnitude * closestNormal;
+                        Rays[0].UpdateRayStep(ref start, ref end);
+                    }
+                    else
+                    {
+                        Vector3 start = Position + touchableDistance * closestNormal;
+                        Vector3 end = Position - touchableDistance * closestNormal;
+                        Rays[0].UpdateRayStep(ref start, ref end);
+                    }
                 }
                 else
                 {
@@ -232,8 +233,12 @@ private bool FindClosestTouchableForLayerMask(LayerMask layerMask, out BaseNearI
                         {
                             continue;
                         }
-                        float distance = touchable.DistanceToTouchable(Position, out Vector3 normal);
-                        if (distance < closestDistance)
+                        float distance = touchable.DistanceToTouchable(Position, out Vector3 normal); 
+                        
+                        // Favor touched volumes, but when there are multiple touched volumes, favor the one with the closest surface.
+                        bool bothInside = (distance <= 0f) && (closestDistance <= 0f);
+                        bool betterFit = bothInside ? Mathf.Abs(distance) < Mathf.Abs(closestDistance) : distance < closestDistance;
+                        if (betterFit)
                         {
                             closest = touchable;
                             closestDistance = distance;

Assets/MRTK/Services/InputSystem/NearInteractionTouchableVolume.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 using UnityEngine;
@@ -52,9 +52,21 @@ public override float DistanceToTouchable(Vector3 samplePoint, out Vector3 norma
                 // inside object, use vector to centre as normal
                 normal = samplePoint - TouchableCollider.bounds.center;
                 normal.Normalize();
-                // Return value less than zero so that when poke pointer is inside
-                // object, it will not raise a touch up event.
-                return -1;
+
+                // Try to calculate the proper penetration distance, to allow more accurate processing of touchable volumes.
+                // Return value less than zero so that when poke pointer is inside object, it will not raise a touch up event.
+                float rayScale = 1.1f;
+                Vector3 outsidePoint = TouchableCollider.bounds.center + normal * (TouchableCollider.bounds.extents.magnitude * rayScale);
+                if (TouchableCollider.Raycast(new Ray(outsidePoint, -normal), out RaycastHit raycastHit, TouchableCollider.bounds.size.magnitude * rayScale))
+                {
+                    return -Vector3.Distance(raycastHit.point, samplePoint);
+                }
+                else
+                {
+                    // Somehow we didn't hit the object, although we're touching it.
+                    // Fallback to the max possible value, so other volumes may get favored over this.
+                    return -TouchableCollider.bounds.extents.magnitude;
+                }
             }
             else
             {

Assets/MRTK/Tests/PlayModeTests/NearInteractionTouchableTests.cs

@@ -318,6 +318,91 @@ public IEnumerator NearInteractionTouchableVolumeVariant()
             Object.Destroy(touchable.gameObject);
         }
 
+        /// <summary>
+        /// Test NearInteractionTouchableVolume raycasting, by placing a signifcant larger touchable volume next to a smaller one.
+        /// Move from one to the other and check if the touch events are only raised once, without loosing "touch".
+        /// </summary>
+        [UnityTest]
+        public IEnumerator NearInteractionTouchableVolumeRaycast()
+        {
+            var touchable = CreateTouchable<NearInteractionTouchableVolume>(Vector3.one);
+            var blocking = CreateTouchable<NearInteractionTouchableVolume>(new Vector3(10f, 10f, 1f));
+            blocking.transform.localPosition = objectPosition - new Vector3(touchable.TouchableCollider.bounds.extents.z + blocking.TouchableCollider.bounds.extents.z, 0f, 0f); 
+
+            yield return new WaitForFixedUpdate();
+            yield return null;
+
+            TestHand testHand = new TestHand(Handedness.Left);
+            yield return testHand.Show(blocking.transform.position);
+            using (var catcher = CreateTouchEventCatcher(touchable))
+            {
+                // Move from center to center, checking if raycasting is hitting the correct touchable volume
+                yield return testHand.MoveTo(objectPosition);
+                Assert.AreEqual(1, catcher.EventsStarted);
+                Assert.AreEqual(0, catcher.EventsCompleted);
+
+                // Move back
+                yield return testHand.MoveTo(blocking.transform.position);
+                Assert.AreEqual(1, catcher.EventsStarted);
+                Assert.AreEqual(1, catcher.EventsCompleted);
+            }
+
+            Object.Destroy(touchable.gameObject);
+            Object.Destroy(blocking.gameObject);
+        }
+        /// <summary>
+        /// Test nested NearInteractionTouchableVolume instances.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator NearInteractionTouchableVolumeNested()
+        {
+            var outer = CreateTouchable<NearInteractionTouchableVolume>(Vector3.one);
+            var inner = CreateTouchable<NearInteractionTouchableVolume>(Vector3.one * 0.1f);
+
+            Vector3 innerPosition = objectPosition + (inner.transform.forward * 0.2f);
+            inner.transform.localPosition = innerPosition;
+
+            var outerCatcher = CreateTouchEventCatcher(outer);
+            var innerCatcher = CreateTouchEventCatcher(inner);
+
+            yield return new WaitForFixedUpdate();
+            yield return null;
+
+            TestHand testHand = new TestHand(Handedness.Left);
+            yield return testHand.Show(Vector3.zero);
+
+            // Move into outer cube
+            yield return testHand.MoveTo(objectPosition);
+            Assert.AreEqual(1, outerCatcher.EventsStarted);
+            Assert.AreEqual(0, outerCatcher.EventsCompleted);
+            Assert.AreEqual(0, innerCatcher.EventsStarted);
+            Assert.AreEqual(0, innerCatcher.EventsCompleted);
+
+            // Move from outer into inner cube
+            yield return testHand.MoveTo(innerPosition);
+            Assert.AreEqual(1, outerCatcher.EventsStarted);
+            Assert.AreEqual(1, outerCatcher.EventsCompleted);
+            Assert.AreEqual(1, innerCatcher.EventsStarted);
+            Assert.AreEqual(0, innerCatcher.EventsCompleted);
+
+            // Move fromm inner to outer cube back
+            yield return testHand.MoveTo(objectPosition);
+            Assert.AreEqual(2, outerCatcher.EventsStarted);
+            Assert.AreEqual(1, outerCatcher.EventsCompleted);
+            Assert.AreEqual(1, innerCatcher.EventsStarted);
+            Assert.AreEqual(1, innerCatcher.EventsCompleted);
+
+            // Move from outer back outside
+            yield return testHand.MoveTo(Vector3.zero);
+            Assert.AreEqual(2, outerCatcher.EventsStarted);
+            Assert.AreEqual(2, outerCatcher.EventsCompleted);
+            Assert.AreEqual(1, innerCatcher.EventsStarted);
+            Assert.AreEqual(1, innerCatcher.EventsCompleted);
+
+            Object.Destroy(outer.gameObject);
+            Object.Destroy(inner.gameObject);
+        }
+
         private static void TestEvents(TouchEventCatcher[] catchers, int[] eventsStarted, int[] eventsCompleted)
         {
             Assert.AreEqual(catchers.Length, eventsCompleted.Length);
@@ -741,6 +826,9 @@ public IEnumerator NearInteractionTouchableSetTouchableCollider()
                 yield return PlayModeTestUtilities.WaitForInputSystemUpdate();
                 Assert.AreEqual(2, catcher.EventsCompleted);
             }
+
+            Object.Destroy(cube);
+            Object.Destroy(cube2);
         }
     }
 }