Fix for InputSystem in 3.0.0 (temp fix for il2cpp)

sinai-dev · sinai-dev · commit c38155ab04dc · 2020-11-20T17:12:40.000+11:00
diff --git a/src/ExplorerCore.cs b/src/ExplorerCore.cs
@@ -15,7 +15,7 @@ namespace UnityExplorer
     public class ExplorerCore
     {
         public const string NAME = "UnityExplorer";
-        public const string VERSION = "3.0.2";
+        public const string VERSION = "3.0.2.1";
         public const string AUTHOR = "Sinai";
         public const string GUID = "com.sinai.unityexplorer";
         public const string EXPLORER_FOLDER = @"Mods\UnityExplorer";
diff --git a/src/Helpers/ReflectionHelpers.cs b/src/Helpers/ReflectionHelpers.cs
@@ -211,6 +211,8 @@ internal static bool LoadModuleInternal(string fullPath)
 
             return false;
         }
+#else
+        public static bool LoadModule(string module) => true;
 #endif
 
         public static bool IsEnumerable(Type t)
diff --git a/src/Input/IHandleInput.cs b/src/Input/IHandleInput.cs
@@ -1,4 +1,5 @@
 ﻿using UnityEngine;
+using UnityEngine.EventSystems;
 
 namespace UnityExplorer.Input
 {
@@ -11,5 +12,12 @@ public interface IHandleInput
 
         bool GetMouseButtonDown(int btn);
         bool GetMouseButton(int btn);
+
+        BaseInputModule UIModule { get; }
+
+        PointerEventData InputPointerEvent { get; }
+
+        void AddUIInputModule();
+        void ActivateModule();
     }
 }
diff --git a/src/Input/InputManager.cs b/src/Input/InputManager.cs
@@ -2,14 +2,24 @@
 using UnityEngine;
 using UnityExplorer.Helpers;
 using System.Diagnostics.CodeAnalysis;
