FIX: ISXB-704 scroll wheel support windows raw input value (#1946)

* Fixed ISXB-766, ISXB-808, ISXB-704, conditional to trunk PR #49932.

* Updated for latest trunk PR changes (5f81a20).

* Reverted fix for ISXB-808 and partly ISXB-766. Kept ISBX-704 fix.

* Added scroll wheel normalization tests for UI and InputForUI.

* Recommended changes from @ekcoh. Added more #if UNITY_6000_0_OR_NEWER.

* Added missing #if UNITY_6000_0_OR_NEWER in InputForUITests

* Added changes to CHANGELOG.md

* Improved Scroll Wheel Delta UI tooltip text

* Improved API docs for ScrollDeltaBehavior

* fixed bad xml tag

* Replaced UNITY_6000_0_OR_NEWER by asmdef versionDefines >= 6000.0.9

* Fixed missed #if replacement in UITests.

* formatting

---------

Co-authored-by: Ben Pitt <benp@unity3d.com>

Author: benoitalain

Assets/Tests/InputSystem/Plugins/InputForUITests.cs

@@ -7,6 +7,7 @@
 using UnityEngine.InputForUI;
 using UnityEngine.InputSystem;
 using UnityEngine.InputSystem.Controls;
+using UnityEngine.InputSystem.LowLevel;
 #if UNITY_EDITOR
 using UnityEditor;
 using UnityEngine.InputSystem.Editor;
@@ -462,6 +463,8 @@ public void UIActionClick_FiresUIClickEvents_FromInputsMousePenAndTouch(bool use
         Assert.AreEqual(10, m_InputForUIEvents.Count);
     }
 
+    const float kScrollUGUIScaleFactor = 3.0f; // See InputSystemProvider OnScrollWheelPerformed() callback
+
     [Test]
     [Category(kTestCategory)]
     [TestCase(true)]
@@ -475,7 +478,6 @@ public void UIActionScroll_FiresUIScrollEvents_FromInputMouse(bool useProjectWid
         }
         Update();
 
-        var kScrollUGUIScaleFactor = 3.0f; // See InputSystemProvider OnScrollWheelPerformed() callback
         var mouse = InputSystem.AddDevice<Mouse>();
         Update();
         // Make the minimum step of scroll delta to be ±1.0f
@@ -489,6 +491,31 @@ public void UIActionScroll_FiresUIScrollEvents_FromInputMouse(bool useProjectWid
         });
     }
 
+#if UNITY_INPUT_SYSTEM_PLATFORM_SCROLL_DELTA
+    [Category(kTestCategory)]
+    [TestCase(1.0f)]
+    [TestCase(120.0f)]
+    public void UIActionScroll_ReceivesNormalizedScrollWheelDelta(float scrollWheelDeltaPerTick)
+    {
+        var mouse = InputSystem.AddDevice<Mouse>();
+        Update();
+
+        // Set scroll delta with a custom range.
+        ((InputTestRuntime)InputRuntime.s_Instance).scrollWheelDeltaPerTick = scrollWheelDeltaPerTick;
+        Set(mouse.scroll, new Vector2(0, scrollWheelDeltaPerTick));
+        Update();
+
+        // UI should receive scroll delta in its expected range.
+        Assert.AreEqual(1, m_InputForUIEvents.Count);
+        Assert.That(GetNextRecordedUIEvent() is
+        {
+            type: Event.Type.PointerEvent,
+            asPointerEvent: { type: PointerEvent.Type.Scroll, eventSource: EventSource.Mouse, scroll: {x: 0, y: -kScrollUGUIScaleFactor} }
+        });
+    }
+
+#endif
+
     #endregion
 
 #if UNITY_EDITOR

Assets/Tests/InputSystem/Plugins/UITests.cs

@@ -1037,7 +1037,7 @@ public IEnumerator UI_CanDriveUIFromPointer(string deviceLayout, UIPointerType p
             Assert.That(scene.rightChildReceiver.events[0].pointerData.pointerId, Is.EqualTo(pointerId));
             Assert.That(scene.rightChildReceiver.events[0].pointerData.position, Is.EqualTo(thirdScreenPosition).Using(Vector2EqualityComparer.Instance));
             Assert.That(scene.rightChildReceiver.events[0].pointerData.delta, Is.EqualTo(Vector2.zero));
-            Assert.That(scene.rightChildReceiver.events[0].pointerData.scrollDelta, Is.EqualTo(Vector2.one * (1 / InputSystemUIInputModule.kPixelPerLine)).Using(Vector2EqualityComparer.Instance));
+            Assert.That(scene.rightChildReceiver.events[0].pointerData.scrollDelta, Is.EqualTo(Vector2.one).Using(Vector2EqualityComparer.Instance));
             Assert.That(scene.rightChildReceiver.events[0].pointerData.pointerEnter, Is.SameAs(scene.rightGameObject));
             Assert.That(scene.rightChildReceiver.events[0].pointerData.pointerDrag, Is.Null);
             Assert.That(scene.rightChildReceiver.events[0].pointerData.pointerPress, Is.Null);
@@ -1174,6 +1174,45 @@ public IEnumerator UI_CanReceivePointerExitsWhenChangingUIStateWithoutMovingPoin
         );
     }
 
