Merge pull request #6987 from microsoft/issue/6986

Fix no OnPointerDragged events from poke pointers

Author: Julia Schwarz

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

@@ -345,6 +345,10 @@ private void RaiseTouchUpdated(GameObject targetObject, Vector3 touchPosition)
                 {
                     CoreServices.InputSystem?.RaiseOnTouchUpdated(InputSourceParent, Controller, Handedness, touchPosition);
                 }
+                else if (closestProximityTouchable.EventsToReceive == TouchableEventType.Pointer)
+                {
+                    CoreServices.InputSystem?.RaisePointerDragged(this, pointerAction, Handedness, InputSourceParent);
+                }
             }
         }
 

Assets/MixedRealityToolkit.Tests/PlayModeTests/EventCatcherTestUtilities.cs

@@ -59,12 +59,51 @@ public void Dispose()
         }
     }
 
+    /// <summary>
+    /// Utility for counting pointer events.
+    /// </summary>
+    internal class PointerEventCatcher : FocusedObjectEventCatcher<PointerEventCatcher>, IMixedRealityPointerHandler
+    {
+        public readonly UnityEvent OnPointerDownEvent = new UnityEvent();
+        public readonly UnityEvent OnPointerUpEvent = new UnityEvent();
+        public readonly UnityEvent OnPointerDraggedEvent = new UnityEvent();
+        public readonly UnityEvent OnPointerClickedEvent = new UnityEvent();
+
+        public int DragEventCount = 0;
+
+        /// <inheritdoc />
+        public void OnPointerClicked(MixedRealityPointerEventData eventData)
+        {
+            OnPointerClickedEvent.Invoke();
+        }
+
+        /// <inheritdoc />
+        public void OnPointerDown(MixedRealityPointerEventData eventData)
+        {
+            ++EventsStarted;
+            OnPointerDownEvent.Invoke();
+        }
+
+        /// <inheritdoc />
+        public void OnPointerDragged(MixedRealityPointerEventData eventData)
+        {
+            ++DragEventCount;
+            OnPointerDraggedEvent.Invoke();
+        }
+
+        /// <inheritdoc />
+        public void OnPointerUp(MixedRealityPointerEventData eventData)
+        {
+            ++EventsCompleted;
+            OnPointerUpEvent.Invoke();
+        }
+
+
+    }
+
     /// <summary>
     /// Utility for counting touch events.
     /// </summary>
-    /// <remarks>
-    /// Touching an object does not imply getting focus, so use a global event handler to be independent from focus.
-    /// </remarks>
     public class TouchEventCatcher : FocusedObjectEventCatcher<TouchEventCatcher>, IMixedRealityTouchHandler
     {
         public readonly UnityEvent OnTouchStartedEvent = new UnityEvent();

Assets/MixedRealityToolkit.Tests/PlayModeTests/NearInteractionTouchableTests.cs

@@ -126,7 +126,7 @@ private T CreateTouchable<T>(Vector3 cubeDimensions) where T : BaseNearInteracti
         }
 
 
