reduce allocations when applying input overrides

Pathoschild · Pathoschild · commit 3474f49c8cc2 · 2026-03-24T00:07:36.000-04:00
diff --git a/src/SMAPI/Framework/Input/GamePadStateBuilder.cs b/src/SMAPI/Framework/Input/GamePadStateBuilder.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Input;
@@ -21,7 +22,7 @@ internal class GamePadStateBuilder : IInputStateBuilder<GamePadStateBuilder, Gam
     private GamePadState? State;
 
     /// <summary>The current button states.</summary>
-    private readonly Dictionary<SButton, ButtonState> ButtonStates = [];
+    private readonly Dictionary<Buttons, ButtonState> ButtonStates = [];
 
     /// <summary>The left trigger value.</summary>
     private float LeftTrigger;
@@ -53,21 +54,21 @@ public void Reset(GamePadState state)
 
             var states = this.ButtonStates;
             states.Clear();
-            states[SButton.DPadUp] = pad.Up;
-            states[SButton.DPadDown] = pad.Down;
-            states[SButton.DPadLeft] = pad.Left;
-            states[SButton.DPadRight] = pad.Right;
-            states[SButton.ControllerA] = buttons.A;
-            states[SButton.ControllerB] = buttons.B;
-            states[SButton.ControllerX] = buttons.X;
-            states[SButton.ControllerY] = buttons.Y;
-            states[SButton.LeftStick] = buttons.LeftStick;
-            states[SButton.RightStick] = buttons.RightStick;
-            states[SButton.LeftShoulder] = buttons.LeftShoulder;
-            states[SButton.RightShoulder] = buttons.RightShoulder;
-            states[SButton.ControllerBack] = buttons.Back;
-            states[SButton.ControllerStart] = buttons.Start;
-            states[SButton.BigButton] = buttons.BigButton;
+            states[Buttons.DPadUp] = pad.Up;
+            states[Buttons.DPadDown] = pad.Down;
+            states[Buttons.DPadLeft] = pad.Left;
+            states[Buttons.DPadRight] = pad.Right;
+            states[Buttons.A] = buttons.A;
+            states[Buttons.B] = buttons.B;
+            states[Buttons.X] = buttons.X;
+            states[Buttons.Y] = buttons.Y;
+            states[Buttons.LeftStick] = buttons.LeftStick;
+            states[Buttons.RightStick] = buttons.RightStick;
+            states[Buttons.LeftShoulder] = buttons.LeftShoulder;
+            states[Buttons.RightShoulder] = buttons.RightShoulder;
+            states[Buttons.Back] = buttons.Back;
+            states[Buttons.Start] = buttons.Start;
+            states[Buttons.BigButton] = buttons.BigButton;
 
             this.LeftTrigger = triggers.Left;
             this.RightTrigger = triggers.Right;
@@ -85,63 +86,81 @@ public void Reset(GamePadState state)
         }
     }
 
