Merge branch 'develop' into ekcoh/rebinding-issues-events

Author: ekcoh

Assets/Tests/InputSystem.Editor/CustomProcessorEnumTest.cs

@@ -0,0 +1,112 @@
+#if UNITY_EDITOR && UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS && UNITY_6000_0_OR_NEWER
+
+using System;
+using NUnit.Framework;
+using System.Collections;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.InputSystem;
+using UnityEngine.InputSystem.Editor;
+using UnityEngine.TestTools;
+using UnityEngine.UIElements;
+
+internal enum SomeEnum
+{
+    OptionA = 10,
+    OptionB = 20
+}
+
+#if UNITY_EDITOR
+[InitializeOnLoad]
+#endif
+internal class CustomProcessor : InputProcessor<float>
+{
+    public SomeEnum SomeEnum;
+
+#if UNITY_EDITOR
+    static CustomProcessor()
+    {
+        Initialize();
+    }
+
+#endif
+
+    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+    private static void Initialize()
+    {
+        InputSystem.RegisterProcessor<CustomProcessor>();
+    }
+
+    public override float Process(float value, InputControl control)
+    {
+        return value;
+    }
+}
+
+internal class CustomProcessorEnumTest : UIToolkitBaseTestWindow<InputActionsEditorWindow>
+{
+    InputActionAsset m_Asset;
+
+    public override void OneTimeSetUp()
+    {
+        base.OneTimeSetUp();
+        m_Asset = AssetDatabaseUtils.CreateAsset<InputActionAsset>();
+
+        var actionMap = m_Asset.AddActionMap("Action Map");
+
+        actionMap.AddAction("Action", InputActionType.Value, processors: "Custom(SomeEnum=10)");
+    }
+
+    public override void OneTimeTearDown()
+    {
+        AssetDatabaseUtils.Restore();
+        base.OneTimeTearDown();
+    }
+
+    public override IEnumerator UnitySetup()
+    {
+        m_Window = InputActionsEditorWindow.OpenEditor(m_Asset);
+        yield return null;
+    }
+
+    [UnityTest]
+    public IEnumerator ProcessorEnum_ShouldSerializeByValue_WhenSerializedToAsset()
+    {
+        // Serialize current asset to JSON, and check that initial JSON contains default enum value for OptionA
+        var json = m_Window.currentAssetInEditor.ToJson();
+
+        Assert.That(json.Contains("Custom(SomeEnum=10)"), Is.True,
+            "Serialized JSON does not contain the expected custom processor string for OptionA.");
+
+        // Query the dropdown with exactly two enum choices and check that the drop down is present in the UI
+        var dropdownList = m_Window.rootVisualElement.Query<DropdownField>().Where(d => d.choices.Count == 2).ToList();
+        Assume.That(dropdownList.Count > 0, Is.True, "Enum parameter dropdown not found in the UI.");
+
+        // Determine the new value to be set in the dropdown, focus the dropdown before dispatching the change
+        var dropdown = dropdownList.First();
+        var newValue = dropdown.choices[1];
+        dropdown.Focus();
+        dropdown.value = newValue;
+
+        // Create and send a change event from OptionA to OptionB
+        var changeEvent = ChangeEvent<Enum>.GetPooled(SomeEnum.OptionA, SomeEnum.OptionB);
+        changeEvent.target = dropdown;
+        dropdown.SendEvent(changeEvent);
+
+        // Find the save button in the window, focus and click the save button to persist the changes
+        var saveButton = m_Window.rootVisualElement.Q<Button>("save-asset-toolbar-button");
+        Assume.That(saveButton, Is.Not.Null, "Save Asset button not found in the UI.");
+        saveButton.Focus();
+        SimulateClickOn(saveButton);
+
+        Assert.That(dropdown.value, Is.EqualTo(newValue));
+
+        // Verify that the updated JSON contains the new enum value for OpitonB
+        var updatedJson = m_Window.currentAssetInEditor.ToJson();
+        Assert.That(updatedJson.Contains("Custom(SomeEnum=20)"), Is.True, "Serialized JSON does not contain the updated custom processor string for OptionB.");
+
+        yield return null;
+    }
+}
+#endif

