FIX: MouseDownEvent is triggered when changing from Scene view to Game view (ISXB-1671)

.github/pull_request_template.md

@@ -11,8 +11,8 @@ _Please describe the testing already done by you and what testing you request/re
 
 _Please rate the potential complexity and halo effect from low to high for the reviewers. Note down potential risks to specific Editor branches if any._
 
-- Complexity: 
-- Halo Effect: 
+- Complexity:
+- Halo Effect:
 
 ### Comments to reviewers
 
@@ -45,7 +45,3 @@ During merge:
     - `DOCS: ___`.
     - `CHANGE: ___`.
     - `RELEASE: 1.1.0-preview.3`.
-
-After merge:
-
-- [ ] Create forward/backward port if needed. If you are blocked from creating a forward port now please add a task to ISX-1444.

Assets/Tests/InputSystem/CoreTests_Actions.cs

@@ -641,6 +641,60 @@ public void Actions_DoNotGetTriggeredByEditorUpdates()
         }
     }
 
+    [Test]
+    [Category("Actions")]
+    [Description("Tests that that only the latest event after focus is regained is able to trigger the action." +
+        "Depends on background behavior. (ISXB-1671)")]
+    [TestCase(InputSettings.BackgroundBehavior.IgnoreFocus)]
+    [TestCase(InputSettings.BackgroundBehavior.ResetAndDisableNonBackgroundDevices)]
+    [TestCase(InputSettings.BackgroundBehavior.ResetAndDisableAllDevices)]
+    public void Actions_DoNotGetTriggeredByOutOfFocusEventInEditor(InputSettings.BackgroundBehavior backgroundBehavior)
+    {
+        InputSystem.settings.backgroundBehavior = backgroundBehavior;
+
+        var mouse = InputSystem.AddDevice<Mouse>();
+        var mousePointAction = new InputAction(binding: "<Mouse>/position", type: InputActionType.PassThrough);
+        mousePointAction.Enable();
+
+        using (var trace = new InputActionTrace(mousePointAction))
+        {
+            // Note: We currently test against timestamps otherwise the test fails. But, ideally, we wouldn't need to.
+            // If we ever reach a point of having all relevant input events in the queue (including focus events) we
+            // could just rely on order of event. Which means this test work for a fixed timestamp and it should
+            // changed accordingly.
+            currentTime += 1.0f;
+            runtime.PlayerFocusLost();
+            currentTime += 1.0f;
+            // Queuing an event like it would be in the editor when the GameView is out of focus.
+            Set(mouse.position, new Vector2(0.234f, 0.345f) , queueEventOnly: true);
+            currentTime += 1.0f;
+            // Gaining focus like it would happen in the editor when the GameView regains focus.
+            runtime.PlayerFocusGained();
+            currentTime += 1.0f;
+            // This emulates a device sync that happens when the player regains focus through an IOCTL command.
+            // That's why it also has it's time incremented.
+            Set(mouse.position, new Vector2(1.0f, 2.0f), queueEventOnly: true);
+            currentTime += 1.0f;
+            // This update should not trigger any ction as it's an editor update.
+            InputSystem.Update(InputUpdateType.Editor);
+            currentTime += 1.0f;
+
+            var actions = trace.ToArray();
+            Assert.That(actions, Has.Length.EqualTo(0));
+            // This update should trigger an action with regards to the event queued after focus was regained.
+            // The one queued while out of focus should have been ignored and we should expect only one action triggered.
+            // Unless background behavior is set to IgnoreFocus in which case both events should trigger the action.
+            InputSystem.Update(InputUpdateType.Dynamic);
+
+            actions = trace.ToArray();
+            Assert.That(actions, Has.Length.EqualTo(backgroundBehavior == InputSettings.BackgroundBehavior.IgnoreFocus ? 2 : 1));
+            Assert.That(actions[0].phase, Is.EqualTo(InputActionPhase.Performed));
+            Vector2Control control = (Vector2Control)actions[0].control;
+            // Make sure the value is from the event after focus was regained.
+            Assert.That(control.value, Is.EqualTo(new Vector2(1.0f, 2.0f)).Using(Vector2EqualityComparer.Instance));
+        }
+    }
+
     [Test]
     [Category("Actions")]
     public void Actions_TimeoutsDoNotGetTriggeredInEditorUpdates()

Assets/Tests/InputSystem/Plugins/InputForUITests.cs

@@ -691,6 +691,72 @@ public void ActionWithDifferentExpectedControlType_ShouldGenerateWarning(string
         LogAssert.NoUnexpectedReceived();
     }
 
