FIX: Successive UI clicks not working with TouchSimulation (case 1330014, #1449).

Author: Rene Damm

Assets/Tests/InputSystem/Plugins/UITests.cs

@@ -1583,14 +1583,19 @@ public IEnumerator UI_CanUseTouchSimulationWithUI()
         scene.uiModule.AssignDefaultActions();
         TouchSimulation.Enable();
 
+        // https://fogbugz.unity3d.com/f/cases/1330014/
+        // Scale the left button down on X just a little bit so as to give us some space where we can hit nothing.
+        // This makes sure that if the code ends up putting something at (0,0), it'll hit nothing.
+        ((RectTransform)scene.leftGameObject.transform).localScale = new Vector3(0.95f, 1, 1);
+
         try
         {
             yield return null;
             scene.leftChildReceiver.events.Clear();
 
             InputSystem.QueueStateEvent(mouse, new MouseState
             {
-                position = scene.From640x480ToScreen(123, 123)
+                position = scene.From640x480ToScreen(180, 180)
             }.WithButton(MouseButton.Left));
             InputSystem.Update();
 
@@ -1600,26 +1605,88 @@ public IEnumerator UI_CanUseTouchSimulationWithUI()
             Assert.That(scene.uiModule.m_PointerIds.length, Is.EqualTo(1));
             Assert.That(scene.uiModule.m_PointerTouchControls.length, Is.EqualTo(1));
             Assert.That(scene.uiModule.m_PointerTouchControls[0], Is.SameAs(Touchscreen.current.touches[0]));
-            Assert.That(scene.leftChildReceiver.events.Select(x => x.type),
-                Is.EquivalentTo(new[]
-                {
-                    EventType.PointerEnter,
-#if UNITY_2021_2_OR_NEWER
-                    EventType.PointerMove,
-#endif
-                    EventType.PointerDown,
-                    EventType.InitializePotentialDrag
-                }));
             Assert.That(scene.leftChildReceiver.events,
-                Has.All.Matches((UICallbackReceiver.Event evt) => evt.pointerData.pointerType == UIPointerType.Touch));
+                EventSequence(
+                    AllEvents("pointerType", UIPointerType.Touch),
+                    AllEvents("touchId", 1),
+                    AllEvents("position", scene.From640x480ToScreen(180, 180)),
+                    OneEvent("type", EventType.PointerEnter)
+                    #if UNITY_2021_2_OR_NEWER
+                    , OneEvent("type", EventType.PointerMove)
+                    #endif
+                    , OneEvent("type", EventType.PointerDown)
+                    , OneEvent("type", EventType.InitializePotentialDrag)
+                )
+            );
+
+            scene.leftChildReceiver.events.Clear();
+
+            Release(mouse.leftButton);
+            yield return null;
+
+            // Touch pointer record lingers for one frame.
+
+            Assert.That(scene.uiModule.m_CurrentPointerType, Is.EqualTo(UIPointerType.Touch));
+            Assert.That(scene.uiModule.m_PointerIds.length, Is.EqualTo(1));
+            Assert.That(scene.uiModule.m_PointerTouchControls.length, Is.EqualTo(1));
+            Assert.That(scene.uiModule.m_PointerTouchControls[0], Is.SameAs(Touchscreen.current.touches[0]));
+            Assert.That(scene.leftChildReceiver.events,
+                EventSequence(
+                    AllEvents("pointerType", UIPointerType.Touch),
+                    AllEvents("touchId", 1),
+                    AllEvents("position", scene.From640x480ToScreen(180, 180)),
+                    OneEvent("type", EventType.PointerUp),
+                    OneEvent("type", EventType.PointerClick)
+                )
+            );
+
+            scene.leftChildReceiver.events.Clear();
+
+            yield return null;
+
+            Assert.That(scene.uiModule.m_CurrentPointerType, Is.EqualTo(UIPointerType.None));
+            Assert.That(scene.uiModule.m_PointerIds.length, Is.Zero);
+            Assert.That(scene.uiModule.m_PointerTouchControls.length, Is.Zero);
+            Assert.That(scene.leftChildReceiver.events,
+                EventSequence(
+                    AllEvents("pointerType", UIPointerType.Touch),
+                    AllEvents("touchId", 1),
+                    AllEvents("position", scene.From640x480ToScreen(180, 180)),
+                    OneEvent("type", EventType.PointerExit)
+                )
+            );
+
+            scene.leftChildReceiver.events.Clear();
+
+            yield return null;
+            Press(mouse.leftButton);
+            yield return null;
+
             Assert.That(scene.leftChildReceiver.events,
-                Has.All.Matches((UICallbackReceiver.Event evt) => evt.pointerData.touchId == 1));
+                EventSequence(
+                    AllEvents("pointerType", UIPointerType.Touch),
+                    AllEvents("touchId", 2),
+                    AllEvents("position", scene.From640x480ToScreen(180, 180)),
+                    OneEvent("type", EventType.PointerEnter),
+                    OneEvent("type", EventType.PointerDown),
+                    OneEvent("type", EventType.InitializePotentialDrag)
+                )
+            );
+
+            scene.leftChildReceiver.events.Clear();
 