-        private TouchEventCatcher CreateEventCatcher(BaseNearInteractionTouchable touchable)
+        private TouchEventCatcher CreateTouchEventCatcher(BaseNearInteractionTouchable touchable)
         {
             var catcher = TouchEventCatcher.Create(touchable.gameObject);
 
@@ -142,6 +142,81 @@ private TouchEventCatcher CreateEventCatcher(BaseNearInteractionTouchable toucha
             return catcher;
         }
 
+
+        private PointerEventCatcher CreatePointerEventCatcher(BaseNearInteractionTouchable touchable)
+        {
+            var catcher = PointerEventCatcher.Create(touchable.gameObject);
+            catcher.OnPointerDownEvent.AddListener(() =>
+            {
+                touchable.GetComponent<Renderer>().material = pokeMaterial;
+            });
+            catcher.OnPointerUpEvent.AddListener(() =>
+            {
+                touchable.GetComponent<Renderer>().material = idleMaterial;
+            });
+
+            return catcher;
+        }
+
+        /// <summary>
+        /// Test that NearInteractionTouchable can raise pointer events
+        /// </summary>
+        [UnityTest]
+        public IEnumerator NearInteractionTouchablePointerEvents()
+        {
+            var touchable = CreateTouchable<NearInteractionTouchable>(objectScale);
+            touchable.SetLocalForward(touchNormal);
+            touchable.SetBounds(new Vector2(0.5f, 0.5f));
+            touchable.EventsToReceive = TouchableEventType.Pointer;
+
+            yield return new WaitForFixedUpdate();
+            yield return null;
+
+            TestHand testHand = new TestHand(Handedness.Right);
+            yield return testHand.Show(initialHandPosition);
+
+            using (var catcher = CreatePointerEventCatcher(touchable))
+            {
+                yield return testHand.MoveTo(objectPosition);
+                Assert.AreEqual(1, catcher.EventsStarted);
+                Assert.AreEqual(0, catcher.EventsCompleted);
+                yield return testHand.MoveTo(rightPosition);
+                Assert.AreEqual(1, catcher.EventsStarted);
+                Assert.AreEqual(1, catcher.EventsCompleted);
+                Assert.Greater(catcher.DragEventCount, 0);
+
+                // Touch started and completed when entering and exiting behind the plane
+                yield return testHand.MoveTo(initialHandPosition);
+                yield return testHand.MoveTo(objectPosition);
+                Assert.AreEqual(2, catcher.EventsStarted);
+                Assert.AreEqual(1, catcher.EventsCompleted);
+                yield return testHand.MoveTo(backPosition);              
+                Assert.AreEqual(2, catcher.EventsStarted);
+                Assert.AreEqual(2, catcher.EventsCompleted);
+                Assert.Greater(catcher.DragEventCount, 1);
+                int dragEventCount = catcher.DragEventCount;
+
+                // No touch when moving at behind the plane
+                yield return testHand.MoveTo(rightPosition);              
+                Assert.AreEqual(2, catcher.EventsStarted);
+                Assert.AreEqual(2, catcher.EventsCompleted);
+                Assert.AreEqual(dragEventCount, catcher.DragEventCount, "No drag events should fire when poke pointer moving behind plane");
+
+
+                // No touch when moving outside the bounds
+                yield return testHand.MoveTo(initialHandPosition + outOfBoundsOffset);
+                yield return testHand.MoveTo(objectPosition + outOfBoundsOffset);
+                yield return testHand.MoveTo(rightPosition);
+                Assert.AreEqual(2, catcher.EventsStarted);
+                Assert.AreEqual(2, catcher.EventsCompleted);
+                Assert.AreEqual(dragEventCount, catcher.DragEventCount, "No drag events should fire when poke pointer moving outside bounds");
+            }
+
+            yield return testHand.Hide();
+
+            UnityEngine.Object.Destroy(touchable.gameObject);
+        }
+
         /// <summary>
         /// Test creates an object with NearInteractionTouchable
         /// </summary>
@@ -155,39 +230,41 @@ public IEnumerator NearInteractionTouchableVariant()
             yield return new WaitForFixedUpdate();
             yield return null;
 
-            yield return PlayModeTestUtilities.ShowHand(Handedness.Right, inputSim);
+            TestHand testHand = new TestHand(Handedness.Right);
+            yield return testHand.Show(initialHandPosition);
 
-            using (var catcher = CreateEventCatcher(touchable))
+            using (var catcher = CreateTouchEventCatcher(touchable))
             {
-                // Touch started and completed when entering and exiting
-                yield return PlayModeTestUtilities.MoveHand(initialHandPosition, objectPosition, ArticulatedHandPose.GestureId.Open, Handedness.Right, inputSim);
+                yield return testHand.MoveTo(objectPosition);
                 Assert.AreEqual(1, catcher.EventsStarted);
                 Assert.AreEqual(0, catcher.EventsCompleted);
-                yield return PlayModeTestUtilities.MoveHand(objectPosition, rightPosition, ArticulatedHandPose.GestureId.Pinch, Handedness.Right, inputSim);
+                yield return testHand.MoveTo(rightPosition);
                 Assert.AreEqual(1, catcher.EventsStarted);
                 Assert.AreEqual(1, catcher.EventsCompleted);
 
                 // Touch started and completed when entering and exiting behind the plane
-                yield return PlayModeTestUtilities.MoveHand(initialHandPosition, objectPosition, ArticulatedHandPose.GestureId.Open, Handedness.Right, inputSim);
+                yield return testHand.MoveTo(initialHandPosition);
+                yield return testHand.MoveTo(objectPosition);
                 Assert.AreEqual(2, catcher.EventsStarted);
                 Assert.AreEqual(1, catcher.EventsCompleted);
-                yield return PlayModeTestUtilities.MoveHand(objectPosition, backPosition, ArticulatedHandPose.GestureId.Pinch, Handedness.Right, inputSim);
+                yield return testHand.MoveTo(backPosition);              
                 Assert.AreEqual(2, catcher.EventsStarted);
                 Assert.AreEqual(2, catcher.EventsCompleted);
 
                 // No touch when moving at behind the plane
-                yield return PlayModeTestUtilities.MoveHand(backPosition, rightPosition, ArticulatedHandPose.GestureId.Pinch, Handedness.Right, inputSim);
+                yield return testHand.MoveTo(rightPosition);              
                 Assert.AreEqual(2, catcher.EventsStarted);
                 Assert.AreEqual(2, catcher.EventsCompleted);
 
                 // No touch when moving outside the bounds
-                yield return PlayModeTestUtilities.MoveHand(initialHandPosition + outOfBoundsOffset, objectPosition + outOfBoundsOffset, ArticulatedHandPose.GestureId.Open, Handedness.Right, inputSim);
-                yield return PlayModeTestUtilities.MoveHand(objectPosition + outOfBoundsOffset, rightPosition, ArticulatedHandPose.GestureId.Open, Handedness.Right, inputSim);
+                yield return testHand.MoveTo(initialHandPosition + outOfBoundsOffset);
+                yield return testHand.MoveTo(objectPosition + outOfBoundsOffset);
+                yield return testHand.MoveTo(rightPosition);
                 Assert.AreEqual(2, catcher.EventsStarted);
                 Assert.AreEqual(2, catcher.EventsCompleted);
             }
 
-            yield return PlayModeTestUtilities.HideHand(Handedness.Right, inputSim);
+            yield return testHand.Hide();
 
             UnityEngine.Object.Destroy(touchable.gameObject);
         }
