Project refactor, namespace cleanup, splitting UI/functionality.

src/Core/Input/IHandleInput.cs

@@ -0,0 +1,23 @@
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UnityExplorer.Core.Input
+{
+    public interface IHandleInput
+    {
+        Vector2 MousePosition { get; }
+
+        bool GetKeyDown(KeyCode key);
+        bool GetKey(KeyCode key);
+
+        bool GetMouseButtonDown(int btn);
+        bool GetMouseButton(int btn);
+
+        BaseInputModule UIModule { get; }
+
+        PointerEventData InputPointerEvent { get; }
+
+        void AddUIInputModule();
+        void ActivateModule();
+    }
+}

src/Core/Input/InputManager.cs

@@ -0,0 +1,61 @@
+using System;
+using UnityEngine;
+using System.Diagnostics.CodeAnalysis;
+using UnityEngine.EventSystems;
+
+namespace UnityExplorer.Core.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;
+
+        public static bool GetKeyDown(KeyCode key) => m_inputModule.GetKeyDown(key);
+        public static bool GetKey(KeyCode key) => m_inputModule.GetKey(key);
+
+        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 (InputSystem.TKeyboard != null || (ReflectionUtility.LoadModule("Unity.InputSystem") && InputSystem.TKeyboard != null))
+            {
+                m_inputModule = new InputSystem();
+                CurrentType = InputType.InputSystem;
+            }
+            else if (LegacyInput.TInput != null || (ReflectionUtility.LoadModule("UnityEngine.InputLegacyModule") && LegacyInput.TInput != null))
+            {
+                m_inputModule = new LegacyInput();
+                CurrentType = InputType.Legacy;
+            }
+
+            if (m_inputModule == null)
+            {
+                ExplorerCore.LogWarning("Could not find any Input module!");
+                m_inputModule = new NoInput();
+                CurrentType = InputType.None;
+            }
+        }
+    }
+}

src/Core/Input/InputSystem.cs

