Changed TypeTable to be tightly coupled to an InputManager instance. Removed property that could be internal to InputManager and be returned as method result instead.

Author: ekcoh

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

@@ -1858,6 +1858,7 @@ internal void Initialize(IInputRuntime runtime, InputSettings settings)
             Debug.Assert(settings != null);
 
             m_Settings = settings;
+            m_LazyLoadCustomTypes =  () => RegisterCustomTypes(); // Cached delegate
 
             InitializeActions();
             InitializeData();
@@ -1913,9 +1914,9 @@ private void InitializeActions()
         internal void InitializeData()
         {
             m_Layouts.Allocate();
-            m_Processors.Initialize();
-            m_Interactions.Initialize();
-            m_Composites.Initialize();
+            m_Processors.Initialize(this);
+            m_Interactions.Initialize(this);
+            m_Composites.Initialize(this);
             m_DevicesById = new Dictionary<int, InputDevice>();
 
             // Determine our default set of enabled update types. By
@@ -2030,7 +2031,7 @@ internal void InitializeData()
             // .inputaction JSON assets. This is managed via TypeTable.cs.
         }
 
-        void RegisterCustomTypes(Type[] types)
+        static void RegisterCustomTypes(Type[] types)
         {
             foreach (Type type in types)
             {
@@ -2053,13 +2054,17 @@ void RegisterCustomTypes(Type[] types)
             }
         }
 
-        internal bool hasCustomTypesBeenRegistered { get; private set; }
+        private bool m_CustomTypesRegistered;
 
-        internal void RegisterCustomTypes()
+        internal bool RegisterCustomTypes()
         {
-            if (hasCustomTypesBeenRegistered)
-                return;
-            hasCustomTypesBeenRegistered = true;
+            // If we have already attempted to register custom types, there is no need to reattempt since we
+            // would end up with the same result again. Only with a domain reload would the resulting types
+            // be different, and hence it is sufficient to use a static flag that we do not reset.
+            if (!m_CustomTypesRegistered)
+                return false;
+
+            m_CustomTypesRegistered = true;
 
             k_InputRegisterCustomTypesMarker.Begin();
 
@@ -2085,11 +2090,13 @@ internal void RegisterCustomTypes()
                 }
                 catch (ReflectionTypeLoadException)
                 {
-                    continue;
+                    // Ignore exception
                 }
             }
 
             k_InputRegisterCustomTypesMarker.End();
+
+            return true;
         }
 
         internal void InstallRuntime(IInputRuntime runtime)
@@ -2270,6 +2277,7 @@ internal struct AvailableDevice
         internal IInputRuntime m_Runtime;
         internal InputMetrics m_Metrics;
         internal InputSettings m_Settings;
+        private Func<bool> m_LazyLoadCustomTypes;
 
         // Extract as booleans (from m_Settings) because feature check is in the hot path
 

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

@@ -25,12 +25,16 @@ internal struct TypeTable
         public HashSet<InternedString> aliases;
         #endif
 
-        public void Initialize()
+        // Strong coupling to Input Manager which is always the owner
+        private InputManager m_Manager;
+
+        public void Initialize(InputManager manager)
         {
             table = new Dictionary<InternedString, Type>();
             #if UNITY_EDITOR
             aliases = new HashSet<InternedString>();
             #endif
+            m_Manager = manager;
         }
 
         public InternedString FindNameForType(Type type)
@@ -80,18 +84,24 @@ public Type LookupTypeRegistration(string name)
             if (table == null)
                 throw new InvalidOperationException("Input System not yet initialized");
 
-            var internedName = new InternedString(name);
+            return TryLookupTypeRegistration(new InternedString(name));
+        }
+
+        private Type TryLookupTypeRegistration(InternedString internedName)
+        {
             if (table.TryGetValue(internedName, out var type))
                 return type;
 
-            // Failed to look-up type, either type do not exist or it is a custom type.
+            // Failed to look-up type, either type do not exist or it is a custom type that has not been registered.
             // Check whether we have attempted to load custom types and otherwise lazily load
             // types only when referenced and reattempt looking up type by name. (ISXB-1766)
-            if (InputSystem.s_Manager == null || InputSystem.s_Manager.hasCustomTypesBeenRegistered)
-                return null;
+            if (m_Manager != null)
+            {
+                if (m_Manager.RegisterCustomTypes())
+                    return TryLookupTypeRegistration(internedName); // Recursive call
+            }
 
-            InputSystem.s_Manager.RegisterCustomTypes();
-            return LookupTypeRegistration(name);
+            return null;
         }
 
         #if UNITY_EDITOR