+#if UNITY_INPUT_SYSTEM_PLATFORM_SCROLL_DELTA
+    [UnityTest]
+    [Category("UI")]
+    [TestCase(1.0f, ExpectedResult = -1)]
+    [TestCase(120.0f, ExpectedResult = -1)]
+    public IEnumerator UI_ReceivesNormalizedScrollWheelDelta(float scrollWheelDeltaPerTick)
+    {
+        var mouse = InputSystem.AddDevice<Mouse>();
+        var scene = CreateTestUI();
+        var actions = new DefaultInputActions();
+        scene.uiModule.point = InputActionReference.Create(actions.UI.Point);
+        scene.uiModule.scrollWheel = InputActionReference.Create(actions.UI.ScrollWheel);
+
+        Set(mouse.position, scene.From640x480ToScreen(100, 100));
+        Set(mouse.scroll, Vector2.zero);
+
+        yield return null;
+
+        Assert.That(scene.eventSystem.IsPointerOverGameObject(), Is.True);
+
+        scene.leftChildReceiver.events.Clear();
+
+        // Set scroll delta with a custom range.
+        ((InputTestRuntime)InputRuntime.s_Instance).scrollWheelDeltaPerTick = scrollWheelDeltaPerTick;
+        Set(mouse.scroll, new Vector2(0, scrollWheelDeltaPerTick));
+        yield return null;
+
+        // UI should receive scroll delta in the [-1, 1] range.
+        Assert.That(scene.leftChildReceiver.events,
+            EventSequence(
+                OneEvent("type", EventType.Scroll),
+                AllEvents("position", scene.From640x480ToScreen(100, 100)),
+                AllEvents("scrollDelta", Vector2.up)
+            )
+        );
+    }
+
+#endif
+
     [UnityTest]
     [Category("UI")]
     [TestCase(UIPointerBehavior.SingleUnifiedPointer, ExpectedResult = -1)]

Assets/Tests/InputSystem/Unity.InputSystem.Tests.asmdef

@@ -45,6 +45,11 @@
             "name": "Unity",
             "expression": "2022.3",
             "define": "UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS"
+        },
+        {
+            "name": "Unity",
+            "expression": "6000.0.9",
+            "define": "UNITY_INPUT_SYSTEM_PLATFORM_SCROLL_DELTA"
         }
     ],
     "noEngineReferences": false

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -10,9 +10,10 @@ however, it has to be formatted properly to pass verification tests.
 
 ## [Unreleased] - yyyy-mm-dd
 
-### Change
+### Changed
 - Added warning messages to both `OnScreenStick` and `OnScreenButton` Inspector editors that would display a warning message in case on-screen control components are added to a `GameObject` not part of a valid UI hierarchy.
 - Changed behavior for internal feature flag relating to Windows Gaming Input to be ignored on non-supported platforms.
+- Changed `DualSenseHIDInputReport` from internal to public visibility
 
 ### Fixed
 - Avoid potential crashes from `NullReferenceException` in `FireStateChangeNotifications`.
@@ -23,6 +24,7 @@ however, it has to be formatted properly to pass verification tests.
 - Fixed error thrown when Cancelling Control Scheme creation in Input Actions Editor.
 - Fixed Scheme Name in Control Scheme editor menu that gets reset when editing devices [ISXB-763](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-763).
 - Fixed an issue where `InputActionAsset.FindAction(string, bool)` would throw `System.NullReferenceException` instead of returning `null` if searching for a non-existent action with an explicit action path and using `throwIfNotFound: false`, e.g. searching for "Map/Action" when `InputActionMap` "Map" exists but no `InputAction` named "Action" exists within that map [ISXB-895](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-895).