@@ -0,0 +1,171 @@
+using System;
+using System.Reflection;
+using UnityExplorer.Core.Unity;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityExplorer.UI;
+using System.Collections.Generic;
+
+namespace UnityExplorer.Core.Input
+{
+    public class InputSystem : IHandleInput
+    {
+        public InputSystem()
+        {
+            ExplorerCore.Log("Initializing new InputSystem support...");
+
+            m_kbCurrentProp = TKeyboard.GetProperty("current");
+            m_kbIndexer = TKeyboard.GetProperty("Item", new Type[] { TKey });
+
+            var btnControl = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.ButtonControl");
+            m_btnIsPressedProp = btnControl.GetProperty("isPressed");
+            m_btnWasPressedProp = btnControl.GetProperty("wasPressedThisFrame");
+
+            m_mouseCurrentProp = TMouse.GetProperty("current");
+            m_leftButtonProp = TMouse.GetProperty("leftButton");
+            m_rightButtonProp = TMouse.GetProperty("rightButton");
+
+            m_positionProp = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Pointer")
+                            .GetProperty("position");
+
+            m_readVector2InputMethod = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.InputControl`1")
+                                      .MakeGenericType(typeof(Vector2))
+                                      .GetMethod("ReadValue");
+        }
+
+        public static Type TKeyboard => m_tKeyboard ?? (m_tKeyboard = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Keyboard"));
+        private static Type m_tKeyboard;
+
+        public static Type TMouse => m_tMouse ?? (m_tMouse = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Mouse"));
+        private static Type m_tMouse;
+
+        public static Type TKey => m_tKey ?? (m_tKey = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Key"));
+        private static Type m_tKey;
+
+        private static PropertyInfo m_btnIsPressedProp;
+        private static PropertyInfo m_btnWasPressedProp;
+
+        private static object CurrentKeyboard => m_currentKeyboard ?? (m_currentKeyboard = m_kbCurrentProp.GetValue(null, null));
+        private static object m_currentKeyboard;
+        private static PropertyInfo m_kbCurrentProp;
+        private static PropertyInfo m_kbIndexer;
+
+        private static object CurrentMouse => m_currentMouse ?? (m_currentMouse = m_mouseCurrentProp.GetValue(null, null));
+        private static object m_currentMouse;
+        private static PropertyInfo m_mouseCurrentProp;
+
+        private static object LeftMouseButton => m_lmb ?? (m_lmb = m_leftButtonProp.GetValue(CurrentMouse, null));
+        private static object m_lmb;
+        private static PropertyInfo m_leftButtonProp;
+
+        private static object RightMouseButton => m_rmb ?? (m_rmb = m_rightButtonProp.GetValue(CurrentMouse, null));
+        private static object m_rmb;
+        private static PropertyInfo m_rightButtonProp;
+
+        private static object MousePositionInfo => m_pos ?? (m_pos = m_positionProp.GetValue(CurrentMouse, null));
+        private static object m_pos;
+        private static PropertyInfo m_positionProp;
+        private static MethodInfo m_readVector2InputMethod;
+
+        public Vector2 MousePosition
+        {
+            get
+            {
+                try
+                {
+                    return (Vector2)m_readVector2InputMethod.Invoke(MousePositionInfo, new object[0]);
+                }
+                catch
+                {
+                    return Vector2.zero;
+                }
+            }
+        }
+
+        internal static Dictionary<KeyCode, object> ActualKeyDict = new Dictionary<KeyCode, object>();
+
+        internal object GetActualKey(KeyCode key)
+        {
+            if (!ActualKeyDict.ContainsKey(key))
+            {
+                var s = key.ToString();
+                if (s.Contains("Control"))
+                    s = s.Replace("Control", "Ctrl");
+                else if (s.Contains("Return"))
+                    s = "Enter";
+
+                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)
+            {
+                case 0: return (bool)m_btnWasPressedProp.GetValue(LeftMouseButton, null);
+                case 1: return (bool)m_btnWasPressedProp.GetValue(RightMouseButton, null);
+                // case 2: return (bool)_btnWasPressedProp.GetValue(MiddleMouseButton, null);
+                default: throw new NotImplementedException();
+            }
+        }
+
+        public bool GetMouseButton(int btn)
+        {
+            switch (btn)
+            {
+                case 0: return (bool)m_btnIsPressedProp.GetValue(LeftMouseButton, null);
+                case 1: return (bool)m_btnIsPressedProp.GetValue(RightMouseButton, null);
+                // case 2: return (bool)_btnIsPressedProp.GetValue(MiddleMouseButton, null);
+                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
+
+
+        }
+    }
+}

src/Core/Input/LegacyInput.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Reflection;
+using UnityExplorer.Core.Unity;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityExplorer.UI;
+
+namespace UnityExplorer.Core.Input
+{
+    public class LegacyInput : IHandleInput
+    {
+        public LegacyInput()
+        {
+            ExplorerCore.Log("Initializing Legacy Input support...");
+
+            m_mousePositionProp = TInput.GetProperty("mousePosition");
+            m_getKeyMethod = TInput.GetMethod("GetKey", new Type[] { typeof(KeyCode) });
+            m_getKeyDownMethod = TInput.GetMethod("GetKeyDown", new Type[] { typeof(KeyCode) });
+            m_getMouseButtonMethod = TInput.GetMethod("GetMouseButton", new Type[] { typeof(int) });
+            m_getMouseButtonDownMethod = TInput.GetMethod("GetMouseButtonDown", new Type[] { typeof(int) });
+        }
+
+        public static Type TInput => m_tInput ?? (m_tInput = ReflectionUtility.GetTypeByName("UnityEngine.Input"));
+        private static Type m_tInput;
+
+        private static PropertyInfo m_mousePositionProp;
+        private static MethodInfo m_getKeyMethod;
+        private static MethodInfo m_getKeyDownMethod;
+        private static MethodInfo m_getMouseButtonMethod;
+        private static MethodInfo m_getMouseButtonDownMethod;
+
+        public Vector2 MousePosition => (Vector3)m_mousePositionProp.GetValue(null, null);
+
+        public bool GetKey(KeyCode key) => (bool)m_getKeyMethod.Invoke(null, new object[] { key });
+
+        public bool GetKeyDown(KeyCode key) => (bool)m_getKeyDownMethod.Invoke(null, new object[] { key });
+
+        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();
+        }
+    }
+}

src/Core/Input/NoInput.cs

@@ -0,0 +1,23 @@
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace UnityExplorer.Core.Input
+{
+    // Just a stub for games where no Input module was able to load at all.
+
+    public class NoInput : IHandleInput
+    {
+        public Vector2 MousePosition => Vector2.zero;
+
+        public bool GetKey(KeyCode key) => false;
+        public bool GetKeyDown(KeyCode key) => false;
+
+        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() { }
+    }
+}