+using UnityEngine.EventSystems;
 #if CPP
 using UnhollowerBaseLib;
 #endif
 
 namespace UnityExplorer.Input
 {
+    public enum InputType
+    {
+        InputSystem,
+        Legacy,
+        None
+    }
+
     public static class InputManager
     {
+        public static InputType CurrentType { get; private set; }
+
         private static IHandleInput m_inputModule;
 
         public static Vector3 MousePosition => m_inputModule.MousePosition;
@@ -20,23 +30,35 @@ public static class InputManager
         public static bool GetMouseButtonDown(int btn) => m_inputModule.GetMouseButtonDown(btn);
         public static bool GetMouseButton(int btn) => m_inputModule.GetMouseButton(btn);
 
+        public static BaseInputModule UIInput => m_inputModule.UIModule;
+        public static PointerEventData InputPointerEvent => m_inputModule.InputPointerEvent;
+
+        public static void ActivateUIModule() => m_inputModule.ActivateModule();
+
+        public static void AddUIModule()
+        {
+            m_inputModule.AddUIInputModule();
+            ActivateUIModule();
+        }
+
         public static void Init()
         {
-#if CPP
             if (InputSystem.TKeyboard != null || (ReflectionHelpers.LoadModule("Unity.InputSystem") && InputSystem.TKeyboard != null))
             {
                 m_inputModule = new InputSystem();
+                CurrentType = InputType.InputSystem;
             }
             else if (LegacyInput.TInput != null || (ReflectionHelpers.LoadModule("UnityEngine.InputLegacyModule") && LegacyInput.TInput != null))
             {
                 m_inputModule = new LegacyInput();
+                CurrentType = InputType.Legacy;
             }
-#endif
 
             if (m_inputModule == null)
             {
                 ExplorerCore.LogWarning("Could not find any Input module!");
                 m_inputModule = new NoInput();
+                CurrentType = InputType.None;
             }
         }
     }
diff --git a/src/Input/InputSystem.cs b/src/Input/InputSystem.cs
@@ -2,6 +2,9 @@
 using System.Reflection;
 using UnityExplorer.Helpers;
 using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityExplorer.UI;
+using System.Collections.Generic;
 
 namespace UnityExplorer.Input
 {
@@ -64,24 +67,46 @@ public InputSystem()
         private static PropertyInfo m_positionProp;
         private static MethodInfo m_readVector2InputMethod;
 
-        public Vector2 MousePosition => (Vector2)m_readVector2InputMethod.Invoke(MousePositionInfo, new object[0]);
-
-        public bool GetKeyDown(KeyCode key)
+        public Vector2 MousePosition
         {
-            var parsedKey = Enum.Parse(TKey, key.ToString());
-            var actualKey = m_kbIndexer.GetValue(CurrentKeyboard, new object[] { parsedKey });
-
-            return (bool)m_btnWasPressedProp.GetValue(actualKey, null);
+            get
+            {
+                try
+                {
+                    return (Vector2)m_readVector2InputMethod.Invoke(MousePositionInfo, new object[0]);
+                }
+                catch
+                {
+                    return Vector2.zero;
+                }
+            }
         }
 
-        public bool GetKey(KeyCode key)
+        internal static Dictionary<KeyCode, object> ActualKeyDict = new Dictionary<KeyCode, object>();
+
+        internal object GetActualKey(KeyCode key)
         {
-            var parsed = Enum.Parse(TKey, key.ToString());
-            var actualKey = m_kbIndexer.GetValue(CurrentKeyboard, new object[] { parsed });
+            if (!ActualKeyDict.ContainsKey(key))
+            {
+                var s = key.ToString();
+                if (s.Contains("Control"))
+                    s = s.Replace("Control", "Ctrl");
+                else if (s.Contains("Return"))
+                    s = "Enter";
 
-            return (bool)m_btnIsPressedProp.GetValue(actualKey, null);
+                var parsed = Enum.Parse(TKey, s);
+                var actualKey = m_kbIndexer.GetValue(CurrentKeyboard, new object[] { parsed });
+
+                ActualKeyDict.Add(key, actualKey);
+            }
+
+            return ActualKeyDict[key];
         }
 
+        public bool GetKeyDown(KeyCode key) => (bool)m_btnWasPressedProp.GetValue(GetActualKey(key), null);
+
+        public bool GetKey(KeyCode key) => (bool)m_btnIsPressedProp.GetValue(GetActualKey(key), null);
+
         public bool GetMouseButtonDown(int btn)
         {
             switch (btn)
@@ -103,5 +128,44 @@ public bool GetMouseButton(int btn)
                 default: throw new NotImplementedException();
             }
         }
+
+        // UI Input
+
+        //public Type TInputSystemUIInputModule 
+        //    => m_tUIInputModule 
+        //    ?? (m_tUIInputModule = ReflectionHelpers.GetTypeByName("UnityEngine.InputSystem.UI.InputSystemUIInputModule"));
+        //internal Type m_tUIInputModule;
+
+        public BaseInputModule UIModule => null; // m_newInputModule;
+        //internal BaseInputModule m_newInputModule;
+
+        public PointerEventData InputPointerEvent => null;
+
+        public void AddUIInputModule()
+        {
+//            if (TInputSystemUIInputModule != null)
+//            {
+//#if CPP
+//                // m_newInputModule = UIManager.CanvasRoot.AddComponent(Il2CppType.From(TInputSystemUIInputModule)).TryCast<BaseInputModule>();
+//#else
+//                m_newInputModule = (BaseInputModule)UIManager.CanvasRoot.AddComponent(TInputSystemUIInputModule);
+//#endif
+//            }
+//            else
+//            {
+//                ExplorerCore.LogWarning("New input system: Could not find type by name 'UnityEngine.InputSystem.UI.InputSystemUIInputModule'");
+//            }
+        }
+
+        public void ActivateModule()
+        {
+//#if CPP
+//            // m_newInputModule.ActivateModule();
+//#else
+//            m_newInputModule.ActivateModule();
+//#endif
+
+
+        }
     }
 }
diff --git a/src/Input/LegacyInput.cs b/src/Input/LegacyInput.cs
@@ -2,6 +2,8 @@
 using System.Reflection;
 using UnityExplorer.Helpers;
 using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityExplorer.UI;
 
 namespace UnityExplorer.Input
 {
@@ -36,5 +38,27 @@ public LegacyInput()
         public bool GetMouseButton(int btn) => (bool)m_getMouseButtonMethod.Invoke(null, new object[] { btn });
 
         public bool GetMouseButtonDown(int btn) => (bool)m_getMouseButtonDownMethod.Invoke(null, new object[] { btn });
+
+        // UI Input module
+
+        public BaseInputModule UIModule => m_inputModule;
+        internal StandaloneInputModule m_inputModule;
+
+        public PointerEventData InputPointerEvent =>
+#if CPP
+            m_inputModule.m_InputPointerEvent;
+#else
+            null;
+#endif
+
+        public void AddUIInputModule()
+        {
+            m_inputModule = UIManager.CanvasRoot.gameObject.AddComponent<StandaloneInputModule>();
+        }
+
+        public void ActivateModule()
+        {
+            m_inputModule.ActivateModule();
+        }
     }
 }