+- Fixed scroll speed being slower when using InputSystemUIInputModule instead of StandaloneInputModule. (https://jira.unity3d.com/browse/ISXB-771)
 - Fixed an issue where adding a `OnScreenButton` or `OnScreenStick` to a regular GameObject would lead to exception in editor.
 - Fixed an issue where adding a `OnScreenStick` to a regular GameObject and entering play-mode would lead to exceptions being generated.
 - Fixed InputActionReference issues when domain reloads are disabled [ISXB-601](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-601), [ISXB-718](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-718), [ISXB-900](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-900)
@@ -32,16 +34,13 @@ however, it has to be formatted properly to pass verification tests.
 - Submit and Cancel UI actions will now respect configured interactions. [ISXB-841](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-841).
 - Fixed the UI generation of enum fields when editing interactions of action properties. The new selected value was lost when saving.
 - Fixed the UI generation of custom interactions of action properties when it rely on OnGUI callback. [ISXB-886](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-886).
-
+- Fixed deletion of last composite part raising an exception. [ISXB-804](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-804)
 
 ### Added
 - Added additional device information when logging the error due to exceeding the maximum number of events processed
   set by `InputSystem.settings.maxEventsBytesPerUpdate`. This additional information is available in development builds
   only.
-- Fixed deletion of last composite part raising an exception. [ISXB-804](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-804)
-
-### Changed
-- Changed `DualSenseHIDInputReport` from internal to public visibility
+- Added Input Setting option allowing to keep platform-specific scroll wheel input values instead of automatically converting them to a normalized range.
 
 ## [1.8.2] - 2024-04-29
 

Packages/com.unity.inputsystem/InputSystem/Editor/Settings/InputSettingsProvider.cs

@@ -122,6 +122,10 @@ public override void OnGUI(string searchContext)
                 if (!runInBackground)
                     EditorGUILayout.HelpBox("Focus change behavior can only be changed if 'Run In Background' is enabled in Player Settings.", MessageType.Info);
 
+#if UNITY_INPUT_SYSTEM_PLATFORM_SCROLL_DELTA
+                EditorGUILayout.PropertyField(m_ScrollDeltaBehavior, m_ScrollDeltaBehaviorContent);
+#endif
+
                 EditorGUILayout.Space();
                 EditorGUILayout.PropertyField(m_CompensateForScreenOrientation, m_CompensateForScreenOrientationContent);
 
@@ -266,6 +270,7 @@ private void InitializeWithCurrentSettings()
             // Look up properties.
             m_SettingsObject = new SerializedObject(m_Settings);
             m_UpdateMode = m_SettingsObject.FindProperty("m_UpdateMode");
+            m_ScrollDeltaBehavior = m_SettingsObject.FindProperty("m_ScrollDeltaBehavior");
             m_CompensateForScreenOrientation = m_SettingsObject.FindProperty("m_CompensateForScreenOrientation");
             m_BackgroundBehavior = m_SettingsObject.FindProperty("m_BackgroundBehavior");
             m_EditorInputBehaviorInPlayMode = m_SettingsObject.FindProperty("m_EditorInputBehaviorInPlayMode");
@@ -281,6 +286,9 @@ private void InitializeWithCurrentSettings()
             m_ShortcutKeysConsumeInputs = m_SettingsObject.FindProperty("m_ShortcutKeysConsumeInputs");
 
             m_UpdateModeContent = new GUIContent("Update Mode", "When should the Input System be updated?");
+#if UNITY_INPUT_SYSTEM_PLATFORM_SCROLL_DELTA
+            m_ScrollDeltaBehaviorContent = new GUIContent("Scroll Delta Behavior", "Controls whether the value returned by the Scroll Wheel Delta is normalized (to be uniform across all platforms), or returns the non-normalized platform-specific range which can vary between platforms.");
+#endif
             m_CompensateForScreenOrientationContent = new GUIContent("Compensate Orientation", "Whether sensor input on mobile devices should be transformed to be relative to the current device orientation.");
             m_BackgroundBehaviorContent = new GUIContent("Background Behavior", "If runInBackground is true (and in standalone *development* players and the editor), "
                 + "determines what happens to InputDevices and events when the application moves in and out of running in the foreground.\n\n"
@@ -404,6 +412,7 @@ private static string[] FindInputSettingsInProject()
         [NonSerialized] private int m_SettingsDirtyCount;
         [NonSerialized] private SerializedObject m_SettingsObject;
         [NonSerialized] private SerializedProperty m_UpdateMode;
+        [NonSerialized] private SerializedProperty m_ScrollDeltaBehavior;
         [NonSerialized] private SerializedProperty m_CompensateForScreenOrientation;
         [NonSerialized] private SerializedProperty m_BackgroundBehavior;
         [NonSerialized] private SerializedProperty m_EditorInputBehaviorInPlayMode;
@@ -427,6 +436,9 @@ private static string[] FindInputSettingsInProject()
         [NonSerialized] private GUIStyle m_NewAssetButtonStyle;
 
         private GUIContent m_UpdateModeContent;
+#if UNITY_INPUT_SYSTEM_PLATFORM_SCROLL_DELTA
+        private GUIContent m_ScrollDeltaBehaviorContent;
+#endif
         private GUIContent m_CompensateForScreenOrientationContent;
         private GUIContent m_BackgroundBehaviorContent;
         private GUIContent m_EditorInputBehaviorInPlayModeContent;

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

@@ -175,6 +175,11 @@ internal unsafe interface IInputRuntime
         Vector2 screenSize { get; }
         ScreenOrientation screenOrientation { get; }
 
+#if UNITY_INPUT_SYSTEM_PLATFORM_SCROLL_DELTA
+        bool normalizeScrollWheelDelta { get; set; }
+        float scrollWheelDeltaPerTick { get; }
+#endif
+
         // If analytics are enabled, the runtime receives analytics events from the input manager.
         // See InputAnalytics.
         #if UNITY_ANALYTICS || UNITY_EDITOR

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

@@ -161,6 +161,23 @@ public InputUpdateType defaultUpdateType
             }
         }
 
