3.3.0 rewrite

* Huge restructure/rewrite. No real changes to any functionality, just a cleaner and more manageable project.

src/Core/CSharp/ScriptInteraction.cs

@@ -1,14 +1,12 @@
 using System;
 using Mono.CSharp;
-using UnityExplorer.UI;
-using UnityExplorer.UI.Main;
-using UnityExplorer.Core.Inspectors;
-using UnityExplorer.UI.Main.CSConsole;
 using System.Collections;
 using UnityEngine;
 using System.Collections.Generic;
 using System.Linq;
 using UnityExplorer.Core.Runtime;
+using UnityExplorer.UI.Main.CSConsole;
+using UnityExplorer.UI.Main.Home;
 
 namespace UnityExplorer.Core.CSharp
 {

src/Core/CSharp/Suggestion.cs

@@ -4,7 +4,6 @@ using System.Linq;
 using System.Reflection;
 using UnityEngine;
 using UnityExplorer.Core;
-using UnityExplorer.Core.Unity;
 using UnityExplorer.UI.Main.CSConsole;
 
 namespace UnityExplorer.Core.CSharp
@@ -47,8 +46,8 @@ namespace UnityExplorer.Core.CSharp
 
         // ~~~~ Static ~~~~
 
-        public static HashSet<string> Namespaces => m_namspaces ?? GetNamespaces();
-        private static HashSet<string> m_namspaces;
+        public static HashSet<string> Namespaces => m_namespaces ?? GetNamespaces();
+        private static HashSet<string> m_namespaces;
 
         public static HashSet<string> Keywords => m_keywords ?? (m_keywords = new HashSet<string>(CSLexerHighlighter.validKeywordMatcher.Keywords));
         private static HashSet<string> m_keywords;
@@ -63,7 +62,7 @@ namespace UnityExplorer.Core.CSharp
                             .Where(x => x.IsPublic && !string.IsNullOrEmpty(x.Namespace))
                             .Select(x => x.Namespace));
 
-            return m_namspaces = set;
+            return m_namespaces = set;
 
             IEnumerable<Type> GetTypes(Assembly asm) => asm.TryGetTypes();
         }

src/Core/Config/ConfigElement.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace UnityExplorer.Core.Config
+{
+    public class ConfigElement<T> : IConfigElement
+    {
+        public string Name { get; }
+        public string Description { get; }
+
+        public bool IsInternal { get; }
+        public Type ElementType => typeof(T);
+
+        public Action<T> OnValueChanged;
+        public Action OnValueChangedNotify { get; set; }
+
+        public T Value
+        {
+            get => m_value;
+            set => SetValue(value);
+        }
+        private T m_value;
+
+        object IConfigElement.BoxedValue
+        {
+            get => m_value;
+            set => SetValue((T)value);
+        }
+
+        public ConfigElement(string name, string description, T defaultValue, bool isInternal)
+        {
+            Name = name;
+            Description = description;
+
+            m_value = defaultValue;
+
+            IsInternal = isInternal;
+
+            ConfigManager.RegisterConfigElement(this);
+        }
+
+        private void SetValue(T value)
+        {
+            if ((m_value == null && value == null) || m_value.Equals(value))
+                return;
+
+            m_value = value;
+
+            ConfigManager.Handler.SetConfigValue(this, value);
+
+            OnValueChanged?.Invoke(value);
+            OnValueChangedNotify?.Invoke();
+        }
+
+        object IConfigElement.GetLoaderConfigValue() => GetLoaderConfigValue();
+
+        public T GetLoaderConfigValue()
+        {
+            return ConfigManager.Handler.GetConfigValue(this);
+        }
+    }
+}

src/Core/Config/ConfigManager.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using UnityExplorer.UI.Main;
+using UnityExplorer.UI.Main.Home;
+
+namespace UnityExplorer.Core.Config
+{
+    public static class ConfigManager
+    {
+        // Each Loader has its own ConfigHandler.
+        // See the UnityExplorer.Loader namespace for the implementations.
+        public static IConfigHandler Handler { get; private set; }
+
+        public static ConfigElement<KeyCode> Main_Menu_Toggle;
+        public static ConfigElement<int>     Default_Page_Limit;
+        public static ConfigElement<string>  Default_Output_Path;
+        public static ConfigElement<bool>    Log_Unity_Debug;
+        public static ConfigElement<bool>    Hide_On_Startup;
+        public static ConfigElement<string>  Last_Window_Anchors;
+        public static ConfigElement<int>     Last_Active_Tab;
+        public static ConfigElement<bool>    Last_DebugConsole_State;
+        public static ConfigElement<bool>    Last_SceneExplorer_State;
+
+        internal static readonly Dictionary<string, IConfigElement> ConfigElements = new Dictionary<string, IConfigElement>();
+
+        public static void Init(IConfigHandler configHandler)
+        {
+            Handler = configHandler;
+            Handler.Init();
+
+            CreateConfigElements();
+
+            Handler.LoadConfig();
+
+            SceneExplorer.OnToggleShow += SceneExplorer_OnToggleShow;
+            PanelDragger.OnFinishResize += PanelDragger_OnFinishResize;
+            MainMenu.OnActiveTabChanged += MainMenu_OnActiveTabChanged;
+            DebugConsole.OnToggleShow += DebugConsole_OnToggleShow;
+        }
+
+        internal static void RegisterConfigElement<T>(ConfigElement<T> configElement)
+        {
+            Handler.RegisterConfigElement(configElement);
+            ConfigElements.Add(configElement.Name, configElement);
+        }
+
+        private static void CreateConfigElements()
+        {
+            Main_Menu_Toggle = new ConfigElement<KeyCode>("Main Menu Toggle",
+                "The UnityEngine.KeyCode to toggle the UnityExplorer Menu.",
+                KeyCode.F7,
+                false);
+
+            Default_Page_Limit = new ConfigElement<int>("Default Page Limit",
+                "The default maximum number of elements per 'page' in UnityExplorer.",
+                25,
+                false);
+
+            Default_Output_Path = new ConfigElement<string>("Default Output Path",
+                "The default output path when exporting things from UnityExplorer.",
+                Path.Combine(ExplorerCore.Loader.ExplorerFolder, "Output"),
+                false);
+
+            Log_Unity_Debug = new ConfigElement<bool>("Log Unity Debug",
+                "Should UnityEngine.Debug.Log messages be printed to UnityExplorer's log?",
+                false,
+                false);
+
+            Hide_On_Startup = new ConfigElement<bool>("Hide On Startup",
+                "Should UnityExplorer be hidden on startup?",
+                false,
+                false);
+
+            Last_Window_Anchors = new ConfigElement<string>("Last_Window_Anchors",
+                "For internal use, the last anchors of the UnityExplorer window.",
+                DEFAULT_WINDOW_ANCHORS,
+                true);
+
+            Last_Active_Tab = new ConfigElement<int>("Last_Active_Tab",
+                "For internal use, the last active tab index.",
+                0,
+                true);
+
+            Last_DebugConsole_State = new ConfigElement<bool>("Last_DebugConsole_State",
+                "For internal use, the collapsed state of the Debug Console.",
+                true,
+                true);
+
+            Last_SceneExplorer_State = new ConfigElement<bool>("Last_SceneExplorer_State",
+                "For internal use, the collapsed state of the Scene Explorer.",
+                true,
+                true);
+        }
+
+        // Internal config callback listeners
+
+        private static void PanelDragger_OnFinishResize(RectTransform rect)
+        {
+            Last_Window_Anchors.Value = RectAnchorsToString(rect);
+            Handler.SaveConfig();
+        }
+
+        private static void MainMenu_OnActiveTabChanged(int page)
+        {
+            Last_Active_Tab.Value = page;
+            Handler.SaveConfig();
+        }
+
+        private static void DebugConsole_OnToggleShow(bool showing)
+        {
+            Last_DebugConsole_State.Value = showing;
+            Handler.SaveConfig();
+        }
+
+        private static void SceneExplorer_OnToggleShow(bool showing)
+        {
+            Last_SceneExplorer_State.Value = showing;
+            Handler.SaveConfig();
+        }
+
+        // Window Anchors helpers
+
+        private const string DEFAULT_WINDOW_ANCHORS = "0.25,0.10,0.78,0.95";
+
+        internal static CultureInfo _enCulture = new CultureInfo("en-US");
+
+        internal static string RectAnchorsToString(this RectTransform rect)
+        {
+            try
+            {
+                return string.Format(_enCulture, "{0},{1},{2},{3}", new object[]
+                {
+                    rect.anchorMin.x,
+                    rect.anchorMin.y,
+                    rect.anchorMax.x,
+                    rect.anchorMax.y
+                });
+            }
+            catch
+            {
+                return DEFAULT_WINDOW_ANCHORS;
+            }
+        }
+
+        internal static void SetAnchorsFromString(this RectTransform panel, string stringAnchors)
+        {
+            Vector4 anchors;
+            try
+            {
+                var split = stringAnchors.Split(',');
+
+                if (split.Length != 4)
+                    throw new Exception();
+
+                anchors.x = float.Parse(split[0], _enCulture);
+                anchors.y = float.Parse(split[1], _enCulture);
+                anchors.z = float.Parse(split[2], _enCulture);
+                anchors.w = float.Parse(split[3], _enCulture);
+            }
+            catch
+            {
+                anchors = new Vector4(0.25f, 0.1f, 0.78f, 0.95f);
+            }
+
+            panel.anchorMin = new Vector2(anchors.x, anchors.y);
+            panel.anchorMax = new Vector2(anchors.z, anchors.w);
+        }
+    }
+}

src/Core/Config/ExplorerConfig.cs

@@ -1,205 +0,0 @@
-using System;
-using System.IO;
-using UnityEngine;
-using IniParser;
-using IniParser.Parser;
-using UnityExplorer.UI;
-using System.Globalization;
-using UnityExplorer.Core.Inspectors;
-using UnityExplorer.UI.Main;
-
-namespace UnityExplorer.Core.Config
-{
-    public class ExplorerConfig
-    {
-        public static ExplorerConfig Instance;
-
-        internal static readonly IniDataParser _parser = new IniDataParser();
-        internal static readonly string INI_PATH = Path.Combine(ExplorerCore.Loader.ConfigFolder, "config.ini");
-
-        internal static CultureInfo _enCulture = new CultureInfo("en-US");
-
-        // Actual configs
-        public KeyCode  Main_Menu_Toggle     = KeyCode.F7;
-        public bool     Force_Unlock_Mouse   = true;
-        public int      Default_Page_Limit   = 25;
-        public string   Default_Output_Path  = Path.Combine(ExplorerCore.EXPLORER_FOLDER, "Output");
-        public bool     Log_Unity_Debug      = false;
-        public bool     Hide_On_Startup      = false;
-        public string   Window_Anchors       = DEFAULT_WINDOW_ANCHORS;
-        public int      Active_Tab           = 0;
-        public bool     DebugConsole_Hidden  = false;
-        public bool     SceneExplorer_Hidden = false;
-
-        private const string DEFAULT_WINDOW_ANCHORS = "0.25,0.10,0.78,0.95";
-
-        public static event Action OnConfigChanged;
-
-        internal static void InvokeConfigChanged()
-        {
-            OnConfigChanged?.Invoke();
-        }
-
-        public static void OnLoad()
-        {
-            Instance = new ExplorerConfig();
-            _parser.Configuration.CommentString = "#";
-
-            PanelDragger.OnFinishResize += PanelDragger_OnFinishResize;
-            SceneExplorer.OnToggleShow += SceneExplorer_OnToggleShow;
-            DebugConsole.OnToggleShow += DebugConsole_OnToggleShow;
-            MainMenu.OnActiveTabChanged += MainMenu_OnActiveTabChanged;
-
-            if (LoadSettings())
-                return;
-
-            SaveSettings();
-        }
-
-        public static bool LoadSettings()
-        {
-            if (!File.Exists(INI_PATH))
-                return false;
-
-            string ini = File.ReadAllText(INI_PATH);
-
-            var data = _parser.Parse(ini);
-
-            foreach (var config in data.Sections["Config"])
-            {
-                switch (config.KeyName)
-                {
-                    case nameof(Main_Menu_Toggle):
-                        Instance.Main_Menu_Toggle = (KeyCode)Enum.Parse(typeof(KeyCode), config.Value);
-                        break;
-                    case nameof(Force_Unlock_Mouse):
-                        Instance.Force_Unlock_Mouse = bool.Parse(config.Value);
-                        break;
-                    case nameof(Default_Page_Limit):
-                        Instance.Default_Page_Limit = int.Parse(config.Value);
-                        break;
-                    case nameof(Log_Unity_Debug):
-                        Instance.Log_Unity_Debug = bool.Parse(config.Value);
-                        break;
-                    case nameof(Default_Output_Path):
-                        Instance.Default_Output_Path = config.Value;
-                        break;
-                    case nameof(Hide_On_Startup):
-                        Instance.Hide_On_Startup = bool.Parse(config.Value);
-                        break;
-                    case nameof(Window_Anchors):
-                        Instance.Window_Anchors = config.Value;
-                        break;
-                    case nameof(Active_Tab):
-                        Instance.Active_Tab = int.Parse(config.Value);
-                        break;
-                    case nameof(DebugConsole_Hidden):
-                        Instance.DebugConsole_Hidden = bool.Parse(config.Value);
-                        break;
-                    case nameof(SceneExplorer_Hidden):
-                        Instance.SceneExplorer_Hidden = bool.Parse(config.Value);
-                        break;
-                }
-            }
-
-            return true;
-        }
-
-        public static void SaveSettings()
-        {
-            var data = new IniParser.Model.IniData();
-
-            data.Sections.AddSection("Config");
-
-            var sec = data.Sections["Config"];
-            sec.AddKey(nameof(Main_Menu_Toggle),     Instance.Main_Menu_Toggle.ToString());
-            sec.AddKey(nameof(Force_Unlock_Mouse),   Instance.Force_Unlock_Mouse.ToString());
-            sec.AddKey(nameof(Default_Page_Limit),   Instance.Default_Page_Limit.ToString());
-            sec.AddKey(nameof(Log_Unity_Debug),      Instance.Log_Unity_Debug.ToString());
-            sec.AddKey(nameof(Default_Output_Path),  Instance.Default_Output_Path);
-            sec.AddKey(nameof(Hide_On_Startup),      Instance.Hide_On_Startup.ToString());
-            sec.AddKey(nameof(Window_Anchors),       GetWindowAnchorsString());
-            sec.AddKey(nameof(Active_Tab),           Instance.Active_Tab.ToString());
-            sec.AddKey(nameof(DebugConsole_Hidden),  Instance.DebugConsole_Hidden.ToString());
-            sec.AddKey(nameof(SceneExplorer_Hidden), Instance.SceneExplorer_Hidden.ToString());
-
-            if (!Directory.Exists(ExplorerCore.Loader.ConfigFolder))
-                Directory.CreateDirectory(ExplorerCore.Loader.ConfigFolder);
-
-            File.WriteAllText(INI_PATH, data.ToString());
-        }
-
-        private static void SceneExplorer_OnToggleShow()
-        {
-            Instance.SceneExplorer_Hidden = SceneExplorer.UI.Hiding;
-            SaveSettings();
-        }
-
-        private static void DebugConsole_OnToggleShow()
-        {
-            Instance.DebugConsole_Hidden = DebugConsole.Hiding;
-            SaveSettings();
-        }
-
-        private static void MainMenu_OnActiveTabChanged(int page)
-        {
-            Instance.Active_Tab = page;
-            SaveSettings();
-        }
-
-        // ============ Window Anchors specific stuff ============== //
-
-        private static void PanelDragger_OnFinishResize()
-        {
-            Instance.Window_Anchors = GetWindowAnchorsString();
-            SaveSettings();
-        }
-
-        internal Vector4 GetWindowAnchorsVector()
-        {
-            try
-            {
-                var split = Window_Anchors.Split(',');
-
-                if (split.Length != 4)
-                    throw new Exception();
-
-                Vector4 ret = Vector4.zero;
-                ret.x = float.Parse(split[0], _enCulture);
-                ret.y = float.Parse(split[1], _enCulture);
-                ret.z = float.Parse(split[2], _enCulture);
-                ret.w = float.Parse(split[3], _enCulture);
-                return ret;
-            }
-            catch
-            {
-                return DefaultWindowAnchors();
-            }
-        }
-
-        internal static string GetWindowAnchorsString()
-        {
-            try
-            {
-                var rect = PanelDragger.Instance.Panel;
-                return string.Format(_enCulture, "{0},{1},{2},{3}", new object[]
-                {
-                    rect.anchorMin.x,
-                    rect.anchorMin.y,
-                    rect.anchorMax.x,
-                    rect.anchorMax.y
-                });
-            }
-            catch
-            {
-                return DEFAULT_WINDOW_ANCHORS;
-            }
-        }
-
-        internal static Vector4 DefaultWindowAnchors()
-        {
-            Instance.Window_Anchors = DEFAULT_WINDOW_ANCHORS;
-            return new Vector4(0.25f, 0.1f, 0.78f, 0.95f);
-        }
-    }
-}

src/Core/Config/IConfigElement.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace UnityExplorer.Core.Config
+{
+    public interface IConfigElement
+    {
+        string Name { get; }
+        string Description { get; }
+
+        bool IsInternal { get; }
+        Type ElementType { get; }
+
+        object BoxedValue { get; set; }
+
+        object GetLoaderConfigValue();
+
+        Action OnValueChangedNotify { get; set; }
+    }
+}

src/Core/Config/IConfigHandler.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace UnityExplorer.Core.Config
+{
+    public interface IConfigHandler
+    {
+        void RegisterConfigElement<T>(ConfigElement<T> element);
+
+        void SetConfigValue<T>(ConfigElement<T> element, T value);
+
+        T GetConfigValue<T>(ConfigElement<T> element);
+
+        void Init();
+
+        void LoadConfig();
+
+        void SaveConfig();
+    }
+}

src/Core/Input/CursorUnlocker.cs

@@ -0,0 +1,238 @@
+using System;
+using UnityEngine;
+using UnityExplorer.Core.Unity;
+using UnityEngine.EventSystems;
+using UnityExplorer.Core.Input;
+using BF = System.Reflection.BindingFlags;
+using UnityExplorer.Core.Config;
+using UnityExplorer.Core;
+using UnityExplorer.UI;
+#if ML
+using Harmony;
+#else
+using HarmonyLib;
+#endif
+
+namespace UnityExplorer.Core.Input
+{
+    public class CursorUnlocker
+    {
+        //public static bool Unlock
+        //{
+        //    get => m_forceUnlock;
+        //    set => SetForceUnlock(value);
+        //}
+        //private static bool m_forceUnlock;
+
+        //private static void SetForceUnlock(bool unlock)
+        //{
+        //    m_forceUnlock = unlock;
+        //    UpdateCursorControl();
+        //}
+
+        //public static bool ShouldForceMouse => UIManager.ShowMenu && Unlock;
+
+        private static CursorLockMode m_lastLockMode;
+        private static bool m_lastVisibleState;
+
+        private static bool m_currentlySettingCursor = false;
+
+        private static Type CursorType
+            => m_cursorType
+            ?? (m_cursorType = ReflectionUtility.GetTypeByName("UnityEngine.Cursor"));
+        private static Type m_cursorType;
+
+        public static void Init()
+        {
+            SetupPatches();
+
+            UpdateCursorControl();
+
+            //Unlock = true;
+        }
+
+        private static void SetupPatches()
+        {
+            try
+            {
+                if (CursorType == null)
+                {
+                    throw new Exception("Could not find Type 'UnityEngine.Cursor'!");
+                }
+
+                // Get current cursor state and enable cursor
+                try
+                {
+                    m_lastLockMode = (CursorLockMode?)typeof(Cursor).GetProperty("lockState", BF.Public | BF.Static)?.GetValue(null, null)
+                                     ?? CursorLockMode.None;
+
+                    m_lastVisibleState = (bool?)typeof(Cursor).GetProperty("visible", BF.Public | BF.Static)?.GetValue(null, null)
+                                         ?? false;
+                }
+                catch { }
+
+                // Setup Harmony Patches
+                TryPatch(typeof(Cursor),
+                    "lockState",
+                    new HarmonyMethod(typeof(CursorUnlocker).GetMethod(nameof(Prefix_set_lockState))),
+                    true);
+
+                TryPatch(typeof(Cursor),
+                    "visible",
+                    new HarmonyMethod(typeof(CursorUnlocker).GetMethod(nameof(Prefix_set_visible))),
+                    true);
+
+                TryPatch(typeof(EventSystem),
+                    "current",
+                    new HarmonyMethod(typeof(CursorUnlocker).GetMethod(nameof(Prefix_EventSystem_set_current))),
+                    true);
+            }
+            catch (Exception e)
+            {
+                ExplorerCore.Log($"Exception on ForceUnlockCursor.Init! {e.GetType()}, {e.Message}");
+            }
+        }
+
+        private static void TryPatch(Type type, string property, HarmonyMethod patch, bool setter)
+        {
+            try
+            {
+                var harmony = ExplorerCore.Loader.HarmonyInstance;
+
+                var prop = type.GetProperty(property);
+
+                if (setter) // setter is prefix
+                {
+                    harmony.Patch(prop.GetSetMethod(), prefix: patch);
+                }
+                else // getter is postfix
+                {
+                    harmony.Patch(prop.GetGetMethod(), postfix: patch);
+                }
+            }
+            catch (Exception e)
+            {
+                string suf = setter ? "set_" : "get_";
+                ExplorerCore.Log($"Unable to patch {type.Name}.{suf}{property}: {e.Message}");
+            }
+        }
+
+        public static void UpdateCursorControl()
+        {
+            try
+            {
+                m_currentlySettingCursor = true;
+                if (UIManager.ShowMenu)
+                {
+                    Cursor.lockState = CursorLockMode.None;
+                    Cursor.visible = true;
+                }
+                else
+                {
+                    Cursor.lockState = m_lastLockMode;
+                    Cursor.visible = m_lastVisibleState;
+                }
+                m_currentlySettingCursor = false;
+            }
+            catch (Exception e)
+            {
+                ExplorerCore.Log($"Exception setting Cursor state: {e.GetType()}, {e.Message}");
+            }
+        }
+
+        // Event system overrides
+
+        private static bool m_settingEventSystem;
+        private static EventSystem m_lastEventSystem;
+        private static BaseInputModule m_lastInputModule;
+
+        public static void SetEventSystem()
+        {
+            // temp disabled for new InputSystem
+            if (InputManager.CurrentType == InputType.InputSystem)
+                return;
+
+            // Disable current event system object
+            if (m_lastEventSystem || EventSystem.current)
+            {
+                if (!m_lastEventSystem)
+                    m_lastEventSystem = EventSystem.current;
+
+                //ExplorerCore.Log("Disabling current event system...");
+                m_lastEventSystem.enabled = false;
+                //m_lastEventSystem.gameObject.SetActive(false);
+            }
+
+            // Set to our current system
+            m_settingEventSystem = true;
+            EventSystem.current = UIManager.EventSys;
+            UIManager.EventSys.enabled = true;
+            InputManager.ActivateUIModule();
+            m_settingEventSystem = false;
+        }
+
+        public static void ReleaseEventSystem()
+        {
+            if (InputManager.CurrentType == InputType.InputSystem)
+                return;
+
+            if (m_lastEventSystem)
+            {
+                m_lastEventSystem.enabled = true;
+                //m_lastEventSystem.gameObject.SetActive(true);
+
+                m_settingEventSystem = true;
+                EventSystem.current = m_lastEventSystem;
+                m_lastInputModule?.ActivateModule();
+                m_settingEventSystem = false;
+            }
+        }
+
+        [HarmonyPrefix]
+        public static void Prefix_EventSystem_set_current(ref EventSystem value)
+        {
+            if (!m_settingEventSystem)
+            {
+                m_lastEventSystem = value;
+                m_lastInputModule = value?.currentInputModule;
+
+                if (UIManager.ShowMenu)
+                {
+                    value = UIManager.EventSys;
+                }
+            }
+        }
+
+        // Force mouse to stay unlocked and visible while UnlockMouse and ShowMenu are true.
+        // Also keep track of when anything else tries to set Cursor state, this will be the
+        // value that we set back to when we close the menu or disable force-unlock.
+
+        [HarmonyPrefix]
+        public static void Prefix_set_lockState(ref CursorLockMode value)
+        {
+            if (!m_currentlySettingCursor)
+            {
+                m_lastLockMode = value;
+
+                if (UIManager.ShowMenu)
+                {
+                    value = CursorLockMode.None;
+                }
+            }
+        }
+
+        [HarmonyPrefix]
+        public static void Prefix_set_visible(ref bool value)
+        {
+            if (!m_currentlySettingCursor)
+            {
+                m_lastVisibleState = value;
+
+                if (UIManager.ShowMenu)
+                {
+                    value = true;
+                }
+            }
+        }
+    }
+}