Assets/Tests/InputSystem.Editor/CustomProcessorEnumTest.cs.meta

@@ -236,7 +236,7 @@ public void Report(string message)
         }
     }
 
-    [Test(Description = "Verifies that the default asset do not generate any verification errors (Regardless of existing requirements)")]
+    [Test(Description = "Verifies that the default asset does not generate any verification errors (Regardless of existing requirements)")]
     [Category(kTestCategory)]
     public void ProjectWideActions_ShouldSupportAssetVerification_AndHaveNoVerificationErrorsForDefaultAsset()
     {

Assets/Tests/InputSystem.Editor/ProjectWideInputActionsEditorTests.cs

@@ -5215,8 +5215,8 @@ public void Actions_CanConvertAssetToAndFromJson()
     static string MinimalJson(string name = null)
     {
         if (name != null)
-            return "{\n    \"name\": \"" + name + "\",\n    \"maps\": [],\n    \"controlSchemes\": []\n}";
-        return "{\n    \"maps\": [],\n    \"controlSchemes\": []\n}";
+            return "{\n    \"version\": 0,\n    \"name\": \"" + name + "\",\n    \"maps\": [],\n    \"controlSchemes\": []\n}";
+        return "{\n    \"version\": 0,\n    \"maps\": [],\n    \"controlSchemes\": []\n}";
     }
 
     [Test]

Assets/Tests/InputSystem/CoreTests_Actions.cs

@@ -157,6 +157,23 @@ public IEnumerator PointerExitChildShouldFullyExit()
             Assert.IsTrue(callbackCheck.pointerData.fullyExited == true);
         }
 
