FIX: ISXB-1674 - Input actions asset not converted correctly when upgrading from 1.14.1 (Regression)

Assets/Tests/InputSystem.Editor/CustomProcessorEnumTest.cs

@@ -47,15 +47,19 @@ public override float Process(float value, InputControl control)
 internal class CustomProcessorEnumTest : UIToolkitBaseTestWindow<InputActionsEditorWindow>
 {
     InputActionAsset m_Asset;
+    InputActionMap m_ActionMap;
 
     public override void OneTimeSetUp()
     {
         base.OneTimeSetUp();
         m_Asset = AssetDatabaseUtils.CreateAsset<InputActionAsset>();
 
-        var actionMap = m_Asset.AddActionMap("Action Map");
+        m_ActionMap = m_Asset.AddActionMap("Action Map");
 
-        actionMap.AddAction("Action", InputActionType.Value, processors: "Custom(SomeEnum=10)");
+        var action = m_ActionMap.AddAction("Action", InputActionType.Value, processors: "InvertVector2(invertX=false), Custom(SomeEnum=10)");
+
+        // A binding is needed to resolve during test. 
+        action.AddBinding("<Gamepad>/leftTrigger");
     }
 
     public override void OneTimeTearDown()
@@ -108,5 +112,24 @@ public IEnumerator ProcessorEnum_ShouldSerializeByValue_WhenSerializedToAsset()
 
         yield return null;
     }
+
+    [Test]
+    public void Migration_ShouldProduceValidActionAsset_WithAllProcessors_AndEnumConverted()
+    {
+        m_ActionMap.ResolveBindings();
+
+        var action = m_ActionMap.actions.First();
+        var migratedList = UnityEngine.InputSystem.Utilities.NameAndParameters.ParseMultiple(action.processors).ToList();
+
+        Assert.That(migratedList.Count, Is.EqualTo(2), "Expected two processors.");
+        Assert.That(migratedList[0].name, Is.EqualTo("InvertVector2"), "First processor should be InvertVector2.");
+
+        var invertX = migratedList[0].parameters.FirstOrDefault(p => p.name == "invertX");
+        Assert.That(invertX.name, Is.EqualTo("invertX"));
+        Assert.That(invertX.value.ToBoolean(), Is.False, "invertX should be false for the first processor.");
+
+        Assert.That(m_ActionMap.m_State.processors[1].GetType(), Is.EqualTo(typeof(CustomProcessor)));
+        Assert.That((m_ActionMap.m_State.processors[1] as CustomProcessor).SomeEnum, Is.EqualTo(SomeEnum.OptionA));
+    }
 }
 #endif

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

@@ -1016,6 +1016,11 @@
                 return;
             if ((parsedJson.maps?.Length ?? 0) > 0 && (parsedJson.version) < JsonVersion.Version1)
             {
+                List<NameAndParameters> parsedList = null;            
+                var converted = new List<NameAndParameters>(8);       
+                var updatedParameters = new List<NamedValue>(4);    
+                var enumValuesCache = new Dictionary<Type, Array>(8);
+
                 for (var mi = 0; mi < parsedJson.maps.Length; ++mi)
                 {
                     var mapJson = parsedJson.maps[mi];
@@ -1026,44 +1031,49 @@
                         if (string.IsNullOrEmpty(raw))
                             continue;
 
-                        var list = NameAndParameters.ParseMultiple(raw).ToList();
-                        var rebuilt = new List<string>(list.Count);
-                        foreach (var nap in list)
+                        if (!NameAndParameters.ParseMultiple(raw, ref parsedList) || parsedList.Count == 0)
+                            continue;
+
+                        converted.Clear();
+
+                        for (int i = 0; i < parsedList.Count; ++i)
                         {
+                            var nap = parsedList[i];
                             var procType = InputSystem.TryGetProcessor(nap.name);
                             if (nap.parameters.Count == 0 || procType == null)
                             {
-                                rebuilt.Add(nap.ToString());
+                                converted.Add(nap);
                                 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))
+                            updatedParameters.Clear();
+                            for (int k = 0; k < nap.parameters.Count; ++k)
                             {
-                                if (dict.TryGetValue(field.Name, out var ordS) && int.TryParse(ordS, out var ord))
+                                var param = nap.parameters[k];
+                                var updatedPar = param;
+
+                                var fieldInfo = procType.GetField(param.name, BindingFlags.Public | BindingFlags.Instance);
+                                if (fieldInfo != null && fieldInfo.FieldType.IsEnum)
                                 {
-                                    var values = Enum.GetValues(field.FieldType).Cast<object>().ToArray();
-                                    if (ord >= 0 && ord < values.Length)
+                                    var index = param.value.ToInt32();
+                                    if (index >= 0)
                                     {
-                                        dict[field.Name] = Convert.ToInt32(values[ord]).ToString();
-                                        anyChanged = true;
+                                        if (!enumValuesCache.TryGetValue(fieldInfo.FieldType, out var values))
+                                        {
+                                            values = Enum.GetValues(fieldInfo.FieldType);
+                                            enumValuesCache[fieldInfo.FieldType] = values;
+                                        }
+                                        if (index < values.Length)
+                                        {
+                                            var convertedValue = Convert.ToInt32(values.GetValue(index));
+                                            updatedPar = NamedValue.From(param.name, convertedValue);
+                                        }
                                     }
                                 }
+                                updatedParameters.Add(updatedPar);
                             }
-
-                            if (!anyChanged)
-                            {
-                                rebuilt.Add(nap.ToString());
-                            }
-                            else
-                            {
-                                var paramText = string.Join(",", dict.Select(kv => $"{kv.Key}={kv.Value}"));
-                                rebuilt.Add($"{nap.name}({paramText})");
-                            }
+                            converted.Add(NameAndParameters.Create(nap.name, updatedParameters));
                         }
-
-                        actionJson.processors = string.Join(";", rebuilt);
+                        actionJson.processors = NameAndParameters.ToSerializableString(converted);
                         mapJson.actions[ai] = actionJson;
                     }
                     parsedJson.maps[mi] = mapJson;

Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/Views/NameAndParametersListView.cs

