FIX: Corrected a bug where suppression flag was tied to action map instead of per action.

Author: ekcoh

Assets/Tests/InputSystem/CoreTests_Actions_Rebinding.cs

@@ -1192,8 +1192,8 @@ public void Actions_InteractiveRebinding_CanSuppressEventsWhileListening(InputEv
             // - SuppressStateUpdates: the event is discarded before state updates, so the
             //   action never observes the press at all.
             // - SuppressActionEventNotifications: state propagates (device sees the press)
-            //   but InputAction.WasPressedThisFrame() is gated by IsSuppressed and returns
-            //   false (see InputAction.cs WasPressedThisFrame).
+            //   but InputAction.WasPressedThisFrame() is gated by the per-action suppressed
+            //   flag (TriggerState.isSuppressed) and returns false.
             Assert.That(observerAction.WasPressedThisFrame(), Is.False);
         }
     }

Assets/Tests/InputSystem/CoreTests_Events.cs

@@ -1607,6 +1607,67 @@ public void Events_AllWasXxxThisFrameAPIsRespectEventSuppression()
         Assert.That(gamepad.buttonSouth.isPressed, Is.False);
     }
 
+    [Test]
+    [Category("Events")]
+    [Description("ISXB-1097 Per-action suppression: mixed handled/unhandled events in the same" +
+        " frame should only suppress the actions affected by the handled event")]
+    public void Events_PerActionSuppressionWithMixedHandledEvents()
+    {
+        // ISXB-1097: When multiple events arrive in the same frame and only some are handled,
+        // the polling APIs should return correct results per-action. An action triggered by an
+        // unhandled event should not be affected by a different handled event in the same frame.
+        var gamepad = InputSystem.AddDevice<Gamepad>();
+
+        var southAction = new InputAction(name: "south", type: InputActionType.Button,
+            binding: "<Gamepad>/buttonSouth");
+        var northAction = new InputAction(name: "north", type: InputActionType.Button,
+            binding: "<Gamepad>/buttonNorth");
+        southAction.Enable();
+        northAction.Enable();
+
+        // Handle events that press buttonSouth, but let buttonNorth events through.
+        InputSystem.onEvent += (eventPtr, device) =>
+        {
+            // We can't selectively handle per-control within a single event, so we use
+            // two separate events: one for south (handled) and one for north (not handled).
+        };
+
+        // Event 1: Press south only — mark as handled.
+        var handleNext = true;
+        InputSystem.onEvent += (eventPtr, _) =>
+        {
+            if (handleNext)
+            {
+                eventPtr.handled = true;
+                handleNext = false;
+            }
+        };
+
+        // Queue two events: first presses south (will be handled), second presses north
+        // (will not be handled). Both arrive in the same frame.
+        InputSystem.QueueStateEvent(gamepad,
+            new GamepadState().WithButton(GamepadButton.South));
+        InputSystem.QueueStateEvent(gamepad,
+            new GamepadState().WithButton(GamepadButton.South).WithButton(GamepadButton.North));
+        InputSystem.Update();
+
+        // South was pressed by the handled event — its polling APIs should be suppressed.
+        Assert.That(southAction.WasPressedThisFrame(), Is.False,
+            "South action triggered by handled event should be suppressed");
+        Assert.That(southAction.WasPerformedThisFrame(), Is.False,
+            "South action triggered by handled event should be suppressed");
+
+        // North was pressed by the unhandled event — its polling APIs should report normally.
+        Assert.That(northAction.WasPressedThisFrame(), Is.True,
+            "North action triggered by unhandled event should NOT be suppressed");
+        Assert.That(northAction.WasPerformedThisFrame(), Is.True,
+            "North action triggered by unhandled event should NOT be suppressed");
+
+        // Both buttons should reflect actual device state regardless of suppression.
+        Assert.That(gamepad.buttonSouth.isPressed, Is.True);
+        Assert.That(gamepad.buttonNorth.isPressed, Is.True);
+    }
+
     [StructLayout(LayoutKind.Explicit, Size = 2)]
     struct StateWith2Bytes : IInputStateTypeInfo
     {

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -10,7 +10,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Fixed
 
 - Fixed `InputEventPtr.handled` not preventing actions from triggering when switching devices. The default event handled policy has been changed from `SuppressStateUpdates` (now deprecated) to `SuppressActionEventNotifications`, which keeps device state synchronized while suppressing action callbacks for handled events. [ISXB-1097](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1097)
-- Fixed `InputAction.WasReleasedThisFrame()`, `WasReleasedThisDynamicUpdate()`, `WasCompletedThisFrame()`, and `WasCompletedThisDynamicUpdate()` not respecting event suppression, making them inconsistent with `WasPressedThisFrame()` and `WasPerformedThisFrame()`. [ISXB-1097](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1097)
+- Fixed all `InputAction.WasXxxThisFrame()` and `WasXxxThisDynamicUpdate()` polling APIs to use per-action suppression tracking instead of a map-wide flag. Previously, when multiple events arrived in the same frame with mixed handled/unhandled states, the last event's suppression state could incorrectly affect all actions in the map. [ISXB-1097](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1097)
 - Fixed a `NullReferenceException` thrown when removing all action maps [UUM-137116](https://jira.unity3d.com/browse/UUM-137116)
 - Simplified default setting messaging by consolidating repetitive messages into a single HelpBox.
 - Fixed a `NullPointerReferenceException` thrown in `InputManagerStateMonitors.FireStateChangeNotifications` logging by adding validation [UUM-136095].

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

@@ -1260,9 +1260,11 @@ private int ExpectedFrame()
         public unsafe bool WasPressedThisFrame()
         {
             var state = GetOrCreateActionMap().m_State;
-            if (state != null && !state.IsSuppressed)
+            if (state != null)
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                if (actionStatePtr->isSuppressed)
+                    return false;
                 var currentUpdateStep = InputUpdate.s_UpdateStepCount;
                 return actionStatePtr->pressedInUpdate == currentUpdateStep && currentUpdateStep != default;
             }
@@ -1300,9 +1302,11 @@ public unsafe bool WasPressedThisFrame()
         public unsafe bool WasPressedThisDynamicUpdate()
         {
             var state = GetOrCreateActionMap().m_State;
-            if (state != null && !state.IsSuppressed)
+            if (state != null)
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                if (actionStatePtr->isSuppressed)
+                    return false;
                 return actionStatePtr->framePressed == ExpectedFrame();
             }
 
@@ -1350,9 +1354,11 @@ public unsafe bool WasPressedThisDynamicUpdate()
         public unsafe bool WasReleasedThisFrame()
         {
             var state = GetOrCreateActionMap().m_State;
-            if (state != null && !state.IsSuppressed)
+            if (state != null)
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                if (actionStatePtr->isSuppressed)
+                    return false;
                 var currentUpdateStep = InputUpdate.s_UpdateStepCount;
                 return actionStatePtr->releasedInUpdate == currentUpdateStep && currentUpdateStep != default;
             }
@@ -1391,9 +1397,11 @@ public unsafe bool WasReleasedThisFrame()
         public unsafe bool WasReleasedThisDynamicUpdate()
         {
             var state = GetOrCreateActionMap().m_State;
-            if (state != null && !state.IsSuppressed)
+            if (state != null)
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                if (actionStatePtr->isSuppressed)
+                    return false;
                 return actionStatePtr->frameReleased == ExpectedFrame();
             }
 
@@ -1451,9 +1459,11 @@ public unsafe bool WasPerformedThisFrame()
         {
             var state = GetOrCreateActionMap().m_State;
 
-            if (state != null && !state.IsSuppressed)
+            if (state != null)
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                if (actionStatePtr->isSuppressed)
+                    return false;
                 var currentUpdateStep = InputUpdate.s_UpdateStepCount;
                 return actionStatePtr->lastPerformedInUpdate == currentUpdateStep && currentUpdateStep != default;
             }
@@ -1490,9 +1500,11 @@ public unsafe bool WasPerformedThisDynamicUpdate()
         {
             var state = GetOrCreateActionMap().m_State;
 
-            if (state != null && !state.IsSuppressed)
+            if (state != null)
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                if (actionStatePtr->isSuppressed)
+                    return false;
                 return actionStatePtr->framePerformed == ExpectedFrame();
             }
 
@@ -1571,9 +1583,11 @@ public unsafe bool WasCompletedThisFrame()
         {
             var state = GetOrCreateActionMap().m_State;
 
-            if (state != null && !state.IsSuppressed)
+            if (state != null)
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                if (actionStatePtr->isSuppressed)
+                    return false;
                 var currentUpdateStep = InputUpdate.s_UpdateStepCount;
                 return actionStatePtr->lastCompletedInUpdate == currentUpdateStep && currentUpdateStep != default;
             }
@@ -1612,9 +1626,11 @@ public unsafe bool WasCompletedThisDynamicUpdate()
         {
             var state = GetOrCreateActionMap().m_State;
 
-            if (state != null && !state.IsSuppressed)
+            if (state != null)
             {
                 var actionStatePtr = &state.actionStates[m_ActionIndexInState];
+                if (actionStatePtr->isSuppressed)
+                    return false;
                 return actionStatePtr->frameCompleted == ExpectedFrame();
             }
 

Packages/com.unity.inputsystem/InputSystem/Runtime/Actions/InputActionState.cs

@@ -368,11 +368,6 @@ private bool CanUseDevice(InputDevice device)
             return false;
         }
 
-        /// <summary>
-        /// Check whether the state is currently reflecting a suppressed state.
-        /// </summary>
-        public bool IsSuppressed => m_Suppressed;
-
         /// <summary>
         /// Check whether the state has any actions that are currently enabled.
         /// </summary>
@@ -2540,6 +2535,12 @@ private void ChangePhaseOfActionInternal(int actionIndex, TriggerState* actionSt
                 newState.startTime = newState.time;
             *actionState = newState;
 
+            // ISXB-1097: Stamp per-action suppression flag so polling APIs (WasPressedThisFrame,
+            // etc.) can check it after the update completes. This captures the suppression state
+            // of the specific event that changed this action, avoiding the last-event-wins issue
+            // with the map-wide m_Suppressed flag.
+            actionState->isSuppressed = m_Suppressed;
+
             // Let listeners know.
             var map = maps[trigger.mapIndex];
             Debug.Assert(actionIndex >= mapIndices[trigger.mapIndex].actionStartIndex,
@@ -3998,6 +3999,18 @@ public bool inProcessing
                 }
             }
 
+            public bool isSuppressed
+            {
+                get => (flags & Flags.Suppressed) != 0;
+                set
+                {
+                    if (value)
+                        flags |= Flags.Suppressed;
+                    else
+                        flags &= ~Flags.Suppressed;
+                }
+            }
+
             public Flags flags
             {
                 get => (Flags)m_Flags;
@@ -4045,6 +4058,19 @@ public enum Flags
                 Button = 1 << 5,
 
                 Pressed = 1 << 6,
+
+                /// <summary>
+                /// Whether the last event that changed this action's state was suppressed
+                /// (handled event under <see cref="InputEventHandledPolicy.SuppressActionEventNotifications"/>).
+                /// </summary>
+                /// <remarks>
+                /// ISXB-1097: This per-action flag is stamped when the action's phase changes,
+                /// capturing the suppression state of the specific event that caused the change.
+                /// Used by polling APIs (WasPressedThisFrame, etc.) instead of the map-wide
+                /// m_Suppressed flag which suffers from last-event-wins issues when multiple
+                /// events with different handled states arrive in the same frame.
+                /// </remarks>
+                Suppressed = 1 << 7,
             }
         }