-            // Release the mouse button so the touch ends. TouchSimulation.Disable() will remove
-            // the touchscreen and thus cancel ongoing actions (like Point). This should not result
-            // in exceptions from the input module trying to read data from the already removed touchscreen.
             Release(mouse.leftButton);
             yield return null;
+
+            Assert.That(scene.leftChildReceiver.events,
+                EventSequence(
+                    AllEvents("pointerType", UIPointerType.Touch),
+                    AllEvents("touchId", 2),
+                    AllEvents("position", scene.From640x480ToScreen(180, 180)),
+                    OneEvent("type", EventType.PointerUp),
+                    OneEvent("type", EventType.PointerClick)
+                )
+            );
         }
         finally
         {

Assets/TextMesh Pro/Sprites/EmojiOne.json.meta

@@ -22,6 +22,7 @@ however, it has to be formatted properly to pass verification tests.
 
 - Fixed writing values into the half-axis controls of sticks (such as `Gamepad.leftStick.left`) producing incorrect values on the stick ([case 1336240](https://issuetracker.unity3d.com/issues/inputtestfixture-tests-return-inverted-values-when-pressing-gamepads-left-or-down-joystick-buttons)).
 - Fixed setting size of event trace in input debugger always growing back to largest size set before.
+- Fixed successive clicks not getting triggered with `TouchSimulation` on when not moving the mouse in-between clicks ([case 1330014](https://issuetracker.unity3d.com/issues/onclick-isnt-triggered-on-the-second-click-when-the-mouse-isnt-moved-and-simulate-touch-input-from-mouse-or-pen-is-enabled)).
 - Fixed `InputSystemUIInputModule` showing incorrect bindings after pressing the 'Fix UI Input Module' button in PlayerInput component([case 1319968](https://issuetracker.unity3d.com/product/unity/issues/guid/1319968/)).
 - Fixed an issue where UI button clicks could be ignored by `InputSystemUIInputModule` if modifying on-screen devices from Update() callbacks ([case 1365070](https://issuetracker.unity3d.com/product/unity/issues/guid/1365070)).
 - Fixed an issue with `InputSystemUIInputModule` that would cause UI to stop responding during play mode after changing a script file while Recompile and Continue mode is active, or by forcing a script recompile using `RequestScriptCompilation`([case 1324215](https://issuetracker.unity3d.com/product/unity/issues/guid/1324215/)).

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -181,9 +181,11 @@ private unsafe void OnEvent(InputEventPtr eventPtr, InputDevice device)
                 {
                     // No, so add it.
                     touchIndex = m_Touches.IndexOfReference((ButtonControl)null);
-                    m_Touches[touchIndex] = (ButtonControl)control;
                     if (touchIndex >= 0) // If negative, we're at max touch count and can't add more.
+                    {
+                        m_Touches[touchIndex] = (ButtonControl)control;
                         UpdateTouch(touchIndex, pointerIndex, TouchPhase.Began, eventPtr);
+                    }
                 }
                 else
                 {

Packages/com.unity.inputsystem/InputSystem/Plugins/EnhancedTouch/TouchSimulation.cs

@@ -1370,18 +1370,33 @@ protected override void OnEnable()
             if (HasNoActions())
                 AssignDefaultActions();
 
+            ResetPointers();
+
             HookActions();
             EnableAllActions();
         }
 
         protected override void OnDisable()
         {
-            base.OnDisable();
+            ResetPointers();
 
             InputActionState.s_GlobalState.onActionControlsChanged.RemoveCallback(m_OnControlsChangedDelegate);
 
             DisableAllActions();
             UnhookActions();
+
+            base.OnDisable();
+        }
+
+        private void ResetPointers()
+        {
+            var numPointers = m_PointerStates.length;
+            for (var i = 0; i < numPointers; ++i)
+                SendPointerExitEventsAndRemovePointer(0);
+
+            m_CurrentPointerId = -1;
+            m_CurrentPointerIndex = -1;
+            m_CurrentPointerType = UIPointerType.None;
         }
 
         private bool HasNoActions()
@@ -1512,10 +1527,13 @@ private ref PointerModel GetPointerStateForIndex(int index)
             return ref m_PointerStates.additionalValues[index - 1];
         }
 
-        private ref PointerModel GetPointerStateFor(ref InputAction.CallbackContext context)
+        private int GetPointerStateIndexFor(ref InputAction.CallbackContext context)
         {
-            var index = GetPointerStateIndexFor(context.control);
-            return ref GetPointerStateForIndex(index);
+            if (CheckForRemovedDevice(ref context))
+                return -1;
+
+            var phase = context.phase;
+            return GetPointerStateIndexFor(context.control, createIfNotExists: phase != InputActionPhase.Canceled);
         }
 
         // This is the key method for determining which pointer a particular input is associated with.
@@ -1558,17 +1576,20 @@ private int GetPointerStateIndexFor(InputControl control, bool createIfNotExists
 
             var pointerId = device.deviceId;
             var touchId = 0;
+            var touchPosition = Vector2.zero;
 
             // Need to check if it's a touch so that we get a correct pointerId.
             if (controlParent is TouchControl touchControl)
             {
                 touchId = touchControl.touchId.ReadValue();
+                touchPosition = touchControl.position.ReadValue();
             }
             // Could be it's a toplevel control on Touchscreen (like "<Touchscreen>/position"). In that case,
             // read the touch ID from primaryTouch.
             else if (controlParent is Touchscreen touchscreen)
             {
                 touchId = touchscreen.primaryTouch.touchId.ReadValue();
+                touchPosition = touchscreen.primaryTouch.position.ReadValue();
             }
             if (touchId != 0)
                 pointerId = ExtendedPointerEventData.MakePointerIdForTouch(pointerId, touchId);
@@ -1668,6 +1689,9 @@ private int GetPointerStateIndexFor(InputControl control, bool createIfNotExists
                     eventData.trackedDevicePosition = default;
                 }
 
+                if (pointerType == UIPointerType.Touch)
+                    GetPointerStateForIndex(m_CurrentPointerIndex).screenPosition = touchPosition;
+
                 m_CurrentPointerId = pointerId;
                 m_CurrentPointerType = pointerType;
 
@@ -1725,6 +1749,9 @@ private int GetPointerStateIndexFor(InputControl control, bool createIfNotExists
                 }
             }
 
+            if (pointerType == UIPointerType.Touch)
+                GetPointerStateForIndex(index).screenPosition = touchPosition;
+
             m_CurrentPointerId = pointerId;
             m_CurrentPointerIndex = index;
             m_CurrentPointerType = pointerType;
@@ -1888,10 +1915,7 @@ private bool IgnoreNextClick(ref InputAction.CallbackContext context)
 
         private void OnLeftClickCallback(InputAction.CallbackContext context)
         {
-            if (CheckForRemovedDevice(ref context))
-                return;
-
-            var index = GetPointerStateIndexFor(context.control, createIfNotExists: !context.canceled);
+            var index = GetPointerStateIndexFor(ref context);
             if (index == -1)
                 return;
 
@@ -1904,10 +1928,7 @@ private void OnLeftClickCallback(InputAction.CallbackContext context)
 
         private void OnRightClickCallback(InputAction.CallbackContext context)
         {
-            if (CheckForRemovedDevice(ref context))
-                return;
-
-            var index = GetPointerStateIndexFor(context.control, createIfNotExists: !context.canceled);
+            var index = GetPointerStateIndexFor(ref context);
             if (index == -1)
                 return;
 
@@ -1920,10 +1941,7 @@ private void OnRightClickCallback(InputAction.CallbackContext context)
 
         private void OnMiddleClickCallback(InputAction.CallbackContext context)
         {
-            if (CheckForRemovedDevice(ref context))
-                return;
-
-            var index = GetPointerStateIndexFor(context.control, createIfNotExists: !context.canceled);
+            var index = GetPointerStateIndexFor(ref context);
             if (index == -1)
                 return;
 
@@ -1952,7 +1970,11 @@ private bool CheckForRemovedDevice(ref InputAction.CallbackContext context)
 
         private void OnScrollCallback(InputAction.CallbackContext context)
         {
-            ref var state = ref GetPointerStateFor(ref context);
+            var index = GetPointerStateIndexFor(ref context);
+            if (index == -1)
+                return;
+
+            ref var state = ref GetPointerStateForIndex(index);
             // The old input system reported scroll deltas in lines, we report pixels.
             // Need to scale as the UI system expects lines.
             state.scrollDelta = context.ReadValue<Vector2>() * (1 / kPixelPerLine);
@@ -1966,13 +1988,21 @@ private void OnMoveCallback(InputAction.CallbackContext context)
 
         private void OnTrackedDeviceOrientationCallback(InputAction.CallbackContext context)
         {
-            ref var state = ref GetPointerStateFor(ref context);
+            var index = GetPointerStateIndexFor(ref context);
+            if (index == -1)
+                return;
+
+            ref var state = ref GetPointerStateForIndex(index);
             state.worldOrientation = context.ReadValue<Quaternion>();
         }
 
         private void OnTrackedDevicePositionCallback(InputAction.CallbackContext context)
         {
-            ref var state = ref GetPointerStateFor(ref context);
+            var index = GetPointerStateIndexFor(ref context);
+            if (index == -1)
+                return;
+
+            ref var state = ref GetPointerStateForIndex(index);
             state.worldPosition = context.ReadValue<Vector3>();
         }
 
@@ -2183,8 +2213,8 @@ private struct InputActionReferenceState
             public bool enabledByInputModule;
         }
 
-        private bool m_ActionsHooked;
-        private bool m_NeedToPurgeStalePointers;
+        [NonSerialized] private bool m_ActionsHooked;
+        [NonSerialized] private bool m_NeedToPurgeStalePointers;
 
         private Action<InputAction.CallbackContext> m_OnPointDelegate;
         private Action<InputAction.CallbackContext> m_OnMoveDelegate;