-    /// <inheritdoc />
-    public GamePadStateBuilder OverrideButtons(IDictionary<SButton, SButtonState> overrides)
+    /// <summary>Override the state for a button.</summary>
+    /// <param name="button">The button to override.</param>
+    /// <param name="state">The new state to set.</param>
+    public void OverrideButton(Buttons button, SButtonState state)
     {
-        foreach (var pair in overrides)
+        bool isDown = state.IsDown();
+        bool changed = false;
+
+        switch (button)
         {
-            bool changed = true;
+            // left thumbstick
+            case Buttons.LeftThumbstickUp:
+                changed = Set(ref this.LeftStickPos.Y, isDown ? 1 : 0);
+                break;
+            case Buttons.LeftThumbstickDown:
+                changed = Set(ref this.LeftStickPos.Y, isDown ? -1 : 0);
+                break;
+            case Buttons.LeftThumbstickLeft:
+                changed = Set(ref this.LeftStickPos.X, isDown ? -1 : 0);
+                break;
+            case Buttons.LeftThumbstickRight:
+                changed = Set(ref this.LeftStickPos.X, isDown ? 1 : 0);
+                break;
+
+            // right thumbstick
+            case Buttons.RightThumbstickUp:
+                changed = Set(ref this.RightStickPos.Y, isDown ? 1 : 0);
+                break;
+            case Buttons.RightThumbstickDown:
+                changed = Set(ref this.RightStickPos.Y, isDown ? -1 : 0);
+                break;
+            case Buttons.RightThumbstickLeft:
+                changed = Set(ref this.RightStickPos.X, isDown ? -1 : 0);
+                break;
+            case Buttons.RightThumbstickRight:
+                changed = Set(ref this.RightStickPos.X, isDown ? 1 : 0);
+                break;
+
+            // triggers
+            case Buttons.LeftTrigger:
+                changed = Set(ref this.LeftTrigger, isDown ? 1 : 0);
+                break;
+            case Buttons.RightTrigger:
+                changed = Set(ref this.RightTrigger, isDown ? 1 : 0);
+                break;
+
+            // buttons
+            default:
+                {
+                    ButtonState newState = isDown ? ButtonState.Pressed : ButtonState.Released;
+
+                    if (!this.ButtonStates.TryGetValue(button, out ButtonState oldState) || newState != oldState)
+                    {
+                        this.ButtonStates[button] = newState;
+                        changed = true;
+                    }
+                }
+                break;
+        }
 
-            bool isDown = pair.Value.IsDown();
-            switch (pair.Key)
+        if (changed)
+            this.State = null;
+        return;
+
+        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator", Justification = "Floating points not an issue for the specific values we're checking.")]
+        static bool Set(ref float field, int newValue)
+        {
+            if (field != newValue)
             {
-                // left thumbstick
-                case SButton.LeftThumbstickUp:
-                    this.LeftStickPos.Y = isDown ? 1 : 0;
-                    break;
-                case SButton.LeftThumbstickDown:
-                    this.LeftStickPos.Y = isDown ? -1 : 0;
-                    break;
-                case SButton.LeftThumbstickLeft:
-                    this.LeftStickPos.X = isDown ? -1 : 0;
-                    break;
-                case SButton.LeftThumbstickRight:
-                    this.LeftStickPos.X = isDown ? 1 : 0;
-                    break;
-
-                // right thumbstick
-                case SButton.RightThumbstickUp:
-                    this.RightStickPos.Y = isDown ? 1 : 0;
-                    break;
-                case SButton.RightThumbstickDown:
-                    this.RightStickPos.Y = isDown ? -1 : 0;
-                    break;
-                case SButton.RightThumbstickLeft:
-                    this.RightStickPos.X = isDown ? -1 : 0;
-                    break;
-                case SButton.RightThumbstickRight:
-                    this.RightStickPos.X = isDown ? 1 : 0;
-                    break;
-
-                // triggers
-                case SButton.LeftTrigger:
-                    this.LeftTrigger = isDown ? 1 : 0;
-                    break;
-                case SButton.RightTrigger:
-                    this.RightTrigger = isDown ? 1 : 0;
-                    break;
-
-                // buttons
-                default:
-                    this.ButtonStates[pair.Key] = isDown ? ButtonState.Pressed : ButtonState.Released;
-                    break;
+                field = newValue;
+                return true;
             }
 
-            if (changed)
-                this.State = null;
+            return false;
         }
-
-        return this;
     }
 
     /// <inheritdoc />
@@ -200,9 +219,9 @@ public GamePadState GetState()
     /// <summary>Get the pressed gamepad buttons.</summary>
     private IEnumerable<Buttons> GetPressedGamePadButtons()
     {
-        foreach (var pair in this.ButtonStates)
+        foreach ((Buttons button, ButtonState state) in this.ButtonStates)
         {
-            if (pair.Value == ButtonState.Pressed && pair.Key.TryGetController(out Buttons button))
+            if (state == ButtonState.Pressed)
                 yield return button;
         }
     }