+        public InputSettings.ScrollDeltaBehavior scrollDeltaBehavior
+        {
+            get => m_ScrollDeltaBehavior;
+            set
+            {
+                if (m_ScrollDeltaBehavior == value)
+                    return;
+
+                m_ScrollDeltaBehavior = value;
+
+#if UNITY_INPUT_SYSTEM_PLATFORM_SCROLL_DELTA
+                InputRuntime.s_Instance.normalizeScrollWheelDelta =
+                    m_ScrollDeltaBehavior == InputSettings.ScrollDeltaBehavior.UniformAcrossAllPlatforms;
+#endif
+            }
+        }
+
         public float pollingFrequency
         {
             get => m_PollingFrequency;
@@ -1853,6 +1870,8 @@ internal void InitializeData()
             m_UpdateMask |= InputUpdateType.Editor;
 #endif
 
+            m_ScrollDeltaBehavior = InputSettings.ScrollDeltaBehavior.UniformAcrossAllPlatforms;
+
             // Default polling frequency is 60 Hz.
             m_PollingFrequency = 60;
 
@@ -2069,6 +2088,8 @@ internal struct AvailableDevice
         private InputUpdateType m_CurrentUpdate;
         internal InputStateBuffers m_StateBuffers;
 
+        private InputSettings.ScrollDeltaBehavior m_ScrollDeltaBehavior;
+
         #if UNITY_EDITOR
         // remember time offset to correctly restore it after editor mode is done
         private double latestNonEditorTimeOffsetToRealtimeSinceStartup;
@@ -2625,6 +2646,8 @@ internal void ApplySettings()
             #endif
             updateMask = newUpdateMask;
 
+            scrollDeltaBehavior = m_Settings.scrollDeltaBehavior;
+
             ////TODO: optimize this so that we don't repeatedly recreate state if we add/remove multiple devices
             ////      (same goes for not resolving actions repeatedly)
 
@@ -3879,6 +3902,7 @@ internal struct SerializedState
             public InputStateBuffers buffers;
             public InputUpdate.SerializedState updateState;
             public InputUpdateType updateMask;
+            public InputSettings.ScrollDeltaBehavior scrollDeltaBehavior;
             public InputMetrics metrics;
             public InputSettings settings;
             public InputActionAsset actions;
@@ -3923,6 +3947,7 @@ internal SerializedState SaveState()
                 buffers = m_StateBuffers,
                 updateState = InputUpdate.Save(),
                 updateMask = m_UpdateMask,
+                scrollDeltaBehavior = m_ScrollDeltaBehavior,
                 metrics = m_Metrics,
                 settings = m_Settings,
                 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
@@ -3940,6 +3965,7 @@ internal void RestoreStateWithoutDevices(SerializedState state)
             m_StateBuffers = state.buffers;
             m_LayoutRegistrationVersion = state.layoutRegistrationVersion + 1;
             updateMask = state.updateMask;
+            scrollDeltaBehavior = state.scrollDeltaBehavior;
             m_Metrics = state.metrics;
             m_PollingFrequency = state.pollingFrequency;
 

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

@@ -84,6 +84,28 @@ public UpdateMode updateMode
             }
         }
 