src/Core/Input/InputManager.cs

@@ -56,6 +56,8 @@ namespace UnityExplorer.Core.Input
                 m_inputModule = new NoInput();
                 CurrentType = InputType.None;
             }
+
+            CursorUnlocker.Init();
         }
     }
 }

src/Core/InspectorManager.cs

@@ -1,138 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.UI;
-using UnityExplorer.UI.Main;
-using UnityEngine;
-using UnityEngine.SceneManagement;
-using UnityEngine.UI;
-using UnityExplorer.Core.Inspectors.Reflection;
-using UnityExplorer.Core.Runtime;
-using UnityExplorer.UI.Main.Home;
-
-namespace UnityExplorer.Core.Inspectors
-{
-    public class InspectorManager
-    {
-        public static InspectorManager Instance { get; private set; }
-
-        internal static InspectorManagerUI UI;
-
-        public InspectorManager() 
-        {
-            Instance = this;
-
-            UI = new InspectorManagerUI(); 
-            UI.ConstructInspectorPane();
-        }
-
-        public InspectorBase m_activeInspector;
-        public readonly List<InspectorBase> m_currentInspectors = new List<InspectorBase>();
-
-        public void Update()
-        {
-            for (int i = 0; i < m_currentInspectors.Count; i++)
-            {
-                if (i >= m_currentInspectors.Count)
-                    break;
-
-                m_currentInspectors[i].Update();
-            }
-        }
-
-        public void Inspect(object obj, CacheObjectBase parentMember = null)
-        {
-            obj = ReflectionProvider.Instance.Cast(obj, ReflectionProvider.Instance.GetActualType(obj));
-
-            UnityEngine.Object unityObj = obj as UnityEngine.Object;
-
-            if (obj.IsNullOrDestroyed(false))
-            {
-                return;
-            }
-
-            // check if currently inspecting this object
-            foreach (InspectorBase tab in m_currentInspectors)
-            {
-                if (ReferenceEquals(obj, tab.Target))
-                {
-                    SetInspectorTab(tab);
-                    return;
-                }
-#if CPP
-                else if (unityObj && tab.Target is UnityEngine.Object uTabObj)
-                {
-                    if (unityObj.m_CachedPtr == uTabObj.m_CachedPtr)
-                    {
-                        SetInspectorTab(tab);
-                        return;
-                    }
-                }
-#endif
-            }
-
-            InspectorBase inspector;
-            if (obj is GameObject go)
-                inspector = new GameObjectInspector(go);
-            else
-                inspector = new InstanceInspector(obj);
-
-            if (inspector is ReflectionInspector ri)
-                ri.ParentMember = parentMember;
-
-            m_currentInspectors.Add(inspector);
-            SetInspectorTab(inspector);
-        }
-
-        public void Inspect(Type type)
-        {
-            if (type == null)
-            { 
-                ExplorerCore.LogWarning("The provided type was null!");
-                return;
-            }
-
-            foreach (var tab in m_currentInspectors.Where(x => x is StaticInspector))
-            {
-                if (ReferenceEquals(tab.Target as Type, type))
-                {
-                    SetInspectorTab(tab);
-                    return;
-                }
-            }
-
-            var inspector = new StaticInspector(type);
-
-            m_currentInspectors.Add(inspector);
-            SetInspectorTab(inspector);
-        }
-
-        public void SetInspectorTab(InspectorBase inspector)
-        {
-            MainMenu.Instance.SetPage(HomePage.Instance);
-
-            if (m_activeInspector == inspector)
-                return;
-
-            UnsetInspectorTab();
-
-            m_activeInspector = inspector;
-            inspector.SetActive();
-
-            UI.OnSetInspectorTab(inspector);
-        }
-
-        public void UnsetInspectorTab()
-        {
-            if (m_activeInspector == null)
-                return;
-
-            m_activeInspector.SetInactive();
-
-            UI.OnUnsetInspectorTab();
-
-            m_activeInspector = null;
-        }
-    }
-}

src/Core/Inspectors/GameObjects/GameObjectInspector.cs

@@ -1,101 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using UnityExplorer.UI;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.Core.Runtime;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.UI.Main.Home.Inspectors;
-
-namespace UnityExplorer.Core.Inspectors
-{
-    public class GameObjectInspector : InspectorBase
-    {
-        public override string TabLabel => $" <color=cyan>[G]</color> {TargetGO?.name}";
-
-        public static GameObjectInspector ActiveInstance { get; private set; }
-
-        public GameObject TargetGO;
-
-        public GameObjectInspectorUI UIModule;
-
-        // sub modules
-        internal static ChildList s_childList;
-        internal static ComponentList s_compList;
-        internal static GameObjectControls s_controls;
-
-        internal static bool m_UIConstructed;
-
-        public GameObjectInspector(GameObject target) : base(target)
-        {
-            ActiveInstance = this;
-
-            TargetGO = target;
-
-            if (!TargetGO)
-            {
-                ExplorerCore.LogWarning("Target GameObject is null!");
-                return;
-            }
-
-            // one UI is used for all gameobject inspectors. no point recreating it.
-            if (!m_UIConstructed)
-            {
-                m_UIConstructed = true;
-
-                s_childList = new ChildList();
-                s_compList = new ComponentList();
-                s_controls = new GameObjectControls();
-
-                UIModule.ConstructUI();
-            }
-        }
-
-        public override void SetActive()
-        {
-            base.SetActive();
-            ActiveInstance = this;
-        }
-
-        public override void SetInactive()
-        {
-            base.SetInactive();
-            ActiveInstance = null;
-        }
-
-        internal void ChangeInspectorTarget(GameObject newTarget)
-        {
-            if (!newTarget)
-                return;
-
-            this.Target = this.TargetGO = newTarget;
-        }
-
-        // Update
-
-        public override void Update()
-        {
-            base.Update();
-
-            if (m_pendingDestroy || !this.IsActive)
-                return;
-
-            UIModule.RefreshTopInfo();
-
-            s_childList.RefreshChildObjectList();
-
-            s_compList.RefreshComponentList();
-
-            s_controls.RefreshControls();
-
-            if (GameObjectControls.s_sliderChangedWanted)
-                GameObjectControls.UpdateSliderControl();
-        }
-
-        public override void CreateUIModule()
-        {
-            base.BaseUI = UIModule = new GameObjectInspectorUI();
-        }
-    }
-}

src/Core/Inspectors/InspectUnderMouse.cs

@@ -1,294 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using UnityEngine;
-using UnityEngine.EventSystems;
-using UnityEngine.UI;
-using UnityExplorer.Core;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.Core.Input;
-using UnityExplorer.Core.Runtime;
-using UnityExplorer.UI;
-using UnityExplorer.UI.Main;
-using UnityExplorer.UI.Main.Home.Inspectors;
-
-namespace UnityExplorer.Core.Inspectors
-{
-    public class InspectUnderMouse
-    {
-        public enum MouseInspectMode
-        {
-            World,
-            UI
-        }
-
-        public static bool Enabled { get; set; }
-
-        public static MouseInspectMode Mode { get; set; }
-
-        private static GameObject s_lastHit;
-        private static Vector3 s_lastMousePos;
-
-        internal static MouseInspectorUI UI;
-
-        static InspectUnderMouse()
-        {
-            UI = new MouseInspectorUI();
-        }
-
-        private static readonly List<Graphic> _wasDisabledGraphics = new List<Graphic>();
-        private static readonly List<CanvasGroup> _wasDisabledCanvasGroups = new List<CanvasGroup>();
-        private static readonly List<GameObject> _objectsAddedCastersTo = new List<GameObject>();
-
-        public static void StartInspect(MouseInspectMode mode)
-        {
-            Mode = mode;
-            Enabled = true;
-            MainMenu.Instance.MainPanel.SetActive(false);
-            
-            UI.s_UIContent.SetActive(true);
-
-            if (mode == MouseInspectMode.UI)
-            {
-                SetupUIRaycast();
-            }
-        }
-
-        internal static void ClearHitData()
-        {
-            s_lastHit = null;
-            UI.s_objNameLabel.text = "No hits...";
-            UI.s_objPathLabel.text = "";
-        }
-
-        public static void StopInspect()
-        {
-            Enabled = false;
-            MainMenu.Instance.MainPanel.SetActive(true);
-            UI.s_UIContent.SetActive(false);
-
-            if (Mode == MouseInspectMode.UI)
-                StopUIInspect();
-
-            ClearHitData();
-        }
-
-        internal static GraphicRaycaster[] m_gCasters;
-
-        public static void UpdateInspect()
-        {
-            if (InputManager.GetKeyDown(KeyCode.Escape))
-            {
-                StopInspect();
-                return;
-            }
-
-            var mousePos = InputManager.MousePosition;
-
-            if (mousePos != s_lastMousePos)
-                UpdatePosition(mousePos);
-
-            if (!UnityHelper.MainCamera)
-                return;
-
-            // actual inspect raycast 
-
-            switch (Mode)
-            {
-                case MouseInspectMode.UI:
-                    RaycastUI(mousePos); break;
-                case MouseInspectMode.World:
-                    RaycastWorld(mousePos); break;
-            }
-        }
-
-        internal static void UpdatePosition(Vector2 mousePos)
-        {
-            s_lastMousePos = mousePos;
-
-            var inversePos = UIManager.CanvasRoot.transform.InverseTransformPoint(mousePos);
-
-            UI.s_mousePosLabel.text = $"<color=grey>Mouse Position:</color> {mousePos.ToString()}";
-
-            float yFix = mousePos.y < 120 ? 80 : -80;
-            UI.s_UIContent.transform.localPosition = new Vector3(inversePos.x, inversePos.y + yFix, 0);
-        }
-
-        internal static void OnHitGameObject(GameObject obj)
-        {
-            if (obj != s_lastHit)
-            {
-                s_lastHit = obj;
-                UI.s_objNameLabel.text = $"<b>Click to Inspect:</b> <color=cyan>{obj.name}</color>";
-                UI.s_objPathLabel.text = $"Path: {obj.transform.GetTransformPath(true)}";
-            }
-
-            if (InputManager.GetMouseButtonDown(0))
-            {
-                StopInspect();
-                InspectorManager.Instance.Inspect(obj);
-            }
-        }
-
-        // Collider raycasting
-
-        internal static void RaycastWorld(Vector2 mousePos)
-        {
-            var ray = UnityHelper.MainCamera.ScreenPointToRay(mousePos);
-            Physics.Raycast(ray, out RaycastHit hit, 1000f);
-
-            if (hit.transform)
-            {
-                var obj = hit.transform.gameObject;
-                OnHitGameObject(obj);
-            }
-            else
-            {
-                if (s_lastHit)
-                    ClearHitData();
-            }
-        }
-
-        // UI Graphic raycasting
-
-        private static void SetupUIRaycast()
-        {
-            foreach (var obj in RuntimeProvider.Instance.FindObjectsOfTypeAll(typeof(Canvas)))
-            {
-                var canvas = obj.Cast(typeof(Canvas)) as Canvas;
-                if (!canvas || !canvas.enabled || !canvas.gameObject.activeInHierarchy)
-                    continue;
-                if (!canvas.GetComponent<GraphicRaycaster>())
-                {
-                    canvas.gameObject.AddComponent<GraphicRaycaster>();
-                    //ExplorerCore.Log("Added raycaster to " + canvas.name);
-                    _objectsAddedCastersTo.Add(canvas.gameObject);
-                }
-            }
-
-            // recache Graphic Raycasters each time we start
-            var casters = RuntimeProvider.Instance.FindObjectsOfTypeAll(typeof(GraphicRaycaster));
-            m_gCasters = new GraphicRaycaster[casters.Length];
-            for (int i = 0; i < casters.Length; i++)
-            {
-                m_gCasters[i] = casters[i].Cast(typeof(GraphicRaycaster)) as GraphicRaycaster;
-            }
-
-            // enable raycastTarget on Graphics
-            foreach (var obj in RuntimeProvider.Instance.FindObjectsOfTypeAll(typeof(Graphic)))
-            {
-                var graphic = obj.Cast(typeof(Graphic)) as Graphic;
-                if (!graphic || !graphic.enabled || graphic.raycastTarget || !graphic.gameObject.activeInHierarchy)
-                    continue;
-                graphic.raycastTarget = true;
-                //ExplorerCore.Log("Enabled raycastTarget on " + graphic.name);
-                _wasDisabledGraphics.Add(graphic);
-            }
-
-            // enable blocksRaycasts on CanvasGroups
-            foreach (var obj in RuntimeProvider.Instance.FindObjectsOfTypeAll(typeof(CanvasGroup)))
-            {
-                var canvas = obj.Cast(typeof(CanvasGroup)) as CanvasGroup;
-                if (!canvas || !canvas.gameObject.activeInHierarchy || canvas.blocksRaycasts)
-                    continue;
-                canvas.blocksRaycasts = true;
-                //ExplorerCore.Log("Enabled raycasts on " + canvas.name);
-                _wasDisabledCanvasGroups.Add(canvas);
-            }
-        }
-
-        internal static void RaycastUI(Vector2 mousePos)
-        {
-            var ped = new PointerEventData(null)
-            {
-                position = mousePos
-            };
-
-#if MONO
-            var list = new List<RaycastResult>();
-#else
-            var list = new Il2CppSystem.Collections.Generic.List<RaycastResult>();
-#endif
-            //ExplorerCore.Log("~~~~~~~~~ begin raycast ~~~~~~~~");
-            GameObject hitObject = null;
-            int highestLayer = int.MinValue;
-            int highestOrder = int.MinValue;
-            int highestDepth = int.MinValue;
-            foreach (var gr in m_gCasters)
-            {
-                gr.Raycast(ped, list);
-
-                if (list.Count > 0)
-                {
-                    foreach (var hit in list)
-                    {
-                        if (!hit.gameObject)
-                            continue;
-
-                        if (hit.gameObject.GetComponent<CanvasGroup>() is CanvasGroup group && group.alpha == 0)
-                            continue;
-
-                        if (hit.gameObject.GetComponent<Graphic>() is Graphic graphic && graphic.color.a == 0f)
-                            continue;
-
-                        //ExplorerCore.Log("Hit: " + hit.gameObject.name + ", depth: " + hit.depth + ", layer: " + hit.sortingLayer + ", order: " + hit.sortingOrder);
-
-                        if (hit.sortingLayer < highestLayer)
-                            continue;
-
-                        if (hit.sortingLayer > highestLayer)
-                        {
-                            highestLayer = hit.sortingLayer;
-                            highestOrder = int.MinValue;
-                        }
-
-                        if (hit.depth < highestDepth)
-                            continue;
-
-                        if (hit.depth > highestDepth)
-                        {
-                            highestDepth = hit.depth;
-                            highestOrder = int.MinValue;
-                        }
-
-                        if (hit.sortingOrder <= highestOrder)
-                            continue;
-
-                        highestOrder = hit.sortingOrder;
-                        hitObject = hit.gameObject;
-                    }
-                }
-                else
-                {
-                    if (s_lastHit)
-                        ClearHitData();
-                }
-            }
-
-            if (hitObject)
-                OnHitGameObject(hitObject);
-
-            //ExplorerCore.Log("~~~~~~~~~ end raycast ~~~~~~~~");
-        }
-
-        private static void StopUIInspect()
-        {
-            foreach (var obj in _objectsAddedCastersTo)
-            {
-                if (obj.GetComponent<GraphicRaycaster>() is GraphicRaycaster raycaster)
-                    GameObject.Destroy(raycaster);
-            }
-
-            foreach (var graphic in _wasDisabledGraphics)
-                graphic.raycastTarget = false;
-
-            foreach (var canvas in _wasDisabledCanvasGroups)
-                canvas.blocksRaycasts = false;
-
-            _objectsAddedCastersTo.Clear();
-            _wasDisabledCanvasGroups.Clear();
-            _wasDisabledGraphics.Clear();
-        }
-    }
-}

src/Core/Inspectors/InspectorBase.cs

@@ -1,92 +0,0 @@
-using System;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.UI;
-using UnityExplorer.UI.Main.Home.Inspectors;
-
-namespace UnityExplorer.Core.Inspectors
-{
-    public abstract class InspectorBase
-    {
-        public object Target;
-
-        public InspectorBaseUI BaseUI;
-
-        public abstract string TabLabel { get; }
-
-        public bool IsActive { get; private set; }
-
-        internal bool m_pendingDestroy;
-
-        public InspectorBase(object target)
-        {
-            Target = target;
-
-            if (Target.IsNullOrDestroyed(false))
-            {
-                Destroy();
-                return;
-            }
-
-            CreateUIModule();
-
-            BaseUI.AddInspectorTab(this);
-        }
-
-        public abstract void CreateUIModule();
-
-        public virtual void SetActive()
-        {
-            this.IsActive = true;
-            BaseUI.Content?.SetActive(true);
-        }
-
-        public virtual void SetInactive()
-        {
-            this.IsActive = false;
-            BaseUI.Content?.SetActive(false);
-        }
-
-        public virtual void Update()
-        {
-            if (Target.IsNullOrDestroyed(false))
-            {
-                Destroy();
-                return;
-            }
-
-            BaseUI.tabText.text = TabLabel;
-        }
-
-        public virtual void Destroy()
-        {
-            m_pendingDestroy = true;
-
-            GameObject tabGroup = BaseUI.tabButton?.transform.parent.gameObject;
-
-            if (tabGroup)
-            {
-                GameObject.Destroy(tabGroup);
-            }
-
-            int thisIndex = -1;
-            if (InspectorManager.Instance.m_currentInspectors.Contains(this))
-            {
-                thisIndex = InspectorManager.Instance.m_currentInspectors.IndexOf(this);
-                InspectorManager.Instance.m_currentInspectors.Remove(this);
-            }
-
-            if (ReferenceEquals(InspectorManager.Instance.m_activeInspector, this))
-            {
-                InspectorManager.Instance.UnsetInspectorTab();
-
-                if (InspectorManager.Instance.m_currentInspectors.Count > 0)
-                {
-                    var prevTab = InspectorManager.Instance.m_currentInspectors[thisIndex > 0 ? thisIndex - 1 : 0];
-                    InspectorManager.Instance.SetInspectorTab(prevTab);
-                }
-            }
-        }
-    }
-}

src/Core/Inspectors/Reflection/CacheObject/CacheEnumerated.cs

@@ -1,63 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using UnityExplorer.UI;
-using UnityEngine;
-using UnityEngine.UI;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class CacheEnumerated : CacheObjectBase
-    {
-        public override Type FallbackType => ParentEnumeration.m_baseEntryType;
-        public override bool CanWrite => RefIList != null && ParentEnumeration.Owner.CanWrite;
-
-        public int Index { get; set; }
-        public IList RefIList { get; set; }
-        public InteractiveEnumerable ParentEnumeration { get; set; }
-
-        public CacheEnumerated(int index, InteractiveEnumerable parentEnumeration, IList refIList, GameObject parentContent)
-        {
-            this.ParentEnumeration = parentEnumeration;
-            this.Index = index;
-            this.RefIList = refIList;
-            this.m_parentContent = parentContent;
-        }
-
-        public override void CreateIValue(object value, Type fallbackType)
-        {
-            IValue = InteractiveValue.Create(value, fallbackType);
-            IValue.Owner = this;
-        }
-
-        public override void SetValue()
-        {
-            RefIList[Index] = IValue.Value;
-            ParentEnumeration.Value = RefIList;
-
-            ParentEnumeration.Owner.SetValue();
-        }
-
-        internal override void ConstructUI()
-        {
-            base.ConstructUI();
-
-            var rowObj = UIFactory.CreateHorizontalGroup(m_mainContent, new Color(1, 1, 1, 0));
-            var rowGroup = rowObj.GetComponent<HorizontalLayoutGroup>();
-            rowGroup.padding.left = 5;
-            rowGroup.padding.right = 2;
-
-            var indexLabelObj = UIFactory.CreateLabel(rowObj, TextAnchor.MiddleLeft);
-            var indexLayout = indexLabelObj.AddComponent<LayoutElement>();
-            indexLayout.minWidth = 20;
-            indexLayout.flexibleWidth = 30;
-            indexLayout.minHeight = 25;
-            var indexText = indexLabelObj.GetComponent<Text>();
-            indexText.text = this.Index + ":";
-
-            IValue.m_mainContentParent = rowObj;
-        }
-    }
-}

src/Core/Inspectors/Reflection/CacheObject/CacheField.cs

@@ -1,40 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Reflection;
-using UnityExplorer.UI;
-using UnityEngine;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class CacheField : CacheMember
-    {
-        public override bool IsStatic => (MemInfo as FieldInfo).IsStatic;
-
-        public override Type FallbackType => (MemInfo as FieldInfo).FieldType;
-
-        public CacheField(FieldInfo fieldInfo, object declaringInstance, GameObject parent) : base(fieldInfo, declaringInstance, parent)
-        {
-            CreateIValue(null, fieldInfo.FieldType);
-        }
-
-        public override void UpdateReflection()
-        {
-            var fi = MemInfo as FieldInfo;
-            IValue.Value = fi.GetValue(fi.IsStatic ? null : DeclaringInstance);
-
-            m_evaluated = true;
-            ReflectionException = null;
-        }
-
-        public override void SetValue()
-        {
-            var fi = MemInfo as FieldInfo;
-            fi.SetValue(fi.IsStatic ? null : DeclaringInstance, IValue.Value);
-
-            if (this.ParentInspector?.ParentMember != null)
-                this.ParentInspector.ParentMember.SetValue();
-        }
-    }
-}

src/Core/Inspectors/Reflection/CacheObject/CacheMember.cs

