Add fix for priorites of the same level not both firing.

Author: Darren-Kelly-Unity

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

@@ -1406,7 +1406,7 @@ private void SplitUpMapAndControlAndBindingIndex(long mapControlAndBindingIndex,
         /// Extract the 'complexity' component from the provided bit packed argument (monitor index).
         /// </summary>
         /// <param name="mapControlAndBindingIndex">Represents a monitor index, which is a bit packed field containing multiple components.</param>
-        internal static int GetComplexityFromMonitorIndex(long mapControlAndBindingIndex)
+        internal static int GetPriorityFromMonitorIndex(long mapControlAndBindingIndex)
         {
             return (int)((mapControlAndBindingIndex >> 48) & 0xff);
         }
@@ -2467,8 +2467,8 @@ private void ChangePhaseOfActionInternal(int actionIndex, TriggerState* actionSt
                 newState.lastCanceledInUpdate = actionState->lastCanceledInUpdate;
 
                 // When we perform an action, we mark the event handled such that FireStateChangeNotifications()
-                // can then reset state monitors in the same group.
-                // NOTE: We don't consume for controls at binding complexity 1. Those we fire in unison.
+                // can then reset state monitors in the same group (strictly lower binding priority only).
+                // NOTE: We don't consume for controls at binding priority 0. Those we fire in unison.
                 if (controlGroupingAndPriority[trigger.controlIndex * 2 + 1] > 0 &&
                     // we can end up switching to performed state from an interaction with a timeout, at which point
                     // the original event will probably have been removed from memory, so make sure to check

Packages/com.unity.inputsystem/InputSystem/InputManagerStateMonitors.cs

@@ -263,11 +263,11 @@ public void SortMonitorsByIndex()
                 {
                     for (var j = i; j > 0; --j)
                     {
-                        // Sort by complexities only to keep the sort stable
-                        // i.e. don't reverse the order of controls which have the same complexity
-                        var firstComplexity = InputActionState.GetComplexityFromMonitorIndex(listeners[j - 1].monitorIndex);
-                        var secondComplexity = InputActionState.GetComplexityFromMonitorIndex(listeners[j].monitorIndex);
-                        if (firstComplexity >= secondComplexity)
+                        // Sort by priorities only to keep the sort stable
+                        // i.e. don't reverse the order of controls which have the same priority
+                        var firstPriority = InputActionState.GetPriorityFromMonitorIndex(listeners[j - 1].monitorIndex);
+                        var secondPriority = InputActionState.GetPriorityFromMonitorIndex(listeners[j].monitorIndex);
+                        if (firstPriority >= secondPriority)
                             break;
 
                         listeners.SwapElements(j, j - 1);
@@ -408,6 +408,7 @@ internal unsafe void FireStateChangeNotifications(int deviceIndex, double intern
                 if (!previouslyHandled && eventPtr->handled)
                 {
                     var groupIndex = listeners[i].groupIndex;
+                    var handlerPriority = InputActionState.GetPriorityFromMonitorIndex(listener.monitorIndex);
                     for (var n = i + 1; n < signals.length; ++n)
                     {
                         // NOTE: We restrict the preemption logic here to a single monitor. Otherwise,
@@ -419,7 +420,13 @@ internal unsafe void FireStateChangeNotifications(int deviceIndex, double intern
                         //       Note that this implies there there is *NO* preemption between singleton
                         //       InputActions. This isn't intuitive.
                         if (listeners[n].groupIndex == groupIndex && listeners[n].monitor == listener.monitor)
-                            signals.ClearBit(n);
+                        {
+                            // Only clear strictly lower binding priorities so equal priorities still
+                            // fire in unison (same as priority 0, but with consumption among lower tiers).
+                            var candidatePriority = InputActionState.GetPriorityFromMonitorIndex(listeners[n].monitorIndex);
+                            if (candidatePriority < handlerPriority)
+                                signals.ClearBit(n);
+                        }
                     }
                 }