+    [Test]
+    [Category("Actions")]
+    [Description("Tests that that only the latest event after focus is regained is able to trigger the action." +
+        "Depends on background behavior. " +
+        "Similar to CoreTests_Actions.Actions_DoNotGetTriggeredByOutOfFocusEventInEditor but with InputForUI nuances.")]
+    [TestCase(InputSettings.BackgroundBehavior.IgnoreFocus)]
+    [TestCase(InputSettings.BackgroundBehavior.ResetAndDisableNonBackgroundDevices)]
+    [TestCase(InputSettings.BackgroundBehavior.ResetAndDisableAllDevices)]
+    public void UIActions_DoNotGetTriggeredByOutOfFocusEventInEditor(InputSettings.BackgroundBehavior backgroundBehavior)
+    {
+        InputSystem.settings.backgroundBehavior = backgroundBehavior;
+        var mouse = InputSystem.AddDevice<Mouse>();
+
+        Vector2 focusPosition = new Vector2(800f, 600f);
+        Vector2 outOfFocusPosition = new Vector2(100f, 500f);
+
+        // Simulate moving the mouse, losing focus, moving out of focus, regaining focus, and moving again to emulate
+        // a device sync that happens when regaining focus in play mode.
+        Update();
+        currentTime += 1.0f;
+        Set(mouse.position, new Vector2(1.0f, 1.0f), queueEventOnly: true);
+        currentTime += 1.0f;
+        Update();
+        currentTime += 1.0f;
+        runtime.PlayerFocusLost();
+        currentTime += 1.0f;
+        Set(mouse.position, outOfFocusPosition , queueEventOnly: true);
+        currentTime += 1.0f;
+        runtime.PlayerFocusGained();
+        currentTime += 1.0f;
+        Set(mouse.position, focusPosition, queueEventOnly: true);
+        currentTime += 1.0f;
+
+        // We call specific updates to simulate editor behavior when regaining focus.
+        InputSystem.Update(InputUpdateType.Editor);
+        Assert.AreEqual(0, m_InputForUIEvents.Count);
+        InputSystem.Update();
+        // Calling the event provider update after we call InputSystem updates so that we trigger InputForUI events
+        EventProvider.NotifyUpdate();
+
+        // Convert the input coordinates to UI panel space. We only assume 1 display for the tests.
+        var focusPositionInUI = InputSystemProvider.ScreenBottomLeftToPanelPosition(focusPosition, 0);
+        var outOfFocusPositionInUI = InputSystemProvider.ScreenBottomLeftToPanelPosition(outOfFocusPosition, 0);
+
+
+        // If we don't ignore focus, we only expect one event (the last one after focus is regained).
+        Assert.AreEqual(backgroundBehavior != InputSettings.BackgroundBehavior.IgnoreFocus ? 1 : 2, m_InputForUIEvents.Count);
+
+        // There will be an out of focus event only if we are ignoring focus. Validate its position.
+        if (backgroundBehavior == InputSettings.BackgroundBehavior.IgnoreFocus)
+        {
+            Assert.That(GetNextRecordedUIEvent() is
+            {
+                type: Event.Type.PointerEvent,
+                asPointerEvent: { type: PointerEvent.Type.PointerMoved, eventSource: EventSource.Mouse, position: var outOfFocusVector2 },
+            } && Mathf.Approximately(outOfFocusVector2.y, outOfFocusPositionInUI.y) && Mathf.Approximately(outOfFocusVector2.x, outOfFocusPositionInUI.x));
+        }
+
+        // Validate that we only we get the event for the position after focus is regained. Make sure its position is correct.
+        Assert.That(GetNextRecordedUIEvent() is
+        {
+            type: Event.Type.PointerEvent,
+            asPointerEvent: { type: PointerEvent.Type.PointerMoved, eventSource: EventSource.Mouse, position: var focusPositionVector2 },
+        } && Mathf.Approximately(focusPositionVector2.y, focusPositionInUI.y) && Mathf.Approximately(focusPositionVector2.x, focusPositionInUI.x));
+    }
+
 #endif // UNITY_EDITOR
 
     [Test]

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -39,6 +39,7 @@ however, it has to be formatted properly to pass verification tests.
 - Fixed an issue where the action icon would shrink or disappear from UI when an action has a very long name. [ISXB-1650](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1650).
 - Fixed upgrading input actions containing multiple processors [ISXB-1674](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1674).
 - Fixed an issue that led to non-deterministic behaviour during `.inputaction` asset imports that could lead to corrupted assets or Unity hanging during asset import when "Generate C# Scripts" was active in importer settings. [ISXB-1746](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1746)
+- An issue where a UITK MouseEvent was triggered when changing from Scene View to Game View in the Editor has been fixed. [ISXB-1671](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1671)
 
 ## [1.15.0] - 2025-10-03