@@ -1,465 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.UI;
-using UnityExplorer.UI.Reusable;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.Core.Runtime;
-using UnityExplorer.Core;
-using UnityExplorer.UI.Utility;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public abstract class CacheMember : CacheObjectBase
-    {
-        public override bool IsMember => true;
-
-        public override Type FallbackType { get; }
-
-        public ReflectionInspector ParentInspector { get; set; }
-        public MemberInfo MemInfo { get; set; }
-        public Type DeclaringType { get; set; }
-        public object DeclaringInstance { get; set; }
-        public virtual bool IsStatic { get; private set; }
-
-        public string ReflectionException { get; set; }
-
-        public override bool CanWrite => m_canWrite ?? GetCanWrite();
-        private bool? m_canWrite;
-
-        public override bool HasParameters => ParamCount > 0;
-        public virtual int ParamCount => m_arguments.Length;
-        public override bool HasEvaluated => m_evaluated;
-        public bool m_evaluated = false;
-        public bool m_isEvaluating;
-        public ParameterInfo[] m_arguments = new ParameterInfo[0];
-        public string[] m_argumentInput = new string[0];
-
-        public string NameForFiltering => m_nameForFilter ?? (m_nameForFilter = $"{MemInfo.DeclaringType.Name}.{MemInfo.Name}".ToLower());
-        private string m_nameForFilter;
-
-        public string RichTextName => m_richTextName ?? GetRichTextName();
-        private string m_richTextName;
-
-        public CacheMember(MemberInfo memberInfo, object declaringInstance, GameObject parentContent)
-        {
-            MemInfo = memberInfo;
-            DeclaringType = memberInfo.DeclaringType;
-            DeclaringInstance = declaringInstance;
-            this.m_parentContent = parentContent;
-
-            DeclaringInstance = ReflectionProvider.Instance.Cast(declaringInstance, DeclaringType);
-        }
-
-        public static bool CanProcessArgs(ParameterInfo[] parameters)
-        {
-            foreach (var param in parameters)
-            {
-                var pType = param.ParameterType;
-
-                if (pType.IsByRef && pType.HasElementType)
-                    pType = pType.GetElementType();
-
-                if (pType != null && (pType.IsPrimitive || pType == typeof(string)))
-                    continue;
-                else
-                    return false;
-            }
-            return true;
-        }
-
-        public override void CreateIValue(object value, Type fallbackType)
-        {
-            IValue = InteractiveValue.Create(value, fallbackType);
-            IValue.Owner = this;
-            IValue.m_mainContentParent = this.m_rightGroup;
-            IValue.m_subContentParent = this.m_subContent;
-        }
-
-        public override void UpdateValue()
-        {
-            if (!HasParameters || m_isEvaluating)
-            {
-                try
-                {
-                    Type baseType = ReflectionUtility.GetType(IValue.Value) ?? FallbackType;
-
-                    if (!ReflectionProvider.Instance.IsReflectionSupported(baseType))
-                        throw new Exception("Type not supported with reflection");
-
-                    UpdateReflection();
-
-                    if (IValue.Value != null)
-                        IValue.Value = IValue.Value.Cast(ReflectionUtility.GetType(IValue.Value));
-                }
-                catch (Exception e)
-                {
-                    ReflectionException = e.ReflectionExToString(true);
-                }
-            }
-
-            base.UpdateValue();
-        }
-
-        public abstract void UpdateReflection();
-
-        public override void SetValue()
-        {
-            // no implementation for base class
-        }
-
-        public object[] ParseArguments()
-        {
-            if (m_arguments.Length < 1)
-                return new object[0];
-
-            var parsedArgs = new List<object>();
-            for (int i = 0; i < m_arguments.Length; i++)
-            {
-                var input = m_argumentInput[i];
-                var type = m_arguments[i].ParameterType;
-
-                if (type.IsByRef)
-                    type = type.GetElementType();
-
-                if (!string.IsNullOrEmpty(input))
-                {
-                    if (type == typeof(string))
-                    {
-                        parsedArgs.Add(input);
-                        continue;
-                    }
-                    else
-                    {
-                        try
-                        {
-                            var arg = type.GetMethod("Parse", new Type[] { typeof(string) })
-                                          .Invoke(null, new object[] { input });
-
-                            parsedArgs.Add(arg);
-                            continue;
-                        }
-                        catch
-                        {
-                            ExplorerCore.Log($"Could not parse input '{input}' for argument #{i} '{m_arguments[i].Name}' ({type.FullName})");
-                        }
-                    }
-                }
-
-                // No input, see if there is a default value.
-                if (m_arguments[i].IsOptional)
-                {
-                    parsedArgs.Add(m_arguments[i].DefaultValue);
-                    continue;
-                }
-
-                // Try add a null arg I guess
-                parsedArgs.Add(null);
-            }
-
-            return parsedArgs.ToArray();
-        }
-
-        private bool GetCanWrite()
-        {
-            if (MemInfo is FieldInfo fi)
-                m_canWrite = !(fi.IsLiteral && !fi.IsInitOnly);
-            else if (MemInfo is PropertyInfo pi)
-                m_canWrite = pi.CanWrite;
-            else
-                m_canWrite = false;
-
-            return (bool)m_canWrite;
-        }
-
-        private string GetRichTextName()
-        {
-            return m_richTextName = SignatureHighlighter.ParseFullSyntax(MemInfo.DeclaringType, false, MemInfo);
-        }
-
-        #region UI 
-
-        internal float GetMemberLabelWidth(RectTransform scrollRect)
-        {
-            var textGenSettings = m_memLabelText.GetGenerationSettings(m_topRowRect.rect.size);
-            textGenSettings.scaleFactor = InputFieldScroller.canvasScaler.scaleFactor;
-
-            var textGen = m_memLabelText.cachedTextGeneratorForLayout;
-            float preferredWidth = textGen.GetPreferredWidth(RichTextName, textGenSettings);
-
-            float max = scrollRect.rect.width * 0.4f;
-
-            if (preferredWidth > max) preferredWidth = max;
-
-            return preferredWidth < 125f ? 125f : preferredWidth;
-        }
-
-        internal void SetWidths(float labelWidth, float valueWidth)
-        {
-            m_leftLayout.preferredWidth = labelWidth;
-            m_rightLayout.preferredWidth = valueWidth;
-        }
-
-        internal RectTransform m_topRowRect;
-        internal Text m_memLabelText;
-        internal GameObject m_leftGroup;
-        internal LayoutElement m_leftLayout;
-        internal GameObject m_rightGroup;
-        internal LayoutElement m_rightLayout;
-
-        internal override void ConstructUI()
-        {
-            base.ConstructUI();
-
-            var topGroupObj = UIFactory.CreateHorizontalGroup(m_mainContent, new Color(1, 1, 1, 0));
-            m_topRowRect = topGroupObj.GetComponent<RectTransform>();
-            var topLayout = topGroupObj.AddComponent<LayoutElement>();
-            topLayout.minHeight = 25;
-            topLayout.flexibleHeight = 0;
-            topLayout.minWidth = 300;
-            topLayout.flexibleWidth = 5000;
-            var topGroup = topGroupObj.GetComponent<HorizontalLayoutGroup>();
-            topGroup.childForceExpandHeight = false;
-            topGroup.childForceExpandWidth = false;
-            topGroup.SetChildControlHeight(true);
-            topGroup.SetChildControlWidth(true);
-            topGroup.spacing = 10;
-            topGroup.padding.left = 3;
-            topGroup.padding.right = 3;
-            topGroup.padding.top = 0;
-            topGroup.padding.bottom = 0;
-
-            // left group
-
-            m_leftGroup = UIFactory.CreateHorizontalGroup(topGroupObj, new Color(1, 1, 1, 0));
-            var leftLayout = m_leftGroup.AddComponent<LayoutElement>();
-            leftLayout.minHeight = 25;
-            leftLayout.flexibleHeight = 0;
-            leftLayout.minWidth = 125;
-            leftLayout.flexibleWidth = 200;
-            var leftGroup = m_leftGroup.GetComponent<HorizontalLayoutGroup>();
-            leftGroup.childForceExpandHeight = true;
-            leftGroup.childForceExpandWidth = false;
-            leftGroup.SetChildControlHeight(true);
-            leftGroup.SetChildControlWidth(true);
-            leftGroup.spacing = 4;
-
-            // member label
-
-            var labelObj = UIFactory.CreateLabel(m_leftGroup, TextAnchor.MiddleLeft);
-            var leftRect = labelObj.GetComponent<RectTransform>();
-            leftRect.anchorMin = Vector2.zero;
-            leftRect.anchorMax = Vector2.one;
-            leftRect.offsetMin = Vector2.zero;
-            leftRect.offsetMax = Vector2.zero;
-            leftRect.sizeDelta = Vector2.zero;
-            m_leftLayout = labelObj.AddComponent<LayoutElement>();
-            m_leftLayout.preferredWidth = 125;
-            m_leftLayout.minHeight = 25;
-            m_leftLayout.flexibleHeight = 100;
-            var labelFitter = labelObj.AddComponent<ContentSizeFitter>();
-            labelFitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
-            labelFitter.horizontalFit = ContentSizeFitter.FitMode.PreferredSize;
-            m_memLabelText = labelObj.GetComponent<Text>();
-            m_memLabelText.horizontalOverflow = HorizontalWrapMode.Wrap;
-            m_memLabelText.text = this.RichTextName;
-
-            // right group
-
-            m_rightGroup = UIFactory.CreateVerticalGroup(topGroupObj, new Color(1, 1, 1, 0));
-            m_rightLayout = m_rightGroup.AddComponent<LayoutElement>();
-            m_rightLayout.minHeight = 25;
-            m_rightLayout.flexibleHeight = 480;
-            m_rightLayout.minWidth = 125;
-            m_rightLayout.flexibleWidth = 5000;
-            var rightGroup = m_rightGroup.GetComponent<VerticalLayoutGroup>();
-            rightGroup.childForceExpandHeight = true;
-            rightGroup.childForceExpandWidth = false;
-            rightGroup.SetChildControlHeight(true);
-            rightGroup.SetChildControlWidth(true);
-            rightGroup.spacing = 2;
-            rightGroup.padding.top = 4;
-            rightGroup.padding.bottom = 2;
-
-            ConstructArgInput(out GameObject argsHolder);
-
-            ConstructEvaluateButtons(argsHolder);
-
-            IValue.m_mainContentParent = m_rightGroup;
-        }
-
-        internal void ConstructArgInput(out GameObject argsHolder)
-        {
-            argsHolder = null;
-
-            if (HasParameters)
-            {
-                argsHolder = UIFactory.CreateVerticalGroup(m_rightGroup, new Color(1, 1, 1, 0));
-                var argsGroup = argsHolder.GetComponent<VerticalLayoutGroup>();
-                argsGroup.spacing = 4;
-
-                if (this is CacheMethod cm && cm.GenericArgs.Length > 0)
-                {
-                    cm.ConstructGenericArgInput(argsHolder);
-                }
-
-                // todo normal args
-
-                if (m_arguments.Length > 0)
-                {
-                    var titleObj = UIFactory.CreateLabel(argsHolder, TextAnchor.MiddleLeft);
-                    var titleText = titleObj.GetComponent<Text>();
-                    titleText.text = "<b>Arguments:</b>";
-
-                    for (int i = 0; i < m_arguments.Length; i++)
-                    {
-                        AddArgRow(i, argsHolder);
-                    }
-                }
-
-                argsHolder.SetActive(false);
-            }
-        }
-
-        internal void AddArgRow(int i, GameObject parent)
-        {
-            var arg = m_arguments[i];
-
-            var rowObj = UIFactory.CreateHorizontalGroup(parent, new Color(1, 1, 1, 0));
-            var rowLayout = rowObj.AddComponent<LayoutElement>();
-            rowLayout.minHeight = 25;
-            rowLayout.flexibleWidth = 5000;
-            var rowGroup = rowObj.GetComponent<HorizontalLayoutGroup>();
-            rowGroup.childForceExpandHeight = false;
-            rowGroup.childForceExpandWidth = true;
-            rowGroup.spacing = 4;
-
-            var argLabelObj = UIFactory.CreateLabel(rowObj, TextAnchor.MiddleLeft);
-            var argLabelLayout = argLabelObj.AddComponent<LayoutElement>();
-            argLabelLayout.minHeight = 25;
-            var argText = argLabelObj.GetComponent<Text>();
-            var argTypeTxt = SignatureHighlighter.ParseFullSyntax(arg.ParameterType, false);
-            argText.text = $"{argTypeTxt} <color={SignatureHighlighter.LOCAL_ARG}>{arg.Name}</color>";
-
-            var argInputObj = UIFactory.CreateInputField(rowObj, 14, (int)TextAnchor.MiddleLeft, 1);
-            var argInputLayout = argInputObj.AddComponent<LayoutElement>();
-            argInputLayout.flexibleWidth = 1200;
-            argInputLayout.preferredWidth = 150;
-            argInputLayout.minWidth = 20;
-            argInputLayout.minHeight = 25;
-            argInputLayout.flexibleHeight = 0;
-            //argInputLayout.layoutPriority = 2;
-
-            var argInput = argInputObj.GetComponent<InputField>();
-            argInput.onValueChanged.AddListener((string val) => { m_argumentInput[i] = val; });
-
-            if (arg.IsOptional)
-            {
-                var phInput = argInput.placeholder.GetComponent<Text>();
-                phInput.text = " = " + arg.DefaultValue?.ToString() ?? "null";
-            }
-        }
-
-        internal void ConstructEvaluateButtons(GameObject argsHolder)
-        {
-            if (HasParameters)
-            {
-                var evalGroupObj = UIFactory.CreateHorizontalGroup(m_rightGroup, new Color(1, 1, 1, 0));
-                var evalGroup = evalGroupObj.GetComponent<HorizontalLayoutGroup>();
-                evalGroup.childForceExpandWidth = false;
-                evalGroup.childForceExpandHeight = false;
-                evalGroup.spacing = 5;
-                var evalGroupLayout = evalGroupObj.AddComponent<LayoutElement>();
-                evalGroupLayout.minHeight = 25;
-                evalGroupLayout.flexibleHeight = 0;
-                evalGroupLayout.flexibleWidth = 5000;
-
-                var evalButtonObj = UIFactory.CreateButton(evalGroupObj, new Color(0.4f, 0.4f, 0.4f));
-                var evalLayout = evalButtonObj.AddComponent<LayoutElement>();
-                evalLayout.minWidth = 100;
-                evalLayout.minHeight = 22;
-                evalLayout.flexibleWidth = 0;
-                var evalText = evalButtonObj.GetComponentInChildren<Text>();
-                evalText.text = $"Evaluate ({ParamCount})";
-
-                var evalButton = evalButtonObj.GetComponent<Button>();
-                var colors = evalButton.colors;
-                colors.highlightedColor = new Color(0.4f, 0.7f, 0.4f);
-                evalButton.colors = colors;
-
-                var cancelButtonObj = UIFactory.CreateButton(evalGroupObj, new Color(0.3f, 0.3f, 0.3f));
-                var cancelLayout = cancelButtonObj.AddComponent<LayoutElement>();
-                cancelLayout.minWidth = 100;
-                cancelLayout.minHeight = 22;
-                cancelLayout.flexibleWidth = 0;
-                var cancelText = cancelButtonObj.GetComponentInChildren<Text>();
-                cancelText.text = "Close";
-
-                cancelButtonObj.SetActive(false);
-
-                evalButton.onClick.AddListener(() =>
-                {
-                    if (!m_isEvaluating)
-                    {
-                        argsHolder.SetActive(true);
-                        m_isEvaluating = true;
-                        evalText.text = "Evaluate";
-                        colors = evalButton.colors;
-                        colors.normalColor = new Color(0.3f, 0.6f, 0.3f);
-                        evalButton.colors = colors;
-
-                        cancelButtonObj.SetActive(true);
-                    }
-                    else
-                    {
-                        if (this is CacheMethod cm)
-                            cm.Evaluate();
-                        else
-                            UpdateValue();
-                    }
-                });
-
-                var cancelButton = cancelButtonObj.GetComponent<Button>();
-                cancelButton.onClick.AddListener(() =>
-                {
-                    cancelButtonObj.SetActive(false);
-                    argsHolder.SetActive(false);
-                    m_isEvaluating = false;
-
-                    evalText.text = $"Evaluate ({ParamCount})";
-                    colors = evalButton.colors;
-                    colors.normalColor = new Color(0.4f, 0.4f, 0.4f);
-                    evalButton.colors = colors;
-                });
-            }
-            else if (this is CacheMethod)
-            {
-                // simple method evaluate button
-
-                var evalButtonObj = UIFactory.CreateButton(m_rightGroup, new Color(0.3f, 0.6f, 0.3f));
-                var evalLayout = evalButtonObj.AddComponent<LayoutElement>();
-                evalLayout.minWidth = 100;
-                evalLayout.minHeight = 22;
-                evalLayout.flexibleWidth = 0;
-                var evalText = evalButtonObj.GetComponentInChildren<Text>();
-                evalText.text = "Evaluate";
-
-                var evalButton = evalButtonObj.GetComponent<Button>();
-                var colors = evalButton.colors;
-                colors.highlightedColor = new Color(0.4f, 0.7f, 0.4f);
-                evalButton.colors = colors;
-
-                evalButton.onClick.AddListener(OnMainEvaluateButton);
-                void OnMainEvaluateButton()
-                {
-                    (this as CacheMethod).Evaluate();
-                }
-            }
-        }
-
-        #endregion
-    }
-}

src/Core/Inspectors/Reflection/CacheObject/CacheMethod.cs

@@ -1,192 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.UI;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.Core;
-using UnityExplorer.UI.Utility;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class CacheMethod : CacheMember
-    {
-        //private CacheObjectBase m_cachedReturnValue;
-
-        public override Type FallbackType => (MemInfo as MethodInfo).ReturnType;
-
-        public override bool HasParameters => base.HasParameters || GenericArgs.Length > 0;
-
-        public override bool IsStatic => (MemInfo as MethodInfo).IsStatic;
-
-        public override int ParamCount => base.ParamCount + m_genericArgInput.Length;
-
-        public Type[] GenericArgs { get; private set; }
-        public Type[][] GenericConstraints { get; private set; }
-
-        public string[] m_genericArgInput = new string[0];
-
-        public CacheMethod(MethodInfo methodInfo, object declaringInstance, GameObject parent) : base(methodInfo, declaringInstance, parent)
-        {
-            GenericArgs = methodInfo.GetGenericArguments();
-
-            GenericConstraints = GenericArgs.Select(x => x.GetGenericParameterConstraints())
-                                            .Where(x => x != null)
-                                            .ToArray();
-
-            m_genericArgInput = new string[GenericArgs.Length];
-
-            m_arguments = methodInfo.GetParameters();
-            m_argumentInput = new string[m_arguments.Length];
-
-            CreateIValue(null, methodInfo.ReturnType);
-        }
-
-        public override void UpdateReflection()
-        {
-            // CacheMethod cannot UpdateValue directly. Need to Evaluate.
-        }
-
-        public void Evaluate()
-        {
-            MethodInfo mi;
-            if (GenericArgs.Length > 0)
-            {
-                mi = MakeGenericMethodFromInput();
-                if (mi == null) return;
-            }
-            else
-            {
-                mi = MemInfo as MethodInfo;
-            }
-
-            object ret = null;
-
-            try
-            {
-                ret = mi.Invoke(mi.IsStatic ? null : DeclaringInstance, ParseArguments());
-                m_evaluated = true;
-                m_isEvaluating = false;
-                ReflectionException = null;
-            }
-            catch (Exception e)
-            {
-                while (e.InnerException != null)
-                    e = e.InnerException;
-
-                ExplorerCore.LogWarning($"Exception evaluating: {e.GetType()}, {e.Message}");
-                ReflectionException = ReflectionUtility.ReflectionExToString(e);
-            }
-
-            IValue.Value = ret;
-            UpdateValue();
-        }
-
-        private MethodInfo MakeGenericMethodFromInput()
-        {
-            var mi = MemInfo as MethodInfo;
-
-            var list = new List<Type>();
-            for (int i = 0; i < GenericArgs.Length; i++)
-            {
-                var input = m_genericArgInput[i];
-                if (ReflectionUtility.GetTypeByName(input) is Type t)
-                {
-                    if (GenericConstraints[i].Length == 0)
-                    {
-                        list.Add(t);
-                    }
-                    else
-                    {
-                        foreach (var constraint in GenericConstraints[i].Where(x => x != null))
-                        {
-                            if (!constraint.IsAssignableFrom(t))
-                            {
-                                ExplorerCore.LogWarning($"Generic argument #{i}, '{input}' is not assignable from the constraint '{constraint}'!");
-                                return null;
-                            }
-                        }
-
-                        list.Add(t);
-                    }
-                }
-                else
-                {
-                    ExplorerCore.LogWarning($"Generic argument #{i}, could not get any type by the name of '{input}'!" +
-                        $" Make sure you use the full name including the namespace.");
-                    return null;
-                }
-            }
-
-            // make into a generic with type list
-            mi = mi.MakeGenericMethod(list.ToArray());
-
-            return mi;
-        }
-
-        #region UI CONSTRUCTION
-
-        internal void ConstructGenericArgInput(GameObject parent)
-        {
-            var titleObj = UIFactory.CreateLabel(parent, TextAnchor.MiddleLeft);
-            var titleText = titleObj.GetComponent<Text>();
-            titleText.text = "<b>Generic Arguments:</b>";
-
-            for (int i = 0; i < GenericArgs.Length; i++)
-            {
-                AddGenericArgRow(i, parent);
-            }
-        }
-
-        internal void AddGenericArgRow(int i, GameObject parent)
-        {
-            var arg = GenericArgs[i];
-
-            string constrainTxt = "";
-            if (this.GenericConstraints[i].Length > 0)
-            {
-                foreach (var constraint in this.GenericConstraints[i])
-                {
-                    if (constrainTxt != "") 
-                        constrainTxt += ", ";
-
-                    constrainTxt += $"{SignatureHighlighter.ParseFullSyntax(constraint, false)}";
-                }
-            }
-            else
-                constrainTxt = $"Any";
-
-            var rowObj = UIFactory.CreateHorizontalGroup(parent, new Color(1, 1, 1, 0));
-            var rowLayout = rowObj.AddComponent<LayoutElement>();
-            rowLayout.minHeight = 25;
-            rowLayout.flexibleWidth = 5000;
-            var rowGroup = rowObj.GetComponent<HorizontalLayoutGroup>();
-            rowGroup.childForceExpandHeight = true;
-            rowGroup.spacing = 4;
-
-            var argLabelObj = UIFactory.CreateLabel(rowObj, TextAnchor.MiddleLeft);
-            //var argLayout = argLabelObj.AddComponent<LayoutElement>();
-            //argLayout.minWidth = 20;
-            var argText = argLabelObj.GetComponent<Text>();
-            argText.text = $"{constrainTxt} <color={SignatureHighlighter.CONST_VAR}>{arg.Name}</color>";
-
-            var argInputObj = UIFactory.CreateInputField(rowObj, 14, (int)TextAnchor.MiddleLeft, 1);
-            var argInputLayout = argInputObj.AddComponent<LayoutElement>();
-            argInputLayout.flexibleWidth = 1200;
-
-            var argInput = argInputObj.GetComponent<InputField>();
-            argInput.onValueChanged.AddListener((string val) => { m_genericArgInput[i] = val; });
-
-            //var constraintLabelObj = UIFactory.CreateLabel(rowObj, TextAnchor.MiddleLeft);
-            //var constraintLayout = constraintLabelObj.AddComponent<LayoutElement>();
-            //constraintLayout.minWidth = 60;
-            //constraintLayout.flexibleWidth = 100;
-            //var constraintText = constraintLabelObj.GetComponent<Text>();
-            //constraintText.text = ;
-        }
-
-        #endregion
-    }
-}

src/Core/Inspectors/Reflection/CacheObject/CacheObjectBase.cs

