NEW: Object picker for InputActionReference combining results from Project-wide Input Actions Asset and Project Input Actions Assets

Assets/Tests/InputSystem/CoreTests_Actions.cs

@@ -9307,7 +9307,6 @@ public void Actions_CanApplyOverrideToActionWithEmptyBinding()
         action.Disable();
         action.ApplyBindingOverride(0, "/gamepad/leftTrigger");
         action.Enable();
-
         Press(gamepad.leftTrigger);
 
         Assert.That(performed);
@@ -9550,6 +9549,36 @@ public void Actions_CanResolveActionReference()
 
         Assert.That(referencedAction, Is.SameAs(action2));
     }
+
+    [Test]
+    [Category("Actions")]
+    public void Actions_CanResolveActionReference_WhenUsingToInputActionToConstructANewReference()
+    {
+        var map = new InputActionMap("map");
+        map.AddAction("action1");
+        var action2 = map.AddAction("action2");
+        var asset = ScriptableObject.CreateInstance<InputActionAsset>();
+        asset.AddActionMap(map);
+
+        var reference = ScriptableObject.CreateInstance<InputActionReference>();
+        reference.Set(asset, "map", "action2");
+
+        var copy1 = InputActionReference.Create(reference.action);
+        var copy2 = InputActionReference.Create(reference.ToInputAction());
+
+        // Expecting action to be the same
+        Assert.That(reference.action, Is.SameAs(copy1.action));
+        Assert.That(reference.action, Is.SameAs(copy2.action));
+    }
+
+    [Test]
+    [Category("Actions")]
+    public void Actions_CanImplicitlyConvertReferenceToAction_WhenAssigningActionFromReference()
+    {
+        var reference = ScriptableObject.CreateInstance<InputActionReference>();
+        InputAction action = reference; // implicit conversion
+        Assert.That(reference.action, Is.Null);
+    }
 
     [Test]
     [Category("Actions")]

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

@@ -1,7 +1,6 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
 using UnityEngine.InputSystem.Utilities;
 
 ////TODO: make the FindAction logic available on any IEnumerable<InputAction> and IInputActionCollection via extension methods
@@ -924,11 +923,41 @@ private void OnDestroy()
             }
         }
 
+        #if UNITY_EDITOR
+
+        private void OnValidate()
+        {
+            // Only currently validates references if serialized property has been set to true
+            if (m_ValidateReferencesInEditMode)
+                Editor.InputActionReferenceValidator.ValidateReferences(this);
+        }
+
+        #endif
+
+        internal InputAction FindActionById(string actionId)
+        {
+            if (m_ActionMaps == null)
+                return null;
+
+            foreach (var t in m_ActionMaps)
+            {
+                var action = t.FindAction(actionId);
+                if (action != null)
+                    return action;
+            }
+
+            return null;
+        }
+
         ////TODO: ApplyBindingOverrides, RemoveBindingOverrides, RemoveAllBindingOverrides
 
         [SerializeField] internal InputActionMap[] m_ActionMaps;
         [SerializeField] internal InputControlScheme[] m_ControlSchemes;
 
+        // Note: not serialized to JSON only as asset objects
+        [NonSerialized] internal InputActionReference[] m_References; // TODO Tentative
+        [SerializeField] internal bool m_ValidateReferencesInEditMode;// TODO Tentative
+
         ////TODO: make this persistent across domain reloads
         /// <summary>
         /// Shared state for all action maps in the asset.

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

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using UnityEditor;
 
 ////REVIEW: Can we somehow make this a simple struct? The one problem we have is that we can't put struct instances as sub-assets into
 ////        the import (i.e. InputActionImporter can't do AddObjectToAsset with them). However, maybe there's a way around that. The thing
@@ -160,6 +161,29 @@ public override string ToString()
             return base.ToString();
         }
 
