FIX: Changed to frame based comparison for tracking UI click/navigation events

Assets/Samples/UIvsGameInput/UIvsGameInputHandler.cs

@@ -137,7 +137,7 @@ public void Update()
                     transform.rotation = default;
 
                 // When using a pointer-based control scheme, we engage camera look explicitly.
-                if (m_ControlStyle != ControlStyle.GamepadJoystick && m_LookEngageAction.WasPressedThisFrame() && IsPointerInsideScreen())
+                if (m_ControlStyle != ControlStyle.GamepadJoystick && m_LookEngageAction.WasPressedThisRenderingFrame() && IsPointerInsideScreen())
                     EngageCameraControl();
 
                 // With gamepad/joystick, we can freely rotate the camera at any time.
@@ -166,14 +166,14 @@ public void Update()
                 if (m_Mouse != null)
                     m_MousePositionToWarpToAfterCursorUnlock = m_MousePositionToWarpToAfterCursorUnlock.Value + m_Mouse.delta.ReadValue();
 
-                if (m_CancelAction.WasPressedThisFrame() || !m_LookEngageAction.IsPressed())
+                if (m_CancelAction.WasPressedThisRenderingFrame() || !m_LookEngageAction.IsPressed())
                     DisengageCameraControl();
 
                 break;
 
             case State.InMenu:
 
-                if (m_CancelAction.WasPressedThisFrame())
+                if (m_CancelAction.WasPressedThisRenderingFrame())
                     OnContinueClicked();
 
                 break;

Assets/Tests/Samples/RebindingUITests.cs

@@ -1,10 +1,12 @@
+using System.Collections;
 using System.IO;
 using NUnit.Framework;
 using UnityEngine;
 using UnityEngine.EventSystems;
 using UnityEngine.InputSystem;
 using UnityEngine.InputSystem.Samples.RebindUI;
 using UnityEngine.InputSystem.UI;
+using UnityEngine.TestTools;
 using UnityEngine.UI;
 
 public class RebindingUITests : CoreTestsFixture
@@ -84,9 +86,9 @@ public void Samples_RebindingUI_UpdatesWhenKeyboardLayoutChanges()
     }
 
     // https://fogbugz.unity3d.com/f/cases/1271591/
-    [Test]
+    [UnityTest]
     [Category("Samples")]