@@ -1,125 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using UnityEngine;
-using UnityExplorer.UI;
-using UnityExplorer.UI.Reusable;
-using UnityExplorer.Core.Unity;
-using UnityEngine.UI;
-using UnityExplorer.Core;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public abstract class CacheObjectBase
-    {
-        public InteractiveValue IValue;
-
-        public virtual bool CanWrite => false;
-        public virtual bool HasParameters => false;
-        public virtual bool IsMember => false;
-        public virtual bool HasEvaluated => true;
-
-        public abstract Type FallbackType { get; }
-
-        public abstract void CreateIValue(object value, Type fallbackType);
-
-        public virtual void Enable()
-        {
-            if (!m_constructedUI)
-            {
-                ConstructUI();
-                UpdateValue();
-            }
-
-            m_mainContent.SetActive(true);
-            m_mainContent.transform.SetAsLastSibling();
-        }
-
-        public virtual void Disable()
-        {
-            if (m_mainContent)
-                m_mainContent.SetActive(false);
-        }
-
-        public void Destroy()
-        {
-            if (this.m_mainContent)
-                GameObject.Destroy(this.m_mainContent);
-        }
-
-        public virtual void UpdateValue()
-        {
-            var value = IValue.Value;
-
-            // if the type has changed fundamentally, make a new interactivevalue for it
-            var type = value == null 
-                ? FallbackType
-                : ReflectionUtility.GetType(value);
-
-            var ivalueType = InteractiveValue.GetIValueForType(type);
-
-            if (ivalueType != IValue.GetType())
-            {
-                IValue.OnDestroy();
-                CreateIValue(value, FallbackType);
-                m_subContent.SetActive(false);
-            }
-
-            IValue.OnValueUpdated();
-
-            IValue.RefreshElementsAfterUpdate();
-        }
-
-        public virtual void SetValue() => throw new NotImplementedException();
-
-        #region UI CONSTRUCTION
-
-        internal bool m_constructedUI;
-        internal GameObject m_parentContent;
-        internal RectTransform m_mainRect;
-        internal GameObject m_mainContent;
-        internal GameObject m_subContent;
-
-        // Make base UI holder for CacheObject, this doesnt actually display anything.
-        internal virtual void ConstructUI()
-        {
-            m_constructedUI = true;
-
-            m_mainContent = UIFactory.CreateVerticalGroup(m_parentContent, new Color(0.1f, 0.1f, 0.1f));
-            m_mainContent.name = "CacheObjectBase.MainContent";
-            m_mainRect = m_mainContent.GetComponent<RectTransform>();
-            m_mainRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 25);
-            var mainGroup = m_mainContent.GetComponent<VerticalLayoutGroup>();
-            mainGroup.childForceExpandWidth = true;
-            mainGroup.SetChildControlWidth(true);
-            mainGroup.childForceExpandHeight = true;
-            mainGroup.SetChildControlHeight(true);
-            var mainLayout = m_mainContent.AddComponent<LayoutElement>();
-            mainLayout.minHeight = 25;
-            mainLayout.flexibleHeight = 9999;
-            mainLayout.minWidth = 200;
-            mainLayout.flexibleWidth = 5000;
-
-            // subcontent
-
-            m_subContent = UIFactory.CreateVerticalGroup(m_mainContent, new Color(0.085f, 0.085f, 0.085f));
-            m_subContent.name = "CacheObjectBase.SubContent";
-            var subGroup = m_subContent.GetComponent<VerticalLayoutGroup>();
-            subGroup.childForceExpandWidth = true;
-            subGroup.childForceExpandHeight = false;
-            var subLayout = m_subContent.AddComponent<LayoutElement>();
-            subLayout.minHeight = 30;
-            subLayout.flexibleHeight = 9999;
-            subLayout.minWidth = 125;
-            subLayout.flexibleWidth = 9000;
-
-            m_subContent.SetActive(false);
-
-            IValue.m_subContentParent = m_subContent;
-        }
-
-        #endregion
-
-    }
-}

src/Core/Inspectors/Reflection/CacheObject/CachePaired.cs

@@ -1,71 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using UnityExplorer.UI;
-using UnityEngine;
-using UnityEngine.UI;
-
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public enum PairTypes
-    {
-        Key,
-        Value
-    }
-
-    public class CachePaired : CacheObjectBase
-    {
-        public override Type FallbackType => PairType == PairTypes.Key
-            ? ParentDictionary.m_typeOfKeys
-            : ParentDictionary.m_typeofValues;
-
-        public override bool CanWrite => false; // todo?
-
-        public PairTypes PairType;
-        public int Index { get; private set; }
-        public InteractiveDictionary ParentDictionary { get; private set; }
-        internal IDictionary RefIDict;
-
-        public CachePaired(int index, InteractiveDictionary parentDict, IDictionary refIDict, PairTypes pairType, GameObject parentContent)
-        {
-            Index = index;
-            ParentDictionary = parentDict;
-            RefIDict = refIDict;
-            this.PairType = pairType;
-            this.m_parentContent = parentContent;
-        }
-
-        public override void CreateIValue(object value, Type fallbackType)
-        {
-            IValue = InteractiveValue.Create(value, fallbackType);
-            IValue.Owner = this;
-        }
-
-        #region UI CONSTRUCTION
-
-        internal override void ConstructUI()
-        {
-            base.ConstructUI();
-
-            var rowObj = UIFactory.CreateHorizontalGroup(m_mainContent, new Color(1, 1, 1, 0));
-            var rowGroup = rowObj.GetComponent<HorizontalLayoutGroup>();
-            rowGroup.padding.left = 5;
-            rowGroup.padding.right = 2;
-
-            var indexLabelObj = UIFactory.CreateLabel(rowObj, TextAnchor.MiddleLeft);
-            var indexLayout = indexLabelObj.AddComponent<LayoutElement>();
-            indexLayout.minWidth = 80;
-            indexLayout.flexibleWidth = 30;
-            indexLayout.minHeight = 25;
-            var indexText = indexLabelObj.GetComponent<Text>();
-            indexText.text = $"{this.PairType} {this.Index}:";
-
-            IValue.m_mainContentParent = rowObj;
-        }
-
-        #endregion
-    }
-}

src/Core/Inspectors/Reflection/CacheObject/CacheProperty.cs

@@ -1,71 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Reflection;
-using UnityExplorer.UI;
-using UnityExplorer.Core.Unity;
-using UnityEngine;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class CacheProperty : CacheMember
-    {
-        public override Type FallbackType => (MemInfo as PropertyInfo).PropertyType;
-
-        public override bool IsStatic => (MemInfo as PropertyInfo).GetAccessors(true)[0].IsStatic;
-
-        public CacheProperty(PropertyInfo propertyInfo, object declaringInstance, GameObject parent) : base(propertyInfo, declaringInstance, parent)
-        {
-            this.m_arguments = propertyInfo.GetIndexParameters();
-            this.m_argumentInput = new string[m_arguments.Length];
-
-            CreateIValue(null, propertyInfo.PropertyType);
-        }
-
-        public override void UpdateReflection()
-        {
-            if (HasParameters && !m_isEvaluating)
-            {
-                // Need to enter parameters first.
-                return;
-            }
-
-            var pi = MemInfo as PropertyInfo;
-
-            if (pi.CanRead)
-            {
-                var target = pi.GetAccessors(true)[0].IsStatic ? null : DeclaringInstance;
-
-                IValue.Value = pi.GetValue(target, ParseArguments());
-
-                m_evaluated = true;
-                ReflectionException = null;
-            }
-            else 
-            {
-                if (FallbackType == typeof(string))
-                {
-                    IValue.Value = "";
-                }
-                else if (FallbackType.IsPrimitive)
-                {
-                    IValue.Value = Activator.CreateInstance(FallbackType);
-                }
-                m_evaluated = true;
-                ReflectionException = null;
-            }
-        }
-
-        public override void SetValue()
-        {
-            var pi = MemInfo as PropertyInfo;
-            var target = pi.GetAccessors()[0].IsStatic ? null : DeclaringInstance;
-
-            pi.SetValue(target, IValue.Value, ParseArguments());
-
-            if (this.ParentInspector?.ParentMember != null)
-                this.ParentInspector.ParentMember.SetValue();
-        }
-    }
-}

src/Core/Inspectors/Reflection/InstanceInspector.cs

@@ -1,54 +0,0 @@
-using System;
-using System.Reflection;
-using UnityEngine;
-using UnityExplorer.UI;
-using UnityEngine.UI;
-using System.IO;
-using UnityExplorer.Core.Runtime;
-using UnityExplorer.UI.Main.Home.Inspectors;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public enum MemberScopes
-    {
-        All,
-        Instance,
-        Static
-    }
-
-    public class InstanceInspector : ReflectionInspector
-    {
-        public override string TabLabel => $" <color=cyan>[R]</color> {base.TabLabel}";
-
-        internal MemberScopes m_scopeFilter;
-        internal Button m_lastActiveScopeButton;
-
-        public InstanceInspector(object target) : base(target) { }
-
-        internal InstanceInspectorUI InstanceUI;
-        public void CreateInstanceUIModule()
-        {
-            InstanceUI = new InstanceInspectorUI(this);
-        }
-
-        internal void OnScopeFilterClicked(MemberScopes type, Button button)
-        {
-            if (m_lastActiveScopeButton)
-            {
-                var lastColors = m_lastActiveScopeButton.colors;
-                lastColors.normalColor = new Color(0.2f, 0.2f, 0.2f);
-                m_lastActiveScopeButton.colors = lastColors;
-            }
-
-            m_scopeFilter = type;
-            m_lastActiveScopeButton = button;
-
-            var colors = m_lastActiveScopeButton.colors;
-            colors.normalColor = new Color(0.2f, 0.6f, 0.2f);
-            m_lastActiveScopeButton.colors = colors;
-
-            FilterMembers(null, true);
-            base.ReflectionUI.m_sliderScroller.m_slider.value = 1f;
-        }
-    }
-}

src/Core/Inspectors/Reflection/InteractiveValue/InteractiveBool.cs

@@ -1,114 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.UI;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class InteractiveBool : InteractiveValue
-    {
-        public InteractiveBool(object value, Type valueType) : base(value, valueType) { }
-
-        public override bool HasSubContent => false;
-        public override bool SubContentWanted => false;
-        public override bool WantInspectBtn => false;
-
-        internal Toggle m_toggle;
-        internal Button m_applyBtn;
-
-        public override void OnValueUpdated()
-        {
-            base.OnValueUpdated();
-        }
-
-        public override void RefreshUIForValue()
-        {
-            GetDefaultLabel();
-
-            if (Owner.HasEvaluated)
-            {
-                var val = (bool)Value;
-
-                if (Owner.CanWrite)
-                {
-                    if (!m_toggle.gameObject.activeSelf)
-                        m_toggle.gameObject.SetActive(true);
-
-                    if (!m_applyBtn.gameObject.activeSelf)
-                        m_applyBtn.gameObject.SetActive(true);
-
-                    if (val != m_toggle.isOn)
-                        m_toggle.isOn = val;
-                }
-
-                var color = val
-                    ? "6bc981"  // on
-                    : "c96b6b"; // off
-
-                m_baseLabel.text = $"<color=#{color}>{val}</color>";
-            }
-            else
-            {
-                m_baseLabel.text = DefaultLabel;
-            }
-        }
-
-        public override void OnException(CacheMember member)
-        {
-            base.OnException(member);
-
-            if (Owner.CanWrite)
-            {
-                if (m_toggle.gameObject.activeSelf)
-                    m_toggle.gameObject.SetActive(false);
-
-                if (m_applyBtn.gameObject.activeSelf)
-                    m_applyBtn.gameObject.SetActive(false);
-            }
-        }
-
-        internal void OnToggleValueChanged(bool val)
-        {
-            Value = val;
-            RefreshUIForValue();
-        }
-
-        public override void ConstructUI(GameObject parent, GameObject subGroup)
-        {
-            base.ConstructUI(parent, subGroup);
-
-            var baseLayout = m_baseLabel.gameObject.GetComponent<LayoutElement>();
-            baseLayout.flexibleWidth = 0;
-            baseLayout.minWidth = 50;
-
-            if (Owner.CanWrite)
-            {
-                var toggleObj = UIFactory.CreateToggle(m_valueContent, out m_toggle, out _, new Color(0.1f, 0.1f, 0.1f));
-                var toggleLayout = toggleObj.AddComponent<LayoutElement>();
-                toggleLayout.minWidth = 24;
-
-                m_toggle.onValueChanged.AddListener(OnToggleValueChanged);
-
-                m_baseLabel.transform.SetAsLastSibling();
-
-                var applyBtnObj = UIFactory.CreateButton(m_valueContent, new Color(0.2f, 0.2f, 0.2f));
-                var applyLayout = applyBtnObj.AddComponent<LayoutElement>();
-                applyLayout.minWidth = 50;
-                applyLayout.minHeight = 25;
-                applyLayout.flexibleWidth = 0;
-                m_applyBtn = applyBtnObj.GetComponent<Button>();
-                m_applyBtn.onClick.AddListener(() => { Owner.SetValue(); });
-
-                var applyText = applyBtnObj.GetComponentInChildren<Text>();
-                applyText.text = "Apply";
-
-                toggleObj.SetActive(false);
-                applyBtnObj.SetActive(false);
-            }
-        }
-    }
-}

src/Core/Inspectors/Reflection/InteractiveValue/InteractiveDictionary.cs

@@ -1,320 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.Core.Config;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.UI;
-using UnityExplorer.UI.Reusable;
-using System.Reflection;
-#if CPP
-using CppDictionary = Il2CppSystem.Collections.IDictionary;
-#endif
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class InteractiveDictionary : InteractiveValue
-    {
-        public InteractiveDictionary(object value, Type valueType) : base(value, valueType)
-        {
-            if (valueType.IsGenericType)
-            {
-                var gArgs = valueType.GetGenericArguments();
-                m_typeOfKeys = gArgs[0];
-                m_typeofValues = gArgs[1];
-            }
-            else
-            {
-                m_typeOfKeys = typeof(object);
-                m_typeofValues = typeof(object);
-            }
-        }
-
-        public override bool WantInspectBtn => false;
-        public override bool HasSubContent => true;
-        // todo fix for il2cpp
-        public override bool SubContentWanted
-        {
-            get
-            {
-                if (m_recacheWanted)
-                    return true;
-                else return m_entries.Count > 0;
-            }
-        }
-
-        internal IDictionary RefIDictionary;
-#if CPP
-        internal CppDictionary RefCppDictionary;
-#else
-        internal IDictionary RefCppDictionary = null;
-#endif
-        internal Type m_typeOfKeys;
-        internal Type m_typeofValues;
-
-        internal readonly List<KeyValuePair<CachePaired, CachePaired>> m_entries 
-            = new List<KeyValuePair<CachePaired, CachePaired>>();
-
-        internal readonly KeyValuePair<CachePaired, CachePaired>[] m_displayedEntries
-            = new KeyValuePair<CachePaired, CachePaired>[ExplorerConfig.Instance.Default_Page_Limit];
-
-        internal bool m_recacheWanted = true;
-
-        public override void OnDestroy()
-        {
-            base.OnDestroy();
-        }
-
-        public override void OnValueUpdated()
-        {
-            RefIDictionary = Value as IDictionary;
-
-#if CPP
-            try { RefCppDictionary = (Value as Il2CppSystem.Object).TryCast<CppDictionary>(); }
-            catch { }
-#endif
-
-            if (m_subContentParent.activeSelf)
-            {
-                GetCacheEntries();
-                RefreshDisplay();
-            }
-            else
-                m_recacheWanted = true;
-
-            base.OnValueUpdated();
-        }
-
-        internal void OnPageTurned()
-        {
-            RefreshDisplay();
-        }
-
-        public override void RefreshUIForValue()
-        {
-            GetDefaultLabel();
-
-            if (Value != null)
-            {
-                string count = "?";
-                if (m_recacheWanted && RefIDictionary != null)
-                    count = RefIDictionary.Count.ToString();
-                else if (!m_recacheWanted)
-                    count = m_entries.Count.ToString();
-
-                m_baseLabel.text = $"[{count}] {m_richValueType}";
-            }
-            else
-            {
-                m_baseLabel.text = DefaultLabel;
-            }
-        }
-
-        public void GetCacheEntries()
-        {
-            if (m_entries.Any())
-            {
-                // maybe improve this, probably could be more efficient i guess
-
-                foreach (var pair in m_entries)
-                {
-                    pair.Key.Destroy();
-                    pair.Value.Destroy();
-                }
-
-                m_entries.Clear();
-            }
-
-#if CPP
-            if (RefIDictionary == null && Value != null)
-                RefIDictionary = EnumerateWithReflection();
-#endif
-
-            if (RefIDictionary != null)
-            {
-                int index = 0;
-
-                foreach (var key in RefIDictionary.Keys)
-                {
-                    var value = RefIDictionary[key];
-
-                    var cacheKey = new CachePaired(index, this, this.RefIDictionary, PairTypes.Key, m_listContent);
-                    cacheKey.CreateIValue(key, this.m_typeOfKeys);
-                    cacheKey.Disable();
-
-                    var cacheValue = new CachePaired(index, this, this.RefIDictionary, PairTypes.Value, m_listContent);
-                    cacheValue.CreateIValue(value, this.m_typeofValues);
-                    cacheValue.Disable();
-
-                    //holder.SetActive(false);
-
-                    m_entries.Add(new KeyValuePair<CachePaired, CachePaired>(cacheKey, cacheValue));
-
-                    index++;
-                }
-            }
-
-            RefreshDisplay();
-        }
-
-        public void RefreshDisplay()
-        {
-            var entries = m_entries;
-            m_pageHandler.ListCount = entries.Count;
-
-            for (int i = 0; i < m_displayedEntries.Length; i++)
-            {
-                var entry = m_displayedEntries[i];
-                if (entry.Key != null && entry.Value != null)
-                {
-                    //m_rowHolders[i].SetActive(false);
-                    entry.Key.Disable();
-                    entry.Value.Disable();
-                }
-                else
-                    break;
-            }
-
-            if (entries.Count < 1)
-                return;
-
-            foreach (var itemIndex in m_pageHandler)
-            {
-                if (itemIndex >= entries.Count)
-                    break;
-
-                var entry = entries[itemIndex];
-                m_displayedEntries[itemIndex - m_pageHandler.StartIndex] = entry;
-
-                //m_rowHolders[itemIndex].SetActive(true);
-                entry.Key.Enable();
-                entry.Value.Enable();
-            }
-
-            //UpdateSubcontentHeight();
-        }
-
-        internal override void OnToggleSubcontent(bool active)
-        {
-            base.OnToggleSubcontent(active);
-
-            if (active && m_recacheWanted)
-            {
-                m_recacheWanted = false;
-                GetCacheEntries();
-                RefreshUIForValue();
-            }
-
-            RefreshDisplay();
-        }
-
-#region CPP fixes
-#if CPP
-        // temp fix for Il2Cpp IDictionary until interfaces are fixed
-
-        private IDictionary EnumerateWithReflection()
-        {
-            var valueType = Value?.GetType() ?? FallbackType;
-
-            // get keys and values
-            var keys = valueType.GetProperty("Keys").GetValue(Value, null);
-            var values = valueType.GetProperty("Values").GetValue(Value, null);
-
-            // create lists to hold them
-            var keyList = new List<object>();
-            var valueList = new List<object>();
-
-            // store entries with reflection
-            EnumerateCollection(keys, keyList);
-            EnumerateCollection(values, valueList);
-
-            // make actual mono dictionary
-            var dict = (IDictionary)Activator.CreateInstance(typeof(Dictionary<,>)
-                                             .MakeGenericType(m_typeOfKeys, m_typeofValues));
-
-            // finally iterate into mono dictionary
-            for (int i = 0; i < keyList.Count; i++)
-                dict.Add(keyList[i], valueList[i]);
-
-            return dict;
-        }
-
-        private void EnumerateCollection(object collection, List<object> list)
-        {
-            // invoke GetEnumerator
-            var enumerator = collection.GetType().GetMethod("GetEnumerator").Invoke(collection, null);
-            // get the type of it
-            var enumeratorType = enumerator.GetType();
-            // reflect MoveNext and Current
-            var moveNext = enumeratorType.GetMethod("MoveNext");
-            var current = enumeratorType.GetProperty("Current");
-            // iterate
-            while ((bool)moveNext.Invoke(enumerator, null))
-            {
-                list.Add(current.GetValue(enumerator, null));
-            }
-        }
-#endif
-
-#endregion
-
-#region UI CONSTRUCTION
-
-        internal GameObject m_listContent;
-        internal LayoutElement m_listLayout;
-
-        internal PageHandler m_pageHandler;
-
-        //internal List<GameObject> m_rowHolders = new List<GameObject>();
-
-        public override void ConstructUI(GameObject parent, GameObject subGroup)
-        {
-            base.ConstructUI(parent, subGroup);
-        }
-
-        public override void ConstructSubcontent()
-        {
-            base.ConstructSubcontent();
-
-            m_pageHandler = new PageHandler(null);
-            m_pageHandler.ConstructUI(m_subContentParent);
-            m_pageHandler.OnPageChanged += OnPageTurned;
-
-            var scrollObj = UIFactory.CreateVerticalGroup(this.m_subContentParent, new Color(0.08f, 0.08f, 0.08f));
-            m_listContent = scrollObj;
-
-            var scrollRect = scrollObj.GetComponent<RectTransform>();
-            scrollRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 0);
-
-            m_listLayout = Owner.m_mainContent.GetComponent<LayoutElement>();
-            m_listLayout.minHeight = 25;
-            m_listLayout.flexibleHeight = 0;
-            Owner.m_mainRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 25);
-
-            var scrollGroup = m_listContent.GetComponent<VerticalLayoutGroup>();
-            scrollGroup.childForceExpandHeight = true;
-            scrollGroup.SetChildControlHeight(true);
-            scrollGroup.spacing = 2;
-            scrollGroup.padding.top = 5;
-            scrollGroup.padding.left = 5;
-            scrollGroup.padding.right = 5;
-            scrollGroup.padding.bottom = 5;
-
-            var contentFitter = scrollObj.AddComponent<ContentSizeFitter>();
-            contentFitter.horizontalFit = ContentSizeFitter.FitMode.Unconstrained;
-            contentFitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
-        }
-
-        //internal void AddRowHolder()
-        //{
-        //    var obj = UIFactory.CreateHorizontalGroup(m_listContent, new Color(0.15f, 0.15f, 0.15f));
-
-        //    m_rowHolders.Add(obj);
-        //}
-
-#endregion
-    }
-}

src/Core/Inspectors/Reflection/InteractiveValue/InteractiveEnum.cs