@@ -199,50 +276,51 @@ public IEnumerator NearInteractionTouchableVariant()
         public IEnumerator NearInteractionTouchableVolumeVariant()
         {
             var touchable = CreateTouchable<NearInteractionTouchableVolume>(Vector3.one);
-
+            
             yield return new WaitForFixedUpdate();
             yield return null;
 
-            yield return PlayModeTestUtilities.ShowHand(Handedness.Right, inputSim);
-
-            using (var catcher = CreateEventCatcher(touchable))
+            TestHand testHand = new TestHand(Handedness.Left);
+            yield return testHand.Show(Vector3.zero);
+            yield return testHand.MoveTo(initialHandPosition);
+            using (var catcher = CreateTouchEventCatcher(touchable))
             {
                 // Touch started when entering collider
-                yield return PlayModeTestUtilities.MoveHand(initialHandPosition, objectPosition, ArticulatedHandPose.GestureId.Open, Handedness.Right, inputSim);
+                yield return testHand.MoveTo(objectPosition);
                 Assert.AreEqual(1, catcher.EventsStarted);
                 Assert.AreEqual(0, catcher.EventsCompleted);
 
                 // Ensure no touch up event fires while moving hand/pokepointer through collider to each corner of volume
                 Vector3[] cornerPositions = new Vector3[8];
                 touchable.GetComponent<BoxCollider>().bounds.GetCornerPositions(ref cornerPositions);
-                var currentPos = objectPosition;
                 for (int i = 0; i < cornerPositions.Length; i++)
                 {
-                    yield return PlayModeTestUtilities.MoveHand(currentPos, cornerPositions[i], ArticulatedHandPose.GestureId.Open, Handedness.Right, inputSim);
-                    currentPos = cornerPositions[i];
-                    Assert.AreEqual(1, catcher.EventsStarted, "Received extra touch down when moving through volume to position " + currentPos);
-                    Assert.AreEqual(0, catcher.EventsCompleted, "Received extra touch up when moving through volume to position " + currentPos);
+                    yield return testHand.MoveTo(cornerPositions[i]);
+                    Assert.AreEqual(1, catcher.EventsStarted, "Received extra touch down when moving through volume to position " + cornerPositions[i]);
+                    Assert.AreEqual(0, catcher.EventsCompleted, "Received extra touch up when moving through volume to position " + cornerPositions[i]);
                 }
 
                 // Touch up when exit collider
-                yield return PlayModeTestUtilities.MoveHand(currentPos, rightPosition, ArticulatedHandPose.GestureId.Pinch, Handedness.Right, inputSim);
+                yield return testHand.MoveTo(rightPosition);
                 Assert.AreEqual(1, catcher.EventsStarted);
                 Assert.AreEqual(1, catcher.EventsCompleted);
 
                 // No touch when moving outside the collider
-                yield return PlayModeTestUtilities.MoveHand(backPosition, rightPosition, ArticulatedHandPose.GestureId.Pinch, Handedness.Right, inputSim);
+                yield return testHand.Hide();
+                yield return testHand.Show(backPosition);
+                yield return testHand.MoveTo(backPosition + new Vector3(2f, 0f, 0f));
                 Assert.AreEqual(1, catcher.EventsStarted);
                 Assert.AreEqual(1, catcher.EventsCompleted);
 
                 // Touch when moving off-center
-                yield return PlayModeTestUtilities.MoveHand(initialHandPosition + outOfBoundsOffset, objectPosition + outOfBoundsOffset, ArticulatedHandPose.GestureId.Open, Handedness.Right, inputSim);
-                yield return PlayModeTestUtilities.MoveHand(objectPosition + outOfBoundsOffset, rightPosition, ArticulatedHandPose.GestureId.Open, Handedness.Right, inputSim);
+                yield return testHand.Hide();
+                yield return testHand.Show(initialHandPosition + outOfBoundsOffset);
+                yield return testHand.MoveTo(objectPosition + outOfBoundsOffset);
+                yield return testHand.MoveTo(rightPosition);
                 Assert.AreEqual(2, catcher.EventsStarted);
                 Assert.AreEqual(2, catcher.EventsCompleted);
             }
 
-            yield return PlayModeTestUtilities.HideHand(Handedness.Right, inputSim);
-
             UnityEngine.Object.Destroy(touchable.gameObject);
         }
 