-    public void Samples_RebindingUI_SuppressingEventsDoesNotInterfereWithUIInput()
+    public IEnumerator Samples_RebindingUI_SuppressingEventsDoesNotInterfereWithUIInput()
     {
         var keyboard = InputSystem.AddDevice<Keyboard>();
 
@@ -135,6 +137,8 @@ public void Samples_RebindingUI_SuppressingEventsDoesNotInterfereWithUIInput()
         // UI should be fine with that.
         PressAndRelease(keyboard.enterKey);
         eventSystem.InvokeUpdate();
+        yield return null;
+
 
         Assert.That(rebind.ongoingRebind, Is.Not.Null);
         Assert.That(rebind.ongoingRebind.started, Is.True);
@@ -144,6 +148,7 @@ public void Samples_RebindingUI_SuppressingEventsDoesNotInterfereWithUIInput()
 
         Press(keyboard.bKey);
         eventSystem.InvokeUpdate();
+        yield return null;
 
         Assert.That(rebind.ongoingRebind, Is.Not.Null);
         Assert.That(rebind.ongoingRebind.started, Is.True);
@@ -162,6 +167,7 @@ public void Samples_RebindingUI_SuppressingEventsDoesNotInterfereWithUIInput()
         // Start another rebind via "Submit".
         PressAndRelease(keyboard.enterKey);
         eventSystem.InvokeUpdate();
+        yield return null;
 
         Assert.That(rebind.ongoingRebind, Is.Not.Null);
         Assert.That(rebind.ongoingRebind.started, Is.True);

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -23,6 +23,7 @@ however, it has to be formatted properly to pass verification tests.
 - Fixed an issue where compiling Addressables with Input System package present would result in failed compilation due to `IInputAnalytic.TryGatherData` not being defined [ISXB-1203](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1203).
 - Pinned Touch Samples sample package dependencies to avoid errors with Cinemachine 3.x and Probuilder 6.x. [ISXB-1245](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1245)
 - Fixed an issue where dropdown menu for Path in Input Actions Editor could not be selected from any button position. [ISXB-1309](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1309)
+- Fixed an issue where updating the InputSystem outside of the dynamic Update would lead to UI input and navigation events get lost.
 
 ## [1.12.0] - 2025-01-15
 

Packages/com.unity.inputsystem/InputSystem/Actions/InputAction.cs

@@ -1248,10 +1248,11 @@ private int ExpectedFrame()
         /// This method will disregard whether the action is currently enabled or disabled. It will keep returning
         /// true for the duration of the frame even if the action was subsequently disabled in the frame.
         ///
-        /// The meaning of "frame" is either the current "dynamic" update (<c>MonoBehaviour.Update</c>) or the current
-        /// fixed update (<c>MonoBehaviour.FixedUpdate</c>) depending on the value of the <see cref="InputSettings.updateMode"/> setting.
+        /// NOTE: If the <see cref="InputSettings.updateMode"/> is set to <see cref="InputSettings.UpdateMode.ProcessEventsInFixedUpdate"/> or <see cref="InputSettings.UpdateMode.ProcessEventsManually"/> and InputSystem.Update() is not called in
+        /// the dynamic Update, use <see cref="WasPressedThisRenderingFrame"/> during dynamic Update instead.
         /// </remarks>
         /// <seealso cref="IsPressed"/>
+        /// <seealso cref="WasPressedThisRenderingFrame"/>
         /// <seealso cref="WasReleasedThisFrame"/>
         /// <seealso cref="CallbackContext.ReadValueAsButton"/>
         /// <seealso cref="WasPerformedThisFrame"/>
@@ -1262,7 +1263,43 @@ public unsafe bool WasPressedThisFrame()
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
                 var currentUpdateStep = InputUpdate.s_UpdateStepCount;
-                return actionStatePtr->pressedInUpdate == currentUpdateStep && currentUpdateStep != default && actionStatePtr->frame == ExpectedFrame();
+                return actionStatePtr->pressedInUpdate == currentUpdateStep && currentUpdateStep != default;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Returns true if the action's value crossed the press threshold (see <see cref="InputSettings.defaultButtonPressPoint"/>)
+        /// in the MonoBehaviour Update cycle (rendering frame).
+        /// </summary>
+        /// <returns>True if the action was pressed in the MonoBehaviour Update cycle (rendering frame).</returns>
+        /// <remarks>
+        /// Unlike <see cref="WasPressedThisFrame"/>, this method will return true only if the InputSystem was updated and the action was pressed in the current dynamic Update cycle (in between the previous and the current frame).
+        /// This can be used in dynamic update if the <see cref="InputSettings.updateMode"/> is set to <see cref="InputSettings.UpdateMode.ProcessEventsInFixedUpdate"/> or <see cref="InputSettings.UpdateMode.ProcessEventsManually"/>.
+        /// If the update mode is set to <see cref="InputSettings.UpdateMode.ProcessEventsInDynamicUpdate"/>, this method will behave exactly like <see cref="WasPressedThisFrame"/>.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// var fire = playerInput.actions["fire"];
+        /// if (fire.WasPressed() &amp;&amp; fire.IsPressed())
+        ///     StartFiring();
+        /// else if (fire.WasReleasedThisFrame())
+        ///     StopFiring();
+        /// </code>
+        /// </example>
+        /// <seealso cref="IsPressed"/>
+        /// <seealso cref="WasPressedThisFrame"/>
+        /// <seealso cref="WasReleasedThisFrame"/>
+        /// <seealso cref="WasPerformedThisFrame"/>
+        /// <seealso cref="InputSettings.updateMode"/>
+        public unsafe bool WasPressedThisRenderingFrame()
+        {
+            var state = GetOrCreateActionMap().m_State;
+            if (state != null)
+            {
+                var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                return actionStatePtr->framePressed == ExpectedFrame();
             }
 
             return false;
@@ -1297,10 +1334,11 @@ public unsafe bool WasPressedThisFrame()
         /// This method will disregard whether the action is currently enabled or disabled. It will keep returning
         /// true for the duration of the frame even if the action was subsequently disabled in the frame.
         ///
-        /// The meaning of "frame" is either the current "dynamic" update (<c>MonoBehaviour.Update</c>) or the current
-        /// fixed update (<c>MonoBehaviour.FixedUpdate</c>) depending on the value of the <see cref="InputSettings.updateMode"/> setting.
+        /// NOTE: If the <see cref="InputSettings.updateMode"/> is set to <see cref="InputSettings.UpdateMode.ProcessEventsInFixedUpdate"/> or <see cref="InputSettings.UpdateMode.ProcessEventsManually"/> and InputSystem.Update() is not called in
+        /// the dynamic Update, use <see cref="WasReleasedThisRenderingFrame"/> during dynamic Update instead.
         /// </remarks>
         /// <seealso cref="IsPressed"/>
+        /// <seealso cref="WasReleasedThisRenderingFrame"/>
         /// <seealso cref="WasPressedThisFrame"/>
         /// <seealso cref="CallbackContext.ReadValueAsButton"/>
         /// <seealso cref="WasCompletedThisFrame"/>
@@ -1311,7 +1349,44 @@ public unsafe bool WasReleasedThisFrame()
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
                 var currentUpdateStep = InputUpdate.s_UpdateStepCount;
-                return actionStatePtr->releasedInUpdate == currentUpdateStep && currentUpdateStep != default && actionStatePtr->frame == ExpectedFrame();
+                return actionStatePtr->releasedInUpdate == currentUpdateStep && currentUpdateStep != default;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Returns true if the action's value crossed the release threshold (see <see cref="InputSettings.buttonReleaseThreshold"/>)
+        /// at any point in the MonoBehaviour Update cycle (rendering frame).
+        /// </summary>
+        /// <returns>True if the action was released in the MonoBehaviour Update cycle (rendering frame).</returns>
+        /// <remarks>
+        /// Unlike <see cref="WasReleasedThisFrame"/>, this method will return true only if the InputSystem was updated and the action was released in the current dynamic Update cycle (in between the previous and the current frame).
+        /// This can be used in dynamic update if the <see cref="InputSettings.updateMode"/> is set to <see cref="InputSettings.UpdateMode.ProcessEventsInFixedUpdate"/> or <see cref="InputSettings.UpdateMode.ProcessEventsManually"/>.
+        /// If the update mode is set to <see cref="InputSettings.UpdateMode.ProcessEventsInDynamicUpdate"/>, this method will behave exactly like <see cref="WasReleasedThisFrame"/>.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// var fire = playerInput.actions["fire"];
+        /// if (fire.WasPressed() &amp;&amp; fire.IsPressed())
+        ///     StartFiring();
+        /// else if (fire.WasReleased())
+        ///     StopFiring();
+        /// </code>
+        /// </example>
+        /// <seealso cref="IsPressed"/>
+        /// <seealso cref="WasPressedThisFrame"/>
+        /// <seealso cref="WasReleasedThisFrame"/>
+        /// <seealso cref="CallbackContext.ReadValueAsButton"/>
+        /// <seealso cref="WasCompletedThisFrame"/>
+        /// <seealso cref="InputSettings.updateMode"/>
+        public unsafe bool WasReleasedThisRenderingFrame()
+        {
+            var state = GetOrCreateActionMap().m_State;
+            if (state != null)
+            {
+                var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                return actionStatePtr->frameReleased == ExpectedFrame();
             }
 
             return false;
@@ -1356,9 +1431,10 @@ public unsafe bool WasReleasedThisFrame()
         /// This method will disregard whether the action is currently enabled or disabled. It will keep returning
         /// true for the duration of the frame even if the action was subsequently disabled in the frame.
         ///
-        /// The meaning of "frame" is either the current "dynamic" update (<c>MonoBehaviour.Update</c>) or the current
-        /// fixed update (<c>MonoBehaviour.FixedUpdate</c>) depending on the value of the <see cref="InputSettings.updateMode"/> setting.
+        /// NOTE: If the <see cref="InputSettings.updateMode"/> is set to <see cref="InputSettings.UpdateMode.ProcessEventsInFixedUpdate"/> or <see cref="InputSettings.UpdateMode.ProcessEventsManually"/> and InputSystem.Update() is not called in
+        /// the dynamic Update, use <see cref="WasPerformedThisRenderingFrame"/> when trying to access in dynamic Update instead.
         /// </remarks>
+        /// <seealso cref="WasPerformedThisRenderingFrame"/>
         /// <seealso cref="WasCompletedThisFrame"/>
         /// <seealso cref="WasPressedThisFrame"/>
         /// <seealso cref="phase"/>
@@ -1370,7 +1446,42 @@ public unsafe bool WasPerformedThisFrame()
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
                 var currentUpdateStep = InputUpdate.s_UpdateStepCount;
-                return actionStatePtr->lastPerformedInUpdate == currentUpdateStep && currentUpdateStep != default && actionStatePtr->frame == ExpectedFrame();
+                return actionStatePtr->lastPerformedInUpdate == currentUpdateStep && currentUpdateStep != default;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Check whether <see cref="phase"/> was <see cref="InputActionPhase.Performed"/> at any point
+        /// in the MonoBehaviour Update cycle (rendering frame).
+        /// </summary>
+        /// <returns>True if the action performed in the MonoBehaviour Update cycle (rendering frame).</returns>
+        /// <remarks>
+        /// Unlike <see cref="WasPerformedThisFrame"/>, this method will return true only if the InputSystem was updated and the action was performed in the current dynamic Update cycle (in between the previous and the current frame).
+        /// This can be used in dynamic update if the <see cref="InputSettings.updateMode"/> is set to <see cref="InputSettings.UpdateMode.ProcessEventsInFixedUpdate"/> or <see cref="InputSettings.UpdateMode.ProcessEventsManually"/>.
+        /// If the update mode is set to <see cref="InputSettings.UpdateMode.ProcessEventsInDynamicUpdate"/>, this method will behave exactly like <see cref="WasPerformedThisFrame"/>.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// var warp = playerInput.actions["Warp"];
+        /// if (warp.WasPerformed())
+        ///     InitiateWarp();
+        /// </code>
+        /// </example>
+        /// <seealso cref="WasPerformedThisFrame"/>
+        /// <seealso cref="WasCompletedThisFrame"/>
+        /// <seealso cref="WasPressedThisFrame"/>
+        /// <seealso cref="phase"/>
+        /// <seealso cref="InputSettings.updateMode"/>
+        public unsafe bool WasPerformedThisRenderingFrame()
+        {
+            var state = GetOrCreateActionMap().m_State;
+
+            if (state != null)
+            {
+                var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                return actionStatePtr->framePerformed == ExpectedFrame();
             }
 
             return false;
@@ -1425,10 +1536,8 @@ public unsafe bool WasPerformedThisFrame()
         /// This method will disregard whether the action is currently enabled or disabled. It will keep returning
         /// true for the duration of the frame even if the action was subsequently disabled in the frame.
         /// </para>
-        /// <para>
-        /// The meaning of "frame" is either the current "dynamic" update (<c>MonoBehaviour.Update</c>) or the current
-        /// fixed update (<c>MonoBehaviour.FixedUpdate</c>) depending on the value of the <see cref="InputSettings.updateMode"/> setting.
-        /// </para>
+        /// NOTE: If the <see cref="InputSettings.updateMode"/> is set to <see cref="InputSettings.UpdateMode.ProcessEventsInFixedUpdate"/> or <see cref="InputSettings.UpdateMode.ProcessEventsManually"/> and InputSystem.Update() is not called in
+        /// the dynamic Update, use <see cref="WasCompletedThisRenderingFrame"/> to access this during dynamic Update instead.
         /// </remarks>
         /// <example>
         /// <code>
@@ -1439,6 +1548,7 @@ public unsafe bool WasPerformedThisFrame()
         ///     StopTeleport();
         /// </code>
         /// </example>
+        /// <seealso cref="WasCompletedThisRenderingFrame"/>
         /// <seealso cref="WasPerformedThisFrame"/>
         /// <seealso cref="WasReleasedThisFrame"/>
         /// <seealso cref="phase"/>
@@ -1450,7 +1560,42 @@ public unsafe bool WasCompletedThisFrame()
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
                 var currentUpdateStep = InputUpdate.s_UpdateStepCount;
-                return actionStatePtr->lastCompletedInUpdate == currentUpdateStep && currentUpdateStep != default && actionStatePtr->frame == ExpectedFrame();
+                return actionStatePtr->lastCompletedInUpdate == currentUpdateStep && currentUpdateStep != default;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Check whether <see cref="phase"/> transitioned from <see cref="InputActionPhase.Performed"/> to any other phase
+        /// value at least once in the MonoBehaviour Update cycle (rendering frame).
+        /// </summary>
+        /// <returns>True if the action completed in this MonoBehaviour Update cycle (rendering frame).</returns>
+        /// <remarks>
+        /// Unlike <see cref="WasCompletedThisFrame"/>, this method will return true only if the InputSystem was updated and the action was completed in the current dynamic Update cycle (in between the previous and the current frame).
+        /// This can be used in dynamic update if the <see cref="InputSettings.updateMode"/> is set to <see cref="InputSettings.UpdateMode.ProcessEventsInFixedUpdate"/> or <see cref="InputSettings.UpdateMode.ProcessEventsManually"/>.
+        /// If the update mode is set to <see cref="InputSettings.UpdateMode.ProcessEventsInDynamicUpdate"/>, this method will behave exactly like <see cref="WasCompletedThisFrame"/>.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// var warp = playerInput.actions["Warp"];
+        /// if (warp.WasPerformed())
+        ///     InitiateWarp();
+        /// </code>
+        /// </example>
+        /// <seealso cref="WasPerformedThisFrame"/>
+        /// <seealso cref="WasCompletedThisFrame"/>
+        /// <seealso cref="WasPressedThisFrame"/>
+        /// <seealso cref="phase"/>
+        /// <seealso cref="InputSettings.updateMode"/>
+        public unsafe bool WasCompletedThisRenderingFrame()
+        {
+            var state = GetOrCreateActionMap().m_State;
+
+            if (state != null)
+            {
+                var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                return actionStatePtr->frameCompleted == ExpectedFrame();
             }
 
             return false;