@@ -1,178 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.UI;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class InteractiveEnum : InteractiveValue
-    {
-        internal static Dictionary<Type, KeyValuePair<int,string>[]> s_enumNamesCache = new Dictionary<Type, KeyValuePair<int, string>[]>();
-
-        public InteractiveEnum(object value, Type valueType) : base(value, valueType)
-        {
-            GetNames();
-        }
-
-        public override bool HasSubContent => true;
-        public override bool SubContentWanted => Owner.CanWrite;
-        public override bool WantInspectBtn => false;
-
-        internal KeyValuePair<int,string>[] m_values = new KeyValuePair<int, string>[0];
-
-        internal Type m_lastEnumType;
-
-        internal void GetNames()
-        {
-            var type = Value?.GetType() ?? FallbackType;
-
-            if (m_lastEnumType == type)
-                return;
-
-            m_lastEnumType = type;
-
-            if (m_subContentConstructed)
-            {
-                DestroySubContent();
-            }
-
-            if (!s_enumNamesCache.ContainsKey(type))
-            {
-                // using GetValues not GetNames, to catch instances of weird enums (eg CameraClearFlags)
-                var values = Enum.GetValues(type);
-
-                var list = new List<KeyValuePair<int, string>>();
-                var set = new HashSet<string>();
-
-                foreach (var value in values)
-                {
-                    var name = value.ToString();
-
-                    if (set.Contains(name)) 
-                        continue;
-
-                    set.Add(name);
-
-                    var backingType = Enum.GetUnderlyingType(type);
-                    int intValue;
-                    try
-                    {
-                        // this approach is necessary, a simple '(int)value' is not sufficient.
-
-                        var unbox = Convert.ChangeType(value, backingType);
-
-                        intValue = (int)Convert.ChangeType(unbox, typeof(int));
-                    }
-                    catch (Exception ex)
-                    {
-                        ExplorerCore.LogWarning("[InteractiveEnum] Could not Unbox underlying type " + backingType.Name + " from " + type.FullName);
-                        ExplorerCore.Log(ex.ToString());
-                        continue;
-                    }
-
-                    list.Add(new KeyValuePair<int, string>(intValue, name));
-                }
-
-                s_enumNamesCache.Add(type, list.ToArray());
-            }
-
-            m_values = s_enumNamesCache[type];
-        }
-
-        public override void OnValueUpdated()
-        {
-            GetNames();
-
-            base.OnValueUpdated();
-        }
-
-        public override void RefreshUIForValue()
-        {
-            base.RefreshUIForValue();
-
-            if (m_subContentConstructed)
-            {
-                m_dropdownText.text = Value?.ToString() ?? "<no value set>";
-            }
-        }
-
-        internal override void OnToggleSubcontent(bool toggle)
-        {
-            base.OnToggleSubcontent(toggle);
-
-            RefreshUIForValue();
-        }
-
-        private void SetValueFromDropdown()
-        {
-            var type = Value?.GetType() ?? FallbackType;
-            var index = m_dropdown.value;
-
-            var value = Enum.Parse(type, s_enumNamesCache[type][index].Value);
-
-            if (value != null)
-            {
-                Value = value;
-                Owner.SetValue();
-                RefreshUIForValue();
-            }
-        }
-
-        internal Dropdown m_dropdown;
-        internal Text m_dropdownText;
-
-        public override void ConstructUI(GameObject parent, GameObject subGroup)
-        {
-            base.ConstructUI(parent, subGroup);
-        }
-
-        public override void ConstructSubcontent()
-        {
-            base.ConstructSubcontent();
-
-            if (Owner.CanWrite)
-            {
-                var groupObj = UIFactory.CreateHorizontalGroup(m_subContentParent, new Color(1, 1, 1, 0));
-                var group = groupObj.GetComponent<HorizontalLayoutGroup>();
-                group.padding.top = 3;
-                group.padding.left = 3;
-                group.padding.right = 3;
-                group.padding.bottom = 3;
-                group.spacing = 5;
-
-                // apply button
-
-                var applyObj = UIFactory.CreateButton(groupObj, new Color(0.3f, 0.3f, 0.3f));
-                var applyLayout = applyObj.AddComponent<LayoutElement>();
-                applyLayout.minHeight = 25;
-                applyLayout.minWidth = 50;
-                var applyText = applyObj.GetComponentInChildren<Text>();
-                applyText.text = "Apply";
-                var applyBtn = applyObj.GetComponent<Button>();
-                applyBtn.onClick.AddListener(SetValueFromDropdown);
-
-                // dropdown
-
-                var dropdownObj = UIFactory.CreateDropdown(groupObj, out m_dropdown);
-                var dropLayout = dropdownObj.AddComponent<LayoutElement>();
-                dropLayout.minWidth = 150;
-                dropLayout.minHeight = 25;
-                dropLayout.flexibleWidth = 120;
-
-                foreach (var kvp in m_values)
-                {
-                    m_dropdown.options.Add(new Dropdown.OptionData
-                    {
-                        text = $"{kvp.Key}: {kvp.Value}"
-                    });
-                }
-
-                m_dropdownText = m_dropdown.transform.Find("Label").GetComponent<Text>();
-            }
-        }
-    }
-}

src/Core/Inspectors/Reflection/InteractiveValue/InteractiveEnumerable.cs

@@ -1,287 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.Core.Config;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.UI;
-using UnityExplorer.UI.Reusable;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class InteractiveEnumerable : InteractiveValue
-    {
-        public InteractiveEnumerable(object value, Type valueType) : base(value, valueType) 
-        {
-            if (valueType.IsGenericType)
-                m_baseEntryType = valueType.GetGenericArguments()[0];
-            else
-                m_baseEntryType = typeof(object);
-        }
-
-        public override bool WantInspectBtn => false;
-        public override bool HasSubContent => true;
-        public override bool SubContentWanted
-        {
-            get
-            {
-                if (m_recacheWanted)
-                    return true;
-                else return m_entries.Count > 0;
-            }
-        }
-
-        internal IEnumerable RefIEnumerable;
-        internal IList RefIList;
-#if CPP
-        internal Il2CppSystem.Collections.ICollection CppICollection;
-#else
-        internal ICollection CppICollection = null;
-#endif
-
-        internal readonly Type m_baseEntryType;
-
-        internal readonly List<CacheEnumerated> m_entries = new List<CacheEnumerated>();
-        internal readonly CacheEnumerated[] m_displayedEntries = new CacheEnumerated[ExplorerConfig.Instance.Default_Page_Limit];
-        internal bool m_recacheWanted = true;
-
-        public override void OnValueUpdated()
-        {
-            RefIEnumerable = Value as IEnumerable;
-            RefIList = Value as IList;
-
-#if CPP
-            if (Value != null && RefIList == null)
-            {
-                try { CppICollection = (Value as Il2CppSystem.Object).TryCast<Il2CppSystem.Collections.ICollection>(); }
-                catch { }
-            }
-#endif
-
-            if (m_subContentParent.activeSelf)
-            {
-                GetCacheEntries();
-                RefreshDisplay();
-            }
-            else
-                m_recacheWanted = true;
-
-            base.OnValueUpdated();
-        }
-
-        public override void OnException(CacheMember member)
-        {
-            base.OnException(member);
-        }
-
-        private void OnPageTurned()
-        {
-            RefreshDisplay();
-        }
-
-        public override void RefreshUIForValue()
-        {
-            GetDefaultLabel();
-
-            if (Value != null)
-            {
-                string count = "?";
-                if (m_recacheWanted && (RefIList != null || CppICollection != null))
-                    count = RefIList?.Count.ToString() ?? CppICollection.Count.ToString();
-                else if (!m_recacheWanted)
-                    count = m_entries.Count.ToString();
-
-                m_baseLabel.text = $"[{count}] {m_richValueType}";
-            }
-            else
-            {
-                m_baseLabel.text = DefaultLabel;
-            }
-        }
-
-        public void GetCacheEntries()
-        {
-            if (m_entries.Any())
-            {
-                // maybe improve this, probably could be more efficient i guess
-
-                foreach (var entry in m_entries)
-                    entry.Destroy();
-
-                m_entries.Clear();
-            }
-
-#if CPP
-            if (RefIEnumerable == null && Value != null)
-                RefIEnumerable = EnumerateWithReflection();
-#endif
-
-            if (RefIEnumerable != null)
-            {
-                int index = 0;
-                foreach (var entry in RefIEnumerable)
-                {
-                    var cache = new CacheEnumerated(index, this, RefIList, this.m_listContent);
-                    cache.CreateIValue(entry, m_baseEntryType);
-                    m_entries.Add(cache);
-
-                    cache.Disable();
-
-                    index++;
-                }
-            }
-
-            RefreshDisplay();
-        }
-
-        public void RefreshDisplay()
-        {
-            var entries = m_entries;
-            m_pageHandler.ListCount = entries.Count;
-
-            for (int i = 0; i < m_displayedEntries.Length; i++)
-            {
-                var entry = m_displayedEntries[i];
-                if (entry != null)
-                    entry.Disable();
-                else
-                    break;
-            }
-
-            if (entries.Count < 1)
-                return;
-
-            foreach (var itemIndex in m_pageHandler)
-            {
-                if (itemIndex >= entries.Count)
-                    break;
-
-                CacheEnumerated entry = entries[itemIndex];
-                m_displayedEntries[itemIndex - m_pageHandler.StartIndex] = entry;
-                entry.Enable();
-            }
-
-            //UpdateSubcontentHeight();
-        }
-
-        internal override void OnToggleSubcontent(bool active)
-        {
-            base.OnToggleSubcontent(active);
-
-            if (active && m_recacheWanted)
-            {
-                m_recacheWanted = false;
-                GetCacheEntries();
-                RefreshUIForValue();
-            }
-
-            RefreshDisplay();
-        }
-
-#region CPP Helpers
-
-#if CPP
-        // some temp fixes for Il2Cpp IEnumerables until interfaces are fixed
-
-        internal static readonly Dictionary<Type, MethodInfo> s_getEnumeratorMethods = new Dictionary<Type, MethodInfo>();
-
-        internal static readonly Dictionary<Type, EnumeratorInfo> s_enumeratorInfos = new Dictionary<Type, EnumeratorInfo>();
-        
-        internal class EnumeratorInfo
-        {
-            internal MethodInfo moveNext;
-            internal PropertyInfo current;
-        }
-
-        private IEnumerable EnumerateWithReflection()
-        {
-            if (Value == null) 
-                return null;
-
-            // new test
-            var CppEnumerable = (Value as Il2CppSystem.Object)?.TryCast<Il2CppSystem.Collections.IEnumerable>();
-            if (CppEnumerable != null)
-            {
-                var type = Value.GetType();
-                if (!s_getEnumeratorMethods.ContainsKey(type))
-                    s_getEnumeratorMethods.Add(type, type.GetMethod("GetEnumerator"));
-                
-                var enumerator = s_getEnumeratorMethods[type].Invoke(Value, null);
-                var enumeratorType = enumerator.GetType();
-
-                if (!s_enumeratorInfos.ContainsKey(enumeratorType))
-                {
-                    s_enumeratorInfos.Add(enumeratorType, new EnumeratorInfo
-                    {
-                        current = enumeratorType.GetProperty("Current"),
-                        moveNext = enumeratorType.GetMethod("MoveNext"),
-                    });
-                }
-                var info = s_enumeratorInfos[enumeratorType];
-
-                // iterate
-                var list = new List<object>();
-                while ((bool)info.moveNext.Invoke(enumerator, null))
-                    list.Add(info.current.GetValue(enumerator));
-
-                return list;
-            }
-
-            return null;
-        }
-#endif
-
-#endregion
-
-#region UI CONSTRUCTION
-
-        internal GameObject m_listContent;
-        internal LayoutElement m_listLayout;
-
-        internal PageHandler m_pageHandler;
-
-        public override void ConstructUI(GameObject parent, GameObject subGroup)
-        {
-            base.ConstructUI(parent, subGroup);
-        }
-
-        public override void ConstructSubcontent()
-        {
-            base.ConstructSubcontent();
-
-            m_pageHandler = new PageHandler(null);
-            m_pageHandler.ConstructUI(m_subContentParent);
-            m_pageHandler.OnPageChanged += OnPageTurned;
-
-            var scrollObj = UIFactory.CreateVerticalGroup(this.m_subContentParent, new Color(0.08f, 0.08f, 0.08f));
-            m_listContent = scrollObj;
-
-            var scrollRect = scrollObj.GetComponent<RectTransform>();
-            scrollRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 0);
-
-            m_listLayout = Owner.m_mainContent.GetComponent<LayoutElement>();
-            m_listLayout.minHeight = 25;
-            m_listLayout.flexibleHeight = 0;
-            Owner.m_mainRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 25);
-
-            var scrollGroup = m_listContent.GetComponent<VerticalLayoutGroup>();
-            scrollGroup.childForceExpandHeight = true;
-            scrollGroup.SetChildControlHeight(true);
-            scrollGroup.spacing = 2;
-            scrollGroup.padding.top = 5;
-            scrollGroup.padding.left = 5;
-            scrollGroup.padding.right = 5;
-            scrollGroup.padding.bottom = 5;
-
-            var contentFitter = scrollObj.AddComponent<ContentSizeFitter>();
-            contentFitter.horizontalFit = ContentSizeFitter.FitMode.Unconstrained;
-            contentFitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
-        }
-
-#endregion
-    }
-}

src/Core/Inspectors/Reflection/InteractiveValue/InteractiveFlags.cs

@@ -1,146 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.UI;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class InteractiveFlags : InteractiveEnum
-    {
-        public InteractiveFlags(object value, Type valueType) : base(value, valueType) 
-        {
-            m_toggles = new Toggle[m_values.Length];
-            m_enabledFlags = new bool[m_values.Length];
-        }
-
-        public override bool HasSubContent => true;
-        public override bool SubContentWanted => Owner.CanWrite;
-        public override bool WantInspectBtn => false;
-
-        internal bool[] m_enabledFlags;
-        internal Toggle[] m_toggles;
-
-        public override void OnValueUpdated()
-        {
-            base.OnValueUpdated();
-
-            if (Owner.CanWrite)
-            {
-                var enabledNames = new List<string>();
-
-                var enabled = Value?.ToString().Split(',').Select(it => it.Trim());
-                if (enabled != null)
-                    enabledNames.AddRange(enabled);
-
-                for (int i = 0; i < m_values.Length; i++)
-                {
-                    m_enabledFlags[i] = enabledNames.Contains(m_values[i].Value);
-                }
-            }
-        }
-
-        public override void RefreshUIForValue()
-        {
-            GetDefaultLabel();
-            m_baseLabel.text = DefaultLabel;
-
-            if (m_subContentConstructed)
-            {
-                for (int i = 0; i < m_values.Length; i++)
-                {
-                    var toggle = m_toggles[i];
-                    if (toggle.isOn != m_enabledFlags[i])
-                        toggle.isOn = m_enabledFlags[i];
-                }
-            }
-        }
-
-        private void SetValueFromToggles()
-        {
-            string val = "";
-            for (int i = 0; i < m_values.Length; i++)
-            {
-                if (m_enabledFlags[i])
-                {
-                    if (val != "") val += ", ";
-                    val += m_values[i].Value;
-                }
-            }
-            var type = Value?.GetType() ?? FallbackType;
-            Value = Enum.Parse(type, val);
-            RefreshUIForValue();
-            Owner.SetValue();
-        }
-
-        internal override void OnToggleSubcontent(bool toggle)
-        {
-            base.OnToggleSubcontent(toggle);
-
-            RefreshUIForValue();
-        }
-
-        public override void ConstructUI(GameObject parent, GameObject subGroup)
-        {
-            base.ConstructUI(parent, subGroup);
-        }
-
-        public override void ConstructSubcontent()
-        {
-            m_subContentConstructed = true;
-
-            if (Owner.CanWrite)
-            {
-                var groupObj = UIFactory.CreateVerticalGroup(m_subContentParent, new Color(1, 1, 1, 0));
-                var group = groupObj.GetComponent<VerticalLayoutGroup>();
-                group.childForceExpandHeight = true;
-                group.childForceExpandWidth = false;
-                group.SetChildControlHeight(true);
-                group.SetChildControlWidth(true);
-                group.padding.top = 3;
-                group.padding.left = 3;
-                group.padding.right = 3;
-                group.padding.bottom = 3;
-                group.spacing = 5;
-
-                // apply button
-
-                var applyObj = UIFactory.CreateButton(groupObj, new Color(0.3f, 0.3f, 0.3f));
-                var applyLayout = applyObj.AddComponent<LayoutElement>();
-                applyLayout.minHeight = 25;
-                applyLayout.minWidth = 50;
-                var applyText = applyObj.GetComponentInChildren<Text>();
-                applyText.text = "Apply";
-                var applyBtn = applyObj.GetComponent<Button>();
-                applyBtn.onClick.AddListener(SetValueFromToggles);
-
-                // toggles
-
-                for (int i = 0; i < m_values.Length; i++)
-                {
-                    AddToggle(i, groupObj);
-                }
-            }
-        }
-
-        internal void AddToggle(int index, GameObject groupObj)
-        {
-            var value = m_values[index];
-
-            var toggleObj = UIFactory.CreateToggle(groupObj, out Toggle toggle, out Text text, new Color(0.1f, 0.1f, 0.1f));
-            var toggleLayout = toggleObj.AddComponent<LayoutElement>();
-            toggleLayout.minWidth = 100;
-            toggleLayout.flexibleWidth = 2000;
-            toggleLayout.minHeight = 25;
-
-            m_toggles[index] = toggle;
-
-            toggle.onValueChanged.AddListener((bool val) => { m_enabledFlags[index] = val; });
-
-            text.text = $"{value.Key}: {value.Value}";
-        }
-    }
-}

src/Core/Inspectors/Reflection/InteractiveValue/InteractiveNumber.cs

@@ -1,128 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Reflection;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.UI;
-using UnityExplorer.Core;
-using UnityExplorer.UI.Utility;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class InteractiveNumber : InteractiveValue
-    {
-        public InteractiveNumber(object value, Type valueType) : base(value, valueType) { }
-
-        public override bool HasSubContent => false;
-        public override bool SubContentWanted => false;
-        public override bool WantInspectBtn => false;
-
-        public override void OnValueUpdated()
-        {
-            base.OnValueUpdated();
-        }
-
-        public override void OnException(CacheMember member)
-        {
-            base.OnException(member);
-
-            if (m_valueInput.gameObject.activeSelf)
-                m_valueInput.gameObject.SetActive(false);
-
-            if (Owner.CanWrite)
-            {
-                if (m_applyBtn.gameObject.activeSelf)
-                    m_applyBtn.gameObject.SetActive(false);
-            }
-        }
-
-        public override void RefreshUIForValue()
-        {
-            if (!Owner.HasEvaluated)
-            {
-                GetDefaultLabel();
-                m_baseLabel.text = DefaultLabel;
-                return;
-            }
-
-            m_baseLabel.text = SignatureHighlighter.ParseFullSyntax(FallbackType, false);
-            m_valueInput.text = Value.ToString();
-
-            var type = Value.GetType();
-            if (type == typeof(float)
-                || type == typeof(double)
-                || type == typeof(decimal))
-            {
-                m_valueInput.characterValidation = InputField.CharacterValidation.Decimal;
-            }
-            else
-            {
-                m_valueInput.characterValidation = InputField.CharacterValidation.Integer;
-            }
-
-            if (Owner.CanWrite)
-            {
-                if (!m_applyBtn.gameObject.activeSelf)
-                    m_applyBtn.gameObject.SetActive(true);
-            }
-
-            if (!m_valueInput.gameObject.activeSelf)
-                m_valueInput.gameObject.SetActive(true);
-        }
-
-        public MethodInfo ParseMethod => m_parseMethod ?? (m_parseMethod = Value.GetType().GetMethod("Parse", new Type[] { typeof(string) }));
-        private MethodInfo m_parseMethod;
-
-        internal void OnApplyClicked()
-        {
-            try
-            {
-                Value = ParseMethod.Invoke(null, new object[] { m_valueInput.text });
-                Owner.SetValue();
-                RefreshUIForValue();
-            }
-            catch (Exception e)
-            {
-                ExplorerCore.LogWarning("Could not parse input! " + ReflectionUtility.ReflectionExToString(e, true));
-            }
-        }
-
-        internal InputField m_valueInput;
-        internal Button m_applyBtn;
-
-        public override void ConstructUI(GameObject parent, GameObject subGroup)
-        {
-            base.ConstructUI(parent, subGroup);
-
-            var labelLayout = m_baseLabel.gameObject.GetComponent<LayoutElement>();
-            labelLayout.minWidth = 50;
-            labelLayout.flexibleWidth = 0;
-
-            var inputObj = UIFactory.CreateInputField(m_valueContent);
-            var inputLayout = inputObj.AddComponent<LayoutElement>();
-            inputLayout.minWidth = 120;
-            inputLayout.minHeight = 25;
-            inputLayout.flexibleWidth = 0;
-
-            m_valueInput = inputObj.GetComponent<InputField>();
-            m_valueInput.gameObject.SetActive(false);
-
-            if (Owner.CanWrite)
-            {
-                var applyBtnObj = UIFactory.CreateButton(m_valueContent, new Color(0.2f, 0.2f, 0.2f));
-                var applyLayout = applyBtnObj.AddComponent<LayoutElement>();
-                applyLayout.minWidth = 50;
-                applyLayout.minHeight = 25;
-                applyLayout.flexibleWidth = 0;
-                m_applyBtn = applyBtnObj.GetComponent<Button>();
-                m_applyBtn.onClick.AddListener(OnApplyClicked);
-
-                var applyText = applyBtnObj.GetComponentInChildren<Text>();
-                applyText.text = "Apply";
-            }
-        }
-    }
-}

src/Core/Inspectors/Reflection/InteractiveValue/InteractiveString.cs

@@ -1,205 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Reflection;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.UI;
-using UnityExplorer.UI.Utility;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class InteractiveString : InteractiveValue
-    {
-        public InteractiveString(object value, Type valueType) : base(value, valueType) { }
-
-        public override bool HasSubContent => true;
-        public override bool SubContentWanted => true;
-
-        public override bool WantInspectBtn => false;
-
-        public override void OnValueUpdated()
-        {
-            base.OnValueUpdated();
-        }
-
-        public override void OnException(CacheMember member)
-        {
-            base.OnException(member); 
-            
-            if (m_subContentConstructed && m_hiddenObj.gameObject.activeSelf)
-                m_hiddenObj.gameObject.SetActive(false);
-
-            m_labelLayout.minWidth = 200;
-            m_labelLayout.flexibleWidth = 5000;
-        }
-
-        public override void RefreshUIForValue()
-        {
-            GetDefaultLabel(false);
-
-            if (!Owner.HasEvaluated)
-            {
-                m_baseLabel.text = DefaultLabel;
-                return;
-            }
-
-            m_baseLabel.text = m_richValueType;
-
-            if (m_subContentConstructed)
-            {
-                if (!m_hiddenObj.gameObject.activeSelf)
-                    m_hiddenObj.gameObject.SetActive(true);
-            }
-
-            if (!string.IsNullOrEmpty((string)Value))
-            {
-                var toString = (string)Value;
-                if (toString.Length > 15000)
-                    toString = toString.Substring(0, 15000);
-
-                m_readonlyInput.text = toString;
-
-                if (m_subContentConstructed)
-                {
-                    m_valueInput.text = toString;
-                    m_placeholderText.text = toString;
-                }
-            }
-            else
-            {
-                string s = Value == null 
-                            ? "null" 
-                            : "empty";
-
-                m_readonlyInput.text = $"<i><color=grey>{s}</color></i>";
-
-                if (m_subContentConstructed)
-                {
-                    m_valueInput.text = "";
-                    m_placeholderText.text = s;
-                }
-            }
-
-            m_labelLayout.minWidth = 50;
-            m_labelLayout.flexibleWidth = 0;
-        }
-
-        internal void OnApplyClicked()
-        {
-            Value = m_valueInput.text;
-            Owner.SetValue();
-            RefreshUIForValue();
-        }
-
-        // for the default label
-        internal LayoutElement m_labelLayout;
-
-        //internal InputField m_readonlyInput;
-        internal Text m_readonlyInput;
-
-        // for input
-        internal InputField m_valueInput;
-        internal GameObject m_hiddenObj;
-        internal Text m_placeholderText;
-
-        public override void ConstructUI(GameObject parent, GameObject subGroup)
-        {
-            base.ConstructUI(parent, subGroup);
-
-            GetDefaultLabel(false);
-            m_richValueType = SignatureHighlighter.ParseFullSyntax(FallbackType, false);
-
-            m_labelLayout = m_baseLabel.gameObject.GetComponent<LayoutElement>();
-
-            var readonlyInputObj = UIFactory.CreateLabel(m_valueContent, TextAnchor.MiddleLeft);
-            m_readonlyInput = readonlyInputObj.GetComponent<Text>();
-            m_readonlyInput.horizontalOverflow = HorizontalWrapMode.Overflow;
-
-            var testFitter = readonlyInputObj.AddComponent<ContentSizeFitter>();
-            testFitter.verticalFit = ContentSizeFitter.FitMode.MinSize;
-
-            var labelLayout = readonlyInputObj.AddComponent<LayoutElement>();
-            labelLayout.minHeight = 25;
-            labelLayout.preferredHeight = 25;
-            labelLayout.flexibleHeight = 0;
-        }
-
-        public override void ConstructSubcontent()
-        {
-            base.ConstructSubcontent();
-
-            var groupObj = UIFactory.CreateVerticalGroup(m_subContentParent, new Color(1, 1, 1, 0));
-            var group = groupObj.GetComponent<VerticalLayoutGroup>();
-            group.spacing = 4;
-            group.padding.top = 3;
-            group.padding.left = 3;
-            group.padding.right = 3;
-            group.padding.bottom = 3;
-
-            m_hiddenObj = UIFactory.CreateLabel(groupObj, TextAnchor.MiddleLeft);
-            m_hiddenObj.SetActive(false);
-            var hiddenText = m_hiddenObj.GetComponent<Text>();
-            hiddenText.color = Color.clear;
-            hiddenText.fontSize = 14;
-            hiddenText.raycastTarget = false;
-            hiddenText.supportRichText = false;
-            var hiddenFitter = m_hiddenObj.AddComponent<ContentSizeFitter>();
-            hiddenFitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
-            var hiddenLayout = m_hiddenObj.AddComponent<LayoutElement>();
-            hiddenLayout.minHeight = 25;
-            hiddenLayout.flexibleHeight = 500;
-            hiddenLayout.minWidth = 250;
-            hiddenLayout.flexibleWidth = 9000;
-            var hiddenGroup = m_hiddenObj.AddComponent<HorizontalLayoutGroup>();
-            hiddenGroup.childForceExpandWidth = true;
-            hiddenGroup.SetChildControlWidth(true);
-            hiddenGroup.childForceExpandHeight = true;
-            hiddenGroup.SetChildControlHeight(true);
-
-            var inputObj = UIFactory.CreateInputField(m_hiddenObj, 14, 3);
-            var inputLayout = inputObj.AddComponent<LayoutElement>();
-            inputLayout.minWidth = 120;
-            inputLayout.minHeight = 25;
-            inputLayout.flexibleWidth = 5000;
-            inputLayout.flexibleHeight = 5000;
-
-            m_valueInput = inputObj.GetComponent<InputField>();
-            m_valueInput.lineType = InputField.LineType.MultiLineNewline;
-
-            m_placeholderText = m_valueInput.placeholder.GetComponent<Text>();
-
-            m_placeholderText.supportRichText = false;
-            m_valueInput.textComponent.supportRichText = false;
-
-            m_valueInput.onValueChanged.AddListener((string val) =>
-            {
-                hiddenText.text = val ?? "";
-                LayoutRebuilder.ForceRebuildLayoutImmediate(Owner.m_mainRect);
-            });
-
-            if (Owner.CanWrite)
-            {
-                var applyBtnObj = UIFactory.CreateButton(groupObj, new Color(0.2f, 0.2f, 0.2f));
-                var applyLayout = applyBtnObj.AddComponent<LayoutElement>();
-                applyLayout.minWidth = 50;
-                applyLayout.minHeight = 25;
-                applyLayout.flexibleWidth = 0;
-
-                var applyBtn = applyBtnObj.GetComponent<Button>();
-                applyBtn.onClick.AddListener(OnApplyClicked);
-
-                var applyText = applyBtnObj.GetComponentInChildren<Text>();
-                applyText.text = "Apply";
-            }
-            else
-            {
-                m_valueInput.readOnly = true;
-            }
-
-            RefreshUIForValue();
-        }
-    }
-}