diff --git a/src/SMAPI/Framework/Input/IInputStateBuilder.cs b/src/SMAPI/Framework/Input/IInputStateBuilder.cs
@@ -16,10 +16,6 @@ internal interface IInputStateBuilder<out THandler, TState>
     /// <param name="state">The initial state before any overrides are applied.</param>
     void Reset(TState state);
 
-    /// <summary>Override the states for a set of buttons.</summary>
-    /// <param name="overrides">The button state overrides.</param>
-    THandler OverrideButtons(IDictionary<SButton, SButtonState> overrides);
-
     /// <summary>Fill a set with the currently pressed buttons.</summary>
     /// <param name="set">The set to populate with the pressed buttons.</param>
     void FillPressedButtons(HashSet<SButton> set);
diff --git a/src/SMAPI/Framework/Input/KeyboardStateBuilder.cs b/src/SMAPI/Framework/Input/KeyboardStateBuilder.cs
@@ -30,23 +30,17 @@ public void Reset(KeyboardState state)
             this.PressedButtons.Add(button);
     }
 
-    /// <inheritdoc />
-    public KeyboardStateBuilder OverrideButtons(IDictionary<SButton, SButtonState> overrides)
+    /// <summary>Override the state for a key.</summary>
+    /// <param name="key">The key to override.</param>
+    /// <param name="state">The new state to set.</param>
+    public void OverrideButton(Keys key, SButtonState state)
     {
-        foreach (var pair in overrides)
-        {
-            if (pair.Key.TryGetKeyboard(out Keys key))
-            {
-                this.State = null;
-
-                if (pair.Value.IsDown())
-                    this.PressedButtons.Add(key);
-                else
-                    this.PressedButtons.Remove(key);
-            }
-        }
+        bool changed = state.IsDown()
+            ? this.PressedButtons.Add(key)
+            : this.PressedButtons.Remove(key);
 
-        return this;
+        if (changed)
+            this.State = null;
     }
 
     /// <inheritdoc />
diff --git a/src/SMAPI/Framework/Input/MouseStateBuilder.cs b/src/SMAPI/Framework/Input/MouseStateBuilder.cs
@@ -50,19 +50,20 @@ public void Reset(MouseState state)
         this.ScrollWheelValue = state.ScrollWheelValue;
     }
 
-    /// <inheritdoc />
-    public MouseStateBuilder OverrideButtons(IDictionary<SButton, SButtonState> overrides)
+    /// <summary>Override the state for a button.</summary>
+    /// <param name="button">The button to override.</param>
+    /// <param name="state">The new state to set.</param>
+    public void OverrideButton(SButton button, SButtonState state)
     {
-        foreach (var pair in overrides)
+        ButtonState newState = state.IsDown()
+            ? ButtonState.Pressed
+            : ButtonState.Released;
+
+        if (this.ButtonStates.TryGetValue(button, out ButtonState oldState) && oldState != newState)
         {
-            if (this.ButtonStates.ContainsKey(pair.Key))
-            {
-                this.State = null;
-                this.ButtonStates[pair.Key] = pair.Value.IsDown() ? ButtonState.Pressed : ButtonState.Released;
-            }
+            this.State = null;
+            this.ButtonStates[button] = newState;
         }
-
-        return this;
     }
 
     /// <inheritdoc />