+        /// <summary>
+        /// Controls how platform-specific input should be converted when returning delta values for scroll wheel input actions.
+        /// </summary>
+        /// <value>The conversion behavior.</value>
+        /// <remarks>
+        /// By default, the range used for the delta is normalized to a range of -1 to 1, to be uniform across all platforms.
+        /// The alternative is that the native platform's scroll wheel range is returned, which is -120 to 120 for windows, and
+        /// -1 to 1 for most other platforms. You should leave this value as the default uniform range unless you need to support
+        /// legacy code that relies on the native platform-specific values.
+        /// </remarks>
+        public ScrollDeltaBehavior scrollDeltaBehavior
+        {
+            get => m_ScrollDeltaBehavior;
+            set
+            {
+                if (m_ScrollDeltaBehavior == value)
+                    return;
+                m_ScrollDeltaBehavior = value;
+                OnChange();
+            }
+        }
+
         /// <summary>
         /// If true, sensors that deliver rotation values on handheld devices will automatically adjust
         /// rotations when the screen orientation changes.
@@ -734,6 +756,7 @@ public void SetInternalFeatureFlag(string featureName, bool enabled)
         [Tooltip("Determine when Unity processes events. By default, accumulated input events are flushed out before each fixed update and "
             + "before each dynamic update. This setting can be used to restrict event processing to only where the application needs it.")]
         [SerializeField] private UpdateMode m_UpdateMode = UpdateMode.ProcessEventsInDynamicUpdate;
+        [SerializeField] private ScrollDeltaBehavior m_ScrollDeltaBehavior = ScrollDeltaBehavior.UniformAcrossAllPlatforms;
         [SerializeField] private int m_MaxEventBytesPerUpdate = 5 * 1024 * 1024;
         [SerializeField] private int m_MaxQueuedEventsPerUpdate = 1000;
 
@@ -826,6 +849,29 @@ public enum UpdateMode
             ProcessEventsManually,
         }
 
+        /// <summary>
+        /// How platform-specific input should be converted when returning delta values for scroll wheel input actions.
+        /// </summary>
+        public enum ScrollDeltaBehavior
+        {
+            /// <summary>
+            /// The range used for the delta is converted to be uniform across all platforms.
+            /// </summary>
+            /// <remarks>
+            /// The resulting range will be [-1, 1] regardless of the platform used.
+            /// </remarks>
+            UniformAcrossAllPlatforms = 0,
+
+            /// <summary>
+            /// The range used for the delta is the same as returned by the platform input.
+            /// </summary>
+            /// <remarks>
+            /// The range will typically be [-120, 120] on Windows and [-1, 1] on MacOS and Linux.
+            /// Other platforms may have different ranges.
+            /// </remarks>
+            KeepPlatformSpecificInputRange = 1
+        }
+
         /// <summary>
         /// Determines how the applications behaves when running in the background. See <see cref="backgroundBehavior"/>.
         /// </summary>

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

@@ -3423,6 +3423,12 @@ public static bool runInBackground
             set => s_Manager.m_Runtime.runInBackground = value;
         }
 
+#if UNITY_INPUT_SYSTEM_PLATFORM_SCROLL_DELTA
+        internal static float scrollWheelDeltaPerTick => InputRuntime.s_Instance.scrollWheelDeltaPerTick;
+#else
+        internal const float scrollWheelDeltaPerTick = 1.0f;
+#endif
+
         ////REVIEW: restrict metrics to editor and development builds?
         /// <summary>
         /// Get various up-to-date metrics about the input system.

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

@@ -281,6 +281,19 @@ private void OnFocusChanged(bool focus)
         public Vector2 screenSize => new Vector2(Screen.width, Screen.height);
         public ScreenOrientation screenOrientation => Screen.orientation;
 
+#if UNITY_INPUT_SYSTEM_PLATFORM_SCROLL_DELTA
+        public bool normalizeScrollWheelDelta
+        {
+            get => NativeInputSystem.normalizeScrollWheelDelta;
+            set => NativeInputSystem.normalizeScrollWheelDelta = value;
+        }
+
+        public float scrollWheelDeltaPerTick
+        {
+            get => NativeInputSystem.GetScrollWheelDeltaPerTick();
+        }
+#endif
+
         public bool isInBatchMode => Application.isBatchMode;
 
         #if UNITY_EDITOR