src/Core/Inspectors/Reflection/InteractiveValue/InteractiveUnityStruct.cs

@@ -1,338 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using UnityEngine;
-using UnityEngine.UI;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.UI;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    #region IStructInfo helper
-
-    public interface IStructInfo
-    {
-        string[] FieldNames { get; }
-        object SetValue(ref object value, int fieldIndex, float val);
-        void RefreshUI(InputField[] inputs, object value);
-    }
-
-    public class StructInfo<T> : IStructInfo where T : struct
-    {
-        public string[] FieldNames { get; set; }
-
-        public delegate void SetMethod(ref T value, int fieldIndex, float val);
-        public SetMethod SetValueMethod;
-
-        public delegate void UpdateMethod(InputField[] inputs, object value);
-        public UpdateMethod UpdateUIMethod;
-
-        public object SetValue(ref object value, int fieldIndex, float val)
-        {
-            var box = (T)value;
-            SetValueMethod.Invoke(ref box, fieldIndex, val);
-            return box;
-        }
-
-        public void RefreshUI(InputField[] inputs, object value)
-        {
-            UpdateUIMethod.Invoke(inputs, value);
-        }
-    }
-
-    // This part is a bit ugly, but everything else is generalized above.
-    // I could generalize it more with reflection, but it would be different for
-    // mono/il2cpp and also slower.
-    public static class StructInfoFactory
-    {
-        public static IStructInfo Create(Type type)
-        {
-            if (type == typeof(Vector2))
-            {
-                return new StructInfo<Vector2>()
-                {
-                    FieldNames = new[] { "x", "y", },
-                    SetValueMethod = (ref Vector2 vec, int fieldIndex, float val) =>
-                    {
-                        switch (fieldIndex)
-                        {
-                            case 0: vec.x = val; break;
-                            case 1: vec.y = val; break;
-                        }
-                    },
-                    UpdateUIMethod = (InputField[] inputs, object value) =>
-                    {
-                        Vector2 vec = (Vector2)value;
-                        inputs[0].text = vec.x.ToString();
-                        inputs[1].text = vec.y.ToString();
-                    }
-                };
-            }
-            else if (type == typeof(Vector3))
-            {
-                return new StructInfo<Vector3>()
-                {
-                    FieldNames = new[] { "x", "y", "z" },
-                    SetValueMethod = (ref Vector3 vec, int fieldIndex, float val) =>
-                    {
-                        switch (fieldIndex)
-                        {
-                            case 0: vec.x = val; break;
-                            case 1: vec.y = val; break;
-                            case 2: vec.z = val; break;
-                        }
-                    },
-                    UpdateUIMethod = (InputField[] inputs, object value) =>
-                    {
-                        Vector3 vec = (Vector3)value;
-                        inputs[0].text = vec.x.ToString();
-                        inputs[1].text = vec.y.ToString();
-                        inputs[2].text = vec.z.ToString();
-                    }
-                };
-            }
-            else if (type == typeof(Vector4))
-            {
-                return new StructInfo<Vector4>()
-                {
-                    FieldNames = new[] { "x", "y", "z", "w" },
-                    SetValueMethod = (ref Vector4 vec, int fieldIndex, float val) =>
-                    {
-                        switch (fieldIndex)
-                        {
-                            case 0: vec.x = val; break;
-                            case 1: vec.y = val; break;
-                            case 2: vec.z = val; break;
-                            case 3: vec.w = val; break;
-                        }
-                    },
-                    UpdateUIMethod = (InputField[] inputs, object value) =>
-                    {
-                        Vector4 vec = (Vector4)value;
-                        inputs[0].text = vec.x.ToString();
-                        inputs[1].text = vec.y.ToString();
-                        inputs[2].text = vec.z.ToString();
-                        inputs[3].text = vec.w.ToString();
-                    }
-                };
-            }
-            else if (type == typeof(Rect))
-            {
-                return new StructInfo<Rect>()
-                {
-                    FieldNames = new[] { "x", "y", "width", "height" },
-                    SetValueMethod = (ref Rect vec, int fieldIndex, float val) =>
-                    {
-                        switch (fieldIndex)
-                        {
-                            case 0: vec.x = val; break;
-                            case 1: vec.y = val; break;
-                            case 2: vec.width = val; break;
-                            case 3: vec.height = val; break;
-                        }
-                    },
-                    UpdateUIMethod = (InputField[] inputs, object value) =>
-                    {
-                        Rect vec = (Rect)value;
-                        inputs[0].text = vec.x.ToString();
-                        inputs[1].text = vec.y.ToString();
-                        inputs[2].text = vec.width.ToString();
-                        inputs[3].text = vec.height.ToString();
-                    }
-                };
-            }
-            else if (type == typeof(Color))
-            {
-                return new StructInfo<Color>()
-                {
-                    FieldNames = new[] { "r", "g", "b", "a" },
-                    SetValueMethod = (ref Color vec, int fieldIndex, float val) =>
-                    {
-                        switch (fieldIndex)
-                        {
-                            case 0: vec.r = val; break;
-                            case 1: vec.g = val; break;
-                            case 2: vec.b = val; break;
-                            case 3: vec.a = val; break;
-                        }
-                    },
-                    UpdateUIMethod = (InputField[] inputs, object value) =>
-                    {
-                        Color vec = (Color)value;
-                        inputs[0].text = vec.r.ToString();
-                        inputs[1].text = vec.g.ToString();
-                        inputs[2].text = vec.b.ToString();
-                        inputs[3].text = vec.a.ToString();
-                    }
-                };
-            }
-            else
-                throw new NotImplementedException();
-        }
-    }
-
-    #endregion
-
-    public class InteractiveUnityStruct : InteractiveValue
-    {
-        public static bool SupportsType(Type type) => s_supportedTypes.Contains(type);
-        private static readonly HashSet<Type> s_supportedTypes = new HashSet<Type>
-        {
-            typeof(Vector2), 
-            typeof(Vector3), 
-            typeof(Vector4),
-            typeof(Rect),
-            typeof(Color) // todo might make a special editor for colors
-        };
-
-        //~~~~~~~~~ Instance ~~~~~~~~~~
-
-        public InteractiveUnityStruct(object value, Type valueType) : base(value, valueType) { }
-
-        public override bool HasSubContent => true;
-        public override bool SubContentWanted => true;
-        public override bool WantInspectBtn => true;
-
-        public IStructInfo StructInfo;
-
-        public override void RefreshUIForValue()
-        {
-            InitializeStructInfo();
-
-            base.RefreshUIForValue();
-
-            if (m_subContentConstructed)
-                StructInfo.RefreshUI(m_inputs, this.Value);
-        }
-
-        internal override void OnToggleSubcontent(bool toggle)
-        {
-            InitializeStructInfo();
-
-            base.OnToggleSubcontent(toggle);
-
-            StructInfo.RefreshUI(m_inputs, this.Value);
-        }
-
-        internal Type m_lastStructType;
-
-        internal void InitializeStructInfo()
-        {
-            var type = Value?.GetType() ?? FallbackType;
-
-            if (StructInfo != null && type == m_lastStructType)
-                return;
-
-            if (StructInfo != null)
-            {
-                DestroySubContent();
-                //// changing types, destroy subcontent
-                //for (int i = 0; i < m_subContentParent.transform.childCount; i++)
-                //{
-                //    var child = m_subContentParent.transform.GetChild(i);
-                //    GameObject.Destroy(child.gameObject);
-                //}
-
-                //m_UIConstructed = false;
-            }
-
-            m_lastStructType = type;
-
-            StructInfo = StructInfoFactory.Create(type);
-
-            if (m_subContentParent.activeSelf)
-            {
-                ConstructSubcontent();
-            }
-        }
-
-        #region UI CONSTRUCTION
-
-        internal InputField[] m_inputs;
-
-        public override void ConstructUI(GameObject parent, GameObject subGroup)
-        {
-            base.ConstructUI(parent, subGroup);
-        }
-
-        public override void ConstructSubcontent()
-        {
-            base.ConstructSubcontent();
-
-            if (StructInfo == null)
-            {
-                ExplorerCore.LogWarning("Setting up subcontent but structinfo is null");
-                return;
-            }
-
-            var editorContainer = UIFactory.CreateVerticalGroup(m_subContentParent, new Color(0.08f, 0.08f, 0.08f));
-            var editorGroup = editorContainer.GetComponent<VerticalLayoutGroup>();
-            editorGroup.childForceExpandWidth = false;
-            editorGroup.padding.top = 4;
-            editorGroup.padding.right = 4;
-            editorGroup.padding.left = 4;
-            editorGroup.padding.bottom = 4;
-            editorGroup.spacing = 2;
-
-            m_inputs = new InputField[StructInfo.FieldNames.Length];
-
-            for (int i = 0; i < StructInfo.FieldNames.Length; i++)
-            {
-                AddEditorRow(i, editorContainer);
-            }
-
-            if (Owner.CanWrite)
-            {
-                var applyBtnObj = UIFactory.CreateButton(editorContainer, new Color(0.2f, 0.2f, 0.2f));
-                var applyLayout = applyBtnObj.AddComponent<LayoutElement>();
-                applyLayout.minWidth = 175;
-                applyLayout.minHeight = 25;
-                applyLayout.flexibleWidth = 0;
-                var m_applyBtn = applyBtnObj.GetComponent<Button>();
-                m_applyBtn.onClick.AddListener(OnSetValue);
-
-                void OnSetValue()
-                {
-                    Owner.SetValue();
-                    RefreshUIForValue();
-                }
-
-                var applyText = applyBtnObj.GetComponentInChildren<Text>();
-                applyText.text = "Apply";
-            }
-        }
-
-        internal void AddEditorRow(int index, GameObject groupObj)
-        {
-            var rowObj = UIFactory.CreateHorizontalGroup(groupObj, new Color(1, 1, 1, 0));
-            var rowGroup = rowObj.GetComponent<HorizontalLayoutGroup>();
-            rowGroup.childForceExpandHeight = true;
-            rowGroup.childForceExpandWidth = false;
-            rowGroup.spacing = 5;
-
-            var label = UIFactory.CreateLabel(rowObj, TextAnchor.MiddleRight);
-            var labelLayout = label.AddComponent<LayoutElement>();
-            labelLayout.minWidth = 50;
-            labelLayout.flexibleWidth = 0;
-            labelLayout.minHeight = 25;
-            var labelText = label.GetComponent<Text>();
-            labelText.text = $"{StructInfo.FieldNames[index]}:";
-            labelText.color = Color.cyan;
-
-            var inputFieldObj = UIFactory.CreateInputField(rowObj, 14, 3, 1);
-            var inputField = inputFieldObj.GetComponent<InputField>();
-            inputField.characterValidation = InputField.CharacterValidation.Decimal;
-            var inputLayout = inputFieldObj.AddComponent<LayoutElement>();
-            inputLayout.flexibleWidth = 0;
-            inputLayout.minWidth = 120;
-            inputLayout.minHeight = 25;
-
-            m_inputs[index] = inputField;
-
-            inputField.onValueChanged.AddListener((string val) => { Value = StructInfo.SetValue(ref this.Value, index, float.Parse(val)); });
-        }
-
-        #endregion
-    }
-}

src/Core/Inspectors/Reflection/InteractiveValue/InteractiveValue.cs

@@ -1,374 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using UnityEngine;
-using UnityEngine.EventSystems;
-using UnityEngine.UI;
-using UnityExplorer.Core;
-using UnityExplorer.Core.Unity;
-using UnityExplorer.Core.Runtime;
-using UnityExplorer.UI;
-using UnityExplorer.UI.Utility;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class InteractiveValue
-    {
-        /// <summary>
-        /// Get the <see cref="InteractiveValue"/> subclass which supports the provided <paramref name="type"/>.
-        /// </summary>
-        /// <param name="type">The <see cref="Type"/> which you want the <see cref="InteractiveValue"/> Type for.</param>
-        /// <returns>The best subclass of <see cref="InteractiveValue"/> which supports the provided <paramref name="type"/>.</returns>
-        public static Type GetIValueForType(Type type)
-        {
-            // rather ugly but I couldn't think of a cleaner way that was worth it.
-            // switch-case doesn't really work here.
-
-            // arbitrarily check some types, fastest methods first.
-            if (type == typeof(bool))
-                return typeof(InteractiveBool);
-            // if type is primitive then it must be a number if its not a bool
-            else if (type.IsPrimitive)
-                return typeof(InteractiveNumber);
-            // check for strings
-            else if (type == typeof(string))
-                return typeof(InteractiveString);
-            // check for enum/flags
-            else if (typeof(Enum).IsAssignableFrom(type))
-            {
-                // NET 3.5 doesn't have "GetCustomAttribute", gotta use the multiple version.
-                if (type.GetCustomAttributes(typeof(FlagsAttribute), true) is object[] fa && fa.Any())
-                    return typeof(InteractiveFlags);
-                else
-                    return typeof(InteractiveEnum);
-            }
-            // check for unity struct types
-            else if (InteractiveUnityStruct.SupportsType(type))
-                return typeof(InteractiveUnityStruct);
-            // check Transform, force InteractiveValue so they dont become InteractiveEnumerables.
-            else if (typeof(Transform).IsAssignableFrom(type))
-                return typeof(InteractiveValue);
-            // check Dictionaries before Enumerables
-            else if (ReflectionUtility.IsDictionary(type))
-                return typeof(InteractiveDictionary);
-            // finally check for Enumerables
-            else if (ReflectionUtility.IsEnumerable(type))
-                return typeof(InteractiveEnumerable);
-            // fallback to default
-            else
-                return typeof(InteractiveValue);
-        }
-
-        public static InteractiveValue Create(object value, Type fallbackType)
-        {
-            var type = ReflectionUtility.GetType(value) ?? fallbackType;
-            var iType = GetIValueForType(type);
-
-            return (InteractiveValue)Activator.CreateInstance(iType, new object[] { value, type });
-        }
-
-        // ~~~~~~~~~ Instance ~~~~~~~~~
-
-        public InteractiveValue(object value, Type valueType)
-        {
-            this.Value = value;
-            this.FallbackType = valueType;
-        }
-
-        public CacheObjectBase Owner;
-
-        public object Value;
-        public readonly Type FallbackType;
-
-        public virtual bool HasSubContent => false;
-        public virtual bool SubContentWanted => false;
-        public virtual bool WantInspectBtn => true;
-
-        public string DefaultLabel => m_defaultLabel ?? GetDefaultLabel();
-        internal string m_defaultLabel;
-        internal string m_richValueType;
-
-        public bool m_UIConstructed;
-
-        public virtual void OnDestroy()
-        {
-            if (this.m_valueContent)
-            {
-                m_valueContent.transform.SetParent(null, false);
-                m_valueContent.SetActive(false); 
-                GameObject.Destroy(this.m_valueContent.gameObject);
-            }
-
-            DestroySubContent();
-        }
-
-        public virtual void DestroySubContent()
-        {
-            if (this.m_subContentParent && HasSubContent)
-            {
-                for (int i = 0; i < this.m_subContentParent.transform.childCount; i++)
-                {
-                    var child = m_subContentParent.transform.GetChild(i);
-                    if (child)
-                        GameObject.Destroy(child.gameObject);
-                }
-            }
-
-            m_subContentConstructed = false;
-        }
-
-        public virtual void OnValueUpdated()
-        {
-            if (!m_UIConstructed)
-                ConstructUI(m_mainContentParent, m_subContentParent);
-
-            if (Owner is CacheMember ownerMember && !string.IsNullOrEmpty(ownerMember.ReflectionException))
-                OnException(ownerMember);
-            else
-                RefreshUIForValue();
-        }
-
-        public virtual void OnException(CacheMember member)
-        {
-            if (m_UIConstructed)
-                m_baseLabel.text = "<color=red>" + member.ReflectionException + "</color>";
-                
-            Value = null;
-        }
-
-        public virtual void RefreshUIForValue()
-        {
-            GetDefaultLabel();
-            m_baseLabel.text = DefaultLabel;
-        }
-
-        public void RefreshElementsAfterUpdate()
-        {
-            if (WantInspectBtn)
-            {
-                bool shouldShowInspect = !Value.IsNullOrDestroyed();
-
-                if (m_inspectButton.activeSelf != shouldShowInspect)
-                    m_inspectButton.SetActive(shouldShowInspect);
-            }
-
-            bool subContentWanted = SubContentWanted;
-            if (Owner is CacheMember cm && (!cm.HasEvaluated || !string.IsNullOrEmpty(cm.ReflectionException)))
-                subContentWanted = false;
-
-            if (HasSubContent)
-            {
-                if (m_subExpandBtn.gameObject.activeSelf != subContentWanted)
-                    m_subExpandBtn.gameObject.SetActive(subContentWanted);
-
-                if (!subContentWanted && m_subContentParent.activeSelf)
-                    ToggleSubcontent();
-            }
-        }
-
-        public virtual void ConstructSubcontent()
-        {
-            m_subContentConstructed = true;
-        }
-
-        public void ToggleSubcontent()
-        {
-            if (!this.m_subContentParent.activeSelf)
-            {
-                this.m_subContentParent.SetActive(true);
-                this.m_subContentParent.transform.SetAsLastSibling();
-                m_subExpandBtn.GetComponentInChildren<Text>().text = "▼";
-            }
-            else
-            {
-                this.m_subContentParent.SetActive(false);
-                m_subExpandBtn.GetComponentInChildren<Text>().text = "▲";
-            }
-
-            OnToggleSubcontent(m_subContentParent.activeSelf);
-
-            RefreshElementsAfterUpdate();
-        }
-
-        internal virtual void OnToggleSubcontent(bool toggle)
-        {
-            if (!m_subContentConstructed)
-                ConstructSubcontent();
-        }
-
-        internal MethodInfo m_toStringMethod;
-        internal MethodInfo m_toStringFormatMethod;
-        internal bool m_gotToStringMethods;
-
-        public string GetDefaultLabel(bool updateType = true)
-        {
-            var valueType = Value?.GetType() ?? this.FallbackType;
-            if (updateType)
-                m_richValueType = SignatureHighlighter.ParseFullSyntax(valueType, true);
-
-            if (!Owner.HasEvaluated)
-                return m_defaultLabel = $"<i><color=grey>Not yet evaluated</color> ({m_richValueType})</i>";
-
-            if (Value.IsNullOrDestroyed())
-                return m_defaultLabel = $"<color=grey>null</color> ({m_richValueType})";
-
-            string label;
-
-            // Two dirty fixes for TextAsset and EventSystem, which can have very long ToString results.
-            if (Value is TextAsset textAsset)
-            {
-                label = textAsset.text;
-
-                if (label.Length > 10)
-                    label = $"{label.Substring(0, 10)}...";
-
-                label = $"\"{label}\" {textAsset.name} ({m_richValueType})";
-            }
-            else if (Value is EventSystem)
-            {
-                label = m_richValueType;
-            }
-            else // For everything else...
-            {
-                if (!m_gotToStringMethods)
-                {
-                    m_gotToStringMethods = true;
-
-                    m_toStringMethod = valueType.GetMethod("ToString", new Type[0]);
-                    m_toStringFormatMethod = valueType.GetMethod("ToString", new Type[] { typeof(string) });
-
-                    // test format method actually works
-                    try
-                    {
-                        m_toStringFormatMethod.Invoke(Value, new object[] { "F3" });
-                    }
-                    catch
-                    {
-                        m_toStringFormatMethod = null;
-                    }
-                }
-
-                string toString;
-                if (m_toStringFormatMethod != null)
-                    toString = (string)m_toStringFormatMethod.Invoke(Value, new object[] { "F3" });
-                else
-                    toString = (string)m_toStringMethod.Invoke(Value, new object[0]);
-
-                toString = toString ?? "";
-
-                string typeName = valueType.FullName;
-                if (typeName.StartsWith("Il2CppSystem."))
-                    typeName = typeName.Substring(6, typeName.Length - 6);
-
-                toString = ReflectionProvider.Instance.ProcessTypeNameInString(valueType, toString, ref typeName);
-
-                // If the ToString is just the type name, use our syntax highlighted type name instead.
-                if (toString == typeName)
-                {
-                    label = m_richValueType;
-                }
-                else // Otherwise, parse the result and put our highlighted name in.
-                {
-                    if (toString.Length > 200)
-                        toString = toString.Substring(0, 200) + "...";
-
-                    label = toString;
-
-                    var unityType = $"({valueType.FullName})";
-                    if (Value is UnityEngine.Object && label.Contains(unityType))
-                        label = label.Replace(unityType, $"({m_richValueType})");
-                    else
-                        label += $" ({m_richValueType})";
-                }
-            }
-
-            return m_defaultLabel = label;
-        }
-
-        #region UI CONSTRUCTION
-
-        internal GameObject m_mainContentParent;
-        internal GameObject m_subContentParent;
-
-        internal GameObject m_valueContent;
-        internal GameObject m_inspectButton;
-        internal Text m_baseLabel;
-
-        internal Button m_subExpandBtn;
-        internal bool m_subContentConstructed;
-
-        public virtual void ConstructUI(GameObject parent, GameObject subGroup)
-        {
-            m_UIConstructed = true;
-
-            m_valueContent = UIFactory.CreateHorizontalGroup(parent, new Color(1, 1, 1, 0));
-            m_valueContent.name = "InteractiveValue.ValueContent";
-            var mainRect = m_valueContent.GetComponent<RectTransform>();
-            mainRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 25);
-            var mainGroup = m_valueContent.GetComponent<HorizontalLayoutGroup>();
-            mainGroup.childForceExpandWidth = false;
-            mainGroup.SetChildControlWidth(true);
-            mainGroup.childForceExpandHeight = false;
-            mainGroup.SetChildControlHeight(true);
-            mainGroup.spacing = 4;
-            mainGroup.childAlignment = TextAnchor.UpperLeft;
-            var mainLayout = m_valueContent.AddComponent<LayoutElement>();
-            mainLayout.flexibleWidth = 9000;
-            mainLayout.minWidth = 175;
-            mainLayout.minHeight = 25;
-            mainLayout.flexibleHeight = 0;
-
-            // subcontent expand button TODO
-            if (HasSubContent)
-            {
-                var subBtnObj = UIFactory.CreateButton(m_valueContent, new Color(0.3f, 0.3f, 0.3f));
-                var btnLayout = subBtnObj.AddComponent<LayoutElement>();
-                btnLayout.minHeight = 25;
-                btnLayout.minWidth = 25;
-                btnLayout.flexibleWidth = 0;
-                btnLayout.flexibleHeight = 0;
-                var btnText = subBtnObj.GetComponentInChildren<Text>();
-                btnText.text = "▲";
-                m_subExpandBtn = subBtnObj.GetComponent<Button>();
-                m_subExpandBtn.onClick.AddListener(() =>
-                {
-                    ToggleSubcontent();
-                });
-            }
-
-            // inspect button
-
-            m_inspectButton = UIFactory.CreateButton(m_valueContent, new Color(0.3f, 0.3f, 0.3f, 0.2f));
-            var inspectLayout = m_inspectButton.AddComponent<LayoutElement>();
-            inspectLayout.minWidth = 60;
-            inspectLayout.minHeight = 25;
-            inspectLayout.flexibleHeight = 0;
-            inspectLayout.flexibleWidth = 0;
-            var inspectText = m_inspectButton.GetComponentInChildren<Text>();
-            inspectText.text = "Inspect";
-            var inspectBtn = m_inspectButton.GetComponent<Button>();
-
-            inspectBtn.onClick.AddListener(OnInspectClicked);
-            void OnInspectClicked()
-            {
-                if (!Value.IsNullOrDestroyed(false))
-                    InspectorManager.Instance.Inspect(this.Value, this.Owner);
-            }
-
-            m_inspectButton.SetActive(false);
-
-            // value label
-
-            var labelObj = UIFactory.CreateLabel(m_valueContent, TextAnchor.MiddleLeft);
-            m_baseLabel = labelObj.GetComponent<Text>();
-            var labelLayout = labelObj.AddComponent<LayoutElement>();
-            labelLayout.flexibleWidth = 9000;
-            labelLayout.minHeight = 25;
-
-            m_subContentParent = subGroup;
-        }
-
-#endregion
-    }
-}