+        [UnityTest]
+        [Description("Regression test for https://jira.unity3d.com/browse/ISXB-1493")]
+        public IEnumerator DisablingDoesNotResetUserActions()
+        {
+            var actions = new DefaultInputActions();
+            m_InputModule.actionsAsset = actions.asset;
+            m_InputModule.cancel = InputActionReference.Create(actions.UI.Cancel);
+
+            m_InputModule.enabled = false;
+
+            yield return null;
+
+            Assert.IsNotNull(m_InputModule.cancel, "Disabling component shouldn't lose its data.");
+
+            actions.Dispose();
+        }
+
         public class PointerExitCallbackCheck : MonoBehaviour, IPointerExitHandler
         {
             public PointerEventData pointerData { get; private set; }

Assets/Tests/InputSystem/Plugins/UITests.InputModuleTests.cs

@@ -11,12 +11,13 @@ however, it has to be formatted properly to pass verification tests.
 ## [Unreleased] - yyyy-mm-dd
 
 ### Changed
-- Expanded `RebindingUISample` to include a "game mode" state and a "menu state" to be more similar to a real game. Also added action-performed indicators illustrating when actions get triggered.
+- Expanded `RebindingUISample` to include a "game mode" state and a "menu state" to be more similar to a real game. Also added action-performed indicators (`InputActionIndicator`) illustrating when actions get triggered.
 
 ### Added
 - Support for Xbox controllers over USB on macOS, using macOS's default driver. [ISXB-1548]
 - Added a new run-time setting `InputSystem.inputEventHandledPolicy` which allows changing how the system processes input events marked as "handled". The new alternative setting (not default) allows for allowing handled events to propagate into state changes but still suppresses action interactions from being processed.
 - Added a new fluent API `WithSuppressedActionPropagation()` to `UnityEngine.InputSystem.InputActionRebindingExtensions` that allows suppressing actions from firing during interactive rebinding while allowing state updates to avoid actions triggering after state event suppression (default). ISXB-1546.
+- Added a new Monobehavior `InputActionLabel` to rebinding sample to allow dynamic text showing relevant binding for an `InputAction`.
 
 ### Fixed
 - Fixed an analytics event being invoked twice when the Save button in the Actions view was pressed. [ISXB-1378](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1378)
@@ -32,14 +33,21 @@ however, it has to be formatted properly to pass verification tests.
 - Fixed Gamepad stick up/down inputs that were not recognized in WebGL. [ISXB-1090](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1090)
 - Fixed reenabling the VirtualMouseInput component may sometimes lead to NullReferenceException. [ISXB-1096](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1096)
 - Fixed the default button press point not being respected in Editor (as well as some other Touchscreen properties). [ISXB-1152](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1152)
+- Fixed the TreeView compilation warnings when used with Unity 6.2 beta (ISX-2320)
+- Fixed actions being reset when disabling the InputSystemUIInputModule component [ISXB-1493](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1493)
+- Fixed a memory leak when disabling and enabling the InputSystemUIInputModule component at runtime [ISXB-1573](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1573)
+- Fixed all InputControls being changed at once when you change just one by reverting `2a37caac288ac09bc9122234339dc5df8d3a0ca6`, which was an attempt at fixing [ISXB-1221] that introduced this regression [ISXB-1531] (https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1493)
 - Fixed PlayerInput component automatically switching away from the default ActionMap set to 'None'.
 - Fixed a console error being shown when targeting visionOS builds in 2022.3.
 - Fixed a Tap Interaction issue with analog controls. The Tap interaction would keep re-starting after timeout. [ISXB-627](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-627)
 - Fixed the defaultActionMap dropdown in the PlayerInput component defaulting to <None> instead of the first ActionMap.
 - Fixed TrackedPoseDriver stops updating position and rotation when device is added after its initialization. [ISXB-1555](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1555)
 - Fixed PlayerInput component not working with C# Wrappers (ISXB-1535). This reverted changes done to fix [ISXB-920](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-920) but users can now fix it themselves.
+- Fixed an issue that caused input processors with enum properties to incorrectly serialise by index instead of by value [ISXB-1474](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1474).
 - Fixed an issue in `RebindingUISample` that fired actions bound to the same control as the target control in a rebinding process. ISXB-1524.
 - Fixed an issue in `RebindingUISample` preventing UI navigation without Keyboard and Mouse present.
+- Fixed an issue in `RebindActionUI` which resulted in active binding not being shown after a scene reload. ISXB-1588.
+- Fixed an issue in `GamepadIconExample` which resulted in icons for left and right triggers not being displayed after a rebind to the exact same controls. ISXB-1593.
 
 ## [1.14.0] - 2025-03-20
 

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -1,6 +1,9 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine.InputSystem.Editor;
 using UnityEngine.InputSystem.Utilities;
 
 ////TODO: make the FindAction logic available on any IEnumerable<InputAction> and IInputActionCollection via extension methods
@@ -275,6 +278,21 @@ public InputAction this[string actionNameOrId]
                 return action;
             }
         }
+        /// <summary>
+        /// File‐format version constants for InputActionAsset JSON.
+        /// </summary>
+        static class JsonVersion
+        {
+            /// <summary>The original JSON version format for InputActionAsset.</summary>
+            public const int Version0 = 0;
+
+            /// <summary>Updated JSON version format for InputActionAsset.</summary>
+            /// <remarks>Changes representation of parameter values from being serialized by value to being serialized by value.</remarks>
+            public const int Version1 = 1;
+
+            /// <summary>The current version.</summary>
+            public const int Current  = Version1;
+        }
 
         /// <summary>
         /// Return a JSON representation of the asset.