@@ -365,7 +443,7 @@ public IEnumerator NearInteractionTouchableOverlapQuerySaturation()
                 touchables[i].SetBounds(new Vector2(0.5f, 0.5f));
                 touchables[i].transform.position = objectPosition + r * radiusStart;
 
-                catchers[i] = CreateEventCatcher(touchables[i]);
+                catchers[i] = CreateTouchEventCatcher(touchables[i]);
             }
 
             yield return new WaitForFixedUpdate();
@@ -491,10 +569,10 @@ public IEnumerator NearInteractionTouchableDistance()
             var touchableRect = CreateTouchable<NearInteractionTouchable>(0.15f);
             touchableRect.SetLocalForward(touchNormal);
             touchableRect.SetBounds(new Vector2(0.5f, 0.5f));
-            var catcherRect = CreateEventCatcher(touchableRect);
+            var catcherRect = CreateTouchEventCatcher(touchableRect);
 
             var touchableVolume = CreateTouchable<NearInteractionTouchableVolume>(0.15f);
-            var catcherVolume = CreateEventCatcher(touchableVolume);
+            var catcherVolume = CreateTouchEventCatcher(touchableVolume);
 
             var canvas = UnityUiUtilities.CreateCanvas(0.002f);
             var touchableUI = canvas.GetComponent<NearInteractionTouchableUnityUI>();
@@ -634,7 +712,7 @@ public IEnumerator NearInteractionTouchableSetTouchableCollider()
             BoxCollider newBoxCollider = cube2.GetComponent<BoxCollider>();
             newBoxCollider.size = new Vector3(4, 2, 1.2f);
 
-            using (var catcher = CreateEventCatcher(nearIT))
+            using (var catcher = CreateTouchEventCatcher(nearIT))
             {
                 // Touch started and completed when entering and exiting the collider
                 yield return rightHand.Move(new Vector3(0, 0, 0.4f));