src/Core/Inspectors/Reflection/ReflectionInspector.cs

@@ -1,360 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using UnityExplorer.Core.Unity;
-using UnityEngine;
-using UnityExplorer.Core.Inspectors.Reflection;
-using UnityExplorer.UI.Reusable;
-using System.Reflection;
-using UnityExplorer.UI;
-using UnityEngine.UI;
-using UnityExplorer.Core.Config;
-using UnityExplorer.Core;
-using UnityExplorer.UI.Utility;
-using UnityExplorer.UI.Main.Home.Inspectors;
-
-namespace UnityExplorer.Core.Inspectors
-{
-    public class ReflectionInspector : InspectorBase
-    {
-        #region STATIC
-
-        public static ReflectionInspector ActiveInstance { get; private set; }
-
-        static ReflectionInspector()
-        {
-            PanelDragger.OnFinishResize += OnContainerResized;
-            SceneExplorer.OnToggleShow += OnContainerResized;
-        }
-
-        private static void OnContainerResized()
-        {
-            if (ActiveInstance == null)
-                return;
-
-            ActiveInstance.ReflectionUI.m_widthUpdateWanted = true;
-        }
-
-        // Blacklists
-        private static readonly HashSet<string> bl_typeAndMember = new HashSet<string>
-        {
-#if CPP
-            // these cause a crash in IL2CPP
-            "Type.DeclaringMethod",
-            "Rigidbody2D.Cast",
-            "Collider2D.Cast",
-            "Collider2D.Raycast",
-            "Texture2D.SetPixelDataImpl",
-            "Camera.CalculateProjectionMatrixFromPhysicalProperties",
-#endif
-        };
-        private static readonly HashSet<string> bl_memberNameStartsWith = new HashSet<string>
-        {
-            // these are redundant
-            "get_",
-            "set_",
-        };
-
-        #endregion
-
-        #region INSTANCE
-
-        public override string TabLabel => m_targetTypeShortName;
-
-        internal CacheObjectBase ParentMember { get; set; }
-
-        internal ReflectionInspectorUI ReflectionUI;
-
-        internal readonly Type m_targetType;
-        internal readonly string m_targetTypeShortName;
-
-        // all cached members of the target
-        internal CacheMember[] m_allMembers;
-        // filtered members based on current filters
-        internal readonly List<CacheMember> m_membersFiltered = new List<CacheMember>();
-        // actual shortlist of displayed members
-        internal readonly CacheMember[] m_displayedMembers = new CacheMember[ExplorerConfig.Instance.Default_Page_Limit];
-
-        internal bool m_autoUpdate;
-
-        public ReflectionInspector(object target) : base(target)
-        {
-            if (this is StaticInspector)
-                m_targetType = target as Type;
-            else
-                m_targetType = ReflectionUtility.GetType(target);
-
-            m_targetTypeShortName = SignatureHighlighter.ParseFullSyntax(m_targetType, false);
-
-            ReflectionUI.ConstructUI();
-
-            CacheMembers(m_targetType);
-
-            FilterMembers();
-        }
-
-        public override void CreateUIModule()
-        {
-            BaseUI = ReflectionUI = new ReflectionInspectorUI(this);
-        }
-
-        public override void SetActive()
-        {
-            base.SetActive();
-            ActiveInstance = this;
-        }
-
-        public override void SetInactive()
-        {
-            base.SetInactive();
-            ActiveInstance = null;
-        }
-
-        public override void Destroy()
-        {
-            base.Destroy();
-
-            if (this.BaseUI.Content)
-                GameObject.Destroy(this.BaseUI.Content);
-        }
-
-        internal void OnPageTurned()
-        {
-            RefreshDisplay();
-        }
-
-        internal bool IsBlacklisted(string sig) => bl_typeAndMember.Any(it => sig.Contains(it));
-        internal bool IsBlacklisted(MethodInfo method) => bl_memberNameStartsWith.Any(it => method.Name.StartsWith(it));
-
-        internal string GetSig(MemberInfo member) => $"{member.DeclaringType.Name}.{member.Name}";
-        internal string AppendArgsToSig(ParameterInfo[] args)
-        {
-            string ret = " (";
-            foreach (var param in args)
-                ret += $"{param.ParameterType.Name} {param.Name}, ";
-            ret += ")";
-            return ret;
-        }
-
-        public void CacheMembers(Type type)
-        {
-            var list = new List<CacheMember>();
-            var cachedSigs = new HashSet<string>();
-
-            var types = ReflectionUtility.GetAllBaseTypes(type);
-
-            var flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static;
-            if (this is InstanceInspector)
-                flags |= BindingFlags.Instance;
-
-            foreach (var declaringType in types)
-            {
-                var target = Target;
-                target = target.Cast(declaringType);
-
-                IEnumerable<MemberInfo> infos = declaringType.GetMethods(flags);
-                infos = infos.Concat(declaringType.GetProperties(flags));
-                infos = infos.Concat(declaringType.GetFields(flags));
-
-                foreach (var member in infos)
-                {
-                    try
-                    {
-                        var sig = GetSig(member);
-
-                        //ExplorerCore.Log($"Trying to cache member {sig}...");
-                        //ExplorerCore.Log(member.DeclaringType.FullName + "." + member.Name);
-
-                        var mi = member as MethodInfo;
-                        var pi = member as PropertyInfo;
-                        var fi = member as FieldInfo;
-
-                        if (IsBlacklisted(sig) || (mi != null && IsBlacklisted(mi)))
-                            continue;
-
-                        var args = mi?.GetParameters() ?? pi?.GetIndexParameters();
-                        if (args != null)
-                        {
-                            if (!CacheMember.CanProcessArgs(args))
-                                continue;
-
-                            sig += AppendArgsToSig(args);
-                        }
-
-                        if (cachedSigs.Contains(sig))
-                            continue;
-
-                        cachedSigs.Add(sig);
-
-                        if (mi != null)
-                            list.Add(new CacheMethod(mi, target, ReflectionUI.m_scrollContent));
-                        else if (pi != null)
-                            list.Add(new CacheProperty(pi, target, ReflectionUI.m_scrollContent));
-                        else
-                            list.Add(new CacheField(fi, target, ReflectionUI.m_scrollContent));
-
-                        list.Last().ParentInspector = this;
-                    }
-                    catch (Exception e)
-                    {
-                        ExplorerCore.LogWarning($"Exception caching member {member.DeclaringType.FullName}.{member.Name}!");
-                        ExplorerCore.Log(e.ToString());
-                    }
-                }
-            }
-
-            var typeList = types.ToList();
-
-            var sorted = new List<CacheMember>();
-            sorted.AddRange(list.Where(it => it is CacheMethod)
-                             .OrderBy(it => typeList.IndexOf(it.DeclaringType))
-                             .ThenBy(it => it.NameForFiltering));
-            sorted.AddRange(list.Where(it => it is CacheProperty)
-                             .OrderBy(it => typeList.IndexOf(it.DeclaringType))
-                             .ThenBy(it => it.NameForFiltering));
-            sorted.AddRange(list.Where(it => it is CacheField)
-                             .OrderBy(it => typeList.IndexOf(it.DeclaringType))
-                             .ThenBy(it => it.NameForFiltering));
-
-            m_allMembers = sorted.ToArray();
-        }
-
-        public override void Update()
-        {
-            base.Update();
-
-            if (m_autoUpdate)
-            {
-                foreach (var member in m_displayedMembers)
-                {
-                    if (member == null) break;
-                    member.UpdateValue();
-                }
-            }
-
-            if (ReflectionUI.m_widthUpdateWanted)
-            {
-                if (!ReflectionUI.m_widthUpdateWaiting)
-                    ReflectionUI.m_widthUpdateWaiting = true;
-                else
-                {
-                    UpdateWidths();
-                    ReflectionUI.m_widthUpdateWaiting = false;
-                    ReflectionUI.m_widthUpdateWanted = false;
-                }
-            }
-        }
-
-        internal void OnMemberFilterClicked(MemberTypes type, Button button)
-        {
-            if (ReflectionUI.m_lastActiveMemButton)
-            {
-                var lastColors = ReflectionUI.m_lastActiveMemButton.colors;
-                lastColors.normalColor = new Color(0.2f, 0.2f, 0.2f);
-                ReflectionUI.m_lastActiveMemButton.colors = lastColors;
-            }
-
-            ReflectionUI.m_memberFilter = type;
-            ReflectionUI.m_lastActiveMemButton = button;
-
-            var colors = ReflectionUI.m_lastActiveMemButton.colors;
-            colors.normalColor = new Color(0.2f, 0.6f, 0.2f);
-            ReflectionUI.m_lastActiveMemButton.colors = colors;
-
-            FilterMembers(null, true);
-            ReflectionUI.m_sliderScroller.m_slider.value = 1f;
-        }
-
-        public void FilterMembers(string nameFilter = null, bool force = false)
-        {
-            int lastCount = m_membersFiltered.Count;
-            m_membersFiltered.Clear();
-
-            nameFilter = nameFilter?.ToLower() ?? ReflectionUI.m_nameFilterText.text.ToLower();
-
-            foreach (var mem in m_allMembers)
-            {
-                // membertype filter
-                if (ReflectionUI.m_memberFilter != MemberTypes.All && mem.MemInfo.MemberType != ReflectionUI.m_memberFilter)
-                    continue;
-
-                if (this is InstanceInspector ii && ii.m_scopeFilter != MemberScopes.All)
-                {
-                    if (mem.IsStatic && ii.m_scopeFilter != MemberScopes.Static)
-                        continue;
-                    else if (!mem.IsStatic && ii.m_scopeFilter != MemberScopes.Instance)
-                        continue;
-                }
-
-                // name filter
-                if (!string.IsNullOrEmpty(nameFilter) && !mem.NameForFiltering.Contains(nameFilter))
-                    continue;
-
-                m_membersFiltered.Add(mem);
-            }
-
-            if (force || lastCount != m_membersFiltered.Count)
-                RefreshDisplay();
-        }
-
-        public void RefreshDisplay()
-        {
-            var members = m_membersFiltered;
-            ReflectionUI.m_pageHandler.ListCount = members.Count;
-
-            // disable current members
-            for (int i = 0; i < m_displayedMembers.Length; i++)
-            {
-                var mem = m_displayedMembers[i];
-                if (mem != null)
-                    mem.Disable();
-                else
-                    break;
-            }
-
-            if (members.Count < 1)
-                return;
-
-            foreach (var itemIndex in ReflectionUI.m_pageHandler)
-            {
-                if (itemIndex >= members.Count)
-                    break;
-
-                CacheMember member = members[itemIndex];
-                m_displayedMembers[itemIndex - ReflectionUI.m_pageHandler.StartIndex] = member;
-                member.Enable();
-            }
-
-            ReflectionUI.m_widthUpdateWanted = true;
-        }
-
-        internal void UpdateWidths()
-        {
-            float labelWidth = 125;
-
-            foreach (var cache in m_displayedMembers)
-            {
-                if (cache == null)
-                    break;
-
-                var width = cache.GetMemberLabelWidth(ReflectionUI.m_scrollContentRect);
-
-                if (width > labelWidth)
-                    labelWidth = width;
-            }
-
-            float valueWidth = ReflectionUI.m_scrollContentRect.rect.width - labelWidth - 20;
-
-            foreach (var cache in m_displayedMembers)
-            {
-                if (cache == null)
-                    break;
-                cache.SetWidths(labelWidth, valueWidth);
-            }
-        }
-
-
-        #endregion // end instance
-    }
-}

src/Core/Inspectors/Reflection/StaticInspector.cs

@@ -1,11 +0,0 @@
-using System;
-
-namespace UnityExplorer.Core.Inspectors.Reflection
-{
-    public class StaticInspector : ReflectionInspector
-    {
-        public override string TabLabel => $" <color=cyan>[S]</color> {base.TabLabel}";
-
-        public StaticInspector(Type type) : base(type) { }
-    }
-}

src/Core/ReflectionUtility.cs

@@ -11,7 +11,7 @@ namespace UnityExplorer.Core
 {
     public static class ReflectionUtility
     {
-        public static BF CommonFlags = BF.Public | BF.Instance | BF.NonPublic | BF.Static;
+        public const BF CommonFlags = BF.Public | BF.Instance | BF.NonPublic | BF.Static;
 
         /// <summary>
         /// Helper for IL2CPP to get the underlying true Type (Unhollowed) of the object.
@@ -32,7 +32,7 @@ namespace UnityExplorer.Core
         /// <param name="obj">The object to cast</param>
         /// <returns>The object, cast to the underlying Type if possible, otherwise the original object.</returns>
         public static object Cast(this object obj)
-            => Cast(obj, GetType(obj));
+            => ReflectionProvider.Instance.Cast(obj, GetType(obj));
 
         /// <summary>
         /// Cast an object to a Type, if possible.
@@ -59,7 +59,10 @@ namespace UnityExplorer.Core
         public static bool IsDictionary(this Type t)
             => ReflectionProvider.Instance.IsAssignableFrom(typeof(IDictionary), t);
 
-        public static bool LoadModule(string module)
+        /// <summary>
+        /// [INTERNAL] Used to load Unhollowed DLLs in IL2CPP.
+        /// </summary>
+        internal static bool LoadModule(string module)
             => ReflectionProvider.Instance.LoadModule(module);
 
         // cache for GetTypeByName

src/Core/Runtime/Il2Cpp/ICallManager.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Runtime.InteropServices;
 
 namespace UnityExplorer.Core.Runtime.Il2Cpp
@@ -9,6 +10,9 @@ namespace UnityExplorer.Core.Runtime.Il2Cpp
     [SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "External methods")]
     public static class ICallManager
     {
+        [DllImport("GameAssembly", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+        public static extern IntPtr il2cpp_resolve_icall([MarshalAs(UnmanagedType.LPStr)] string name);
+
         private static readonly Dictionary<string, Delegate> iCallCache = new Dictionary<string, Delegate>();
 
         /// <summary>
@@ -26,9 +30,7 @@ namespace UnityExplorer.Core.Runtime.Il2Cpp
             IntPtr ptr = il2cpp_resolve_icall(signature);
 
             if (ptr == IntPtr.Zero)
-            {
-                throw new MissingMethodException($"Could not resolve internal call by name '{signature}'!");
-            }
+                throw new MissingMethodException($"Could not find any iCall with the signature '{signature}'!");
 
             Delegate iCall = Marshal.GetDelegateForFunctionPointer(ptr, typeof(T));
             iCallCache.Add(signature, iCall);
@@ -36,8 +38,35 @@ namespace UnityExplorer.Core.Runtime.Il2Cpp
             return (T)iCall;
         }
 
-        [DllImport("GameAssembly", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        public static extern IntPtr il2cpp_resolve_icall([MarshalAs(UnmanagedType.LPStr)] string name);
+        private static readonly Dictionary<string, Delegate> s_unreliableCache = new Dictionary<string, Delegate>();
+
+        /// <summary>
+        /// Get an iCall which may be one of multiple different signatures (ie, it changed in different Unity versions).
+        /// Each possible signature must have the same Type pattern, it can only vary by name.
+        /// </summary>
+        public static T GetICallUnreliable<T>(IEnumerable<string> possibleSignatures) where T : Delegate
+        {
+            // use the first possible signature as the 'key'.
+            string key = possibleSignatures.First();
+
+            if (s_unreliableCache.ContainsKey(key))
+                return (T)s_unreliableCache[key];
+
+            T iCall;
+            IntPtr ptr;
+            foreach (var sig in possibleSignatures)
+            {
+                ptr = il2cpp_resolve_icall(sig);
+                if (ptr != IntPtr.Zero)
+                {
+                    iCall = (T)Marshal.GetDelegateForFunctionPointer(ptr, typeof(T));
+                    s_unreliableCache.Add(key, iCall);
+                    return iCall;
+                }
+            }
+
+            throw new MissingMethodException($"Could not find any iCall from list of provided signatures starting with '{key}'!");
+        }
     }
 }
 #endif

src/Core/Runtime/Il2Cpp/Il2CppProvider.cs

@@ -12,6 +12,7 @@ using UnityEngine.Events;
 using UnityEngine.SceneManagement;
 using System.Collections;
 using UnityEngine.UI;
+using UnityExplorer.Core.Input;
 
 namespace UnityExplorer.Core.Runtime.Il2Cpp
 {
@@ -34,7 +35,7 @@ namespace UnityExplorer.Core.Runtime.Il2Cpp
                 var addMethod = typeof(Application).GetMethod("add_logMessageReceived", BF.Static | BF.Public, null, new[] { logType }, null);
                 addMethod.Invoke(null, new[]
                 {
-                    castMethod.Invoke(null, new[] { new Action<string, string, LogType>(ExplorerCore.Instance.OnUnityLog) })
+                    castMethod.Invoke(null, new[] { new Action<string, string, LogType>(Application_logMessageReceived) })
                 });
             }
             catch 
@@ -43,11 +44,20 @@ namespace UnityExplorer.Core.Runtime.Il2Cpp
             }
         }
 
+        private void Application_logMessageReceived(string condition, string stackTrace, LogType type)
+        {
+            ExplorerCore.Log(condition, type, true);
+        }
+
         public override void StartConsoleCoroutine(IEnumerator routine)
         {
             Il2CppCoroutine.Start(routine);
         }
 
+        // Unity API Handlers
+
+        // LayerMask.LayerToName
+
         internal delegate IntPtr d_LayerToName(int layer);
 
         public override string LayerToName(int layer)
@@ -56,20 +66,25 @@ namespace UnityExplorer.Core.Runtime.Il2Cpp
             return IL2CPP.Il2CppStringToManaged(iCall.Invoke(layer));
         }
 
+        // Resources.FindObjectsOfTypeAll
+
         internal delegate IntPtr d_FindObjectsOfTypeAll(IntPtr type);
 
         public override UnityEngine.Object[] FindObjectsOfTypeAll(Type type)
         {
-            var iCall = ICallManager.GetICall<d_FindObjectsOfTypeAll>("UnityEngine.Resources::FindObjectsOfTypeAll");
-            var cppType = Il2CppType.From(type);
+            var iCall = ICallManager.GetICallUnreliable<d_FindObjectsOfTypeAll>(new[]
+            {
+                "UnityEngine.Resources::FindObjectsOfTypeAll",
+                "UnityEngine.ResourcesAPIInternal::FindObjectsOfTypeAll" // Unity 2020+ updated to this
+            });
 
-            return new Il2CppReferenceArray<UnityEngine.Object>(iCall.Invoke(cppType.Pointer));
+            return new Il2CppReferenceArray<UnityEngine.Object>(iCall.Invoke(Il2CppType.From(type).Pointer));
         }
 
         public override int GetSceneHandle(Scene scene)
             => scene.handle;
 
-        //Scene.GetRootGameObjects();
+        // Scene.GetRootGameObjects();
 
         internal delegate void d_GetRootGameObjects(int handle, IntPtr list);
 
@@ -94,7 +109,7 @@ namespace UnityExplorer.Core.Runtime.Il2Cpp
             return list.ToArray();
         }
 
-        //Scene.rootCount;
+        // Scene.rootCount
 
         internal delegate int d_GetRootCountInternal(int handle);
 
@@ -105,6 +120,36 @@ namespace UnityExplorer.Core.Runtime.Il2Cpp
             return ICallManager.GetICall<d_GetRootCountInternal>("UnityEngine.SceneManagement.Scene::GetRootCountInternal")
                    .Invoke(handle);
         }
+
+        // ColorBlock set
+
+        public override void SetColorBlockColors(ref ColorBlock colorBlock, Color? normal, Color? highlighted, Color? pressed)
+        {
+            if (normal != null)
+            {
+                colorBlock.m_NormalColor = (Color)normal;
+                colorBlock.m_SelectedColor = (Color)normal;
+            }
+
+            if (highlighted != null)
+                colorBlock.m_HighlightedColor = (Color)highlighted;
+
+            if (pressed != null)
+                colorBlock.m_PressedColor = (Color)pressed;
+        }
+
+        // Custom check for il2cpp input pointer event
+
+        public override void CheckInputPointerEvent()
+        {
+            // Some IL2CPP games behave weird with multiple UI Input Systems, some fixes for them.
+            var evt = InputManager.InputPointerEvent;
+            if (evt != null)
+            {
+                if (!evt.eligibleForClick && evt.selectedObject)
+                    evt.eligibleForClick = true;
+            }
+        }
     }
 }
 

src/Core/Runtime/Il2Cpp/Il2CppReflection.cs

@@ -5,7 +5,6 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using UnhollowerBaseLib;
-using UnityExplorer.Core.Unity;
 using UnhollowerRuntimeLib;
 using System.Runtime.InteropServices;
 using System.Reflection;

src/Core/Runtime/Mono/MonoProvider.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Reflection;
 using System.Text;
 using UnityEngine;
+using UnityEngine.Events;
 using UnityEngine.SceneManagement;
 using UnityEngine.UI;
 using UnityExplorer.Core;