diff --git a/src/Input/NoInput.cs b/src/Input/NoInput.cs
@@ -1,4 +1,5 @@
 ﻿using UnityEngine;
+using UnityEngine.EventSystems;
 
 namespace UnityExplorer.Input
 {
@@ -13,5 +14,10 @@ public class NoInput : IHandleInput
 
         public bool GetMouseButton(int btn) => false;
         public bool GetMouseButtonDown(int btn) => false;
+
+        public BaseInputModule UIModule => null;
+        public PointerEventData InputPointerEvent => null;
+        public void ActivateModule() { }
+        public void AddUIInputModule() { }
     }
 }
diff --git a/src/UI/ForceUnlockCursor.cs b/src/UI/ForceUnlockCursor.cs
@@ -63,6 +63,8 @@ private static void SetupPatches()
                     throw new Exception("Could not find Type 'UnityEngine.Cursor'!");
                 }
 
+                ExplorerCore.Log("setting up forceunlockcursor patches...");
+
                 // Get current cursor state and enable cursor
                 try
                 {
@@ -100,7 +102,7 @@ private static void SetupPatches()
             }
             catch (Exception e)
             {
-                ExplorerCore.Log($"Exception on CursorControl.Init! {e.GetType()}, {e.Message}");
+                ExplorerCore.Log($"Exception on ForceUnlockCursor.Init! {e.GetType()}, {e.Message}");
             }
         }
 