@@ -37,7 +37,7 @@
             var newElement = new NameAndParameters() { name = name};
             interactionsOrProcessorsList.Add(newElement);
 
-            m_ListProperty.stringValue = ToSerializableString(interactionsOrProcessorsList);
+            m_ListProperty.stringValue = NameAndParameters.ToSerializableString(interactionsOrProcessorsList);
             m_ListProperty.serializedObject.ApplyModifiedProperties();
         }
 
@@ -61,35 +61,26 @@
             if (interactionsOrProcessors.Length == 0 || !newIndexIsValid || !oldIndexIsValid)
                 return;
             MemoryHelpers.Swap(ref interactionsOrProcessors[oldIndex], ref interactionsOrProcessors[newIndex]);
-            m_ListProperty.stringValue = ToSerializableString(interactionsOrProcessors);
+            m_ListProperty.stringValue = NameAndParameters.ToSerializableString(interactionsOrProcessors);
             m_ListProperty.serializedObject.ApplyModifiedProperties();
         }
 
         private void DeleteElement(int index)
         {
             var interactionsOrProcessorsList = NameAndParameters.ParseMultiple(m_ListProperty.stringValue).ToList();
             interactionsOrProcessorsList.RemoveAt(index);
-            m_ListProperty.stringValue = ToSerializableString(interactionsOrProcessorsList);
+            m_ListProperty.stringValue = NameAndParameters.ToSerializableString(interactionsOrProcessorsList);
             m_ListProperty.serializedObject.ApplyModifiedProperties();
         }
 
         private void OnParametersChanged(ParameterListView listView, int index)
         {
             var interactionsOrProcessorsList = NameAndParameters.ParseMultiple(m_ListProperty.stringValue).ToList();
             interactionsOrProcessorsList[index] = new NameAndParameters { name = interactionsOrProcessorsList[index].name, parameters = listView.GetParameters() };
-            m_ListProperty.stringValue = ToSerializableString(interactionsOrProcessorsList);
+            m_ListProperty.stringValue = NameAndParameters.ToSerializableString(interactionsOrProcessorsList);
             m_ListProperty.serializedObject.ApplyModifiedProperties();
         }
 
-        private static string ToSerializableString(IEnumerable<NameAndParameters> parametersForEachListItem)
-        {
-            if (parametersForEachListItem == null)
-                return string.Empty;
-
-            return string.Join(NamedValue.Separator,
-                parametersForEachListItem.Select(x => x.ToString()).ToArray());
-        }
-
         public override void RedrawUI(InputActionsEditorState state)
         {
             if (m_ContentContainer != null)

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

@@ -27,6 +27,23 @@
             return $"{name}({parameterString})";
         }
 
+        internal static string ToSerializableString(IEnumerable<NameAndParameters> list)
+        {
+            if(list == null)
+                return string.Empty;
+
+            return string.Join(NamedValue.Separator, list.Select(x => x.ToString()).ToArray());
+        }
+
+        internal static NameAndParameters Create(string name, IList<NamedValue> parameters)
+        {
+            return new NameAndParameters
+            {
+                name = name,
+                parameters = new ReadOnlyArray<NamedValue>(parameters.ToArray())
+            };
+        }
+
         public static IEnumerable<NameAndParameters> ParseMultiple(string text)
         {
             List<NameAndParameters> list = null;