@@ -23,9 +24,12 @@ namespace UnityExplorer.Core.Runtime.Mono
 
         public override void SetupEvents()
         {
-            Application.logMessageReceived += ExplorerCore.Instance.OnUnityLog;
-            //SceneManager.sceneLoaded += ExplorerCore.Instance.OnSceneLoaded1;
-            //SceneManager.activeSceneChanged += ExplorerCore.Instance.OnSceneLoaded2;
+            Application.logMessageReceived += Application_logMessageReceived;
+        }
+
+        private void Application_logMessageReceived(string condition, string stackTrace, LogType type)
+        {
+            ExplorerCore.Log(condition, type, true);
         }
 
         public override void StartConsoleCoroutine(IEnumerator routine)
@@ -55,11 +59,38 @@ namespace UnityExplorer.Core.Runtime.Mono
         {
             return scene.rootCount;
         }
+
+        public override void SetColorBlockColors(ref ColorBlock block, Color? normal, Color? highlighted, Color? pressed)
+        {
+            if (normal != null)
+                block.normalColor = (Color)normal;
+
+            if (highlighted != null)
+                block.highlightedColor = (Color)highlighted;
+
+            if (pressed != null)
+                block.pressedColor = (Color)pressed;
+        }
+
+        public override void CheckInputPointerEvent()
+        {
+            // Not necessary afaik
+        }
     }
 }
 
 public static class MonoExtensions
 {
+    public static void AddListener(this UnityEvent _event, Action listener)
+    {
+        _event.AddListener(new UnityAction(listener));
+    }
+
+    public static void AddListener<T>(this UnityEvent<T> _event, Action<T> listener)
+    {
+        _event.AddListener(new UnityAction<T>(listener));
+    }
+
     public static void Clear(this StringBuilder sb)
     {
         sb.Remove(0, sb.Length);

src/Core/Runtime/RuntimeProvider.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Text;
 using UnityEngine;
 using UnityEngine.SceneManagement;
+using UnityEngine.UI;
 
 namespace UnityExplorer.Core.Runtime
 {
@@ -50,5 +51,9 @@ namespace UnityExplorer.Core.Runtime
         public abstract GameObject[] GetRootGameObjects(Scene scene);
 
         public abstract int GetRootCount(Scene scene);
+
+        public abstract void SetColorBlockColors(ref ColorBlock block, Color? normal, Color? highlight, Color? pressed);
+
+        public abstract void CheckInputPointerEvent();
     }
 }

src/Core/SceneExplorer.cs

@@ -1,206 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using UnityExplorer.UI;
-using UnityExplorer.UI.Main;
-using UnityExplorer.UI.Reusable;
-using UnityEngine;
-using UnityEngine.SceneManagement;
-using UnityEngine.UI;
-using UnityExplorer.Core.Runtime;
-using UnityExplorer.UI.Main.Home;
-using UnityExplorer.Core.Config;
-
-namespace UnityExplorer.Core.Inspectors
-{
-    public class SceneExplorer
-    {
-        public static SceneExplorer Instance;
-
-        public static SceneExplorerUI UI;
-
-        internal static Action OnToggleShow;
-
-        public SceneExplorer()
-        { 
-            Instance = this;
-
-            UI = new SceneExplorerUI();
-            UI.ConstructScenePane();
-        }
-
-        private const float UPDATE_INTERVAL = 1f;
-        private float m_timeOfLastSceneUpdate;
-
-        // private int m_currentSceneHandle = -1;
-        public static Scene DontDestroyScene => DontDestroyObject.scene;
-        internal Scene m_currentScene;
-        internal Scene[] m_currentScenes = new Scene[0];
-
-        internal GameObject[] m_allObjects = new GameObject[0];
-
-        internal GameObject m_selectedSceneObject;
-        internal int m_lastCount;
-
-        internal static GameObject DontDestroyObject
-        {
-            get
-            {
-                if (!s_dontDestroyObject)
-                {
-                    s_dontDestroyObject = new GameObject("DontDestroyMe");
-                    GameObject.DontDestroyOnLoad(s_dontDestroyObject);
-                }
-                return s_dontDestroyObject;
-            }
-        }
-        internal static GameObject s_dontDestroyObject;
-
-        public void Init()
-        {
-            RefreshSceneSelector();
-
-            if (ExplorerConfig.Instance.SceneExplorer_Hidden)
-                UI.ToggleShow();
-        }
-
-        public void Update()
-        {
-            if (UI.Hiding || Time.realtimeSinceStartup - m_timeOfLastSceneUpdate < UPDATE_INTERVAL)
-                return;
-
-            RefreshSceneSelector();
-
-            if (!m_selectedSceneObject)
-            {
-                if (m_currentScene != default)
-                {
-                    var rootObjects = RuntimeProvider.Instance.GetRootGameObjects(m_currentScene);
-                    SetSceneObjectList(rootObjects);
-                }
-            }
-            else
-            {
-                RefreshSelectedSceneObject();
-            }
-        }
-
-        private void RefreshSceneSelector()
-        {
-            var newNames = new List<string>();
-            var newScenes = new List<Scene>();
-
-            if (m_currentScenes == null)
-                m_currentScenes = new Scene[0];
-
-            bool anyChange = SceneManager.sceneCount != m_currentScenes.Length - 1;
-
-            for (int i = 0; i < SceneManager.sceneCount; i++)
-            {
-                Scene scene = SceneManager.GetSceneAt(i);
-
-                if (scene == default)
-                    continue;
-
-                int handle = RuntimeProvider.Instance.GetSceneHandle(scene);
-
-                if (!anyChange && !m_currentScenes.Any(it => handle == RuntimeProvider.Instance.GetSceneHandle(it)))
-                    anyChange = true;
-
-                newScenes.Add(scene);
-                newNames.Add(scene.name);
-            }
-
-            if (anyChange)
-            {
-                newNames.Add("DontDestroyOnLoad");
-                newScenes.Add(DontDestroyScene);
-                m_currentScenes = newScenes.ToArray();
-
-                UI.OnActiveScenesChanged(newNames);
-
-                SetTargetScene(newScenes[0]);
-
-                SearchPage.Instance.OnSceneChange();
-            }
-        }
-
-        public void SetTargetScene(int index)
-            => SetTargetScene(m_currentScenes[index]);
-
-        public void SetTargetScene(Scene scene)
-        {
-            if (scene == default)
-                return;
-
-            m_currentScene = scene;
-            var rootObjs = RuntimeProvider.Instance.GetRootGameObjects(scene);
-            SetSceneObjectList(rootObjs);
-
-            m_selectedSceneObject = null;
-
-            UI.OnSceneSelected();
-        }
-
-        public void SetSceneObjectParent()
-        {
-            if (!m_selectedSceneObject || !m_selectedSceneObject.transform.parent?.gameObject)
-            {
-                m_selectedSceneObject = null;
-                SetTargetScene(m_currentScene);
-            }
-            else
-            {
-                SetTargetObject(m_selectedSceneObject.transform.parent.gameObject);
-            }
-        }
-
-        public void SetTargetObject(GameObject obj)
-        {
-            if (!obj)
-                return;
-
-            UI.OnGameObjectSelected(obj);
-
-            m_selectedSceneObject = obj;
-
-            RefreshSelectedSceneObject();
-        }
-
-        private void RefreshSelectedSceneObject()
-        {
-            GameObject[] list = new GameObject[m_selectedSceneObject.transform.childCount];
-            for (int i = 0; i < m_selectedSceneObject.transform.childCount; i++)
-            {
-                list[i] = m_selectedSceneObject.transform.GetChild(i).gameObject;
-            }
-
-            SetSceneObjectList(list);
-        }
-
-        private void SetSceneObjectList(GameObject[] objects)
-        {
-            m_allObjects = objects;
-            RefreshSceneObjectList();
-        }
-
-        internal void RefreshSceneObjectList()
-        {
-            m_timeOfLastSceneUpdate = Time.realtimeSinceStartup;
-
-            UI.RefreshSceneObjectList(m_allObjects, out int newCount);
-
-            m_lastCount = newCount;
-        }
-
-        internal static void InspectSelectedGameObject()
-        {
-            InspectorManager.Instance.Inspect(Instance.m_selectedSceneObject);
-        }
-
-        internal static void InvokeOnToggleShow()
-        {
-            OnToggleShow?.Invoke();
-        }
-    }
-}

src/Core/Search/ChildFilter.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
-namespace UnityExplorer.Search
+namespace UnityExplorer.Core.Search
 {
     internal enum ChildFilter
     {

src/Core/Search/SceneFilter.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
-namespace UnityExplorer.Search
+namespace UnityExplorer.Core.Search
 {
     internal enum SceneFilter
     {

src/Core/Search/SearchContext.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
-namespace UnityExplorer.Search
+namespace UnityExplorer.Core.Search
 {
     internal enum SearchContext
     {

src/Core/Search/SearchProvider.cs

@@ -4,11 +4,11 @@ using System.Linq;
 using System.Reflection;
 using System.Text;
 using UnityEngine;
-using UnityExplorer.Core;
 using UnityExplorer.Core.Runtime;
 using UnityExplorer.UI.Main;
+using UnityExplorer.UI.Main.Search;
 
-namespace UnityExplorer.Search
+namespace UnityExplorer.Core.Search
 {
     public static class SearchProvider
     {

src/Core/Tests/Tests.cs

@@ -1,290 +0,0 @@
-//using System.Collections;
-//using System.Collections.Generic;
-//using UnityExplorer.UI;
-//using UnityEngine;
-//using System;
-//using System.Runtime.InteropServices;
-//using System.Text;
-//using UnityExplorer.Core.Runtime;
-
-//namespace UnityExplorer.Core.Tests
-//{
-//    internal enum TestByteEnum : byte
-//    {
-//        One,
-//        Two,
-//        Three,
-//        TwoFiftyFive = 255,
-//    }
-
-//    public static class StaticTestClass
-//    {
-//        public static int StaticProperty => 5;
-//        public static int StaticField = 69;
-//        public static List<string> StaticList = new List<string>
-//        {
-//            "one",
-//            "two",
-//            "three",
-//        };
-//        public static void StaticMethod() { }
-//    }
-
-//    public class TestClass
-//    {
-//        internal static TestByteEnum testingByte = TestByteEnum.One;
-
-//        public string AAALongString = @"1
-//2
-//3
-//4
-//5";
-
-//        public Vector2 AATestVector2 = new Vector2(1, 2);
-//        public Vector3 AATestVector3 = new Vector3(1, 2, 3);
-//        public Vector4 AATestVector4 = new Vector4(1, 2, 3, 4);
-//        public Rect AATestRect = new Rect(1, 2, 3, 4);
-//        public Color AATestColor = new Color(0.1f, 0.2f, 0.3f, 0.4f);
-
-//        public bool ATestBoolMethod() => false;
-
-//        public bool this[int index]
-//        {
-//            get => index % 2 == 0;
-//            set => m_thisBool = value;
-//        }
-//        internal bool m_thisBool;
-
-//        static int testInt;
-//        public static List<string> ExceptionList
-//        {
-//            get
-//            {
-//                testInt++;
-//                if (testInt % 2 == 0)
-//                    throw new Exception("its even");
-//                else
-//                    return new List<string> { "one" };
-//            }
-//        }
-
-//        static bool abool;
-//        public static bool ATestExceptionBool
-//        {
-//            get
-//            {
-//                abool = !abool;
-//                if (!abool)
-//                    throw new Exception("false");
-//                else
-//                    return true;
-//            }
-//        }
-
-//        public static string ExceptionString => throw new NotImplementedException();
-        
-//        public static string ANullString = null;
-//        public static float ATestFloat = 420.69f;
-//        public static int ATestInt = -1;
-//        public static string ATestString = "hello world";
-//        public static uint ATestUInt = 1u;
-//        public static byte ATestByte = 255;
-//        public static ulong AReadonlyUlong = 82934UL;
-
-//        public static TestClass Instance => m_instance ?? (m_instance = new TestClass());
-//        private static TestClass m_instance;
-
-//        public object AmbigObject;
-
-//        public List<List<List<string>>> ANestedNestedList = new List<List<List<string>>>
-//        {
-//            new List<List<string>>
-//            {
-//                new List<string>
-//                {
-//                    "one",
-//                    "two",
-//                },
-//                new List<string>
-//                {
-//                    "three",
-//                    "four"
-//                }
-//            },
-//            new List<List<string>>
-//            {
-//                new List<string>
-//                {
-//                    "five",
-//                    "six"
-//                }
-//            }
-//        };
-
-//        public static bool SetOnlyProperty
-//        {
-//            set => m_setOnlyProperty = value;
-//        }
-//        private static bool m_setOnlyProperty;
-//        public static bool ReadSetOnlyProperty => m_setOnlyProperty;
-
-//        public Texture2D TestTexture;
-//        public static Sprite TestSprite;
-
-//#if CPP
-//        public static Il2CppSystem.Collections.Generic.HashSet<string> CppHashSetTest;
-//        public static Il2CppSystem.Collections.Generic.List<string> CppStringTest;
-//        public static Il2CppSystem.Collections.IList CppIList;
-//        //public static Il2CppSystem.Collections.Generic.Dictionary<string, string> CppDictTest;
-//        //public static Il2CppSystem.Collections.Generic.Dictionary<int, float> CppDictTest2;
-//#endif
-
-//        public TestClass()
-//        {
-//            int a = 0;
-//            foreach (var list in ANestedNestedList)
-//            {
-//                foreach (var list2 in list)
-//                {
-//                    for (int i = 0; i < 33; i++)
-//                        list2.Add(a++.ToString());
-//                }
-//            }
-
-//#if CPP
-//            //TextureSpriteTest();
-
-//            CppHashSetTest = new Il2CppSystem.Collections.Generic.HashSet<string>();
-//            CppHashSetTest.Add("1");
-//            CppHashSetTest.Add("2");
-//            CppHashSetTest.Add("3");
-
-//            CppStringTest = new Il2CppSystem.Collections.Generic.List<string>();
-//            CppStringTest.Add("1");
-//            CppStringTest.Add("2");
-
-//            //CppDictTest = new Il2CppSystem.Collections.Generic.Dictionary<string, string>();
-//            //CppDictTest.Add("key1", "value1");
-//            //CppDictTest.Add("key2", "value2");
-//            //CppDictTest.Add("key3", "value3");
-
-//            //CppDictTest2 = new Il2CppSystem.Collections.Generic.Dictionary<int, float>();
-//            //CppDictTest2.Add(0, 0.5f);
-//            //CppDictTest2.Add(1, 0.5f);
-//            //CppDictTest2.Add(2, 0.5f);
-//#endif
-//        }
-
-//        //private void TextureSpriteTest()
-//        //{
-//        //    TestTexture = new Texture2D(32, 32, TextureFormat.ARGB32, false)
-//        //    {
-//        //        name = "TestTexture"
-//        //    };
-//        //    TestSprite = TextureUtilProvider.Instance.CreateSprite(TestTexture);
-
-//        //    GameObject.DontDestroyOnLoad(TestTexture);
-//        //    GameObject.DontDestroyOnLoad(TestSprite);
-
-//        //    // test loading a tex from file
-//        //    if (System.IO.File.Exists(@"D:\Downloads\test.png"))
-//        //    {
-//        //        var dataToLoad = System.IO.File.ReadAllBytes(@"D:\Downloads\test.png");
-//        //        ExplorerCore.Log($"Tex load success: {TestTexture.LoadImage(dataToLoad, false)}");
-//        //    }
-//        //}
-
-//        //public static string TestRefInOutGeneric<T>(ref string arg0, in int arg1, out string arg2) where T : Component
-//        //{
-//        //    arg2 = "this is arg2";
-
-//        //    return $"T: '{typeof(T).FullName}', ref arg0: '{arg0}', in arg1: '{arg1}', out arg2: '{arg2}'";
-//        //}
-
-//        // test a non-generic dictionary
-
-//        public Hashtable TestNonGenericDict()
-//        {
-//            return new Hashtable
-//            {
-//                { "One",   1 },
-//                { "Two",   2 },
-//                { "Three", 3 },
-//            };
-//        }
-
-//        // test HashSets
-
-//        public static HashSet<string> HashSetTest = new HashSet<string>
-//        {
-//            "One",
-//            "Two",
-//            "Three"
-//        };
-
-
-//        // Test indexed parameter
-
-//        public string this[int arg0, string arg1]
-//        {
-//            get
-//            {
-//                return $"arg0: {arg0}, arg1: {arg1}";
-//            }
-//        }
-
-//        // Test basic list
-
-//        public static List<string> TestList = new List<string>
-//        {
-//            "1",
-//            "2",
-//            "3",
-//            "etc..."
-//        };
-
-//        // Test a nested dictionary
-
-//        public static Dictionary<int, Dictionary<string, int>> NestedDictionary = new Dictionary<int, Dictionary<string, int>>
-//        {
-//            {
-//                1,
-//                new  Dictionary<string, int>
-//                {
-//                    {
-//                        "Sub 1", 123
-//                    },
-//                    {
-//                        "Sub 2", 456
-//                    },
-//                }
-//            },
-//            {
-//                2,
-//                new  Dictionary<string, int>
-//                {
-//                    {
-//                        "Sub 3", 789
-//                    },
-//                    {
-//                        "Sub 4", 000
-//                    },
-//                }
-//            },
-//        };
-
-//        // Test a basic method
-
-//        public static Color TestMethod(float r, float g, float b, float a)
-//        {
-//            return new Color(r, g, b, a);
-//        }
-
-//        // A method with default arguments
-
-//        public static Vector3 TestDefaultArgs(float arg0, float arg1, float arg2 = 5.0f)
-//        {
-//            return new Vector3(arg0, arg1, arg2);
-//        }
-//    }
-//}

src/Core/Unity/ColorHelper.cs

@@ -1,46 +0,0 @@
-using System.Globalization;
-using UnityEngine;
-
-namespace UnityExplorer.Core.Unity
-{
-    public static class ColorHelper
-    {
-        /// <summary>
-        /// Converts Color to 6-digit RGB hex code (without # symbol). Eg, RGBA(1,0,0,1) -> FF0000
-        /// </summary>
-        public static string ToHex(this Color color)
-        {
-            byte r = (byte)Mathf.Clamp(Mathf.RoundToInt(color.r * 255f), 0, 255);
-            byte g = (byte)Mathf.Clamp(Mathf.RoundToInt(color.g * 255f), 0, 255);
-            byte b = (byte)Mathf.Clamp(Mathf.RoundToInt(color.b * 255f), 0, 255);
-
-            return $"{r:X2}{g:X2}{b:X2}";
-        }
-
-        /// <summary>
-        /// Assumes the string is a 6-digit RGB Hex color code, which it will parse into a UnityEngine.Color.
-        /// Eg, FF0000 -> RGBA(1,0,0,1)
-        /// </summary>
-        public static Color ToColor(this string _string)
-        {
-            _string = _string.Replace("#", "");
-
-            if (_string.Length != 6)
-                return Color.magenta;
-
-            var r = byte.Parse(_string.Substring(0, 2), NumberStyles.HexNumber);
-            var g = byte.Parse(_string.Substring(2, 2), NumberStyles.HexNumber);
-            var b = byte.Parse(_string.Substring(4, 2), NumberStyles.HexNumber);
-
-            var color = new Color
-            {
-                r = (float)(r / (decimal)255),
-                g = (float)(g / (decimal)255),
-                b = (float)(b / (decimal)255),
-                a = 1
-            };
-
-            return color;
-        }
-    }
-}

src/Core/Unity/UnityHelper.cs

@@ -1,62 +0,0 @@
-using UnityEngine;
-
-namespace UnityExplorer.Core.Unity
-{
-    public static class UnityHelper
-    {
-        private static Camera m_mainCamera;
-
-        public static Camera MainCamera
-        {
-            get
-            {
-                if (!m_mainCamera)
-                {
-                    m_mainCamera = Camera.main;
-                }
-                return m_mainCamera;
-            }
-        }
-
-        public static bool IsNullOrDestroyed(this object obj, bool suppressWarning = true)
-        {
-            var unityObj = obj as Object;
-            if (obj == null)
-            {
-                if (!suppressWarning)
-                    ExplorerCore.LogWarning("The target instance is null!");
-
-                return true;
-            }
-            else if (obj is Object)
-            {
-                if (!unityObj)
-                {
-                    if (!suppressWarning)
-                        ExplorerCore.LogWarning("The target UnityEngine.Object was destroyed!");
-
-                    return true;
-                }
-            }
-            return false;
-        }
-
-        public static string ToStringLong(this Vector3 vec)
-        {
-            return $"{vec.x:F3}, {vec.y:F3}, {vec.z:F3}";
-        }
-
-        public static string GetTransformPath(this Transform t, bool includeThisName = false)
-        {
-            string path = includeThisName ? t.transform.name : "";
-
-            while (t.parent != null)
-            {
-                t = t.parent;
-                path = $"{t.name}/{path}";
-            }
-
-            return path;
-        }
-    }
-}

src/Core/Unity/UnityHelpers.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace UnityExplorer.Core.Unity
+{
+    public static class UnityHelpers
+    {
+        /// <summary>
+        /// Check if an object is null, and if it's a UnityEngine.Object then also check if it was destroyed.
+        /// </summary>
+        public static bool IsNullOrDestroyed(this object obj, bool suppressWarning = true)
+        {
+            var unityObj = obj as Object;
+            if (obj == null)
+            {
+                if (!suppressWarning)
+                    ExplorerCore.LogWarning("The target instance is null!");
+
+                return true;
+            }
+            else if (obj is Object)
+            {
+                if (!unityObj)
+                {
+                    if (!suppressWarning)
+                        ExplorerCore.LogWarning("The target UnityEngine.Object was destroyed!");
+
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Print a nice {X, Y, Z} output of the Vector3, formatted to 3 decimal places.
+        /// </summary>
+        public static string ToStringPretty(this Vector3 vec)
+        {
+            return $"{vec.x:F3}, {vec.y:F3}, {vec.z:F3}";
+        }
+        
+        /// <summary>
+        /// Get the full Transform heirarchy path for this provided Transform.
+        /// </summary>
+        public static string GetTransformPath(this Transform transform, bool includeSelf = false)
+        {
+            string path = includeSelf 
+                ? transform.transform.name 
+                : "";
+
+            while (transform.parent)
+            {
+                transform = transform.parent;
+                path = $"{transform.name}/{path}";
+            }
+
+            return path;
+        }
+
+        /// <summary>
+        /// Converts Color to 6-digit RGB hex code (without # symbol). Eg, RGBA(1,0,0,1) -> FF0000
+        /// </summary>
+        public static string ToHex(this Color color)
+        {
+            byte r = (byte)Mathf.Clamp(Mathf.RoundToInt(color.r * 255f), 0, 255);
+            byte g = (byte)Mathf.Clamp(Mathf.RoundToInt(color.g * 255f), 0, 255);
+            byte b = (byte)Mathf.Clamp(Mathf.RoundToInt(color.b * 255f), 0, 255);
+
+            return $"{r:X2}{g:X2}{b:X2}";
+        }
+
+        /// <summary>
+        /// Assumes the string is a 6-digit RGB Hex color code, which it will parse into a UnityEngine.Color.
+        /// Eg, FF0000 -> RGBA(1,0,0,1)
+        /// </summary>
+        public static Color ToColor(this string _string)
+        {
+            _string = _string.Replace("#", "");
+
+            if (_string.Length != 6)
+                return Color.magenta;
+
+            var r = byte.Parse(_string.Substring(0, 2), NumberStyles.HexNumber);
+            var g = byte.Parse(_string.Substring(2, 2), NumberStyles.HexNumber);
+            var b = byte.Parse(_string.Substring(4, 2), NumberStyles.HexNumber);
+
+            var color = new Color
+            {
+                r = (float)(r / (decimal)255),
+                g = (float)(g / (decimal)255),
+                b = (float)(b / (decimal)255),
+                a = 1
+            };
+
+            return color;
+        }
+    }
+}