@@ -164,13 +166,20 @@ public static void UpdateCursorControl()
 
         public static void SetEventSystem()
         {
+            if (InputManager.CurrentType == InputType.InputSystem)
+                return;
+
             m_settingEventSystem = true;
-            UIManager.SetEventSystem();
+            EventSystem.current = UIManager.EventSys;
+            InputManager.ActivateUIModule();
             m_settingEventSystem = false;
         }
 
         public static void ReleaseEventSystem()
         {
+            if (InputManager.CurrentType == InputType.InputSystem)
+                return;
+
             if (m_lastEventSystem)
             {
                 m_settingEventSystem = true;
diff --git a/src/UI/UIManager.cs b/src/UI/UIManager.cs
diff --git a/src/UnityExplorer.csproj b/src/UnityExplorer.csproj

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ namespace UnityExplorer`
`15`	`15`	`public class ExplorerCore`
`16`	`16`	`{`
`17`	`17`	`public const string NAME = "UnityExplorer";`
`18`		`- public const string VERSION = "3.0.2";`
	`18`	`+ public const string VERSION = "3.0.2.1";`
`19`	`19`	`public const string AUTHOR = "Sinai";`
`20`	`20`	`public const string GUID = "com.sinai.unityexplorer";`
`21`	`21`	`public const string EXPLORER_FOLDER = @"Mods\UnityExplorer";`
Original file line number	Diff line number	Diff line change
`@@ -211,6 +211,8 @@ internal static bool LoadModuleInternal(string fullPath)`
`211`	`211`
`212`	`212`	`return false;`
`213`	`213`	`}`
	`214`	`+#else`
	`215`	`+ public static bool LoadModule(string module) => true;`
`214`	`216`	`#endif`
`215`	`217`
`216`	`218`	`public static bool IsEnumerable(Type t)`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using UnityEngine;`
	`2`	`+using UnityEngine.EventSystems;`
`2`	`3`
`3`	`4`	`namespace UnityExplorer.Input`
`4`	`5`	`{`
`@@ -11,5 +12,12 @@ public interface IHandleInput`
`11`	`12`
`12`	`13`	`bool GetMouseButtonDown(int btn);`
`13`	`14`	`bool GetMouseButton(int btn);`
	`15`	`+`
	`16`	`+ BaseInputModule UIModule { get; }`
	`17`	`+`
	`18`	`+ PointerEventData InputPointerEvent { get; }`
	`19`	`+`
	`20`	`+ void AddUIInputModule();`
	`21`	`+ void ActivateModule();`
`14`	`22`	`}`
`15`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,14 +2,24 @@`
`2`	`2`	`using UnityEngine;`
`3`	`3`	`using UnityExplorer.Helpers;`
`4`	`4`	`using System.Diagnostics.CodeAnalysis;`
	`5`	`+using UnityEngine.EventSystems;`
`5`	`6`	`#if CPP`
`6`	`7`	`using UnhollowerBaseLib;`
`7`	`8`	`#endif`
`8`	`9`
`9`	`10`	`namespace UnityExplorer.Input`
`10`	`11`	`{`
	`12`	`+ public enum InputType`
	`13`	`+ {`
	`14`	`+ InputSystem,`
	`15`	`+ Legacy,`
	`16`	`+ None`
	`17`	`+ }`
	`18`	`+`
`11`	`19`	`public static class InputManager`
`12`	`20`	`{`
	`21`	`+ public static InputType CurrentType { get; private set; }`
	`22`	`+`
`13`	`23`	`private static IHandleInput m_inputModule;`
`14`	`24`
`15`	`25`	`public static Vector3 MousePosition => m_inputModule.MousePosition;`
`@@ -20,23 +30,35 @@ public static class InputManager`
`20`	`30`	`public static bool GetMouseButtonDown(int btn) => m_inputModule.GetMouseButtonDown(btn);`
`21`	`31`	`public static bool GetMouseButton(int btn) => m_inputModule.GetMouseButton(btn);`
`22`	`32`
	`33`	`+ public static BaseInputModule UIInput => m_inputModule.UIModule;`
	`34`	`+ public static PointerEventData InputPointerEvent => m_inputModule.InputPointerEvent;`
	`35`	`+`
	`36`	`+ public static void ActivateUIModule() => m_inputModule.ActivateModule();`
	`37`	`+`
	`38`	`+ public static void AddUIModule()`
	`39`	`+ {`
	`40`	`+ m_inputModule.AddUIInputModule();`
	`41`	`+ ActivateUIModule();`
	`42`	`+ }`
	`43`	`+`
`23`	`44`	`public static void Init()`
`24`	`45`	`{`
`25`		`-#if CPP`
`26`	`46`	`if (InputSystem.TKeyboard != null \|\| (ReflectionHelpers.LoadModule("Unity.InputSystem") && InputSystem.TKeyboard != null))`
`27`	`47`	`{`
`28`	`48`	`m_inputModule = new InputSystem();`
	`49`	`+ CurrentType = InputType.InputSystem;`
`29`	`50`	`}`
`30`	`51`	`else if (LegacyInput.TInput != null \|\| (ReflectionHelpers.LoadModule("UnityEngine.InputLegacyModule") && LegacyInput.TInput != null))`
`31`	`52`	`{`
`32`	`53`	`m_inputModule = new LegacyInput();`
	`54`	`+ CurrentType = InputType.Legacy;`
`33`	`55`	`}`
`34`		`-#endif`
`35`	`56`
`36`	`57`	`if (m_inputModule == null)`
`37`	`58`	`{`
`38`	`59`	`ExplorerCore.LogWarning("Could not find any Input module!");`
`39`	`60`	`m_inputModule = new NoInput();`
	`61`	`+ CurrentType = InputType.None;`
`40`	`62`	`}`
`41`	`63`	`}`
`42`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,6 +63,8 @@ private static void SetupPatches()`
`63`	`63`	`throw new Exception("Could not find Type 'UnityEngine.Cursor'!");`
`64`	`64`	`}`
`65`	`65`
	`66`	`+ ExplorerCore.Log("setting up forceunlockcursor patches...");`
	`67`	`+`
`66`	`68`	`// Get current cursor state and enable cursor`
`67`	`69`	`try`
`68`	`70`	`{`
`@@ -100,7 +102,7 @@ private static void SetupPatches()`
`100`	`102`	`}`
`101`	`103`	`catch (Exception e)`
`102`	`104`	`{`
`103`		`- ExplorerCore.Log($"Exception on CursorControl.Init! {e.GetType()}, {e.Message}");`
	`105`	`+ ExplorerCore.Log($"Exception on ForceUnlockCursor.Init! {e.GetType()}, {e.Message}");`
`104`	`106`	`}`
`105`	`107`	`}`
`106`	`108`
`@@ -164,13 +166,20 @@ public static void UpdateCursorControl()`
`164`	`166`
`165`	`167`	`public static void SetEventSystem()`
`166`	`168`	`{`
	`169`	`+ if (InputManager.CurrentType == InputType.InputSystem)`
	`170`	`+ return;`
	`171`	`+`
`167`	`172`	`m_settingEventSystem = true;`
`168`		`- UIManager.SetEventSystem();`
	`173`	`+ EventSystem.current = UIManager.EventSys;`
	`174`	`+ InputManager.ActivateUIModule();`
`169`	`175`	`m_settingEventSystem = false;`
`170`	`176`	`}`
`171`	`177`
`172`	`178`	`public static void ReleaseEventSystem()`
`173`	`179`	`{`
	`180`	`+ if (InputManager.CurrentType == InputType.InputSystem)`
	`181`	`+ return;`
	`182`	`+`
`174`	`183`	`if (m_lastEventSystem)`
`175`	`184`	`{`
`176`	`185`	`m_settingEventSystem = true;`