Refactor DeferBindingResolution to remove statics (ISX-1840)

- Consolidate functionality into DeferBindingResolutionContext class
- Instantiate Context object as a non-static InputManager field exposed via InputManager methods

Author: timkeo

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

@@ -809,8 +809,6 @@ private enum Flags
             BindingsForEachActionInitialized = 1 << 3,
         }
 
-        internal static int s_DeferBindingResolution;
-
         internal struct DeviceArray
         {
             private bool m_HaveValue;
@@ -1206,7 +1204,7 @@ internal bool LazyResolveBindings(bool fullResolve)
             needToResolveBindings = true;
             bindingResolutionNeedsFullReResolve |= fullResolve;
 
-            if (s_DeferBindingResolution > 0)
+            if (InputSystem.manager.areDeferredBindingsToResolve)
                 return false;
 
             // Have to do it straight away.
@@ -1225,7 +1223,7 @@ internal bool ResolveBindingsIfNecessary()
             {
                 if (m_State != null && m_State.isProcessingControlStateChange)
                 {
-                    Debug.Assert(s_DeferBindingResolution > 0, "While processing control state changes, binding resolution should be suppressed");
+                    Debug.Assert(InputSystem.manager.areDeferredBindingsToResolve, "While processing control state changes, binding resolution should be suppressed");
                     return false;
                 }
 

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

@@ -2776,39 +2776,70 @@ public static RebindingOperation PerformInteractiveRebinding(this InputAction ac
             return rebind;
         }
 
+        internal static DeferBindingResolutionContext DeferBindingResolution()
+        {
+            return InputSystem.manager.DeferBindingResolution();
+        }
+    }
+
+    internal class DeferBindingResolutionContext : IDisposable
+    {
+        public int deferredCount => m_DeferredCount;
+
+        public void Acquire()
+        {
+            ++m_DeferredCount;
+        }
+
+        public void Release()
+        {
+            if (m_DeferredCount > 0)
+                --m_DeferredCount;
+            if (m_DeferredCount == 0)
+                ExecuteDeferredResolutionOfBindings();
+        }
+
         /// <summary>
-        /// Temporarily suspend immediate re-resolution of bindings.
+        /// Allows usage within using() blocks.
         /// </summary>
-        /// <remarks>
-        /// When changing control setups, it may take multiple steps to get to the final setup but each individual
-        /// step may trigger bindings to be resolved again in order to update controls on actions (see <see cref="InputAction.controls"/>).
-        /// Using this struct, this can be avoided and binding resolution can be deferred to after the whole operation
-        /// is complete and the final binding setup is in place.
-        /// </remarks>
-        internal static DeferBindingResolutionWrapper DeferBindingResolution()
+        public void Dispose()
         {
-            if (s_DeferBindingResolutionWrapper == null)
-                s_DeferBindingResolutionWrapper = new DeferBindingResolutionWrapper();
-            s_DeferBindingResolutionWrapper.Acquire();
-            return s_DeferBindingResolutionWrapper;
+            Release();
         }
 
-        private static DeferBindingResolutionWrapper s_DeferBindingResolutionWrapper;
-
-        internal class DeferBindingResolutionWrapper : IDisposable
+        private void ExecuteDeferredResolutionOfBindings()
         {
-            public void Acquire()
+            ++m_DeferredCount;
+            try
             {
-                ++InputActionMap.s_DeferBindingResolution;
-            }
+                ref var globalList = ref InputActionState.s_GlobalState.globalList;
 
-            public void Dispose()
+                for (var i = 0; i < globalList.length; ++i)
+                {
+                    var handle = globalList[i];
+
+                    var state = handle.IsAllocated ? (InputActionState)handle.Target : null;
+                    if (state == null)
+                    {
+                        // Stale entry in the list. State has already been reclaimed by GC. Remove it.
+                        if (handle.IsAllocated)
+                            globalList[i].Free();
+                        globalList.RemoveAtWithCapacity(i);
+                        --i;
+                        continue;
+                    }
+
+                    for (var n = 0; n < state.totalMapCount; ++n)
+                        state.maps[n].ResolveBindingsIfNecessary();
+                }
+            }
+            finally
             {
-                if (InputActionMap.s_DeferBindingResolution > 0)
-                    --InputActionMap.s_DeferBindingResolution;
-                if (InputActionMap.s_DeferBindingResolution == 0)
-                    InputActionState.DeferredResolutionOfBindings();
+                --m_DeferredCount;
             }
         }
+
+
+        private int m_DeferredCount;
     }
 }

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