@@ -296,8 +314,10 @@ public InputAction this[string actionNameOrId]
         /// <seealso cref="FromJson"/>
         public string ToJson()
         {
+            var hasContent = m_ActionMaps.LengthSafe() > 0 || m_ControlSchemes.LengthSafe() > 0;
             return JsonUtility.ToJson(new WriteFileJson
             {
+                version = hasContent ? JsonVersion.Current : JsonVersion.Version0,
                 name = name,
                 maps = InputActionMap.WriteFileJson.FromMaps(m_ActionMaps).maps,
                 controlSchemes = InputControlScheme.SchemeJson.ToJson(m_ControlSchemes),
@@ -379,6 +399,7 @@ public void LoadFromJson(string json)
                 throw new ArgumentNullException(nameof(json));
 
             var parsedJson = JsonUtility.FromJson<ReadFileJson>(json);
+            MigrateJson(ref parsedJson);
             parsedJson.ToAsset(this);
         }
 
@@ -950,6 +971,7 @@ private void OnDestroy()
         [Serializable]
         internal struct WriteFileJson
         {
+            public int version;
             public string name;
             public InputActionMap.WriteMapJson[] maps;
             public InputControlScheme.SchemeJson[] controlSchemes;
@@ -965,6 +987,7 @@ internal struct WriteFileJsonNoName
         [Serializable]
         internal struct ReadFileJson
         {
+            public int version;
             public string name;
             public InputActionMap.ReadMapJson[] maps;
             public InputControlScheme.SchemeJson[] controlSchemes;
@@ -981,5 +1004,73 @@ public void ToAsset(InputActionAsset asset)
                         map.m_Asset = asset;
             }
         }
+
+        /// <summary>
+        /// If parsedJson.version is older than Current, rewrite every
+        /// action.processors entry to replace “enumName(Ordinal=…)” with
+        /// “enumName(Value=…)” and bump parsedJson.version.
+        /// </summary>
+        internal void MigrateJson(ref ReadFileJson parsedJson)
+        {
+            if (parsedJson.version >= JsonVersion.Version1)
+                return;
+            if ((parsedJson.maps?.Length ?? 0) > 0 && (parsedJson.version) < JsonVersion.Version1)
+            {
+                for (var mi = 0; mi < parsedJson.maps.Length; ++mi)
+                {
+                    var mapJson = parsedJson.maps[mi];
+                    for (var ai = 0; ai < mapJson.actions.Length; ++ai)
+                    {
+                        var actionJson = mapJson.actions[ai];
+                        var raw = actionJson.processors;
+                        if (string.IsNullOrEmpty(raw))
+                            continue;
+
+                        var list = NameAndParameters.ParseMultiple(raw).ToList();
+                        var rebuilt = new List<string>(list.Count);
+                        foreach (var nap in list)
+                        {
+                            var procType = InputSystem.TryGetProcessor(nap.name);
+                            if (nap.parameters.Count == 0 || procType == null)
+                            {
+                                rebuilt.Add(nap.ToString());
+                                continue;
+                            }
+
+                            var dict = nap.parameters.ToDictionary(p => p.name, p => p.value.ToString());
+                            var anyChanged = false;
+                            foreach (var field in procType.GetFields(BindingFlags.Public | BindingFlags.Instance).Where(f => f.FieldType.IsEnum))
+                            {
+                                if (dict.TryGetValue(field.Name, out var ordS) && int.TryParse(ordS, out var ord))
+                                {
+                                    var values = Enum.GetValues(field.FieldType).Cast<object>().ToArray();
+                                    if (ord >= 0 && ord < values.Length)
+                                    {
+                                        dict[field.Name] = Convert.ToInt32(values[ord]).ToString();
+                                        anyChanged = true;
+                                    }
+                                }
+                            }
+
+                            if (!anyChanged)
+                            {
+                                rebuilt.Add(nap.ToString());
+                            }
+                            else
+                            {
+                                var paramText = string.Join(",", dict.Select(kv => $"{kv.Key}={kv.Value}"));
+                                rebuilt.Add($"{nap.name}({paramText})");
+                            }
+                        }
+
+                        actionJson.processors = string.Join(";", rebuilt);
+                        mapJson.actions[ai] = actionJson;
+                    }
+                    parsedJson.maps[mi] = mapJson;
+                }
+            }
+            // Bump the version so we never re-migrate
+            parsedJson.version = JsonVersion.Version1;
+        }
     }
 }