Input System Fix Pointers Dispatching PointerEvents to all other Pointers

Author: Julia Schwarz

Assets/MixedRealityToolkit.Services/InputSystem/MixedRealityInputSystem.cs

@@ -244,24 +244,55 @@ public override void Disable()
         /// <inheritdoc />
         public override void HandleEvent<T>(BaseEventData eventData, ExecuteEvents.EventFunction<T> eventHandler)
         {
+            Debug.Assert(eventData != null);
+            Debug.Assert(!(eventData is  MixedRealityPointerEventData), "HandleEvent called with a pointer event. All events raised by pointer should call HandlePointerEvent");
+
             if (disabledRefCount > 0)
             {
                 return;
             }
 
-            Debug.Assert(eventData != null);
             var baseInputEventData = ExecuteEvents.ValidateEventData<BaseInputEventData>(eventData);
-            Debug.Assert(baseInputEventData != null);
-            Debug.Assert(!baseInputEventData.used);
+            DispatchEventToGlobalListeners(baseInputEventData, eventHandler);
+            
+            if (baseInputEventData.used)
+            {
+                // All global listeners get a chance to see the event,
+                // but if any of them marked it used,
+                // we stop the event from going any further.
+                return;
+            }
+
+            Debug.Assert(baseInputEventData.InputSource.Pointers != null, $"InputSource {baseInputEventData.InputSource.SourceName} doesn't have any registered pointers! Input Sources without pointers should use the GazeProvider's pointer as a default fallback.");
+
+            var modalEventHandled = false;
+            // Get the focused object for each pointer of the event source
+            for (int i = 0; i < baseInputEventData.InputSource.Pointers.Length && !baseInputEventData.used; i++)
+            {
+                modalEventHandled = DispatchEventToObjectFocusedByPointer(baseInputEventData.InputSource.Pointers[i], baseInputEventData, modalEventHandled, eventHandler);
+            }
 
-            if (baseInputEventData.InputSource == null)
+            if (!baseInputEventData.used)
+            {
+                DispatchEventToFallbackHandlers(baseInputEventData, eventHandler);
+            }
+        }
+        
+        /// <summary>
+        /// Handles a pointer event
+        /// Assumption: We only send pointer events to the objects that pointers are focusing, except for global event listeners (which listen to everything)
+        /// In contract, all other events get sent to all other pointers attached to a given input source
+        /// </summary>
+        private void HandlePointerEvent<T>(BaseEventData eventData, ExecuteEvents.EventFunction<T> eventHandler) where T : IMixedRealityPointerHandler
+        {
+            if (disabledRefCount > 0)
             {
-                Debug.LogError($"Failed to find an input source for {baseInputEventData}");
                 return;
             }
 
-            // Send the event to global listeners
-            base.HandleEvent(eventData, eventHandler);
+            Debug.Assert(eventData != null);
+            var baseInputEventData = ExecuteEvents.ValidateEventData<BaseInputEventData>(eventData);
+            DispatchEventToGlobalListeners(baseInputEventData, eventHandler);
 
             if (baseInputEventData.used)
             {
@@ -271,70 +302,86 @@ public override void HandleEvent<T>(BaseEventData eventData, ExecuteEvents.Event
                 return;
             }
 
-            if (baseInputEventData.InputSource.Pointers == null)
+            Debug.Assert(pointerEventData.Pointer != null, "Trying to dispatch event on pointer but pointerEventData is null");
+
+            DispatchEventToObjectFocusedByPointer(pointerEventData.Pointer, baseInputEventData, false, eventHandler);                
+
+            if (!baseInputEventData.used)
             {
-                Debug.LogError($"InputSource {baseInputEventData.InputSource.SourceName} doesn't have any registered pointers! Input Sources without pointers should use the GazeProvider's pointer as a default fallback.");
-                return;
+                DispatchEventToFallbackHandlers(baseInputEventData, eventHandler);
             }
+        }
 
-            var modalEventHandled = false;
+        /// <summary>
+        /// Dispatch an input event to all global event listeners
+        /// Return true if the event has been handled by a global event listener
+        /// </summary>
+        private void DispatchEventToGlobalListeners<T>(BaseInputEventData baseInputEventData, ExecuteEvents.EventFunction<T> eventHandler) where T : IEventSystemHandler
+        {
+            Debug.Assert(baseInputEventData != null);
+            Debug.Assert(!baseInputEventData.used);
+            Debug.Assert(baseInputEventData.InputSource != null, $"Failed to find an input source for {baseInputEventData}");
 
-            // Get the focused object for each pointer of the event source
-            for (int i = 0; i < baseInputEventData.InputSource.Pointers.Length; i++)
+            // Send the event to global listeners
+            base.HandleEvent(baseInputEventData, eventHandler);            
+        }
+
+        private void DispatchEventToFallbackHandlers<T>(BaseInputEventData baseInputEventData, ExecuteEvents.EventFunction<T> eventHandler) where T : IEventSystemHandler
+        {
+            // If event was not handled by the focused object, pass it on to any fallback handlers
+            if (!baseInputEventData.used && fallbackInputStack.Count > 0)
             {
-                GameObject focusedObject = FocusProvider?.GetFocusedObject(baseInputEventData.InputSource.Pointers[i]);
+                GameObject fallbackInput = fallbackInputStack.Peek();
+                ExecuteEvents.ExecuteHierarchy(fallbackInput, baseInputEventData, eventHandler);
+            }
+        }
 
-                // Handle modal input if one exists
-                if (modalInputStack.Count > 0 && !modalEventHandled)
-                {
-                    GameObject modalInput = modalInputStack.Peek();
+        
+        /// <summary>
+        /// Dispatch an input event to the object focused by the given IMixedRealityPointer.
+        /// If a modal dialog is active, dispatch the pointer event to that modal dialog
+        /// Returns true if the event was handled by a modal handler
+        private bool DispatchEventToObjectFocusedByPointer<T>(IMixedRealityPointer mixedRealityPointer, BaseInputEventData baseInputEventData, 
+            bool modalEventHandled, ExecuteEvents.EventFunction<T> eventHandler) where T : IEventSystemHandler
+        {
+            GameObject focusedObject = FocusProvider?.GetFocusedObject(mixedRealityPointer);
 
-                    if (modalInput != null)
-                    {
-                        modalEventHandled = true;
+            // Handle modal input if one exists
+            if (modalInputStack.Count > 0 && !modalEventHandled)
+            {
+                GameObject modalInput = modalInputStack.Peek();
 
-                        // If there is a focused object in the hierarchy of the modal handler, start the event bubble there
-                        if (focusedObject != null && focusedObject.transform.IsChildOf(modalInput.transform))
-                        {
-                            if (ExecuteEvents.ExecuteHierarchy(focusedObject, baseInputEventData, eventHandler) && baseInputEventData.used)
-                            {
-                                return;
-                            }
-                        }
-                        // Otherwise, just invoke the event on the modal handler itself
-                        else
+                if (modalInput != null)
+                {
+                    // If there is a focused object in the hierarchy of the modal handler, start the event bubble there
+                    if (focusedObject != null && focusedObject.transform.IsChildOf(modalInput.transform))
+                    {
+                        if (ExecuteEvents.ExecuteHierarchy(focusedObject, baseInputEventData, eventHandler) && baseInputEventData.used)
                         {
-                            if (ExecuteEvents.ExecuteHierarchy(modalInput, baseInputEventData, eventHandler) && baseInputEventData.used)
-                            {
-                                return;
-                            }
+                            return true;
                         }
                     }
+                    // Otherwise, just invoke the event on the modal handler itself
                     else
                     {
-                        Debug.LogError("ModalInput GameObject reference was null!\nDid this GameObject get destroyed?");
+                        if (ExecuteEvents.ExecuteHierarchy(modalInput, baseInputEventData, eventHandler) && baseInputEventData.used)
+                        {
+                            return true;
+                        }
                     }
                 }
-
-                // If event was not handled by modal, pass it on to the current focused object
-                if (focusedObject != null)
+                else
                 {
-                    if (ExecuteEvents.ExecuteHierarchy(focusedObject, baseInputEventData, eventHandler) && baseInputEventData.used)
-                    {
-                        return;
-                    }
+                    Debug.LogError("ModalInput GameObject reference was null!\nDid this GameObject get destroyed?");
                 }
             }
 
-            // If event was not handled by the focused object, pass it on to any fallback handlers
-            if (fallbackInputStack.Count > 0)
+            // If event was not handled by modal, pass it on to the current focused object
+            if (focusedObject != null)
             {
-                GameObject fallbackInput = fallbackInputStack.Peek();
-                if (ExecuteEvents.ExecuteHierarchy(fallbackInput, baseInputEventData, eventHandler) && baseInputEventData.used)
-                {
-                    // return;
-                }
+                ExecuteEvents.ExecuteHierarchy(focusedObject, baseInputEventData, eventHandler);
             }
+            return modalEventHandled;
         }
 
         /// <summary>
@@ -820,7 +867,8 @@ public void RaisePointerDown(IMixedRealityPointer pointer, MixedRealityInputActi
         private GraphicInputEventData HandlePointerDown(IMixedRealityPointer pointer)
         {
             // Pass handler through HandleEvent to perform modal/fallback logic
-            HandleEvent(pointerEventData, OnPointerDownEventHandler);
+            HandlePointerEvent(pointerEventData, OnPointerDownEventHandler);
+
             GraphicInputEventData graphicEventData;
             FocusProvider.TryGetSpecificPointerGraphicEventData(pointer, out graphicEventData);
             return graphicEventData;
@@ -866,7 +914,7 @@ public void RaisePointerClicked(IMixedRealityPointer pointer, MixedRealityInputA
         private void HandleClick()
         {
             // Pass handler through HandleEvent to perform modal/fallback logic
-            HandleEvent(pointerEventData, OnInputClickedEventHandler);
+            HandlePointerEvent(pointerEventData, OnInputClickedEventHandler);
 
             // NOTE: In Unity UI, a "click" happens on every pointer up, so we have RaisePointerUp call the pointerClickHandler.
         }
@@ -917,7 +965,7 @@ private static void ExecutePointerUp(GraphicInputEventData graphicInputEventData
         private GraphicInputEventData HandlePointerUp(IMixedRealityPointer pointer)
         {
             // Pass handler through HandleEvent to perform modal/fallback logic
-            HandleEvent(pointerEventData, OnPointerUpEventHandler);
+            HandlePointerEvent(pointerEventData, OnPointerUpEventHandler);
 
             GraphicInputEventData graphicEventData;
             FocusProvider.TryGetSpecificPointerGraphicEventData(pointer, out graphicEventData);