@@ -4483,36 +4483,6 @@ internal static void OnDeviceChange(InputDevice device, InputDeviceChange change
             }
         }
 
-        internal static void DeferredResolutionOfBindings()
-        {
-            ++InputActionMap.s_DeferBindingResolution;
-            try
-            {
-                for (var i = 0; i < s_GlobalState.globalList.length; ++i)
-                {
-                    var handle = s_GlobalState.globalList[i];
-
-                    var state = handle.IsAllocated ? (InputActionState)handle.Target : null;
-                    if (state == null)
-                    {
-                        // Stale entry in the list. State has already been reclaimed by GC. Remove it.
-                        if (handle.IsAllocated)
-                            s_GlobalState.globalList[i].Free();
-                        s_GlobalState.globalList.RemoveAtWithCapacity(i);
-                        --i;
-                        continue;
-                    }
-
-                    for (var n = 0; n < state.totalMapCount; ++n)
-                        state.maps[n].ResolveBindingsIfNecessary();
-                }
-            }
-            finally
-            {
-                --InputActionMap.s_DeferBindingResolution;
-            }
-        }
-
         internal static void DisableAllActions()
         {
             for (var i = 0; i < s_GlobalState.globalList.length; ++i)

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

@@ -64,6 +64,9 @@ public static InputManager CreateAndInitialize(IInputRuntime runtime, InputSetti
         {
             var newInst = new InputManager();
 
+            // Not directly used by InputManager, but we need  a single instance that's used in a variety of places without a static field
+            newInst.m_DeferBindingResolutionContext = new DeferBindingResolutionContext();
+
             // If settings object wasn't provided, create a temporary settings object for now
             if (settings == null)
             {
@@ -2069,6 +2072,25 @@ internal void UninstallGlobals()
             }
         }
 
+        /// <summary>
+        /// Acquires a temporary "lock" to suspend immediate re-resolution of bindings.
+        /// </summary>
+        /// <remarks>
+        /// When changing control setups, it may take multiple steps to get to the final setup but each individual
+        /// step may trigger bindings to be resolved again in order to update controls on actions (see <see cref="InputAction.controls"/>).
+        /// Using Acquire/Release semantics via the returned context object, binding resolution can be deferred until the entire operation
+        /// is complete and the final binding setup is in place.
+        /// 
+        /// NOTE: Returned DeferBindingResolutionContext object is used globally for all ActionMaps.
+        /// </remarks>
+        internal DeferBindingResolutionContext DeferBindingResolution()
+        {
+            m_DeferBindingResolutionContext.Acquire();
+            return m_DeferBindingResolutionContext;
+        }
+
+        internal bool areDeferredBindingsToResolve => m_DeferBindingResolutionContext.deferredCount > 0;
+
         [Serializable]
         internal struct AvailableDevice
         {
@@ -2158,6 +2180,8 @@ internal struct AvailableDevice
         internal IInputDiagnostics m_Diagnostics;
         #endif
 
+        private DeferBindingResolutionContext m_DeferBindingResolutionContext;
+
         ////REVIEW: Make it so that device names *always* have a number appended? (i.e. Gamepad1, Gamepad2, etc. instead of Gamepad, Gamepad1, etc)
 
         private void MakeDeviceNameUnique(InputDevice device)