+#if UNITY_EDITOR
+
+        private void OnEnable()
+        {
+            // This is invoked after InputActionReference deserialization
+            if (m_Action == null && m_Asset != null)
+            {
+                m_Action = m_Asset.FindActionById(m_ActionId);
+                Invalidate();
+            }
+        }
+
+        internal void Invalidate()
+        {
+            // TODO Check if it makes a difference to do full re-evaluation here (only to see if reference invalidation for asset is broken)
+
+            // Reflect action name as the name of this SerializableObject
+            if (m_Action != null)
+                name = GetDisplayName(m_Action);
+        }
+
+#endif // #if UNITY_EDITOR
+
         private static string GetDisplayName(InputAction action)
         {
             return !string.IsNullOrEmpty(action?.actionMap?.name) ? $"{action.actionMap?.name}/{action.name}" : action?.name;

Packages/com.unity.inputsystem/InputSystem/Editor/AssetImporter/InputActionAssetIconProvider.cs

@@ -0,0 +1,35 @@
+#if UNITY_EDITOR
+using UnityEditor;
+
+namespace UnityEngine.InputSystem.Editor
+{
+    /// <summary>
+    /// Provides access to icons associated with <code>InputActionAsset</code>.
+    /// </summary>
+    internal static class InputActionAssetIconProvider
+    {
+        private const string kActionIcon = "Packages/com.unity.inputsystem/InputSystem/Editor/Icons/InputAction.png";
+        private const string kAssetIcon = "Packages/com.unity.inputsystem/InputSystem/Editor/Icons/InputActionAsset.png";
+
+        /// <summary>
+        /// Attempts to load the icon associated with an <code>InputActionAsset</code> (.inputactions) asset.
+        /// </summary>
+        /// <returns>Icon resource reference or <code>null</code> if the resource could not be loaded.</returns>
+        public static Texture2D LoadAssetIcon()
+        {
+            return (Texture2D)EditorGUIUtility.Load(kAssetIcon);
+        }
+
+        /// <summary>
+        /// Attempts to load the icon associated with an <code>InputActionReference</code> sub-asset of an
+        /// <code>InputActionAsset</code> (.inputactions) asset.
+        /// </summary>
+        /// <returns>Icon resource reference or <code>null</code> if the resource could not be loaded.</returns>
+        public static Texture2D LoadActionIcon()
+        {
+            return (Texture2D)EditorGUIUtility.Load(kActionIcon);
+        }
+    }
+}
+
+#endif // #if UNITY_EDITOR

Packages/com.unity.inputsystem/InputSystem/Editor/AssetImporter/InputActionImporter.cs

@@ -1,5 +1,6 @@
 #if UNITY_EDITOR
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using UnityEditor;
@@ -29,9 +30,6 @@ internal class InputActionImporter : ScriptedImporter
     {
         private const int kVersion = 13;
 
-        private const string kActionIcon = "Packages/com.unity.inputsystem/InputSystem/Editor/Icons/InputAction.png";
-        private const string kAssetIcon = "Packages/com.unity.inputsystem/InputSystem/Editor/Icons/InputActionAsset.png";
-
         [SerializeField] private bool m_GenerateWrapperCode;
         [SerializeField] private string m_WrapperCodePath;
         [SerializeField] private string m_WrapperClassName;
@@ -88,8 +86,8 @@ public override void OnImportAsset(AssetImportContext ctx)
 
             // Load icons.
             ////REVIEW: the icons won't change if the user changes skin; not sure it makes sense to differentiate here
-            var assetIcon = (Texture2D)EditorGUIUtility.Load(kAssetIcon);
-            var actionIcon = (Texture2D)EditorGUIUtility.Load(kActionIcon);
+            var assetIcon = InputActionAssetIconProvider.LoadAssetIcon();
+            var actionIcon = InputActionAssetIconProvider.LoadActionIcon();
 
             // Add asset.
             ctx.AddObjectToAsset("<root>", asset, assetIcon);
@@ -212,12 +210,50 @@ public override void OnImportAsset(AssetImportContext ctx)
             InputActionEditorWindow.RefreshAllOnAssetReimport();
         }
 
+        internal static IEnumerable<InputActionReference> LoadInputActionReferencesFromAsset(InputActionAsset asset)
+        {
+            //Get all InputActionReferences are stored at the same asset path as InputActionAsset
+            return AssetDatabase.LoadAllAssetsAtPath(AssetDatabase.GetAssetPath(asset)).Where(
+                o => o is InputActionReference).Cast<InputActionReference>();
+        }
+
+        internal static IEnumerable<InputActionReference> LoadInputActionReferencesFromAssetDatabase(string[] folderPath = null)
+        {
+            string[] searchInFolderPath = null;
+            // If folderPath is null, search in "Assets" folder.
+            if (folderPath == null)
+            {
+                searchInFolderPath = new string[] { "Assets" };
+            }
+
+            // Get all InputActionReference from assets in "Asset" folder. It does not search inside "Packages" folder.
+            var inputActionReferenceGUIDs = AssetDatabase.FindAssets($"t:{typeof(InputActionReference).Name}", searchInFolderPath);
+
+            // To find all the InputActionReferences, the GUID of the asset containing at least one action reference is
+            // used to find the asset path. This is because InputActionReferences are stored in the asset database as sub-assets of InputActionAsset.
+            // Then the whole asset is loaded and all the InputActionReferences are extracted from it.
+            // Also, the action references are duplicated to have backwards compatibility with the 1.0.0-preview.7. That
+            // is why we look for references withouth the `HideFlags.HideInHierarchy` flag.
+            var inputActionReferencesList = new List<InputActionReference>();
+            foreach (var guid in inputActionReferenceGUIDs)
+            {
+                var assetName = AssetDatabase.GUIDToAssetPath(guid);
+                var assetInputActionReferenceList = AssetDatabase.LoadAllAssetsAtPath(assetName).Where(
+                    o => o is InputActionReference &&
+                    !((InputActionReference)o).hideFlags.HasFlag(HideFlags.HideInHierarchy))
+                    .Cast<InputActionReference>().ToList();
+
+                inputActionReferencesList.AddRange(assetInputActionReferenceList);
+            }
+            return inputActionReferencesList;
+        }
+
         // Add item to plop an .inputactions asset into the project.
         [MenuItem("Assets/Create/Input Actions")]
         public static void CreateInputAsset()
         {
             ProjectWindowUtil.CreateAssetWithContent("New Controls." + InputActionAsset.Extension,
-                InputActionAsset.kDefaultAssetLayoutJson, (Texture2D)EditorGUIUtility.Load(kAssetIcon));
+                InputActionAsset.kDefaultAssetLayoutJson, InputActionAssetIconProvider.LoadAssetIcon());
         }
     }
 }