diff --git a/src/SMAPI/Framework/Input/SInputState.cs b/src/SMAPI/Framework/Input/SInputState.cs
@@ -251,34 +251,24 @@ private bool ApplyOverrides(ISet<SButton> pressed, ISet<SButton> released, GameP
         if (pressed.Count == 0 && released.Count == 0)
             return false;
 
-        // group keys by type
-        IDictionary<SButton, SButtonState> keyboardOverrides = new Dictionary<SButton, SButtonState>();
-        IDictionary<SButton, SButtonState> controllerOverrides = new Dictionary<SButton, SButtonState>();
-        IDictionary<SButton, SButtonState> mouseOverrides = new Dictionary<SButton, SButtonState>();
-        foreach (SButton button in pressed.Concat(released))
+        foreach (SButton button in pressed)
+            Apply(button, this.GetState(button), isDown: true, controller, keyboard, mouse);
+        foreach (SButton button in released)
+            Apply(button, this.GetState(button), isDown: pressed.Contains(button), controller, keyboard, mouse);
+
+        return true;
+
+        static void Apply(SButton button, SButtonState oldState, bool isDown, GamePadStateBuilder controller, KeyboardStateBuilder keyboard, MouseStateBuilder mouse)
         {
-            SButtonState newState = SInputState.DeriveState(
-                oldState: this.GetState(button),
-                isDown: pressed.Contains(button)
-            );
+            SButtonState newState = SInputState.DeriveState(oldState, isDown);
 
             if (button is SButton.MouseLeft or SButton.MouseMiddle or SButton.MouseRight or SButton.MouseX1 or SButton.MouseX2)
-                mouseOverrides[button] = newState;
-            else if (button.TryGetKeyboard(out Keys _))
-                keyboardOverrides[button] = newState;
-            else if (button.TryGetController(out Buttons _))
-                controllerOverrides[button] = newState;
+                mouse.OverrideButton(button, newState);
+            else if (button.TryGetKeyboard(out Keys key))
+                keyboard.OverrideButton(key, newState);
+            else if (button.TryGetController(out Buttons controllerButton))
+                controller.OverrideButton(controllerButton, newState);
         }
-
-        // override states
-        if (keyboardOverrides.Count > 0)
-            keyboard.OverrideButtons(keyboardOverrides);
-        if (controllerOverrides.Count > 0)
-            controller.OverrideButtons(controllerOverrides);
-        if (mouseOverrides.Count > 0)
-            mouse.OverrideButtons(mouseOverrides);
-
-        return true;
     }
 
     /// <summary>Update active button states based on the currently pressed buttons.</summary>

Original file line number	Diff line number	Diff line change
`@@ -50,19 +50,20 @@ public void Reset(MouseState state)`
`50`	`50`	`this.ScrollWheelValue = state.ScrollWheelValue;`
`51`	`51`	`}`
`52`	`52`
`53`		`- /// <inheritdoc />`
`54`		`- public MouseStateBuilder OverrideButtons(IDictionary<SButton, SButtonState> overrides)`
	`53`	`+ /// <summary>Override the state for a button.</summary>`
	`54`	`+ /// <param name="button">The button to override.</param>`
	`55`	`+ /// <param name="state">The new state to set.</param>`
	`56`	`+ public void OverrideButton(SButton button, SButtonState state)`
`55`	`57`	`{`
`56`		`- foreach (var pair in overrides)`
	`58`	`+ ButtonState newState = state.IsDown()`
	`59`	`+ ? ButtonState.Pressed`
	`60`	`+ : ButtonState.Released;`
	`61`	`+`
	`62`	`+ if (this.ButtonStates.TryGetValue(button, out ButtonState oldState) && oldState != newState)`
`57`	`63`	`{`
`58`		`- if (this.ButtonStates.ContainsKey(pair.Key))`
`59`		`- {`
`60`		`- this.State = null;`
`61`		`- this.ButtonStates[pair.Key] = pair.Value.IsDown() ? ButtonState.Pressed : ButtonState.Released;`
`62`		`- }`
	`64`	`+ this.State = null;`
	`65`	`+ this.ButtonStates[button] = newState;`
`63`	`66`	`}`
`64`		`-`
`65`		`- return this;`
`66`	`67`	`}`
`67`	`68`
`68`	`69`	`/// <inheritdoc />`