Bump version

Fix standalone reading config item type casting bug

README.md

@@ -45,12 +45,18 @@
 
 The standalone release can be used with any injector or loader of your choice, but it requires you to load the dependencies manually.
 
-1. Ensure the required libs are loaded - UniverseLib, HarmonyX and MonoMod
+1. Ensure the required libs are loaded - UniverseLib, HarmonyX and MonoMod. Take them from the [`UnityExplorer.Editor`](https://github.com/sinai-dev/UnityExplorer/releases/latest/download/UnityExplorer.Editor.zip) release if you need them.
 2. For IL2CPP, load Il2CppAssemblyUnhollower and start an [Il2CppAssemblyUnhollower runtime](https://github.com/knah/Il2CppAssemblyUnhollower#required-external-setup)
 2. Load the UnityExplorer DLL
 3. Create an instance of Unity Explorer with `UnityExplorer.ExplorerStandalone.CreateInstance();`
 4. Optionally subscribe to the `ExplorerStandalone.OnLog` event to handle logging if you wish
 
+## Unity Editor
+
+1. Download the [`UnityExplorer.Editor`](https://github.com/sinai-dev/UnityExplorer/releases/latest/download/UnityExplorer.Editor.zip) release.
+2. Install the package, either by using the Package Manager and importing the `package.json` file, or by manually dragging the folder into your `Assets` folder.
+3. Drag the `Runtime/UnityExplorer` prefab into your scene, or create a GameObject and add the `Explorer Editor Behaviour` script to it.
+
 # Common issues and solutions
 
 Although UnityExplorer should work out of the box for most Unity games, in some cases you may need to tweak the settings for it to work properly.

src/CSConsole/ConsoleController.cs

@@ -18,6 +18,8 @@ using UniverseLib.UI;
 using UniverseLib;
 using UniverseLib.UI.Models;
 using UniverseLib.Utility;
+using HarmonyLib;
+using UniverseLib.Runtime;
 
 namespace UnityExplorer.CSConsole
 {
@@ -60,6 +62,8 @@ namespace UnityExplorer.CSConsole
 
         public static void Init()
         {
+            InitEventSystemPropertyHandlers();
+
             // Make sure console is supported on this platform
             try
             {
@@ -383,30 +387,81 @@ namespace UnityExplorer.CSConsole
             RuntimeHelper.StartCoroutine(SetCaretCoroutine(caretPosition));
         }
 
-        internal static PropertyInfo SelectionGuardProperty => selectionGuardPropInfo ?? GetSelectionGuardPropInfo();
-
-        private static PropertyInfo GetSelectionGuardPropInfo()
+        static void InitEventSystemPropertyHandlers()
         {
-            selectionGuardPropInfo = typeof(EventSystem).GetProperty("m_SelectionGuard");
-            if (selectionGuardPropInfo == null)
-                selectionGuardPropInfo = typeof(EventSystem).GetProperty("m_selectionGuard");
-            return selectionGuardPropInfo;
+            try
+            {
+                foreach (var member in typeof(EventSystem).GetMembers(AccessTools.all))
+                {
+                    if (member.Name == "m_CurrentSelected")
+                    {
+                        Type backingType;
+                        if (member.MemberType == MemberTypes.Property)
+                            backingType = (member as PropertyInfo).PropertyType;
+                        else
+                            backingType = (member as FieldInfo).FieldType;
+
+                        usingEventSystemDictionaryMembers = ReflectionUtility.IsDictionary(backingType);
+                        break;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                ExplorerCore.LogWarning($"Exception checking EventSystem property backing type: {ex}");
+            }
         }
 
-        private static PropertyInfo selectionGuardPropInfo;
+        static bool usingEventSystemDictionaryMembers;
+
+        static readonly AmbiguousMemberHandler<EventSystem, GameObject> m_CurrentSelected_Handler_Normal 
+            = new(true, true, "m_CurrentSelected", "m_currentSelected");
+        static readonly AmbiguousMemberHandler<EventSystem, Dictionary<int, GameObject>> m_CurrentSelected_Handler_Dictionary 
+            = new(true, true, "m_CurrentSelected", "m_currentSelected");
+
+        static readonly AmbiguousMemberHandler<EventSystem, bool> m_SelectionGuard_Handler_Normal 
+            = new(true, true, "m_SelectionGuard", "m_selectionGuard");
+        static readonly AmbiguousMemberHandler<EventSystem, Dictionary<int, bool>> m_SelectionGuard_Handler_Dictionary 
+            = new(true, true, "m_SelectionGuard", "m_selectionGuard");
+
+        static void SetCurrentSelectedGameObject(EventSystem instance, GameObject value)
+        {
+            instance.SetSelectedGameObject(value);
+
+            if (usingEventSystemDictionaryMembers)
+                m_CurrentSelected_Handler_Dictionary.GetValue(instance)[0] = value;
+            else
+                m_CurrentSelected_Handler_Normal.SetValue(instance, value);
+        }
+
+        static void SetSelectionGuard(EventSystem instance, bool value)
+        {
+            if (usingEventSystemDictionaryMembers)
+                m_SelectionGuard_Handler_Dictionary.GetValue(instance)[0] = value;
+            else
+                m_SelectionGuard_Handler_Normal.SetValue(instance, value);
+        }
 
         private static IEnumerator SetCaretCoroutine(int caretPosition)
         {
             var color = Input.Component.selectionColor;
             color.a = 0f;
             Input.Component.selectionColor = color;
-            try { EventSystem.current.SetSelectedGameObject(null, null); } catch { }
-            yield return null;
 
-            try { SelectionGuardProperty.SetValue(EventSystem.current, false, null); } catch { }
-            try { EventSystem.current.SetSelectedGameObject(Input.UIRoot, null); } catch { }
+            try { SetCurrentSelectedGameObject(CursorUnlocker.CurrentEventSystem, null); } 
+            catch (Exception ex) { ExplorerCore.Log($"Failed removing selected object: {ex}"); }
+
+            yield return null; // ~~~~~~~ YIELD FRAME ~~~~~~~~~
+
+            try { SetSelectionGuard(CursorUnlocker.CurrentEventSystem, false); }
+            catch (Exception ex) { ExplorerCore.Log($"Failed setting selection guard: {ex}"); }
+
+            try { SetCurrentSelectedGameObject(CursorUnlocker.CurrentEventSystem, Input.GameObject); } 
+            catch (Exception ex) { ExplorerCore.Log($"Failed setting selected gameobject: {ex}"); }
+
+            yield return null; // ~~~~~~~ YIELD FRAME ~~~~~~~~~
+
             Input.Component.Select();
-            yield return null;
 
             Input.Component.caretPosition = caretPosition;
             Input.Component.selectionFocusPosition = caretPosition;
@@ -665,7 +720,8 @@ var x = 5;
  * Log(obj);          - prints a message to the console log
  * Inspect(obj);      - inspect the object with the Inspector
  * Inspect(someType); - inspect a Type with static reflection
- * Start(enumerator); - starts the IEnumerator as a Coroutine
+ * Start(enumerator); - Coroutine, starts the IEnumerator as a Coroutine, and returns the Coroutine.
+ * Stop(coroutine);   - stop the Coroutine ONLY if it was started with Start(ienumerator).
  * Copy(obj);         - copies the object to the UnityExplorer Clipboard
  * Paste();           - System.Object, the contents of the Clipboard.
  * GetUsing();        - prints the current using directives to the console log

src/CSConsole/ScriptEvaluator.cs

@@ -51,13 +51,8 @@ namespace UnityExplorer.CSConsole
             ReferenceAssembly(asm);
         }
 
-        private static CompilerContext context;
-
         private static CompilerContext BuildContext(TextWriter tw)
         {
-            if (context != null)
-                return context;
-
             _reportPrinter = new StreamReportPrinter(tw);
 
             var settings = new CompilerSettings
@@ -70,7 +65,7 @@ namespace UnityExplorer.CSConsole
                 EnhancedWarnings = false
             };
 
-            return context = new CompilerContext(settings, _reportPrinter);
+            return new CompilerContext(settings, _reportPrinter);
         }
 
         private static void ImportAppdomainAssemblies(Action<Assembly> import)

src/CSConsole/ScriptInteraction.cs

@@ -29,9 +29,12 @@ namespace UnityExplorer.CSConsole
         public static void Inspect(Type type)
             => InspectorManager.Inspect(type);
 
-        public static void Start(IEnumerator ienumerator) 
+        public static Coroutine Start(IEnumerator ienumerator) 
             => RuntimeHelper.StartCoroutine(ienumerator);
 
+        public static void Stop(Coroutine coro)
+            => RuntimeHelper.StopCoroutine(coro);
+
         public static void Copy(object obj) 
             => ClipboardPanel.Copy(obj);
 

src/CacheObject/CacheConstructor.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using UnityExplorer.Inspectors;
+using UniverseLib.Utility;
+
+namespace UnityExplorer.CacheObject
+{
+    public class CacheConstructor : CacheMember
+    {
+        public ConstructorInfo CtorInfo { get; }
+        readonly Type typeForStructConstructor;
+
+        public override Type DeclaringType => typeForStructConstructor ?? CtorInfo.DeclaringType;
+        public override bool IsStatic => true;
+        public override bool ShouldAutoEvaluate => false;
+        public override bool CanWrite => false;
+
+        public CacheConstructor(ConstructorInfo ci)
+        {
+            this.CtorInfo = ci;
+        }
+
+        public CacheConstructor(Type typeForStructConstructor)
+        {
+            this.typeForStructConstructor = typeForStructConstructor;
+        }
+
+        public override void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member)
+        {
+            Type ctorReturnType;
+            // if is parameterless struct ctor
+            if (typeForStructConstructor != null)
+            {
+                ctorReturnType = typeForStructConstructor;
+                this.Owner = inspector;
+
+                // eg. Vector3.Vector3()
+                this.NameLabelText = SignatureHighlighter.Parse(typeForStructConstructor, false);
+                NameLabelText += $".{NameLabelText}()";
+
+                this.NameForFiltering = SignatureHighlighter.RemoveHighlighting(NameLabelText);
+                this.NameLabelTextRaw = NameForFiltering;
+                return;
+            }
+            else
+            {
+                base.SetInspectorOwner(inspector, member);
+
+                Arguments = CtorInfo.GetParameters();
+                ctorReturnType = CtorInfo.DeclaringType;
+            }
+            
+            if (ctorReturnType.IsGenericTypeDefinition)
+                GenericArguments = ctorReturnType.GetGenericArguments();
+        }
+
+        protected override object TryEvaluate()
+        {
+            try
+            {
+                Type returnType = DeclaringType;
+
+                if (returnType.IsGenericTypeDefinition)
+                    returnType = DeclaringType.MakeGenericType(Evaluator.TryParseGenericArguments());
+
+                object ret;
+                if (HasArguments)
+                    ret = Activator.CreateInstance(returnType, Evaluator.TryParseArguments());
+                else
+                    ret = Activator.CreateInstance(returnType, ArgumentUtility.EmptyArgs);
+
+                LastException = null;
+                return ret;
+            }
+            catch (Exception ex)
+            {
+                LastException = ex;
+                return null;
+            }
+        }
+
+        protected override void TrySetValue(object value) => throw new NotImplementedException("You can't set a constructor");
+    }
+}

src/CacheObject/CacheField.cs

@@ -17,6 +17,11 @@ namespace UnityExplorer.CacheObject
 
         public override bool ShouldAutoEvaluate => true;
 
+        public CacheField(FieldInfo fi)
+        {
+            this.FieldInfo = fi;
+        }
+
         public override void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member)
         {
             base.SetInspectorOwner(inspector, member);
@@ -27,13 +32,11 @@ namespace UnityExplorer.CacheObject
             try
             {
                 var ret = FieldInfo.GetValue(DeclaringInstance);
-                HadException = false;
                 LastException = null;
                 return ret;
             }
             catch (Exception ex)
             {
-                HadException = true;
                 LastException = ex;
                 return null;
             }

src/CacheObject/CacheMember.cs

@@ -14,6 +14,8 @@ using UniverseLib.UI;
 using UnityExplorer.UI.Widgets;
 using UniverseLib.Utility;
 using UniverseLib.UI.ObjectPool;
+using System.Collections;
+using HarmonyLib;
 
 namespace UnityExplorer.CacheObject
 {
@@ -21,7 +23,7 @@ namespace UnityExplorer.CacheObject
     {
         public abstract Type DeclaringType { get; }
         public string NameForFiltering { get; protected set; }
-        public object DeclaringInstance => IsStatic ? null : (m_declaringInstance ?? (m_declaringInstance = Owner.Target.TryCast(DeclaringType)));
+        public object DeclaringInstance => IsStatic ? null : (m_declaringInstance ??= Owner.Target.TryCast(DeclaringType));
         private object m_declaringInstance;
 
         public abstract bool IsStatic { get; }
@@ -34,10 +36,14 @@ namespace UnityExplorer.CacheObject
         public virtual void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member)
         {
             this.Owner = inspector;
-            this.NameLabelText = this is CacheMethod 
-                ? SignatureHighlighter.HighlightMethod(member as MethodInfo) 
-                : SignatureHighlighter.Parse(member.DeclaringType, false, member);
-            this.NameForFiltering = $"{member.DeclaringType.Name}.{member.Name}";
+            this.NameLabelText = this switch
+            {
+                CacheMethod => SignatureHighlighter.HighlightMethod(member as MethodInfo),
+                CacheConstructor => SignatureHighlighter.HighlightConstructor(member as ConstructorInfo),
+                _ => SignatureHighlighter.Parse(member.DeclaringType, false, member),
+            };
+
+            this.NameForFiltering = SignatureHighlighter.RemoveHighlighting(NameLabelText);
             this.NameLabelTextRaw = NameForFiltering;
         }
 
@@ -94,8 +100,8 @@ namespace UnityExplorer.CacheObject
             base.SetValueState(cell, args);
         }
 
-        private static readonly Color evalEnabledColor = new Color(0.15f, 0.25f, 0.15f);
-        private static readonly Color evalDisabledColor = new Color(0.15f, 0.15f, 0.15f);
+        private static readonly Color evalEnabledColor = new(0.15f, 0.25f, 0.15f);
+        private static readonly Color evalDisabledColor = new(0.15f, 0.15f, 0.15f);
 
         protected override bool TryAutoEvaluateIfUnitialized(CacheObjectCell objectcell)
         {
@@ -163,184 +169,5 @@ namespace UnityExplorer.CacheObject
                 }
             }
         }
-
-
-        #region Cache Member Util
-
-        //public static bool CanParseArgs(ParameterInfo[] parameters)
-        //{
-        //    foreach (var param in parameters)
-        //    {
-        //        var pType = param.ParameterType;
-        //
-        //        if (pType.IsByRef && pType.HasElementType)
-        //            pType = pType.GetElementType();
-        //
-        //        if (pType != null && ParseUtility.CanParse(pType))
-        //            continue;
-        //        else
-        //            return false;
-        //    }
-        //    return true;
-        //}
-
-        public static List<CacheMember> GetCacheMembers(object inspectorTarget, Type _type, ReflectionInspector _inspector)
-        {
-            var list = new List<CacheMember>();
-            var cachedSigs = new HashSet<string>();
-
-            var types = ReflectionUtility.GetAllBaseTypes(_type);
-
-            var flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static;
-            if (!_inspector.StaticOnly)
-                flags |= BindingFlags.Instance;
-
-            var infos = new List<MemberInfo>();
-
-            foreach (var declaringType in types)
-            {
-                var target = inspectorTarget;
-                if (!_inspector.StaticOnly)
-                    target = target.TryCast(declaringType);
-
-                infos.Clear();
-                infos.AddRange(declaringType.GetProperties(flags));
-                infos.AddRange(declaringType.GetFields(flags));
-                infos.AddRange(declaringType.GetMethods(flags));
-
-                foreach (var member in infos)
-                {
-                    if (member.DeclaringType != declaringType)
-                        continue;
-                    TryCacheMember(member, list, cachedSigs, declaringType, _inspector);
-                }
-            }
-
-            var typeList = types.ToList();
-
-            var sorted = new List<CacheMember>();
-            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));
-            sorted.AddRange(list.Where(it => it is CacheMethod)
-                             .OrderBy(it => typeList.IndexOf(it.DeclaringType))
-                             .ThenBy(it => it.NameForFiltering));
-
-            return sorted;
-        }
-
-        private static void TryCacheMember(MemberInfo member, List<CacheMember> list, HashSet<string> cachedSigs,
-            Type declaringType, ReflectionInspector _inspector, bool ignorePropertyMethodInfos = true)
-        {
-            try
-            {
-                if (UERuntimeHelper.IsBlacklisted(member))
-                    return;
-
-                var sig = GetSig(member);
-
-                //ExplorerCore.Log($"Trying to cache member {sig}... ({member.MemberType})");
-
-                CacheMember cached;
-                Type returnType;
-                switch (member.MemberType)
-                {
-                    case MemberTypes.Method:
-                        {
-                            var mi = member as MethodInfo;
-                            if (ignorePropertyMethodInfos
-                                && (mi.Name.StartsWith("get_") || mi.Name.StartsWith("set_")))
-                                return;
-
-                            //var args = mi.GetParameters();
-                            //if (!CanParseArgs(args))
-                            //    return;
-
-                            sig += GetArgumentString(mi.GetParameters());
-                            if (cachedSigs.Contains(sig))
-                                return;
-
-                            cached = new CacheMethod() { MethodInfo = mi };
-                            returnType = mi.ReturnType;
-                            break;
-                        }
-
-                    case MemberTypes.Property:
-                        {
-                            var pi = member as PropertyInfo;
-
-                            //var args = pi.GetIndexParameters();
-                            //if (!CanParseArgs(args))
-                            //    return;
-
-                            if (!pi.CanRead && pi.CanWrite)
-                            {
-                                // write-only property, cache the set method instead.
-                                var setMethod = pi.GetSetMethod(true);
-                                if (setMethod != null)
-                                    TryCacheMember(setMethod, list, cachedSigs, declaringType, _inspector, false);
-                                return;
-                            }
-
-                            sig += GetArgumentString(pi.GetIndexParameters());
-                            if (cachedSigs.Contains(sig))
-                                return;
-
-                            cached = new CacheProperty() { PropertyInfo = pi };
-                            returnType = pi.PropertyType;
-                            break;
-                        }
-
-                    case MemberTypes.Field:
-                        {
-                            var fi = member as FieldInfo;
-                            cached = new CacheField() { FieldInfo = fi };
-                            returnType = fi.FieldType;
-                            break;
-                        }
-
-                    default: return;
-                }
-
-                cachedSigs.Add(sig);
-
-                cached.SetFallbackType(returnType);
-                cached.SetInspectorOwner(_inspector, member);
-
-                list.Add(cached);
-            }
-            catch (Exception e)
-            {
-                ExplorerCore.LogWarning($"Exception caching member {member.DeclaringType.FullName}.{member.Name}!");
-                ExplorerCore.Log(e.ToString());
-            }
-        }
-
-        internal static string GetSig(MemberInfo member)
-            => $"{member.DeclaringType.Name}.{member.Name}";
-
-        internal static string GetArgumentString(ParameterInfo[] args)
-        {
-            var sb = new StringBuilder();
-            sb.Append(' ');
-            sb.Append('(');
-            foreach (var param in args)
-            {
-                sb.Append(param.ParameterType.Name);
-                sb.Append(' ');
-                sb.Append(param.Name);
-                sb.Append(',');
-                sb.Append(' ');
-            }
-            sb.Append(')');
-            return sb.ToString();
-        }
-
-        #endregion
-
-
     }
 }

src/CacheObject/CacheMemberFactory.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using UnityExplorer.Inspectors;
+using UnityExplorer.Runtime;
+using UniverseLib;
+using HarmonyLib;
+using HarmonyLib.Tools;
+
+namespace UnityExplorer.CacheObject
+{
+    public static class CacheMemberFactory
+    {
+        public static List<CacheMember> GetCacheMembers(Type type, ReflectionInspector inspector)
+        {
+            //var list = new List<CacheMember>();
+            HashSet<string> cachedSigs = new();
+            List<CacheMember> props = new();
+            List<CacheMember> fields = new();
+            List<CacheMember> ctors = new();
+            List<CacheMember> methods = new();
+
+            var types = ReflectionUtility.GetAllBaseTypes(type);
+
+            var flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static;
+            if (!inspector.StaticOnly)
+                flags |= BindingFlags.Instance;
+
+            if (!type.IsAbstract)
+            {
+                // Get non-static constructors of the main type.
+                // There's no reason to get the static cctor, it will be invoked when we inspect the class.
+                // Also no point getting ctors on inherited types.
+                foreach (var ctor in type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
+                    TryCacheMember(ctor, ctors, cachedSigs, type, inspector);
+
+                // structs always have a parameterless constructor
+                if (type.IsValueType)
+                {
+                    CacheConstructor cached = new(type);
+                    cached.SetFallbackType(type);
+                    cached.SetInspectorOwner(inspector, null);
+                    ctors.Add(cached);
+                }
+            }
+
+            foreach (var declaringType in types)
+            {
+                foreach (var prop in declaringType.GetProperties(flags))
+                    if (prop.DeclaringType == declaringType)
+                        TryCacheMember(prop, props, cachedSigs, declaringType, inspector);
+
+                foreach (var field in declaringType.GetFields(flags))
+                    if (field.DeclaringType == declaringType)
+                        TryCacheMember(field, fields, cachedSigs, declaringType, inspector);
+
+                foreach (var method in declaringType.GetMethods(flags))
+                    if (method.DeclaringType == declaringType)
+                        TryCacheMember(method, methods, cachedSigs, declaringType, inspector);
+
+            }
+
+            var sorted = new List<CacheMember>();
+            sorted.AddRange(props.OrderBy(it => Array.IndexOf(types, it.DeclaringType))
+                                 .ThenBy(it => it.NameForFiltering));
+            sorted.AddRange(fields.OrderBy(it => Array.IndexOf(types, it.DeclaringType))
+                                 .ThenBy(it => it.NameForFiltering));
+            sorted.AddRange(ctors.OrderBy(it => Array.IndexOf(types, it.DeclaringType))
+                                 .ThenBy(it => it.NameForFiltering));
+            sorted.AddRange(methods.OrderBy(it => Array.IndexOf(types, it.DeclaringType))
+                                 .ThenBy(it => it.NameForFiltering));
+            return sorted;
+        }
+
+        static void TryCacheMember<T>(MemberInfo member, List<T> list, HashSet<string> cachedSigs, 
+            Type declaringType, ReflectionInspector inspector, bool ignorePropertyMethodInfos = true) 
+            where T : CacheMember
+        {
+            try
+            {
+                if (UERuntimeHelper.IsBlacklisted(member))
+                    return;
+
+                string sig = member switch
+                {
+                    // method or constructor
+                    MethodBase mb => mb.FullDescription(),
+                    // property or field
+                    PropertyInfo or FieldInfo => $"{member.DeclaringType.FullDescription()}.{member.Name}",
+                    _ => throw new NotImplementedException(),
+                };
+
+                if (cachedSigs.Contains(sig))
+                    return;
+
+                // ExplorerCore.Log($"Trying to cache member {sig}... ({member.MemberType})");
+
+                CacheMember cached;
+                Type returnType;
+
+                switch (member.MemberType)
+                {
+                    case MemberTypes.Constructor:
+                        {
+                            var ci = member as ConstructorInfo;
+                            cached = new CacheConstructor(ci);
+                            returnType = ci.DeclaringType;
+                        }
+                        break;
+
+                    case MemberTypes.Method:
+                        {
+                            var mi = member as MethodInfo;
+                            if (ignorePropertyMethodInfos
+                                && (mi.Name.StartsWith("get_") || mi.Name.StartsWith("set_")))
+                                return;
+
+                            cached = new CacheMethod(mi);
+                            returnType = mi.ReturnType;
+                            break;
+                        }
+
+                    case MemberTypes.Property:
+                        {
+                            var pi = member as PropertyInfo;
+
+                            if (!pi.CanRead && pi.CanWrite)
+                            {
+                                // write-only property, cache the set method instead.
+                                var setMethod = pi.GetSetMethod(true);
+                                if (setMethod != null)
+                                    TryCacheMember(setMethod, list, cachedSigs, declaringType, inspector, false);
+                                return;
+                            }
+
+                            cached = new CacheProperty(pi);
+                            returnType = pi.PropertyType;
+                            break;
+                        }
+
+                    case MemberTypes.Field:
+                        {
+                            var fi = member as FieldInfo;
+                            cached = new CacheField(fi);
+                            returnType = fi.FieldType;
+                            break;
+                        }
+
+                    default:
+                        throw new NotImplementedException();
+                }
+
+                cachedSigs.Add(sig);
+
+                cached.SetFallbackType(returnType);
+                cached.SetInspectorOwner(inspector, member);
+
+                list.Add((T)cached);
+            }
+            catch (Exception e)
+            {
+                ExplorerCore.LogWarning($"Exception caching member {member.DeclaringType.FullName}.{member.Name}!");
+                ExplorerCore.Log(e);
+            }
+        }
+    }
+}

src/CacheObject/CacheMethod.cs

@@ -11,13 +11,18 @@ namespace UnityExplorer.CacheObject
 {
     public class CacheMethod : CacheMember
     {
-        public MethodInfo MethodInfo { get; internal set; }
+        public MethodInfo MethodInfo { get; }
         public override Type DeclaringType => MethodInfo.DeclaringType;
         public override bool CanWrite => false;
         public override bool IsStatic => MethodInfo.IsStatic;
 
         public override bool ShouldAutoEvaluate => false;
 
+        public CacheMethod (MethodInfo mi)
+        {
+            this.MethodInfo = mi;
+        }
+
         public override void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member)
         {
             base.SetInspectorOwner(inspector, member);
@@ -40,13 +45,11 @@ namespace UnityExplorer.CacheObject
                     ret = methodInfo.Invoke(DeclaringInstance, Evaluator.TryParseArguments());
                 else 
                     ret = methodInfo.Invoke(DeclaringInstance, ArgumentUtility.EmptyArgs);
-                HadException = false;
                 LastException = null;
                 return ret;
             }
             catch (Exception ex)
             {
-                HadException = true;
                 LastException = ex;
                 return null;
             }

src/CacheObject/CacheObjectBase.cs

@@ -57,7 +57,6 @@ namespace UnityExplorer.CacheObject
         public abstract bool ShouldAutoEvaluate { get; }
         public abstract bool HasArguments { get; }
         public abstract bool CanWrite { get; }
-        public bool HadException { get; protected set; }
         public Exception LastException { get; protected set; }
 
         public virtual void SetFallbackType(Type fallbackType)
@@ -106,8 +105,8 @@ namespace UnityExplorer.CacheObject
             if (CellView != null)
                 SetDataToCell(CellView);
 
-            // If the owner's parent CacheObject is set, we are setting the value of an inspected struct.
-            // Set the inspector target as the value back to that parent cacheobject.
+            // If the owner's ParentCacheObject is set, we are setting the value of an inspected struct.
+            // Set the inspector target as the value back to that parent.
             if (Owner.ParentCacheObject != null)
                 Owner.ParentCacheObject.SetUserValue(Owner.Target);
         }
@@ -137,7 +136,7 @@ namespace UnityExplorer.CacheObject
         {
             var prevState = State;
 
-            if (HadException)
+            if (LastException != null)
             {
                 LastValueWasNull = true;
                 LastValueType = FallbackType;
@@ -158,7 +157,7 @@ namespace UnityExplorer.CacheObject
             {
                 // If we changed states (always needs IValue change)
                 // or if the value is null, and the fallback type isnt string (we always want to edit strings).
-                if (State != prevState || (State != ValueState.String && Value.IsNullOrDestroyed()))
+                if (State != prevState || (State != ValueState.String && State != ValueState.Exception && Value.IsNullOrDestroyed()))
                 {
                     // need to return IValue
                     ReleaseIValue();
@@ -206,7 +205,7 @@ namespace UnityExplorer.CacheObject
                     return $"<i>{NOT_YET_EVAL} ({SignatureHighlighter.Parse(FallbackType, true)})</i>";
 
                 case ValueState.Exception:
-                    return $"<i><color=red>{LastException.ReflectionExToString()}</color></i>";
+                    return $"<i><color=#eb4034>{LastException.ReflectionExToString()}</color></i>";
 
                 // bool and number dont want the label for the value at all
                 case ValueState.Boolean:
@@ -291,36 +290,36 @@ namespace UnityExplorer.CacheObject
             switch (State)
             {
                 case ValueState.Exception:
-                    SetValueState(cell, ValueStateArgs.Default);
+                    SetValueState(cell, new(true, subContentButtonActive: true));
                     break;
                 case ValueState.Boolean:
-                    SetValueState(cell, new ValueStateArgs(false, toggleActive: true, applyActive: CanWrite));
+                    SetValueState(cell, new(false, toggleActive: true, applyActive: CanWrite));
                     break;
                 case ValueState.Number:
-                    SetValueState(cell, new ValueStateArgs(false, typeLabelActive: true, inputActive: true, applyActive: CanWrite));
+                    SetValueState(cell, new(false, typeLabelActive: true, inputActive: true, applyActive: CanWrite));
                     break;
                 case ValueState.String:
                     if (LastValueWasNull)
-                        SetValueState(cell, new ValueStateArgs(true, subContentButtonActive: true));
+                        SetValueState(cell, new(true, subContentButtonActive: true));
                     else
-                        SetValueState(cell, new ValueStateArgs(true, false, SignatureHighlighter.StringOrange, subContentButtonActive: true));
+                        SetValueState(cell, new(true, false, SignatureHighlighter.StringOrange, subContentButtonActive: true));
                     break;
                 case ValueState.Enum:
-                    SetValueState(cell, new ValueStateArgs(true, subContentButtonActive: CanWrite));
+                    SetValueState(cell, new(true, subContentButtonActive: CanWrite));
                     break;
                 case ValueState.Color:
                 case ValueState.ValueStruct:
                     if (ParseUtility.CanParse(LastValueType))
-                        SetValueState(cell, new ValueStateArgs(false, false, null, true, false, true, CanWrite, true, true));
+                        SetValueState(cell, new(false, false, null, true, false, true, CanWrite, true, true));
                     else
-                        SetValueState(cell, new ValueStateArgs(true, inspectActive: true, subContentButtonActive: true));
+                        SetValueState(cell, new(true, inspectActive: true, subContentButtonActive: true));
                     break;
                 case ValueState.Collection:
                 case ValueState.Dictionary:
-                    SetValueState(cell, new ValueStateArgs(true, inspectActive: !LastValueWasNull, subContentButtonActive: !LastValueWasNull));
+                    SetValueState(cell, new(true, inspectActive: !LastValueWasNull, subContentButtonActive: !LastValueWasNull));
                     break;
                 case ValueState.Unsupported:
-                    SetValueState(cell, new ValueStateArgs(true, inspectActive: !LastValueWasNull));
+                    SetValueState(cell, new (true, inspectActive: !LastValueWasNull));
                     break;
             }
 
@@ -368,8 +367,10 @@ namespace UnityExplorer.CacheObject
             if (cell.InspectButton != null)
                 cell.InspectButton.Component.gameObject.SetActive(args.inspectActive && !LastValueWasNull);
 
-            // allow IValue for null strings though
-            cell.SubContentButton.Component.gameObject.SetActive(args.subContentButtonActive && (!LastValueWasNull || State == ValueState.String));
+            // set subcontent button if needed, and for null strings and exceptions
+            cell.SubContentButton.Component.gameObject.SetActive(
+                args.subContentButtonActive 
+                && (!LastValueWasNull || State == ValueState.String || State == ValueState.Exception));
         }
 
         // CacheObjectCell Apply
@@ -401,7 +402,7 @@ namespace UnityExplorer.CacheObject
         {
             if (this.IValue == null)
             {
-                var ivalueType = InteractiveValue.GetIValueTypeForState(State);
+                Type ivalueType = InteractiveValue.GetIValueTypeForState(State);
 
                 if (ivalueType == null)
                     return;
@@ -455,6 +456,7 @@ namespace UnityExplorer.CacheObject
                 {
                     inactiveIValueHolder = new GameObject("Temp_IValue_Holder");
                     GameObject.DontDestroyOnLoad(inactiveIValueHolder);
+                    inactiveIValueHolder.hideFlags = HideFlags.HideAndDontSave;
                     inactiveIValueHolder.transform.parent = UniversalUI.PoolHolder.transform;
                     inactiveIValueHolder.SetActive(false);
                 }
@@ -467,9 +469,20 @@ namespace UnityExplorer.CacheObject
 
         public struct ValueStateArgs
         {
-            public ValueStateArgs(bool valueActive = true, bool valueRichText = true, Color? valueColor = null,
-                bool typeLabelActive = false, bool toggleActive = false, bool inputActive = false, bool applyActive = false,
-                bool inspectActive = false, bool subContentButtonActive = false)
+            public static ValueStateArgs Default { get; } = new(true);
+
+            public Color valueColor;
+            public bool valueActive, valueRichText, typeLabelActive, toggleActive, inputActive, applyActive, inspectActive, subContentButtonActive;
+
+            public ValueStateArgs(bool valueActive = true, 
+                bool valueRichText = true, 
+                Color? valueColor = null,
+                bool typeLabelActive = false, 
+                bool toggleActive = false, 
+                bool inputActive = false, 
+                bool applyActive = false,
+                bool inspectActive = false,
+                bool subContentButtonActive = false)
             {
                 this.valueActive = valueActive;
                 this.valueRichText = valueRichText;
@@ -481,14 +494,6 @@ namespace UnityExplorer.CacheObject
                 this.inspectActive = inspectActive;
                 this.subContentButtonActive = subContentButtonActive;
             }
-
-            public static ValueStateArgs Default => _default;
-            private static ValueStateArgs _default = new ValueStateArgs(true);
-
-            public bool valueActive, valueRichText, typeLabelActive, toggleActive,
-                inputActive, applyActive, inspectActive, subContentButtonActive;
-
-            public Color valueColor;
         }
     }
 }

src/CacheObject/CacheProperty.cs

@@ -3,7 +3,9 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Text;
+using UnityEngine;
 using UnityExplorer.Inspectors;
+using UnityExplorer.Runtime;
 
 namespace UnityExplorer.CacheObject
 {
@@ -17,6 +19,11 @@ namespace UnityExplorer.CacheObject
 
         public override bool ShouldAutoEvaluate => !HasArguments;
 
+        public CacheProperty(PropertyInfo pi)
+        {
+            this.PropertyInfo = pi;
+        }
+
         public override void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member)
         {
             base.SetInspectorOwner(inspector, member);
@@ -33,13 +40,11 @@ namespace UnityExplorer.CacheObject
                     ret = PropertyInfo.GetValue(DeclaringInstance, this.Evaluator.TryParseArguments());
                 else
                     ret = PropertyInfo.GetValue(DeclaringInstance, null);
-                HadException = false;
                 LastException = null;
                 return ret;
             }
             catch (Exception ex)
             {
-                HadException = true;
                 LastException = ex;
                 return null;
             }

src/CacheObject/IValues/InteractiveEnum.cs

@@ -29,8 +29,11 @@ namespace UnityExplorer.CacheObject.IValues
         private EnumCompleter enumCompleter;
 
         private GameObject toggleHolder;
-        private readonly List<Toggle> flagToggles = new List<Toggle>();
-        private readonly List<Text> flagTexts = new List<Text>();
+        private readonly List<Toggle> flagToggles = new();
+        private readonly List<Text> flagTexts = new();
+
+        public CachedEnumValue ValueAtIndex(int idx) => (CachedEnumValue)CurrentValues[idx];
+        public CachedEnumValue ValueAtKey(object key) => (CachedEnumValue)CurrentValues[key];
 
         // Setting value from owner
         public override void SetValue(object value)
@@ -70,13 +73,8 @@ namespace UnityExplorer.CacheObject.IValues
         {
             try
             {
-                var split = value.ToString().Split(',');
-                var set = new HashSet<string>();
-                foreach (var s in split)
-                    set.Add(s.Trim());
-
                 for (int i = 0; i < CurrentValues.Count; i++)
-                    flagToggles[i].isOn = set.Contains(ValueAtIdx(i).Name);
+                    flagToggles[i].isOn = (value as Enum).HasFlag(ValueAtIndex(i).ActualValue as Enum);
             }
             catch (Exception ex)
             {
@@ -116,7 +114,7 @@ namespace UnityExplorer.CacheObject.IValues
                 for (int i = 0; i < CurrentValues.Count; i++)
                 {
                     if (flagToggles[i].isOn)
-                        values.Add(ValueAtIdx(i).Name);
+                        values.Add(ValueAtIndex(i).Name);
                 }
 
                 CurrentOwner.SetUserValue(Enum.Parse(EnumType, string.Join(", ", values.ToArray())));
@@ -166,9 +164,6 @@ namespace UnityExplorer.CacheObject.IValues
             return UIRoot;
         }
 
-        public CachedEnumValue ValueAtIdx(int idx) => (CachedEnumValue)CurrentValues[idx];
-        public CachedEnumValue ValueAtKey(object key) => (CachedEnumValue)CurrentValues[key];
-
         private void SetupTogglesForEnumType()
         {
             toggleHolder.SetActive(true);
@@ -191,7 +186,7 @@ namespace UnityExplorer.CacheObject.IValues
                     AddToggleRow();
 
                 flagToggles[i].isOn = false;
-                flagTexts[i].text = ValueAtIdx(i).Name;
+                flagTexts[i].text = ValueAtIndex(i).Name;
             }
         }
 

src/CacheObject/IValues/InteractiveString.cs

@@ -31,8 +31,9 @@ namespace UnityExplorer.CacheObject.IValues
         {
             base.OnBorrowed(owner);
 
-            inputField.Component.readOnly = !owner.CanWrite;
-            ApplyButton.Component.gameObject.SetActive(owner.CanWrite);
+            bool canWrite = owner.CanWrite && owner.State != ValueState.Exception;
+            inputField.Component.readOnly = !canWrite;
+            ApplyButton.Component.gameObject.SetActive(canWrite);
 
             SaveFilePath.Text = Path.Combine(ConfigManager.Default_Output_Path.Value, "untitled.txt");
         }
@@ -47,6 +48,9 @@ namespace UnityExplorer.CacheObject.IValues
 
         public override void SetValue(object value)
         {
+            if (CurrentOwner.State == ValueState.Exception)
+                value = CurrentOwner.LastException.ToString();
+
             RealValue = value as string;
             SaveFileRow.SetActive(IsStringTooLong(RealValue));
 

src/CacheObject/IValues/InteractiveValue.cs

@@ -16,22 +16,16 @@ namespace UnityExplorer.CacheObject.IValues
     {
         public static Type GetIValueTypeForState(ValueState state)
         {
-            switch (state)
+            return state switch
             {
-                case ValueState.String:
-                    return typeof(InteractiveString);
-                case ValueState.Enum:
-                    return typeof(InteractiveEnum);
-                case ValueState.Collection:
-                    return typeof(InteractiveList);
-                case ValueState.Dictionary:
-                    return typeof(InteractiveDictionary);
-                case ValueState.ValueStruct:
-                    return typeof(InteractiveValueStruct);
-                case ValueState.Color:
-                    return typeof(InteractiveColor);
-                default: return null;
-            }
+                ValueState.Exception or ValueState.String => typeof(InteractiveString),
+                ValueState.Enum => typeof(InteractiveEnum),
+                ValueState.Collection => typeof(InteractiveList),
+                ValueState.Dictionary => typeof(InteractiveDictionary),
+                ValueState.ValueStruct => typeof(InteractiveValueStruct),
+                ValueState.Color => typeof(InteractiveColor),
+                _ => null,
+            };
         }
 
         public GameObject UIRoot { get; set; }
@@ -39,28 +33,28 @@ namespace UnityExplorer.CacheObject.IValues
 
         public virtual bool CanWrite => this.CurrentOwner.CanWrite;
 
-        public CacheObjectBase CurrentOwner => m_owner;
-        private CacheObjectBase m_owner;
+        public CacheObjectBase CurrentOwner => owner;
+        private CacheObjectBase owner;
 
         public bool PendingValueWanted;
 
         public virtual void OnBorrowed(CacheObjectBase owner)
         {
-            if (this.m_owner != null)
+            if (this.owner != null)
             {
                 ExplorerCore.LogWarning("Setting an IValue's owner but there is already one set. Maybe it wasn't cleaned up?");
                 ReleaseFromOwner();
             }
 
-            this.m_owner = owner;
+            this.owner = owner;
         }
 
         public virtual void ReleaseFromOwner()
         {
-            if (this.m_owner == null)
+            if (this.owner == null)
                 return;
 
-            this.m_owner = null;
+            this.owner = null;
         }
 
         public abstract void SetValue(object value);

src/Config/ConfigManager.cs

@@ -32,6 +32,8 @@ namespace UnityExplorer.Config
         public static ConfigElement<bool> Hide_On_Startup;
         public static ConfigElement<float> Startup_Delay_Time;
         public static ConfigElement<string> Reflection_Signature_Blacklist;
+        public static ConfigElement<KeyCode> World_MouseInspect_Keybind;
+        public static ConfigElement<KeyCode> UI_MouseInspect_Keybind;
 
         // internal configs
         internal static InternalConfigHandler InternalHandler { get; private set; }
@@ -93,13 +95,18 @@ namespace UnityExplorer.Config
                 "Should UnityExplorer be hidden on startup?",
                 false);
 
+            World_MouseInspect_Keybind = new("World Mouse-Inspect Keybind",
+                "Optional keybind to being a World-mode Mouse Inspect.",
+                KeyCode.None);
+
+            UI_MouseInspect_Keybind = new("UI Mouse-Inspect Keybind", 
+                "Optional keybind to begin a UI_mode Mouse Inspect.",
+                KeyCode.None);
+
             Force_Unlock_Mouse = new ConfigElement<bool>("Force Unlock Mouse",
                 "Force the Cursor to be unlocked (visible) when the UnityExplorer menu is open.",
                 true);
-            Force_Unlock_Mouse.OnValueChanged += (bool value) =>
-            {
-                UniverseLib.Config.ConfigManager.Force_Unlock_Mouse = value;
-            };
+            Force_Unlock_Mouse.OnValueChanged += (bool value) => UniverseLib.Config.ConfigManager.Force_Unlock_Mouse = value;
 
             Force_Unlock_Toggle = new ConfigElement<KeyCode>("Force Unlock Toggle Key",
                 "The keybind to toggle the 'Force Unlock Mouse' setting. Only usable when UnityExplorer is open.",
@@ -108,10 +115,7 @@ namespace UnityExplorer.Config
             Disable_EventSystem_Override = new ConfigElement<bool>("Disable EventSystem override",
                 "If enabled, UnityExplorer will not override the EventSystem from the game.\n<b>May require restart to take effect.</b>",
                 false);
-            Disable_EventSystem_Override.OnValueChanged += (bool value) => 
-            {
-                UniverseLib.Config.ConfigManager.Disable_EventSystem_Override = value;
-            };
+            Disable_EventSystem_Override.OnValueChanged += (bool value) => UniverseLib.Config.ConfigManager.Disable_EventSystem_Override = value;
 
             Log_Unity_Debug = new ConfigElement<bool>("Log Unity Debug",
                 "Should UnityEngine.Debug.Log messages be printed to UnityExplorer's log?",

src/ExplorerBehaviour.cs

@@ -9,29 +9,26 @@ using UnhollowerRuntimeLib;
 
 namespace UnityExplorer
 {
-    // Handles all Behaviour update calls for UnityExplorer (Update, FixedUpdate, OnPostRender).
-    // Basically just a wrapper which calls the corresponding methods in ExplorerCore.
-
     public class ExplorerBehaviour : MonoBehaviour
     {
         internal static ExplorerBehaviour Instance { get; private set; }
 
+#if CPP
+        public ExplorerBehaviour(IntPtr ptr) : base(ptr) { }
+#endif
+
         internal static void Setup()
         {
 #if CPP
             ClassInjector.RegisterTypeInIl2Cpp<ExplorerBehaviour>();
 #endif
 
-            var obj = new GameObject("ExplorerBehaviour");
-            GameObject.DontDestroyOnLoad(obj);
-            obj.hideFlags |= HideFlags.HideAndDontSave;
+            GameObject obj = new("ExplorerBehaviour");
+            DontDestroyOnLoad(obj);
+            obj.hideFlags = HideFlags.HideAndDontSave;
             Instance = obj.AddComponent<ExplorerBehaviour>();
         }
 
-#if CPP
-        public ExplorerBehaviour(IntPtr ptr) : base(ptr) { }
-#endif
-
         internal void Update()
         {
             ExplorerCore.Update();

src/ExplorerCore.cs

@@ -1,23 +1,21 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
 using System.IO;
 using UnityEngine;
-using UnityEngine.UI;
+using UnityExplorer.CacheObject;
 using UnityExplorer.Config;
-using UnityExplorer.UI;
 using UnityExplorer.ObjectExplorer;
-using UnityExplorer.UI.Panels;
 using UnityExplorer.Runtime;
+using UnityExplorer.UI;
+using UnityExplorer.UI.Panels;
+using UniverseLib;
 using UniverseLib.Input;
-using UniverseLib.UI;
 
 namespace UnityExplorer
 {
     public static class ExplorerCore
     {
         public const string NAME = "UnityExplorer";
-        public const string VERSION = "4.5.2";
+        public const string VERSION = "4.6.3";
         public const string AUTHOR = "Sinai";
         public const string GUID = "com.sinai.unityexplorer";
 
@@ -31,22 +29,20 @@ namespace UnityExplorer
         public static void Init(IExplorerLoader loader)
         {
             if (Loader != null)
-            {
-                LogWarning("UnityExplorer is already loaded!");
-                return;
-            }
+                throw new Exception("UnityExplorer is already loaded.");
+
             Loader = loader;
 
             Log($"{NAME} {VERSION} initializing...");
 
-            if (!Directory.Exists(Loader.ExplorerFolder))
-                Directory.CreateDirectory(Loader.ExplorerFolder);
-
+            Directory.CreateDirectory(Loader.ExplorerFolder);
             ConfigManager.Init(Loader.ConfigHandler);
+
             UERuntimeHelper.Init();
             ExplorerBehaviour.Setup();
+            UnityCrashPrevention.Init();
 
-            UniverseLib.Universe.Init(ConfigManager.Startup_Delay_Time.Value, LateInit, Log, new()
+            Universe.Init(ConfigManager.Startup_Delay_Time.Value, LateInit, Log, new()
             {
                 Disable_EventSystem_Override = ConfigManager.Disable_EventSystem_Override.Value,
                 Force_Unlock_Mouse = ConfigManager.Force_Unlock_Mouse.Value,
@@ -57,7 +53,7 @@ namespace UnityExplorer
         // Do a delayed setup so that objects aren't destroyed instantly.
         // This can happen for a multitude of reasons.
         // Default delay is 1 second which is usually enough.
-        private static void LateInit()
+        static void LateInit()
         {
             Log($"Setting up late core features...");
 
@@ -67,21 +63,18 @@ namespace UnityExplorer
 
             UIManager.InitUI();
 
-            Log($"{NAME} {VERSION} initialized.");
+            Log($"{NAME} {VERSION} ({Universe.Context}) initialized.");
 
             //InspectorManager.Inspect(typeof(Tests.TestClass));
         }
 
-        /// <summary>
-        /// Should be called once per frame.
-        /// </summary>
-        public static void Update()
+        internal static void Update()
         {
-            UIManager.Update();
-
             // check master toggle
             if (InputManager.GetKeyDown(ConfigManager.Master_Toggle.Value))
                 UIManager.ShowMenu = !UIManager.ShowMenu;
+
+            UIManager.Update();
         }
 
         #region LOGGING

src/Inspectors/GameObjectInspector.cs

@@ -82,7 +82,7 @@ namespace UnityExplorer.Inspectors
             this.Target = newTarget;
             GOControls.UpdateGameObjectInfo(true, true);
             GOControls.UpdateTransformControlValues(true);
-            TransformTree.RefreshData(true, false);
+            TransformTree.RefreshData(true, false, true, false);
             UpdateComponents();
         }
 
@@ -109,7 +109,7 @@ namespace UnityExplorer.Inspectors
 
                 GOControls.UpdateGameObjectInfo(false, false);
 
-                TransformTree.RefreshData(true, false);
+                TransformTree.RefreshData(true, false, false, false);
                 UpdateComponents();
             }
         }
@@ -220,7 +220,7 @@ namespace UnityExplorer.Inspectors
             var newObject = new GameObject(input);
             newObject.transform.parent = GOTarget.transform;
 
-            TransformTree.RefreshData(true, false);
+            TransformTree.RefreshData(true, false, true, false);
         }
 
         private void OnAddComponentClicked(string input)

src/Inspectors/InspectorManager.cs

@@ -18,7 +18,7 @@ namespace UnityExplorer
 {
     public static class InspectorManager
     {
-        public static readonly List<InspectorBase> Inspectors = new List<InspectorBase>();
+        public static readonly List<InspectorBase> Inspectors = new();
 
         public static InspectorBase ActiveInspector { get; private set; }
         private static InspectorBase lastActiveInspector;
@@ -94,17 +94,17 @@ namespace UnityExplorer
         }
 
         private static void CreateInspector<T>(object target, bool staticReflection = false,
-            CacheObjectBase sourceCache = null) where T : InspectorBase
+            CacheObjectBase parentObject = null) where T : InspectorBase
         {
             var inspector = Pool<T>.Borrow();
             Inspectors.Add(inspector);
             inspector.Target = target;
 
-            if (sourceCache != null && sourceCache.CanWrite)
+            if (parentObject != null && parentObject.CanWrite)
             {
                 // only set parent cache object if we are inspecting a struct, otherwise there is no point.
                 if (target.GetType().IsValueType && inspector is ReflectionInspector ri)
-                    ri.ParentCacheObject = sourceCache;
+                    ri.ParentCacheObject = parentObject;
             }
 
             UIManager.SetPanelActive(UIManager.Panels.Inspector, true);

src/Inspectors/InspectorTab.cs

@@ -43,9 +43,10 @@ namespace UnityExplorer.Inspectors
             TabButton = UIFactory.CreateButton(UIRoot, "TabButton", "");
             UIFactory.SetLayoutElement(TabButton.Component.gameObject, minWidth: 173, flexibleWidth: 0);
             UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(TabButton.Component.gameObject, false, false, true, true, 0, 0, 0, 3);
+            TabButton.GameObject.AddComponent<Mask>();
 
-            TabText = TabButton.Component.GetComponentInChildren<Text>();
-            UIFactory.SetLayoutElement(TabText.gameObject, minHeight: 25, minWidth: 173, flexibleWidth: 0);
+            TabText = TabButton.ButtonText;
+            UIFactory.SetLayoutElement(TabText.gameObject, minHeight: 25, minWidth: 150, flexibleWidth: 0);
             TabText.alignment = TextAnchor.MiddleLeft;
             TabText.fontSize = 12;
             TabText.horizontalOverflow = HorizontalWrapMode.Overflow;

src/Inspectors/MouseInspector.cs

@@ -13,6 +13,7 @@ using UnityExplorer.UI.Panels;
 using UniverseLib;
 using UniverseLib.UI;
 using UniverseLib.Utility;
+using UnityExplorer.Config;
 
 namespace UnityExplorer.Inspectors
 {
@@ -22,9 +23,9 @@ namespace UnityExplorer.Inspectors
         UI
     }
 
-    public class InspectUnderMouse : UIPanel
+    public class MouseInspector : UIPanel
     {
-        public static InspectUnderMouse Instance { get; private set; }
+        public static MouseInspector Instance { get; private set; }
 
         private readonly WorldInspector worldInspector;
         private readonly UiInspector uiInspector;
@@ -58,7 +59,7 @@ namespace UnityExplorer.Inspectors
         internal Text objPathLabel;
         internal Text mousePosLabel;
 
-        public InspectUnderMouse() 
+        public MouseInspector() 
         {
             Instance = this;
             worldInspector = new WorldInspector();
@@ -116,6 +117,26 @@ namespace UnityExplorer.Inspectors
 
         private static float timeOfLastRaycast;
 
+        public bool TryUpdate()
+        {
+            if (ConfigManager.World_MouseInspect_Keybind.Value != KeyCode.None)
+            {
+                if (InputManager.GetKeyDown(ConfigManager.World_MouseInspect_Keybind.Value))
+                    Instance.StartInspect(MouseInspectMode.World);
+            }
+
+            if (ConfigManager.World_MouseInspect_Keybind.Value != KeyCode.None)
+            {
+                if (InputManager.GetKeyDown(ConfigManager.World_MouseInspect_Keybind.Value))
+                    Instance.StartInspect(MouseInspectMode.World);
+            }
+            
+            if (Inspecting)
+                UpdateInspect();
+
+            return Inspecting;
+        }
+
         public void UpdateInspect()
         {
             if (InputManager.GetKeyDown(KeyCode.Escape))
@@ -177,10 +198,10 @@ namespace UnityExplorer.Inspectors
         public override void ConstructPanelContent()
         {
             // hide title bar
-            this.titleBar.SetActive(false);
+            this.TitleBar.SetActive(false);
             this.UIRoot.transform.SetParent(UIManager.UIRoot.transform, false);
 
-            var inspectContent = UIFactory.CreateVerticalGroup(this.uiRoot, "InspectContent", true, true, true, true, 3, new Vector4(2, 2, 2, 2));
+            var inspectContent = UIFactory.CreateVerticalGroup(this.uiContent, "InspectContent", true, true, true, true, 3, new Vector4(2, 2, 2, 2));
             UIFactory.SetLayoutElement(inspectContent, flexibleWidth: 9999, flexibleHeight: 9999);
 
             // Title text

src/Inspectors/MouseInspectors/UiInspector.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -8,6 +9,7 @@ using UnityEngine.UI;
 using UnityExplorer.UI;
 using UnityExplorer.UI.Panels;
 using UniverseLib;
+using UniverseLib.Input;
 
 namespace UnityExplorer.Inspectors.MouseInspectors
 {
@@ -26,7 +28,7 @@ namespace UnityExplorer.Inspectors.MouseInspectors
         public override void OnBeginMouseInspect()
         {
             SetupUIRaycast();
-            InspectUnderMouse.Instance.objPathLabel.text = "";
+            MouseInspector.Instance.objPathLabel.text = "";
         }
 
         public override void ClearHitData()
@@ -38,6 +40,12 @@ namespace UnityExplorer.Inspectors.MouseInspectors
         {
             LastHitObjects.Clear();
             LastHitObjects.AddRange(currentHitObjects);
+            RuntimeHelper.StartCoroutine(SetPanelActiveCoro());
+        }
+
+        IEnumerator SetPanelActiveCoro()
+        {
+            yield return null;
             var panel = UIManager.GetPanel<UiInspectorResultsPanel>(UIManager.Panels.UIInspectorResults);
             panel.SetActive(true);
             panel.ShowResults();
@@ -70,9 +78,9 @@ namespace UnityExplorer.Inspectors.MouseInspectors
             }
             
             if (currentHitObjects.Any())
-                InspectUnderMouse.Instance.objNameLabel.text = $"Click to view UI Objects under mouse: {currentHitObjects.Count}";
+                MouseInspector.Instance.objNameLabel.text = $"Click to view UI Objects under mouse: {currentHitObjects.Count}";
             else
-                InspectUnderMouse.Instance.objNameLabel.text = $"No UI objects under mouse.";
+                MouseInspector.Instance.objNameLabel.text = $"No UI objects under mouse.";
         }
 
         private static void SetupUIRaycast()

src/Inspectors/MouseInspectors/WorldInspector.cs

@@ -41,7 +41,7 @@ namespace UnityExplorer.Inspectors.MouseInspectors
             if (!MainCamera)
             {
                 ExplorerCore.LogWarning("No Main Camera was found, unable to inspect world!");
-                InspectUnderMouse.Instance.StopInspect();
+                MouseInspector.Instance.StopInspect();
                 return;
             }
 
@@ -51,7 +51,7 @@ namespace UnityExplorer.Inspectors.MouseInspectors
             if (hit.transform)
                 OnHitGameObject(hit.transform.gameObject);
             else if (lastHitObject)
-                InspectUnderMouse.Instance.ClearHitData();
+                MouseInspector.Instance.ClearHitData();
         }
 
         internal void OnHitGameObject(GameObject obj)
@@ -59,8 +59,8 @@ namespace UnityExplorer.Inspectors.MouseInspectors
             if (obj != lastHitObject)
             {
                 lastHitObject = obj;
-                InspectUnderMouse.Instance.objNameLabel.text = $"<b>Click to Inspect:</b> <color=cyan>{obj.name}</color>";
-                InspectUnderMouse.Instance.objPathLabel.text = $"Path: {obj.transform.GetTransformPath(true)}";
+                MouseInspector.Instance.objNameLabel.text = $"<b>Click to Inspect:</b> <color=cyan>{obj.name}</color>";
+                MouseInspector.Instance.objPathLabel.text = $"Path: {obj.transform.GetTransformPath(true)}";
             }
         }
 

src/Inspectors/ReflectionInspector.cs

@@ -2,29 +2,34 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
-using System.Text;
 using UnityEngine;
 using UnityEngine.UI;
-using UnityExplorer.Config;
-using UnityExplorer.Runtime;
 using UnityExplorer.CacheObject;
 using UnityExplorer.CacheObject.Views;
 using UnityExplorer.UI.Panels;
 using UnityExplorer.UI.Widgets;
-using UnityExplorer.UI;
-using UniverseLib.UI.Widgets;
-using UniverseLib.UI;
 using UniverseLib;
-using UniverseLib.Runtime;
+using UniverseLib.UI;
 using UniverseLib.UI.Models;
+using UniverseLib.UI.ObjectPool;
 using UniverseLib.UI.Widgets.ScrollView;
 using UniverseLib.Utility;
 
 namespace UnityExplorer.Inspectors
 {
+    [Flags]
+    public enum MemberFilter
+    {
+        None = 0,
+        Property = 1,
+        Field = 2,
+        Constructor = 4,
+        Method = 8,
+        All = Property | Field | Method | Constructor,
+    }
+
     public class ReflectionInspector : InspectorBase, ICellPoolDataSource<CacheMemberCell>, ICacheObjectController
     {
         public CacheObjectBase ParentCacheObject { get; set; }
@@ -32,43 +37,52 @@ namespace UnityExplorer.Inspectors
         public bool StaticOnly { get; internal set; }
         public bool CanWrite => true;
 
+        public bool AutoUpdateWanted => autoUpdateToggle.isOn;
+
         private List<CacheMember> members = new();
         private readonly List<CacheMember> filteredMembers = new();
 
-        public bool AutoUpdateWanted => autoUpdateToggle.isOn;
+        private BindingFlags scopeFlagsFilter;
+        private string nameFilter;
 
-        private BindingFlags FlagsFilter;
-        private string NameFilter;
+        private MemberFilter MemberFilter = MemberFilter.All;
 
-        private MemberFlags MemberFilter = MemberFlags.All;
-        private enum MemberFlags
-        {
-            None = 0,
-            Property = 1,
-            Field = 2,
-            Method = 4,
-            All = 7
-        }
+        // Updating
+
+        private bool refreshWanted;
+        private string lastNameFilter;
+        private BindingFlags lastFlagsFilter;
+        private MemberFilter lastMemberFilter = MemberFilter.All;
+        private float timeOfLastAutoUpdate;
 
         // UI
 
+        internal GameObject mainContentHolder;
+        private static int LeftGroupWidth { get; set; }
+        private static int RightGroupWidth { get; set; }
+
         public ScrollPool<CacheMemberCell> MemberScrollPool { get; private set; }
+        public int ItemCount => filteredMembers.Count;
+
+        public UnityObjectWidget UnityWidget;
 
         public InputFieldRef HiddenNameText;
         public Text NameText;
         public Text AssemblyText;
         private Toggle autoUpdateToggle;
 
-        private string currentBaseTabText;
-
-        private readonly Color disabledButtonColor = new(0.24f, 0.24f, 0.24f);
-        private readonly Color enabledButtonColor = new(0.2f, 0.27f, 0.2f);
+        internal string currentBaseTabText;
 
         private readonly Dictionary<BindingFlags, ButtonRef> scopeFilterButtons = new();
         private readonly List<Toggle> memberTypeToggles = new();
         private InputFieldRef filterInputField;
 
-        // Setup / return
+        // const
+
+        private readonly Color disabledButtonColor = new(0.24f, 0.24f, 0.24f);
+        private readonly Color enabledButtonColor = new(0.2f, 0.27f, 0.2f);
+
+        // Setup
 
         public override void OnBorrowedFromPool(object target)
         {
@@ -104,10 +118,12 @@ namespace UnityExplorer.Inspectors
 
             autoUpdateToggle.isOn = false;
 
-            UnityObjectRef = null;
-            ComponentRef = null;
-            TextureRef = null;
-            CleanupTextureViewer();
+            if (UnityWidget != null)
+            {
+                UnityWidget.OnReturnToPool();
+                Pool.Return(UnityWidget.GetType(), UnityWidget);
+                this.UnityWidget = null;
+            }
 
             base.OnReturnToPool();
         }
@@ -133,7 +149,7 @@ namespace UnityExplorer.Inspectors
             currentBaseTabText = $"{prefix} {SignatureHighlighter.Parse(TargetType, false)}";
             Tab.TabText.text = currentBaseTabText;
             NameText.text = SignatureHighlighter.Parse(TargetType, true);
-            HiddenNameText.Text = TargetType.FullName;
+            HiddenNameText.Text = SignatureHighlighter.RemoveHighlighting(NameText.text);
 
             string asmText;
             if (TargetType.Assembly is AssemblyBuilder || string.IsNullOrEmpty(TargetType.Assembly.Location))
@@ -142,18 +158,20 @@ namespace UnityExplorer.Inspectors
                 asmText = Path.GetFileName(TargetType.Assembly.Location);
             AssemblyText.text = $"<color=grey>Assembly:</color> {asmText}";
 
-            // unity helpers
-            SetUnityTargets();
+            // Unity object helper widget
+
+            if (!StaticOnly)
+                this.UnityWidget = UnityObjectWidget.GetUnityWidget(target, TargetType, this);
 
             // Get cache members
 
-            this.members = CacheMember.GetCacheMembers(Target, TargetType, this);
+            this.members = CacheMemberFactory.GetCacheMembers(TargetType, this);
 
             // reset filters
 
-            this.filterInputField.Text = "";
+            this.filterInputField.Text = string.Empty;
 
-            SetFilter("", StaticOnly ? BindingFlags.Static : BindingFlags.Instance);
+            SetFilter(string.Empty, StaticOnly ? BindingFlags.Static : BindingFlags.Default);
             scopeFilterButtons[BindingFlags.Default].Component.gameObject.SetActive(!StaticOnly);
             scopeFilterButtons[BindingFlags.Instance].Component.gameObject.SetActive(!StaticOnly);
 
@@ -165,12 +183,6 @@ namespace UnityExplorer.Inspectors
 
         // Updating
 
-        private bool refreshWanted;
-        private string lastNameFilter;
-        private BindingFlags lastFlagsFilter;
-        private MemberFlags lastMemberFilter = MemberFlags.All;
-        private float timeOfLastAutoUpdate;
-
         public override void Update()
         {
             if (!this.IsActive)
@@ -183,10 +195,10 @@ namespace UnityExplorer.Inspectors
             }
 
             // check filter changes or force-refresh
-            if (refreshWanted || NameFilter != lastNameFilter || FlagsFilter != lastFlagsFilter || lastMemberFilter != MemberFilter)
+            if (refreshWanted || nameFilter != lastNameFilter || scopeFlagsFilter != lastFlagsFilter || lastMemberFilter != MemberFilter)
             {
-                lastNameFilter = NameFilter;
-                lastFlagsFilter = FlagsFilter;
+                lastNameFilter = nameFilter;
+                lastFlagsFilter = scopeFlagsFilter;
                 lastMemberFilter = MemberFilter;
 
                 FilterMembers();
@@ -199,11 +211,8 @@ namespace UnityExplorer.Inspectors
             {
                 timeOfLastAutoUpdate = Time.realtimeSinceStartup;
 
-                if (this.UnityObjectRef)
-                {
-                    nameInput.Text = UnityObjectRef.name;
-                    this.Tab.TabText.text = $"{currentBaseTabText} \"{UnityObjectRef.name}\"";
-                }
+                if (this.UnityWidget != null)
+                    UnityWidget.Update();
 
                 if (AutoUpdateWanted)
                     UpdateDisplayedMembers();
@@ -217,26 +226,26 @@ namespace UnityExplorer.Inspectors
 
         // Filtering
 
-        public void SetFilter(string filter) => SetFilter(filter, FlagsFilter);
+        public void SetFilter(string name) => SetFilter(name, scopeFlagsFilter);
 
-        public void SetFilter(BindingFlags flagsFilter) => SetFilter(NameFilter, flagsFilter);
+        public void SetFilter(BindingFlags flags) => SetFilter(nameFilter, flags);
 
-        public void SetFilter(string nameFilter, BindingFlags flagsFilter)
+        public void SetFilter(string name, BindingFlags flags)
         {
-            this.NameFilter = nameFilter;
+            this.nameFilter = name;
 
-            if (flagsFilter != FlagsFilter)
+            if (flags != scopeFlagsFilter)
             {
-                var btn = scopeFilterButtons[FlagsFilter].Component;
+                var btn = scopeFilterButtons[scopeFlagsFilter].Component;
                 RuntimeHelper.SetColorBlock(btn, disabledButtonColor, disabledButtonColor * 1.3f);
 
-                this.FlagsFilter = flagsFilter;
-                btn = scopeFilterButtons[FlagsFilter].Component;
+                this.scopeFlagsFilter = flags;
+                btn = scopeFilterButtons[scopeFlagsFilter].Component;
                 RuntimeHelper.SetColorBlock(btn, enabledButtonColor, enabledButtonColor * 1.3f);
             }
         }
 
-        private void OnMemberTypeToggled(MemberFlags flag, bool val)
+        private void OnMemberTypeToggled(MemberFilter flag, bool val)
         {
             if (!val)
                 MemberFilter &= ~flag;
@@ -252,19 +261,20 @@ namespace UnityExplorer.Inspectors
             {
                 var member = members[i];
 
-                if (FlagsFilter != BindingFlags.Default)
+                if (scopeFlagsFilter != BindingFlags.Default)
                 {
-                    if (FlagsFilter == BindingFlags.Instance && member.IsStatic
-                        || FlagsFilter == BindingFlags.Static && !member.IsStatic)
+                    if (scopeFlagsFilter == BindingFlags.Instance && member.IsStatic
+                        || scopeFlagsFilter == BindingFlags.Static && !member.IsStatic)
                         continue;
                 }
 
-                if ((member is CacheMethod && !MemberFilter.HasFlag(MemberFlags.Method))
-                    || (member is CacheField && !MemberFilter.HasFlag(MemberFlags.Field))
-                    || (member is CacheProperty && !MemberFilter.HasFlag(MemberFlags.Property)))
+                if ((member is CacheMethod && !MemberFilter.HasFlag(MemberFilter.Method))
+                    || (member is CacheField && !MemberFilter.HasFlag(MemberFilter.Field))
+                    || (member is CacheProperty && !MemberFilter.HasFlag(MemberFilter.Property))
+                    || (member is CacheConstructor && !MemberFilter.HasFlag(MemberFilter.Constructor)))
                     continue;
 
-                if (!string.IsNullOrEmpty(NameFilter) && !member.NameForFiltering.ContainsIgnoreCase(NameFilter))
+                if (!string.IsNullOrEmpty(nameFilter) && !member.NameForFiltering.ContainsIgnoreCase(nameFilter))
                     continue;
 
                 filteredMembers.Add(member);
@@ -293,8 +303,6 @@ namespace UnityExplorer.Inspectors
 
         // Member cells
 
-        public int ItemCount => filteredMembers.Count;
-
         public void OnCellBorrowed(CacheMemberCell cell) { } // not needed
 
         public void SetCell(CacheMemberCell cell, int index)
@@ -304,9 +312,6 @@ namespace UnityExplorer.Inspectors
 
         // Cell layout (fake table alignment)
 
-        private static int LeftGroupWidth { get; set; }
-        private static int RightGroupWidth { get; set; }
-
         internal void SetLayouts()
         {
             CalculateLayouts();
@@ -337,8 +342,6 @@ namespace UnityExplorer.Inspectors
 
         // UI Construction
 
-        private GameObject mainContentHolder;
-
         public override GameObject CreateContent(GameObject parent)
         {
             UIRoot = UIFactory.CreateVerticalGroup(parent, "ReflectionInspector", true, true, true, true, 5,
@@ -379,8 +382,6 @@ namespace UnityExplorer.Inspectors
             AssemblyText = UIFactory.CreateLabel(UIRoot, "AssemblyLabel", "not set", TextAnchor.MiddleLeft);
             UIFactory.SetLayoutElement(AssemblyText.gameObject, minHeight: 25, flexibleWidth: 9999);
 
-            ConstructUnityObjectRow();
-
             mainContentHolder = UIFactory.CreateVerticalGroup(UIRoot, "MemberHolder", false, false, true, true, 5, new Vector4(2, 2, 2, 2),
                 new Color(0.12f, 0.12f, 0.12f));
             UIFactory.SetLayoutElement(mainContentHolder, flexibleWidth: 9999, flexibleHeight: 9999);
@@ -462,6 +463,7 @@ namespace UnityExplorer.Inspectors
             AddMemberTypeToggle(rowObj, MemberTypes.Property, 90);
             AddMemberTypeToggle(rowObj, MemberTypes.Field, 70);
             AddMemberTypeToggle(rowObj, MemberTypes.Method, 90);
+            AddMemberTypeToggle(rowObj, MemberTypes.Constructor, 110);
         }
 
         private void AddScopeFilterButton(GameObject parent, BindingFlags flags, bool setAsActive = false)
@@ -480,261 +482,30 @@ namespace UnityExplorer.Inspectors
         {
             var toggleObj = UIFactory.CreateToggle(parent, "Toggle_" + type, out Toggle toggle, out Text toggleText);
             UIFactory.SetLayoutElement(toggleObj, minHeight: 25, minWidth: width);
-            var color = type switch
+            string color = type switch
             {
                 MemberTypes.Method => SignatureHighlighter.METHOD_INSTANCE,
                 MemberTypes.Field => SignatureHighlighter.FIELD_INSTANCE,
                 MemberTypes.Property => SignatureHighlighter.PROP_INSTANCE,
+                MemberTypes.Constructor => SignatureHighlighter.CLASS_INSTANCE,
                 _ => throw new NotImplementedException()
             };
             toggleText.text = $"<color={color}>{type}</color>";
 
             toggle.graphic.TryCast<Image>().color = color.ToColor() * 0.65f;
 
-            MemberFlags flag;
-            switch (type)
+            MemberFilter flag = type switch
             {
-                case MemberTypes.Method: flag = MemberFlags.Method; break;
-                case MemberTypes.Property: flag = MemberFlags.Property; break;
-                case MemberTypes.Field: flag = MemberFlags.Field; break;
-                default: return;
-            }
+                MemberTypes.Method => MemberFilter.Method,
+                MemberTypes.Property => MemberFilter.Property,
+                MemberTypes.Field => MemberFilter.Field,
+                MemberTypes.Constructor => MemberFilter.Constructor,
+                _ => throw new NotImplementedException()
+            };
 
             toggle.onValueChanged.AddListener((bool val) => { OnMemberTypeToggled(flag, val); });
 
             memberTypeToggles.Add(toggle);
         }
-
-
-        // Todo should probably put this in a separate class or maybe as a widget
-
-        #region UNITY OBJECT SPECIFIC
-
-        // Unity object helpers
-
-        private UnityEngine.Object UnityObjectRef;
-        private Component ComponentRef;
-        private Texture2D TextureRef;
-        private bool TextureViewerWanted;
-        private GameObject unityObjectRow;
-        private ButtonRef gameObjectButton;
-        private InputFieldRef nameInput;
-        private InputFieldRef instanceIdInput;
-        private ButtonRef textureButton;
-        private GameObject textureViewer;
-
-        private void SetUnityTargets()
-        {
-            if (StaticOnly || !typeof(UnityEngine.Object).IsAssignableFrom(TargetType))
-            {
-                unityObjectRow.SetActive(false);
-                textureViewer.SetActive(false);
-                return;
-            }
-
-            UnityObjectRef = (UnityEngine.Object)Target.TryCast(typeof(UnityEngine.Object));
-            unityObjectRow.SetActive(true);
-
-            nameInput.Text = UnityObjectRef.name;
-            instanceIdInput.Text = UnityObjectRef.GetInstanceID().ToString();
-
-            if (typeof(Component).IsAssignableFrom(TargetType))
-            {
-                ComponentRef = (Component)Target.TryCast(typeof(Component));
-                gameObjectButton.Component.gameObject.SetActive(true);
-            }
-            else
-                gameObjectButton.Component.gameObject.SetActive(false);
-
-            if (typeof(Texture2D).IsAssignableFrom(TargetType))
-            {
-                TextureRef = (Texture2D)Target.TryCast(typeof(Texture2D));
-                textureButton.Component.gameObject.SetActive(true);
-            }
-            else
-                textureButton.Component.gameObject.SetActive(false);
-        }
-
-        private void OnGameObjectButtonClicked()
-        {
-            if (!ComponentRef)
-            {
-                ExplorerCore.LogWarning("Component reference is null or destroyed!");
-                return;
-            }
-
-            InspectorManager.Inspect(ComponentRef.gameObject);
-        }
-
-        private void ToggleTextureViewer()
-        {
-            if (TextureViewerWanted)
-            {
-                // disable
-                TextureViewerWanted = false;
-                textureViewer.SetActive(false);
-                mainContentHolder.SetActive(true);
-                textureButton.ButtonText.text = "View Texture";
-            }
-            else
-            {
-                if (!textureImage.sprite)
-                {
-                    // First show, need to create sprite for displaying texture
-                    SetTextureViewer();
-                }
-
-                // enable
-                TextureViewerWanted = true;
-                textureViewer.SetActive(true);
-                mainContentHolder.gameObject.SetActive(false);
-                textureButton.ButtonText.text = "Hide Texture";
-            }
-        }
-
-        // UI construction
-
-        private void ConstructUnityObjectRow()
-        {
-            unityObjectRow = UIFactory.CreateUIObject("UnityObjectRow", UIRoot);
-            UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(unityObjectRow, false, false, true, true, 5);
-            UIFactory.SetLayoutElement(unityObjectRow, minHeight: 25, flexibleHeight: 0, flexibleWidth: 9999);
-
-            textureButton = UIFactory.CreateButton(unityObjectRow, "TextureButton", "View Texture", new Color(0.2f, 0.2f, 0.2f));
-            UIFactory.SetLayoutElement(textureButton.Component.gameObject, minHeight: 25, minWidth: 150);
-            textureButton.OnClick += ToggleTextureViewer;
-
-            var nameLabel = UIFactory.CreateLabel(unityObjectRow, "NameLabel", "Name:", TextAnchor.MiddleLeft, Color.grey);
-            UIFactory.SetLayoutElement(nameLabel.gameObject, minHeight: 25, minWidth: 45, flexibleWidth: 0);
-
-            nameInput = UIFactory.CreateInputField(unityObjectRow, "NameInput", "untitled");
-            UIFactory.SetLayoutElement(nameInput.UIRoot, minHeight: 25, minWidth: 100, flexibleWidth: 1000);
-            nameInput.Component.readOnly = true;
-
-            gameObjectButton = UIFactory.CreateButton(unityObjectRow, "GameObjectButton", "Inspect GameObject", new Color(0.2f, 0.2f, 0.2f));
-            UIFactory.SetLayoutElement(gameObjectButton.Component.gameObject, minHeight: 25, minWidth: 160);
-            gameObjectButton.OnClick += OnGameObjectButtonClicked;
-
-            var instanceLabel = UIFactory.CreateLabel(unityObjectRow, "InstanceLabel", "Instance ID:", TextAnchor.MiddleRight, Color.grey);
-            UIFactory.SetLayoutElement(instanceLabel.gameObject, minHeight: 25, minWidth: 100, flexibleWidth: 0);
-
-            instanceIdInput = UIFactory.CreateInputField(unityObjectRow, "InstanceIDInput", "ERROR");
-            UIFactory.SetLayoutElement(instanceIdInput.UIRoot, minHeight: 25, minWidth: 100, flexibleWidth: 0);
-            instanceIdInput.Component.readOnly = true;
-
-            unityObjectRow.SetActive(false);
-
-            ConstructTextureHelper();
-        }
-
-        // Texture viewer helper
-
-        private InputFieldRef textureSavePathInput;
-        private Image textureImage;
-        private LayoutElement textureImageLayout;
-
-        private void CleanupTextureViewer()
-        {
-            if (textureImage.sprite)
-                GameObject.Destroy(textureImage.sprite);
-
-            if (TextureViewerWanted)
-                ToggleTextureViewer();
-        }
-
-        private void ConstructTextureHelper()
-        {
-            textureViewer = UIFactory.CreateVerticalGroup(UIRoot, "TextureViewer", false, false, true, true, 2, new Vector4(5, 5, 5, 5),
-                new Color(0.1f, 0.1f, 0.1f));
-            UIFactory.SetLayoutElement(textureViewer, flexibleWidth: 9999, flexibleHeight: 9999);
-
-            // Save helper
-
-            var saveRowObj = UIFactory.CreateHorizontalGroup(textureViewer, "SaveRow", false, false, true, true, 2, new Vector4(2, 2, 2, 2),
-                new Color(0.1f, 0.1f, 0.1f));
-
-            var saveBtn = UIFactory.CreateButton(saveRowObj, "SaveButton", "Save .PNG", new Color(0.2f, 0.25f, 0.2f));
-            UIFactory.SetLayoutElement(saveBtn.Component.gameObject, minHeight: 25, minWidth: 100, flexibleWidth: 0);
-            saveBtn.OnClick += OnSaveTextureClicked;
-
-            textureSavePathInput = UIFactory.CreateInputField(saveRowObj, "SaveInput", "...");
-            UIFactory.SetLayoutElement(textureSavePathInput.UIRoot, minHeight: 25, minWidth: 100, flexibleWidth: 9999);
-
-            // Actual texture viewer
-
-            var imageViewport = UIFactory.CreateVerticalGroup(textureViewer, "Viewport", false, false, true, true);
-            imageViewport.GetComponent<Image>().color = Color.white;
-            imageViewport.AddComponent<Mask>().showMaskGraphic = false;
-
-            var imageObj = UIFactory.CreateUIObject("Image", imageViewport);
-            var fitter = imageObj.AddComponent<ContentSizeFitter>();
-            fitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
-            textureImage = imageObj.AddComponent<Image>();
-            textureImageLayout = UIFactory.SetLayoutElement(imageObj, flexibleWidth: 1, flexibleHeight: 1);
-
-            textureViewer.SetActive(false);
-        }
-
-        private void SetTextureViewer()
-        {
-            if (!this.TextureRef)
-                return;
-
-            var name = TextureRef.name;
-            if (string.IsNullOrEmpty(name))
-                name = "untitled";
-
-            textureSavePathInput.Text = Path.Combine(ConfigManager.Default_Output_Path.Value, $"{name}.png");
-
-            var sprite = TextureHelper.CreateSprite(TextureRef);
-            textureImage.sprite = sprite;
-
-            textureImageLayout.preferredHeight = sprite.rect.height;
-            // not really working, its always stretched horizontally for some reason.
-            textureImageLayout.preferredWidth = sprite.rect.width;
-        }
-
-        private void OnSaveTextureClicked()
-        {
-            if (!TextureRef)
-            {
-                ExplorerCore.LogWarning("Ref Texture is null, maybe it was destroyed?");
-                return;
-            }
-
-            if (string.IsNullOrEmpty(textureSavePathInput.Text))
-            {
-                ExplorerCore.LogWarning("Save path cannot be empty!");
-                return;
-            }
-
-            var path = textureSavePathInput.Text;
-            if (!path.EndsWith(".png", StringComparison.InvariantCultureIgnoreCase))
-            {
-                ExplorerCore.LogWarning("Desired save path must end with '.png'!");
-                return;
-            }
-
-            path = IOUtility.EnsureValidFilePath(path);
-
-            if (File.Exists(path))
-                File.Delete(path);
-
-            var tex = TextureRef;
-
-            if (!TextureHelper.IsReadable(tex))
-                tex = TextureHelper.ForceReadTexture(tex);
-
-            byte[] data = TextureHelper.EncodeToPNG(tex);
-            File.WriteAllBytes(path, data);
-
-            if (tex != TextureRef)
-            {
-                // cleanup temp texture if we had to force-read it.
-                GameObject.Destroy(tex);
-            }
-        }
-
-        #endregion
     }
 }

src/Loader/MelonLoader/ExplorerMelonMod.cs

@@ -6,7 +6,12 @@ using UnityExplorer;
 using UnityExplorer.Config;
 using UnityExplorer.Loader.ML;
 
-[assembly: MelonPlatformDomain(MelonPlatformDomainAttribute.CompatibleDomains.UNIVERSAL)]
+#if CPP
+[assembly: MelonPlatformDomain(MelonPlatformDomainAttribute.CompatibleDomains.IL2CPP)]
+#else
+[assembly: MelonPlatformDomain(MelonPlatformDomainAttribute.CompatibleDomains.MONO)]
+#endif
+
 [assembly: MelonInfo(typeof(ExplorerMelonMod), ExplorerCore.NAME, ExplorerCore.VERSION, ExplorerCore.AUTHOR)]
 [assembly: MelonGame(null, null)]
 [assembly: MelonColor(ConsoleColor.DarkCyan)]
@@ -26,9 +31,9 @@ namespace UnityExplorer
         public ConfigHandler ConfigHandler => _configHandler;
         public MelonLoaderConfigHandler _configHandler;
 
-        public Action<object> OnLogMessage => MelonLogger.Msg;
-        public Action<object> OnLogWarning => MelonLogger.Warning;
-        public Action<object> OnLogError   => MelonLogger.Error;
+        public Action<object> OnLogMessage => LoggerInstance.Msg;
+        public Action<object> OnLogWarning => LoggerInstance.Warning;
+        public Action<object> OnLogError   => LoggerInstance.Error;
 
         public override void OnApplicationStart()
         {

src/Loader/Standalone/Editor/ExplorerEditorBehaviour.cs

@@ -0,0 +1,33 @@
+#if STANDALONE
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using UnityEngine;
+
+namespace UnityExplorer.Loader.Standalone
+{
+    public class ExplorerEditorBehaviour : MonoBehaviour
+    {
+        internal void Awake()
+        {
+            ExplorerEditorLoader.Initialize();
+            DontDestroyOnLoad(this);
+            this.gameObject.hideFlags = HideFlags.HideAndDontSave;
+        }
+
+        internal void OnDestroy()
+        {
+            OnApplicationQuit();
+        }
+
+        internal void OnApplicationQuit()
+        {
+            if (UI.UIManager.UIRoot)
+                Destroy(UI.UIManager.UIRoot.transform.root.gameObject);
+        }
+    }
+}
+#endif

src/Loader/Standalone/Editor/ExplorerEditorLoader.cs

@@ -0,0 +1,41 @@
+#if STANDALONE
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+
+namespace UnityExplorer.Loader.Standalone
+{
+    public class ExplorerEditorLoader : ExplorerStandalone
+    {
+        public static void Initialize()
+        {
+            Instance = new ExplorerEditorLoader();
+            OnLog += LogHandler;
+            Instance.configHandler = new StandaloneConfigHandler();
+
+            ExplorerCore.Init(Instance);
+        }
+
+        static void LogHandler(string message, LogType logType)
+        {
+            switch (logType)
+            {
+                case LogType.Assert:    Debug.LogError(message); break;
+                case LogType.Error:     Debug.LogError(message); break;
+                case LogType.Exception: Debug.LogError(message); break;
+                case LogType.Log:       Debug.Log(message); break;
+                case LogType.Warning:   Debug.LogWarning(message); break;
+            }
+        }
+
+        protected override void CheckExplorerFolder()
+        {
+            if (explorerFolder == null)
+                explorerFolder = Path.Combine(Application.dataPath, "UnityExplorer~");
+        }
+    }
+}
+#endif

src/Loader/Standalone/ExplorerStandalone.cs

@@ -5,9 +5,9 @@ using System.IO;
 using System.Reflection;
 using UnityEngine;
 using UnityExplorer.Config;
-using UnityExplorer.Loader.STANDALONE;
 using UnityEngine.EventSystems;
 using UniverseLib.Input;
+using UnityExplorer.Loader.Standalone;
 #if CPP
 using UnhollowerRuntimeLib;
 #endif
@@ -16,6 +16,33 @@ namespace UnityExplorer
 {
 	public class ExplorerStandalone : IExplorerLoader
     {
+        public static ExplorerStandalone Instance { get; protected set; }
+
+        /// <summary>
+        /// Invoked whenever Explorer logs something. Subscribe to this to handle logging.
+        /// </summary>
+        public static event Action<string, LogType> OnLog;
+
+        public string UnhollowedModulesFolder => unhollowedPath;
+        private string unhollowedPath;
+
+        public ConfigHandler ConfigHandler => configHandler;
+        internal StandaloneConfigHandler configHandler;
+
+        public string ExplorerFolder
+        {
+            get
+            {
+                CheckExplorerFolder();
+                return explorerFolder;
+            }
+        }
+        protected static string explorerFolder;
+        
+        Action<object> IExplorerLoader.OnLogMessage => (object log) => { OnLog?.Invoke(log?.ToString() ?? "", LogType.Log); };
+        Action<object> IExplorerLoader.OnLogWarning => (object log) => { OnLog?.Invoke(log?.ToString() ?? "", LogType.Warning); };
+        Action<object> IExplorerLoader.OnLogError   => (object log) => { OnLog?.Invoke(log?.ToString() ?? "", LogType.Error); };
+
         /// <summary>
         /// Call this to initialize UnityExplorer without adding a log listener or Unhollowed modules path.
         /// The default Unhollowed path "UnityExplorer\Modules\" will be used.
@@ -50,60 +77,33 @@ namespace UnityExplorer
                 OnLog += logListener;
 
             if (string.IsNullOrEmpty(unhollowedModulesPath) || !Directory.Exists(unhollowedModulesPath))
-                instance._unhollowedPath = Path.Combine(instance.ExplorerFolder, "Modules");
+                instance.unhollowedPath = Path.Combine(instance.ExplorerFolder, "Modules");
             else
-                instance._unhollowedPath = unhollowedModulesPath;
+                instance.unhollowedPath = unhollowedModulesPath;
 
             return instance;
         }
 
-        public static ExplorerStandalone Instance { get; private set; }
-
-        /// <summary>
-        /// Invoked whenever Explorer logs something. Subscribe to this to handle logging.
-        /// </summary>
-        public static event Action<string, LogType> OnLog;
-
-        public string UnhollowedModulesFolder => _unhollowedPath;
-        private string _unhollowedPath;
-
-        public ConfigHandler ConfigHandler => _configHandler;
-        private StandaloneConfigHandler _configHandler;
-
-        public string ExplorerFolder
-        {
-            get
-            {
-                CheckExplorerFolder();
-                return s_explorerFolder;
-            }
-        }
-        private static string s_explorerFolder;
-        
-        Action<object> IExplorerLoader.OnLogMessage => (object log) => { OnLog?.Invoke(log?.ToString() ?? "", LogType.Log); };
-        Action<object> IExplorerLoader.OnLogWarning => (object log) => { OnLog?.Invoke(log?.ToString() ?? "", LogType.Warning); };
-        Action<object> IExplorerLoader.OnLogError   => (object log) => { OnLog?.Invoke(log?.ToString() ?? "", LogType.Error); };
-
-        private void Init()
+        internal void Init()
         {
             Instance = this;
-            _configHandler = new StandaloneConfigHandler();
+            configHandler = new StandaloneConfigHandler();
 
             ExplorerCore.Init(this);
         }
 
-        private void CheckExplorerFolder()
+        protected virtual void CheckExplorerFolder()
         {
-            if (s_explorerFolder == null)
+            if (explorerFolder == null)
             {
-                s_explorerFolder =
+                explorerFolder =
                     Path.Combine(
                         Path.GetDirectoryName(
                             Uri.UnescapeDataString(new Uri(Assembly.GetExecutingAssembly().CodeBase).AbsolutePath)),
                         "UnityExplorer");
 
-                if (!Directory.Exists(s_explorerFolder))
-                    Directory.CreateDirectory(s_explorerFolder);
+                if (!Directory.Exists(explorerFolder))
+                    Directory.CreateDirectory(explorerFolder);
             }
         }
     }

src/Loader/Standalone/StandaloneConfigHandler.cs

@@ -9,7 +9,7 @@ using UnityEngine;
 using Tomlet;
 using Tomlet.Models;
 
-namespace UnityExplorer.Loader.STANDALONE
+namespace UnityExplorer.Loader.Standalone
 {
     public class StandaloneConfigHandler : ConfigHandler
     {
@@ -73,7 +73,11 @@ namespace UnityExplorer.Loader.STANDALONE
                 return bool.Parse(value);
             else if (elementType == typeof(int))
                 return int.Parse(value);
-            else 
+            else if (elementType == typeof(float))
+                return float.Parse(value);
+            else if (elementType.IsEnum)
+                return Enum.Parse(elementType, value);
+            else
                 return value;
         }
 

src/ObjectExplorer/ObjectSearch.cs

@@ -99,7 +99,13 @@ namespace UnityExplorer.ObjectExplorer
 
             nameInputRow.SetActive(context == SearchContext.UnityObject);
 
-            typeAutocompleter.BaseType = context == SearchContext.UnityObject ? typeof(UnityEngine.Object) : typeof(object);
+            if (context == SearchContext.Class)
+                typeAutocompleter.AllTypes = true;
+            else
+            {
+                typeAutocompleter.BaseType = context == SearchContext.UnityObject ? typeof(UnityEngine.Object) : typeof(object);
+                typeAutocompleter.AllTypes = false;
+            }
             typeAutocompleter.CacheTypes();
         }
 

src/ObjectExplorer/SceneExplorer.cs

@@ -27,7 +27,7 @@ namespace UnityExplorer.ObjectExplorer
             Parent = parent;
 
             SceneHandler.OnInspectedSceneChanged += SceneHandler_OnInspectedSceneChanged;
-            SceneHandler.OnLoadedScenesChanged += SceneHandler_OnLoadedScenesChanged;
+            SceneHandler.OnLoadedScenesUpdated += SceneHandler_OnLoadedScenesUpdated;
         }
 
         public override GameObject UIRoot => uiRoot;
@@ -64,7 +64,7 @@ namespace UnityExplorer.ObjectExplorer
         public void UpdateTree()
         {
             SceneHandler.Update();
-            Tree.RefreshData(true);
+            Tree.RefreshData(true, false, false, false);
         }
 
         public void JumpToTransform(Transform transform)
@@ -87,21 +87,21 @@ namespace UnityExplorer.ObjectExplorer
             Tree.JumpAndExpandToTransform(transform);
         }
 
-        private void OnDropdownChanged(int value)
+        private void OnSceneSelectionDropdownChanged(int value)
         {
             if (value < 0 || SceneHandler.LoadedScenes.Count <= value)
                 return;
 
             SceneHandler.SelectedScene = SceneHandler.LoadedScenes[value];
             SceneHandler.Update();
-            Tree.RefreshData(true);
+            Tree.RefreshData(true, true, true, false);
             OnSelectedSceneChanged(SceneHandler.SelectedScene.Value);
         }
 
         private void SceneHandler_OnInspectedSceneChanged(Scene scene)
         {
             if (!sceneToDropdownOption.ContainsKey(scene))
-                PopulateSceneDropdown();
+                PopulateSceneDropdown(SceneHandler.LoadedScenes);
 
             if (sceneToDropdownOption.ContainsKey(scene))
             {
@@ -122,17 +122,17 @@ namespace UnityExplorer.ObjectExplorer
                 refreshRow.SetActive(!scene.IsValid());
         }
 
-        private void SceneHandler_OnLoadedScenesChanged(List<Scene> loadedScenes)
+        private void SceneHandler_OnLoadedScenesUpdated(List<Scene> loadedScenes)
         {
-            PopulateSceneDropdown();
+            PopulateSceneDropdown(loadedScenes);
         }
 
-        private void PopulateSceneDropdown()
+        private void PopulateSceneDropdown(List<Scene> loadedScenes)
         {
             sceneToDropdownOption.Clear();
             sceneDropdown.options.Clear();
 
-            foreach (var scene in SceneHandler.LoadedScenes)
+            foreach (var scene in loadedScenes)
             {
                 if (sceneToDropdownOption.ContainsKey(scene))
                     continue;
@@ -158,7 +158,7 @@ namespace UnityExplorer.ObjectExplorer
             }
 
             Tree.CurrentFilter = input;
-            Tree.RefreshData(true, true);
+            Tree.RefreshData(true, false, true, false);
         }
 
         private void TryLoadScene(LoadSceneMode mode, Dropdown allSceneDrop)
@@ -198,11 +198,11 @@ namespace UnityExplorer.ObjectExplorer
             var dropLabel = UIFactory.CreateLabel(dropRow, "SelectorLabel", "Scene:", TextAnchor.MiddleLeft, Color.cyan, false, 15);
             UIFactory.SetLayoutElement(dropLabel.gameObject, minHeight: 25, minWidth: 60, flexibleWidth: 0);
 
-            var dropdownObj = UIFactory.CreateDropdown(dropRow, "SceneDropdown", out sceneDropdown, "<notset>", 13, OnDropdownChanged);
+            var dropdownObj = UIFactory.CreateDropdown(dropRow, "SceneDropdown", out sceneDropdown, "<notset>", 13, OnSceneSelectionDropdownChanged);
             UIFactory.SetLayoutElement(dropdownObj, minHeight: 25, flexibleHeight: 0, flexibleWidth: 9999);
 
             SceneHandler.Update();
-            PopulateSceneDropdown();
+            PopulateSceneDropdown(SceneHandler.LoadedScenes);
             sceneDropdown.captionText.text = sceneToDropdownOption.First().Value.text;
 
             // Filter row
@@ -239,6 +239,17 @@ namespace UnityExplorer.ObjectExplorer
 
             refreshRow.SetActive(false);
 
+            // tree labels row
+
+            var labelsRow = UIFactory.CreateHorizontalGroup(toolbar, "LabelsRow", true, true, true, true, 2, new Vector4(2, 2, 2, 2));
+            UIFactory.SetLayoutElement(labelsRow, minHeight: 30, flexibleHeight: 0);
+
+            var nameLabel = UIFactory.CreateLabel(labelsRow, "NameLabel", "Name", TextAnchor.MiddleLeft, color: Color.grey);
+            UIFactory.SetLayoutElement(nameLabel.gameObject, flexibleWidth: 9999, minHeight: 25);
+
+            var indexLabel = UIFactory.CreateLabel(labelsRow, "IndexLabel", "Sibling Index", TextAnchor.MiddleLeft, fontSize: 12, color: Color.grey);
+            UIFactory.SetLayoutElement(indexLabel.gameObject, minWidth: 100, flexibleWidth: 0, minHeight: 25);
+
             // Transform Tree
 
             var scrollPool = UIFactory.CreateScrollPool<TransformCell>(uiRoot, "TransformTree", out GameObject scrollObj,
@@ -248,7 +259,7 @@ namespace UnityExplorer.ObjectExplorer
 
             Tree = new TransformTree(scrollPool, GetRootEntries);
             Tree.Init();
-            Tree.RefreshData(true, true);
+            Tree.RefreshData(true, true, true, false);
             //scrollPool.Viewport.GetComponent<Mask>().enabled = false;
             //UIRoot.GetComponent<Mask>().enabled = false;
 

src/ObjectExplorer/SceneHandler.cs

@@ -17,7 +17,7 @@ namespace UnityExplorer.ObjectExplorer
             get => selectedScene;
             internal set
             {
-                if (selectedScene != null && selectedScene == value)
+                if (selectedScene.HasValue && selectedScene == value)
                     return;
                 selectedScene = value;
                 OnInspectedSceneChanged?.Invoke((Scene)selectedScene);
@@ -26,11 +26,11 @@ namespace UnityExplorer.ObjectExplorer
         private static Scene? selectedScene;
 
         /// <summary>The GameObjects in the currently inspected scene.</summary>
-        public static GameObject[] CurrentRootObjects { get; private set; } = new GameObject[0];
+        public static IEnumerable<GameObject> CurrentRootObjects { get; private set; } = new GameObject[0];
 
         /// <summary>All currently loaded Scenes.</summary>
         public static List<Scene> LoadedScenes { get; private set; } = new();
-        private static HashSet<Scene> previousLoadedScenes;
+        //private static HashSet<Scene> previousLoadedScenes;
 
         /// <summary>The names of all scenes in the build settings, if they could be retrieved.</summary>
         public static List<string> AllSceneNames { get; private set; } = new();
@@ -39,7 +39,7 @@ namespace UnityExplorer.ObjectExplorer
         public static event Action<Scene> OnInspectedSceneChanged;
 
         /// <summary>Invoked whenever the list of currently loaded Scenes changes. The argument contains all loaded scenes after the change.</summary>
-        public static event Action<List<Scene>> OnLoadedScenesChanged;
+        public static event Action<List<Scene>> OnLoadedScenesUpdated;
 
         /// <summary>Generally will be 2, unless DontDestroyExists == false, then this will be 1.</summary>
         internal static int DefaultSceneCount => 1 + (DontDestroyExists ? 1 : 0);
@@ -84,23 +84,20 @@ namespace UnityExplorer.ObjectExplorer
 
         internal static void Update()
         {
-            // check if the loaded scenes changed. always confirm DontDestroy / HideAndDontSave
-            int confirmedCount = DefaultSceneCount;
-            bool inspectedExists = (SelectedScene.HasValue && SelectedScene.Value.handle == -12) 
-                                   || (SelectedScene.HasValue && SelectedScene.Value.handle == -1);
+            // Inspected scene will exist if it's DontDestroyOnLoad or HideAndDontSave
+            bool inspectedExists = 
+                SelectedScene.HasValue 
+                && ((DontDestroyExists && SelectedScene.Value.handle == -12) 
+                    || SelectedScene.Value.handle == -1);
 
             LoadedScenes.Clear();
 
             for (int i = 0; i < SceneManager.sceneCount; i++)
             {
                 Scene scene = SceneManager.GetSceneAt(i);
-                if (scene == default || !scene.isLoaded)
+                if (scene == default || !scene.isLoaded || !scene.IsValid())
                     continue;
 
-                // If no changes yet, ensure the previous list contained the scene
-                if (previousLoadedScenes != null && previousLoadedScenes.Contains(scene))
-                    confirmedCount++;
-
                 // If we have not yet confirmed inspectedExists, check if this scene is our currently inspected one.
                 if (!inspectedExists && scene == SelectedScene)
                     inspectedExists = true;
@@ -112,17 +109,12 @@ namespace UnityExplorer.ObjectExplorer
                 LoadedScenes.Add(new Scene { m_Handle = -12 });
             LoadedScenes.Add(new Scene { m_Handle = -1 });
 
-            bool anyChange = confirmedCount != LoadedScenes.Count;
-
-            previousLoadedScenes = new HashSet<Scene>(LoadedScenes);
-
             // Default to first scene if none selected or previous selection no longer exists.
             if (!inspectedExists)
                 SelectedScene = LoadedScenes.First();
 
             // Notify on the list changing at all
-            if (anyChange)
-                OnLoadedScenesChanged?.Invoke(LoadedScenes);
+            OnLoadedScenesUpdated?.Invoke(LoadedScenes);
 
             // Finally, update the root objects list.
             if (SelectedScene != null && ((Scene)SelectedScene).IsValid())
@@ -137,7 +129,7 @@ namespace UnityExplorer.ObjectExplorer
                     if (go.transform.parent == null && !go.scene.IsValid())
                         objects.Add(go);
                 }
-                CurrentRootObjects = objects.ToArray();
+                CurrentRootObjects = objects;
             }
         }
     }

src/Runtime/MonoHelper.cs

@@ -1,5 +1,4 @@
 #if MONO
-using System;
 using UnityEngine;
 
 namespace UnityExplorer.Runtime

src/Runtime/UnityCrashPrevention.cs

@@ -0,0 +1,38 @@
+using HarmonyLib;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using UnityExplorer.CacheObject;
+
+namespace UnityExplorer.Runtime
+{
+    internal static class UnityCrashPrevention
+    {
+        internal static void Init()
+        {
+            try
+            {
+                ExplorerCore.Harmony.PatchAll(typeof(UnityCrashPrevention));
+                ExplorerCore.Log("Initialized UnityCrashPrevention.");
+            }
+            catch //(Exception ex)
+            {
+                //ExplorerCore.Log($"Exception setting up Canvas crash prevention patch: {ex}");
+            }
+        }
+
+        // In Unity 2020 they introduced "Canvas.renderingDisplaySize".
+        // If you try to get the value on a Canvas which has a renderMode value of WorldSpace and no worldCamera set,
+        // the game will Crash (I think from Unity trying to read from null ptr).
+        [HarmonyPatch(typeof(Canvas), "renderingDisplaySize", MethodType.Getter)]
+        [HarmonyPrefix]
+        internal static void Prefix_Canvas_renderingDisplaySize(Canvas __instance)
+        {
+            if (__instance.renderMode == RenderMode.WorldSpace && !__instance.worldCamera)
+                throw new InvalidOperationException(
+                    "Canvas is set to RenderMode.WorldSpace but not worldCamera is set, cannot get renderingDisplaySize.");
+        }
+    }
+}

src/Tests/TestClass.cs

@@ -24,8 +24,12 @@ namespace UnityExplorer.Tests
 #endif
         }
 
+        #region MONO
+
         public static object LiterallyAnything = null;
 
+        public static string Exception => throw new Exception("This is a test.");
+
         // Test enumerables
         public static int[,,] MultiDimensionalArray = new int[45, 45, 45];
         public static List<object> ListOfInts;
@@ -90,12 +94,12 @@ namespace UnityExplorer.Tests
             ExplorerCore.Log($"Test3 {typeof(T).FullName}");
         }
 
-        public static void TestArgumentParse(string _string, 
-                                             int integer, 
-                                             Color color, 
-                                             CameraClearFlags flags, 
-                                             Vector3 vector, 
-                                             Quaternion quaternion, 
+        public static void TestArgumentParse(string _string,
+                                             int integer,
+                                             Color color,
+                                             CameraClearFlags flags,
+                                             Vector3 vector,
+                                             Quaternion quaternion,
                                              object obj,
                                              Type type,
                                              GameObject go)
@@ -145,23 +149,25 @@ namespace UnityExplorer.Tests
             ExplorerCore.Log("Finished TestClass Init_Mono");
         }
 
+        #endregion
+
 #if CPP
+        public static Il2CppSystem.Collections.Generic.Dictionary<string, string> IL2CPP_Dict;
+        public static Il2CppSystem.Collections.Generic.HashSet<string> IL2CPP_HashSet;
         public static Il2CppSystem.Collections.Generic.List<string> IL2CPP_ListString;
+        public static Il2CppSystem.Collections.Hashtable IL2CPP_HashTable;
         public static List<Il2CppSystem.Object> IL2CPP_listOfBoxedObjects;
         public static Il2CppStructArray<int> IL2CPP_structArray;
         public static Il2CppReferenceArray<Il2CppSystem.Object> IL2CPP_ReferenceArray;
         public static Il2CppSystem.Collections.IDictionary IL2CPP_IDict;
         public static Il2CppSystem.Collections.IList IL2CPP_IList;
-        public static Dictionary<Il2CppSystem.String, Il2CppSystem.Object> CppBoxedDict;
+        public static Dictionary<Il2CppSystem.Object, Il2CppSystem.Object> IL2CPP_BoxedDict;
 
-        public static Il2CppSystem.Collections.Generic.HashSet<string> IL2CPP_HashSet;
-        public static Il2CppSystem.Collections.Generic.Dictionary<string, string> IL2CPP_Dict;
-        public static Il2CppSystem.Collections.Hashtable IL2CPP_HashTable;
-        public static Il2CppSystem.Object cppBoxedInt;
-        public static Il2CppSystem.Int32 cppInt;
-        public static Il2CppSystem.Decimal cppDecimal;
-        public static Il2CppSystem.Object cppDecimalBoxed;
-        public static Il2CppSystem.Object cppVector3Boxed;
+        public static Il2CppSystem.Object IL2CPP_BoxedInt;
+        public static Il2CppSystem.Int32 IL2CPP_Int;
+        public static Il2CppSystem.Decimal IL2CPP_Decimal;
+        public static Il2CppSystem.Object IL2CPP_DecimalBoxed;
+        public static Il2CppSystem.Object IL2CPP_Vector3Boxed;
         public static string IL2CPP_systemString = "Test";
         public static Il2CppSystem.Object IL2CPP_objectString = "string boxed as cpp object";
         public static Il2CppSystem.String IL2CPP_il2cppString = "string boxed as cpp string";
@@ -175,6 +181,11 @@ namespace UnityExplorer.Tests
             IL2CPP_Dict.Add("key2", "value2");
             IL2CPP_Dict.Add("key3", "value3");
 
+            ExplorerCore.Log($"IL2CPP 6: Il2Cpp HashSet of strings");
+            IL2CPP_HashSet = new Il2CppSystem.Collections.Generic.HashSet<string>();
+            IL2CPP_HashSet.Add("one");
+            IL2CPP_HashSet.Add("two");
+
             ExplorerCore.Log($"IL2CPP 2: Il2Cpp Hashtable");
             IL2CPP_HashTable = new Il2CppSystem.Collections.Hashtable();
             IL2CPP_HashTable.Add("key1", "value1");
@@ -197,17 +208,13 @@ namespace UnityExplorer.Tests
             IL2CPP_ListString.Add("hello,");
             IL2CPP_ListString.Add("world!");
 
-            ExplorerCore.Log($"IL2CPP 6: Il2Cpp HashSet of strings");
-            IL2CPP_HashSet = new Il2CppSystem.Collections.Generic.HashSet<string>();
-            IL2CPP_HashSet.Add("one");
-            IL2CPP_HashSet.Add("two");
 
             ExplorerCore.Log($"IL2CPP 7: Dictionary of Il2Cpp String and Il2Cpp Object");
-            CppBoxedDict = new Dictionary<Il2CppSystem.String, Il2CppSystem.Object>();
-            CppBoxedDict.Add("1", new Il2CppSystem.Int32 { m_value = 1 }.BoxIl2CppObject());
-            CppBoxedDict.Add("2", new Il2CppSystem.Int32 { m_value = 2 }.BoxIl2CppObject());
-            CppBoxedDict.Add("3", new Il2CppSystem.Int32 { m_value = 3 }.BoxIl2CppObject());
-            CppBoxedDict.Add("4", new Il2CppSystem.Int32 { m_value = 4 }.BoxIl2CppObject());
+            IL2CPP_BoxedDict = new();
+            IL2CPP_BoxedDict[(Il2CppSystem.String)"one"] = new Il2CppSystem.Int32 { m_value = 1 }.BoxIl2CppObject();
+            IL2CPP_BoxedDict[(Il2CppSystem.String)"two"] = new Il2CppSystem.Int32 { m_value = 2 }.BoxIl2CppObject();
+            IL2CPP_BoxedDict[(Il2CppSystem.String)"three"] = new Il2CppSystem.Int32 { m_value = 3 }.BoxIl2CppObject();
+            IL2CPP_BoxedDict[(Il2CppSystem.String)"four"] = new Il2CppSystem.Int32 { m_value = 4 }.BoxIl2CppObject();
 
             ExplorerCore.Log($"IL2CPP 8: List of boxed Il2Cpp Objects");
             IL2CPP_listOfBoxedObjects = new List<Il2CppSystem.Object>();
@@ -248,14 +255,15 @@ namespace UnityExplorer.Tests
             IL2CPP_ReferenceArray[2] = (Il2CppSystem.String)"whats up";
 
             ExplorerCore.Log($"IL2CPP 11: Misc il2cpp members");
-            cppBoxedInt = new Il2CppSystem.Int32() { m_value = 5 }.BoxIl2CppObject();
-            cppInt = new Il2CppSystem.Int32 { m_value = 420 };
-            cppDecimal = new Il2CppSystem.Decimal(1f);
-            cppDecimalBoxed = new Il2CppSystem.Decimal(1f).BoxIl2CppObject();
-            cppVector3Boxed = Vector3.down.BoxIl2CppObject();
+            IL2CPP_BoxedInt = new Il2CppSystem.Int32() { m_value = 5 }.BoxIl2CppObject();
+            IL2CPP_Int = new Il2CppSystem.Int32 { m_value = 420 };
+            IL2CPP_Decimal = new Il2CppSystem.Decimal(1f);
+            IL2CPP_DecimalBoxed = new Il2CppSystem.Decimal(1f).BoxIl2CppObject();
+            IL2CPP_Vector3Boxed = Vector3.down.BoxIl2CppObject();
 
             ExplorerCore.Log($"Finished Init_Il2Cpp");
         }
+
 #endif
     }
 }

src/UI/DisplayManager.cs

@@ -18,7 +18,10 @@ namespace UnityExplorer.UI
         public static int Width => ActiveDisplay.renderingWidth;
         public static int Height => ActiveDisplay.renderingHeight;
 
-        public static Vector3 MousePosition => Display.RelativeMouseAt(InputManager.MousePosition);
+        public static Vector3 MousePosition => Application.isEditor
+            ? InputManager.MousePosition
+            : Display.RelativeMouseAt(InputManager.MousePosition);
+
         public static bool MouseInTargetDisplay => MousePosition.z == ActiveDisplayIndex;
 
         private static Camera canvasCamera;

src/UI/Panels/AutoCompleteModal.cs

@@ -30,13 +30,13 @@ namespace UnityExplorer.UI.Widgets.AutoComplete
         public override int MinWidth => -1;
         public override int MinHeight => -1;
 
-        public override bool CanDragAndResize => false;
+        public override bool CanDragAndResize => true;
         public override bool ShouldSaveActiveState => false;
         public override bool NavButtonWanted => false;
 
         public static ISuggestionProvider CurrentHandler { get; private set; }
 
-        public static ButtonListHandler<Suggestion, ButtonCell> dataHandler;
+        public static ButtonListHandler<Suggestion, ButtonCell> buttonListDataHandler;
         public static ScrollPool<ButtonCell> scrollPool;
         private static GameObject navigationTipRow;
 
@@ -82,7 +82,7 @@ namespace UnityExplorer.UI.Widgets.AutoComplete
             {
                 base.UIRoot.SetActive(true);
                 base.UIRoot.transform.SetAsLastSibling();
-                dataHandler.RefreshData();
+                buttonListDataHandler.RefreshData();
                 scrollPool.Refresh(true, true);
             }
         }
@@ -294,24 +294,44 @@ namespace UnityExplorer.UI.Widgets.AutoComplete
 
         // UI Construction
 
+        const float MIN_X = 0.42f;
+        const float MAX_Y = 0.6f;
+
         protected internal override void DoSetDefaultPosAndAnchors()
         {
             Rect.pivot = new Vector2(0f, 1f);
-            Rect.anchorMin = new Vector2(0.42f, 0.4f);
-            Rect.anchorMax = new Vector2(0.68f, 0.6f);
+            Rect.anchorMin = new Vector2(MIN_X, 0.4f);
+            Rect.anchorMax = new Vector2(0.68f, MAX_Y);
+        }
+
+        public override void OnFinishResize(RectTransform panel)
+        {
+            float xDiff = panel.anchorMin.x - MIN_X;
+            float yDiff = panel.anchorMax.y - MAX_Y;
+
+            if (xDiff != 0 || yDiff != 0)
+            {
+                panel.anchorMin = new(MIN_X, panel.anchorMin.y - yDiff);
+                panel.anchorMax = new(panel.anchorMax.x - xDiff, MAX_Y);
+            }
+
+            base.OnFinishResize(panel);
         }
 
         public override void ConstructPanelContent()
         {
-            dataHandler = new ButtonListHandler<Suggestion, ButtonCell>(scrollPool, GetEntries, SetCell, ShouldDisplay, OnCellClicked);
+            // hide the titlebar
+            this.TitleBar.gameObject.SetActive(false);
 
-            scrollPool = UIFactory.CreateScrollPool<ButtonCell>(this.uiRoot, "AutoCompleter", out GameObject scrollObj,
+            buttonListDataHandler = new ButtonListHandler<Suggestion, ButtonCell>(scrollPool, GetEntries, SetCell, ShouldDisplay, OnCellClicked);
+
+            scrollPool = UIFactory.CreateScrollPool<ButtonCell>(this.uiContent, "AutoCompleter", out GameObject scrollObj,
                 out GameObject scrollContent);
-            scrollPool.Initialize(dataHandler);
+            scrollPool.Initialize(buttonListDataHandler);
             UIFactory.SetLayoutElement(scrollObj, flexibleHeight: 9999);
             UIFactory.SetLayoutGroup<VerticalLayoutGroup>(scrollContent, true, false, true, false);
 
-            navigationTipRow = UIFactory.CreateHorizontalGroup(this.uiRoot, "BottomRow", true, true, true, true, 0, new Vector4(2, 2, 2, 2));
+            navigationTipRow = UIFactory.CreateHorizontalGroup(this.uiContent, "BottomRow", true, true, true, true, 0, new Vector4(2, 2, 2, 2));
             UIFactory.SetLayoutElement(navigationTipRow, minHeight: 20, flexibleWidth: 9999);
             UIFactory.CreateLabel(navigationTipRow, "HelpText", "Up/Down to select, Enter to use, Esc to close",
                 TextAnchor.MiddleLeft, Color.grey, false, 13);

src/UI/Panels/CSConsolePanel.cs

@@ -75,7 +75,7 @@ namespace UnityExplorer.UI.Panels
         {
             // Tools Row
 
-            var toolsRow = UIFactory.CreateHorizontalGroup(this.uiRoot, "ToggleRow", false, false, true, true, 5, new Vector4(8, 8, 10, 5),
+            var toolsRow = UIFactory.CreateHorizontalGroup(this.uiContent, "ToggleRow", false, false, true, true, 5, new Vector4(8, 8, 10, 5),
                 default, TextAnchor.MiddleLeft);
             UIFactory.SetLayoutElement(toolsRow, minHeight: 25, flexibleHeight: 0, flexibleWidth: 9999);
 
@@ -124,7 +124,7 @@ namespace UnityExplorer.UI.Panels
 
             // Console Input
 
-            var inputArea = UIFactory.CreateUIObject("InputGroup", uiRoot);
+            var inputArea = UIFactory.CreateUIObject("InputGroup", uiContent);
             UIFactory.SetLayoutElement(inputArea, flexibleWidth: 9999, flexibleHeight: 9999);
             UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(inputArea, false, true, true, true);
             inputArea.AddComponent<Image>().color = Color.white;

src/UI/Panels/ClipboardPanel.cs

@@ -89,7 +89,7 @@ namespace UnityExplorer.UI.Panels
 
             // Actual panel content
 
-            var firstRow = UIFactory.CreateHorizontalGroup(UIRoot, "FirstRow", false, false, true, true, 5, new(2,2,2,2), new(1,1,1,0));
+            var firstRow = UIFactory.CreateHorizontalGroup(uiContent, "FirstRow", false, false, true, true, 5, new(2,2,2,2), new(1,1,1,0));
             UIFactory.SetLayoutElement(firstRow, minHeight: 25, flexibleWidth: 999);
 
             // Title for "Current Paste:"
@@ -102,7 +102,7 @@ namespace UnityExplorer.UI.Panels
             clearButton.OnClick += () => Copy(null);
 
             // Current Paste info row
-            var currentPasteHolder = UIFactory.CreateHorizontalGroup(UIRoot, "SecondRow", false, false, true, true, 0, 
+            var currentPasteHolder = UIFactory.CreateHorizontalGroup(uiContent, "SecondRow", false, false, true, true, 0, 
                 new(2, 2, 2, 2), childAlignment: TextAnchor.UpperCenter);
 
             // Actual current paste info label

src/UI/Panels/HookManagerPanel.cs

@@ -83,7 +83,7 @@ namespace UnityExplorer.UI.Panels
         {
             // ~~~~~~~~~ Active hooks scroll pool
 
-            currentHooksPanel = UIFactory.CreateUIObject("CurrentHooksPanel", this.uiRoot);
+            currentHooksPanel = UIFactory.CreateUIObject("CurrentHooksPanel", this.uiContent);
             UIFactory.SetLayoutElement(currentHooksPanel, flexibleHeight: 9999, flexibleWidth: 9999);
             UIFactory.SetLayoutGroup<VerticalLayoutGroup>(currentHooksPanel, true, true, true, true);
 
@@ -109,7 +109,7 @@ namespace UnityExplorer.UI.Panels
 
             // ~~~~~~~~~ Add hooks panel
 
-            addHooksPanel = UIFactory.CreateUIObject("AddHooksPanel", this.uiRoot);
+            addHooksPanel = UIFactory.CreateUIObject("AddHooksPanel", this.uiContent);
             UIFactory.SetLayoutElement(addHooksPanel, flexibleHeight: 9999, flexibleWidth: 9999);
             UIFactory.SetLayoutGroup<VerticalLayoutGroup>(addHooksPanel, true, true, true, true);
 
@@ -136,7 +136,7 @@ namespace UnityExplorer.UI.Panels
 
             // ~~~~~~~~~ Hook source editor panel
 
-            editorPanel = UIFactory.CreateUIObject("HookSourceEditor", this.uiRoot);
+            editorPanel = UIFactory.CreateUIObject("HookSourceEditor", this.uiContent);
             UIFactory.SetLayoutElement(editorPanel, flexibleHeight: 9999, flexibleWidth: 9999);
             UIFactory.SetLayoutGroup<VerticalLayoutGroup>(editorPanel, true, true, true, true);
 

src/UI/Panels/InspectorPanel.cs

@@ -54,12 +54,12 @@ namespace UnityExplorer.UI.Panels
 
         public override void ConstructPanelContent()
         {
-            var closeHolder = this.titleBar.transform.Find("CloseHolder").gameObject;
+            var closeHolder = this.TitleBar.transform.Find("CloseHolder").gameObject;
 
             // Inspect under mouse dropdown on title bar
 
             var mouseDropdown = UIFactory.CreateDropdown(closeHolder, "MouseInspectDropdown", out MouseInspectDropdown, "Mouse Inspect", 14,
-                InspectUnderMouse.OnDropdownSelect);
+                MouseInspector.OnDropdownSelect);
             UIFactory.SetLayoutElement(mouseDropdown, minHeight: 25, minWidth: 140);
             MouseInspectDropdown.options.Add(new Dropdown.OptionData("Mouse Inspect"));
             MouseInspectDropdown.options.Add(new Dropdown.OptionData("World"));
@@ -76,14 +76,14 @@ namespace UnityExplorer.UI.Panels
 
             // this.UIRoot.GetComponent<Mask>().enabled = false;
 
-            UIFactory.SetLayoutGroup<VerticalLayoutGroup>(this.uiRoot, true, true, true, true, 4, padLeft: 5, padRight: 5);
+            UIFactory.SetLayoutGroup<VerticalLayoutGroup>(this.uiContent, true, true, true, true, 4, padLeft: 5, padRight: 5);
 
-            this.NavbarHolder = UIFactory.CreateGridGroup(this.uiRoot, "Navbar", new Vector2(200, 22), new Vector2(4, 4),
+            this.NavbarHolder = UIFactory.CreateGridGroup(this.uiContent, "Navbar", new Vector2(200, 22), new Vector2(4, 4),
                 new Color(0.05f, 0.05f, 0.05f));
             //UIFactory.SetLayoutElement(NavbarHolder, flexibleWidth: 9999, minHeight: 0, preferredHeight: 0, flexibleHeight: 9999);
             NavbarHolder.AddComponent<ContentSizeFitter>().verticalFit = ContentSizeFitter.FitMode.PreferredSize;
 
-            this.ContentHolder = UIFactory.CreateVerticalGroup(this.uiRoot, "ContentHolder", true, true, true, true, 0, default,
+            this.ContentHolder = UIFactory.CreateVerticalGroup(this.uiContent, "ContentHolder", true, true, true, true, 0, default,
                 new Color(0.1f, 0.1f, 0.1f));
             UIFactory.SetLayoutElement(ContentHolder, flexibleHeight: 9999);
             ContentRect = ContentHolder.GetComponent<RectTransform>();

src/UI/Panels/LogPanel.cs

@@ -161,13 +161,13 @@ namespace UnityExplorer.UI.Panels
         {
             // Log scroll pool
 
-            logScrollPool = UIFactory.CreateScrollPool<ConsoleLogCell>(this.uiRoot, "Logs", out GameObject scrollObj,
+            logScrollPool = UIFactory.CreateScrollPool<ConsoleLogCell>(this.uiContent, "Logs", out GameObject scrollObj,
                 out GameObject scrollContent, new Color(0.03f, 0.03f, 0.03f));
             UIFactory.SetLayoutElement(scrollObj, flexibleWidth: 9999, flexibleHeight: 9999);
 
             // Buttons and toggles
 
-            var optionsRow = UIFactory.CreateUIObject("OptionsRow", this.uiRoot);
+            var optionsRow = UIFactory.CreateUIObject("OptionsRow", this.uiContent);
             UIFactory.SetLayoutElement(optionsRow, minHeight: 25, flexibleWidth: 9999);
             UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(optionsRow, false, false, true, true, 5, 2, 2, 2, 2);
 

src/UI/Panels/ObjectExplorerPanel.cs

@@ -99,17 +99,17 @@ namespace UnityExplorer.UI.Panels
         public override void ConstructPanelContent()
         {
             // Tab bar
-            var tabGroup = UIFactory.CreateHorizontalGroup(uiRoot, "TabBar", true, true, true, true, 2, new Vector4(2, 2, 2, 2));
+            var tabGroup = UIFactory.CreateHorizontalGroup(uiContent, "TabBar", true, true, true, true, 2, new Vector4(2, 2, 2, 2));
             UIFactory.SetLayoutElement(tabGroup, minHeight: 25, flexibleHeight: 0);
 
             // Scene Explorer
             SceneExplorer = new SceneExplorer(this);
-            SceneExplorer.ConstructUI(uiRoot);
+            SceneExplorer.ConstructUI(uiContent);
             tabPages.Add(SceneExplorer);
 
             // Object search
             ObjectSearch = new ObjectSearch(this);
-            ObjectSearch.ConstructUI(uiRoot);
+            ObjectSearch.ConstructUI(uiContent);
             tabPages.Add(ObjectSearch);
 
             // set up tabs

src/UI/Panels/OptionsPanel.cs

@@ -71,13 +71,13 @@ namespace UnityExplorer.UI.Panels
         {
             // Save button
 
-            var saveBtn = UIFactory.CreateButton(this.uiRoot, "Save", "Save Options", new Color(0.2f, 0.3f, 0.2f));
+            var saveBtn = UIFactory.CreateButton(this.uiContent, "Save", "Save Options", new Color(0.2f, 0.3f, 0.2f));
             UIFactory.SetLayoutElement(saveBtn.Component.gameObject, flexibleWidth: 9999, minHeight: 30, flexibleHeight: 0);
             saveBtn.OnClick += ConfigManager.Handler.SaveConfig;
 
             // Config entries
 
-            var scrollPool = UIFactory.CreateScrollPool<ConfigEntryCell>(this.uiRoot, "ConfigEntries", out GameObject scrollObj,
+            var scrollPool = UIFactory.CreateScrollPool<ConfigEntryCell>(this.uiContent, "ConfigEntries", out GameObject scrollObj,
                 out GameObject scrollContent);
 
             scrollPool.Initialize(this);

src/UI/Panels/PanelDragger.cs

@@ -471,6 +471,9 @@ namespace UnityExplorer.UI.Panels
             {
                 var text = UIFactory.CreateLabel(UIManager.UIRoot, "ResizeCursor", "↔", TextAnchor.MiddleCenter, Color.white, true, 35);
                 resizeCursorObj = text.gameObject;
+                var outline = text.gameObject.AddComponent<Outline>();
+                outline.effectColor = Color.black;
+                outline.effectDistance = new(1, 1);
 
                 RectTransform rect = resizeCursorObj.GetComponent<RectTransform>();
                 rect.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, 64);

src/UI/Panels/UIPanel.cs

@@ -87,13 +87,14 @@ namespace UnityExplorer.UI.Panels
         public virtual bool CanDragAndResize => true;
         public virtual bool NavButtonWanted => true;
 
-        public ButtonRef NavButton;
-        public PanelDragger Dragger;
+        public ButtonRef NavButton { get; internal set; }
+        public PanelDragger Dragger { get; internal set; }
 
         public override GameObject UIRoot => uiRoot;
         protected GameObject uiRoot;
-        public RectTransform Rect;
-        public GameObject titleBar;
+        protected GameObject uiContent;
+        public RectTransform Rect { get; private set; }
+        public GameObject TitleBar { get; private set; }
 
         public virtual void OnFinishResize(RectTransform panel)
         {
@@ -107,22 +108,27 @@ namespace UnityExplorer.UI.Panels
 
         public override void SetActive(bool active)
         {
-            if (this.Enabled == active)
-                return;
-
-            base.SetActive(active);
-
-            if (!ApplyingSaveData)
-                SaveInternalData();
-
-            if (NavButtonWanted)
+            if (this.Enabled != active)
             {
-                var color = active ? UniversalUI.EnabledButtonColor : UniversalUI.DisabledButtonColor;
-                RuntimeHelper.SetColorBlock(NavButton.Component, color, color * 1.2f);
+                base.SetActive(active);
+
+                if (!ApplyingSaveData)
+                    SaveInternalData();
+
+                if (NavButtonWanted)
+                {
+                    var color = active ? UniversalUI.EnabledButtonColor : UniversalUI.DisabledButtonColor;
+                    RuntimeHelper.SetColorBlock(NavButton.Component, color, color * 1.2f);
+                }
             }
 
             if (!active)
                 this.Dragger.WasDragging = false;
+            else
+            {
+                this.UIRoot.transform.SetAsLastSibling();
+                InvokeOnPanelsReordered();
+            }
         }
 
         public override void Destroy()
@@ -247,29 +253,28 @@ namespace UnityExplorer.UI.Panels
             }
 
             // create core canvas 
-            uiRoot = UIFactory.CreatePanel(Name, UIManager.PanelHolder);
+            uiRoot = UIFactory.CreatePanel(Name, UIManager.PanelHolder, out uiContent);
             Rect = this.uiRoot.GetComponent<RectTransform>();
-            UIFactory.SetLayoutGroup<VerticalLayoutGroup>(this.uiRoot, false, false, true, true, 2, 2, 2, 2, 2, TextAnchor.UpperLeft);
+            //UIFactory.SetLayoutGroup<VerticalLayoutGroup>(this.uiRoot, false, false, true, true, 0, 2, 2, 2, 2, TextAnchor.UpperLeft);
 
             int id = this.uiRoot.transform.GetInstanceID();
             transformToPanelDict.Add(id, this);
 
-            //content = panelContent;
-            //UIFactory.SetLayoutGroup<VerticalLayoutGroup>(this.content, false, false, true, true, 2, 2, 2, 2, 2, TextAnchor.UpperLeft);
+            UIFactory.SetLayoutGroup<VerticalLayoutGroup>(this.uiContent, false, false, true, true, 2, 2, 2, 2, 2, TextAnchor.UpperLeft);
 
             // Title bar
-            titleBar = UIFactory.CreateHorizontalGroup(uiRoot, "TitleBar", false, true, true, true, 2,
+            TitleBar = UIFactory.CreateHorizontalGroup(uiContent, "TitleBar", false, true, true, true, 2,
                 new Vector4(2, 2, 2, 2), new Color(0.06f, 0.06f, 0.06f));
-            UIFactory.SetLayoutElement(titleBar, minHeight: 25, flexibleHeight: 0);
+            UIFactory.SetLayoutElement(TitleBar, minHeight: 25, flexibleHeight: 0);
 
             // Title text
 
-            var titleTxt = UIFactory.CreateLabel(titleBar, "TitleBar", Name, TextAnchor.MiddleLeft);
+            var titleTxt = UIFactory.CreateLabel(TitleBar, "TitleBar", Name, TextAnchor.MiddleLeft);
             UIFactory.SetLayoutElement(titleTxt.gameObject, minWidth: 250, minHeight: 25, flexibleHeight: 0);
 
             // close button
 
-            var closeHolder = UIFactory.CreateUIObject("CloseHolder", titleBar);
+            var closeHolder = UIFactory.CreateUIObject("CloseHolder", TitleBar);
             UIFactory.SetLayoutElement(closeHolder, minHeight: 25, flexibleHeight: 0, minWidth: 30, flexibleWidth: 9999);
             UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(closeHolder, false, false, true, true, 3, childAlignment: TextAnchor.MiddleRight);
             var closeBtn = UIFactory.CreateButton(closeHolder, "CloseButton", "—");
@@ -283,11 +288,11 @@ namespace UnityExplorer.UI.Panels
             };
 
             if (!CanDragAndResize)
-                titleBar.SetActive(false);
+                TitleBar.SetActive(false);
 
             // Panel dragger
 
-            Dragger = new PanelDragger(titleBar.GetComponent<RectTransform>(), Rect, this);
+            Dragger = new PanelDragger(TitleBar.GetComponent<RectTransform>(), Rect, this);
             Dragger.OnFinishResize += OnFinishResize;
             Dragger.OnFinishDrag += OnFinishDrag;
 

src/UI/Panels/UiInspectorResultsPanel.cs

@@ -61,7 +61,7 @@ namespace UnityExplorer.UI.Panels
         {
             dataHandler = new ButtonListHandler<GameObject, ButtonCell>(buttonScrollPool, GetEntries, SetCell, ShouldDisplayCell, OnCellClicked);
 
-            buttonScrollPool = UIFactory.CreateScrollPool<ButtonCell>(this.uiRoot, "ResultsList", out GameObject scrollObj,
+            buttonScrollPool = UIFactory.CreateScrollPool<ButtonCell>(this.uiContent, "ResultsList", out GameObject scrollObj,
                 out GameObject scrollContent);
 
             buttonScrollPool.Initialize(dataHandler);

src/UI/UIManager.cs

@@ -73,7 +73,7 @@ namespace UnityExplorer.UI
                     return;
 
                 UniversalUI.SetUIActive(ExplorerCore.GUID, value);
-                UniversalUI.SetUIActive(InspectUnderMouse.UIBaseGUID, value);
+                UniversalUI.SetUIActive(MouseInspector.UIBaseGUID, value);
             }
         }
 
@@ -88,7 +88,7 @@ namespace UnityExplorer.UI
 
             DisplayManager.Init();
 
-            var display = DisplayManager.ActiveDisplay;
+            Display display = DisplayManager.ActiveDisplay;
             lastScreenWidth = display.renderingWidth;
             lastScreenHeight = display.renderingHeight;
 
@@ -106,7 +106,7 @@ namespace UnityExplorer.UI
             UIPanels.Add(Panels.ConsoleLog, new LogPanel());
             UIPanels.Add(Panels.Options, new OptionsPanel());
             UIPanels.Add(Panels.UIInspectorResults, new UiInspectorResultsPanel());
-            UIPanels.Add(Panels.MouseInspector, new InspectUnderMouse());
+            UIPanels.Add(Panels.MouseInspector, new MouseInspector());
 
             foreach (var panel in UIPanels.Values)
                 panel.ConstructUI();
@@ -135,12 +135,9 @@ namespace UnityExplorer.UI
             if (!UIRoot)
                 return;
 
-            // if doing Mouse Inspect, update that and return.
-            if (InspectUnderMouse.Inspecting)
-            {
-                InspectUnderMouse.Instance.UpdateInspect();
+            // If we are doing a Mouse Inspect, we don't need to update anything else.
+            if (MouseInspector.Instance.TryUpdate())
                 return;
-            }
 
             // Update Notification modal
             Notification.Update();
@@ -187,26 +184,21 @@ namespace UnityExplorer.UI
             SetPanelActive(panel, !uiPanel.Enabled);
         }
 
-        public static void SetPanelActive(Panels panel, bool active)
+        public static void SetPanelActive(Panels panelType, bool active)
         {
-            var obj = GetPanel(panel);
-            SetPanelActive(obj, active);
+            GetPanel(panelType)
+                .SetActive(active);
         }
 
         public static void SetPanelActive(UIPanel panel, bool active)
         {
             panel.SetActive(active);
-            if (active)
-            {
-                panel.UIRoot.transform.SetAsLastSibling();
-                UIPanel.InvokeOnPanelsReordered();
-            }
         }
 
         internal static void SetPanelActive(Transform transform, bool value)
         {
             if (UIPanel.transformToPanelDict.TryGetValue(transform.GetInstanceID(), out UIPanel panel))
-                SetPanelActive(panel, value);
+                panel.SetActive(value);
         }
 
         // navbar

src/UI/Widgets/AutoComplete/TypeCompleter.cs

@@ -1,5 +1,7 @@
-using System;
+using HarmonyLib;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using UniverseLib;
 using UniverseLib.UI;
 using UniverseLib.UI.Models;
@@ -25,6 +27,8 @@ namespace UnityExplorer.UI.Widgets.AutoComplete
 
         public Type BaseType { get; set; }
         public Type[] GenericConstraints { get; set; }
+        public bool AllTypes { get; set; }
+
         private readonly bool allowAbstract;
         private readonly bool allowEnum;
 
@@ -58,7 +62,24 @@ namespace UnityExplorer.UI.Widgets.AutoComplete
 
         public void CacheTypes()
         {
-            allowedTypes = ReflectionUtility.GetImplementationsOf(BaseType, allowAbstract, allowEnum, false);
+            if (!AllTypes)
+                allowedTypes = ReflectionUtility.GetImplementationsOf(BaseType, allowAbstract, allowEnum, false);
+            else
+            {
+                allowedTypes = new();
+                foreach (var entry in ReflectionUtility.AllTypes)
+                {
+                    // skip <PrivateImplementationDetails> and <AnonymousClass> classes
+                    var type = entry.Value;
+                    if (type.FullName.Contains("PrivateImplementationDetails")
+                             || type.FullName.Contains("DisplayClass")
+                             || type.FullName.Contains('<'))
+                    {
+                        continue;
+                    }
+                    allowedTypes.Add(type);
+                }
+            }
         }
 
         public void OnSuggestionClicked(Suggestion suggestion)

src/UI/Widgets/EvaluateWidget/EvaluateWidget.cs

@@ -12,6 +12,7 @@ using UniverseLib.UI;
 using UniverseLib;
 using UnityExplorer.CacheObject;
 using UniverseLib.UI.ObjectPool;
+using UniverseLib.Utility;
 
 namespace UnityExplorer.UI.Widgets
 {
@@ -76,6 +77,9 @@ namespace UnityExplorer.UI.Widgets
 
         public object[] TryParseArguments()
         {
+            if (!parameters.Any())
+                return ArgumentUtility.EmptyArgs;
+
             object[] outArgs = new object[parameters.Length];
 
             for (int i = 0; i < parameters.Length; i++)

src/UI/Widgets/TransformTree/CachedTransform.cs

@@ -10,43 +10,50 @@ namespace UnityExplorer.UI.Widgets
     {
         public TransformTree Tree { get; }
         public Transform Value { get; private set; }
-        public int InstanceID { get; private set; }
+        public int InstanceID { get; }
         public CachedTransform Parent { get; internal set; }
 
         public int Depth { get; internal set; }
         public int ChildCount { get; internal set; }
         public string Name { get; internal set; }
         public bool Enabled { get; internal set; }
+        public int SiblingIndex { get; internal set; }
 
-        public bool Expanded => Tree.IsCellExpanded(InstanceID);
+        public bool Expanded => Tree.IsTransformExpanded(InstanceID);
 
         public CachedTransform(TransformTree tree, Transform transform, int depth, CachedTransform parent = null)
         {
+            InstanceID = transform.GetInstanceID();
+
             Tree = tree;
             Value = transform;
             Parent = parent;
-            InstanceID = transform.GetInstanceID();
+            SiblingIndex = transform.GetSiblingIndex();
             Update(transform, depth);
         }
 
         public bool Update(Transform transform, int depth)
         {
-            bool ret = false;
+            bool changed = false;
 
             if (Value != transform
                 || depth != Depth
                 || ChildCount != transform.childCount
                 || Name != transform.name
-                || Enabled != transform.gameObject.activeSelf)
+                || Enabled != transform.gameObject.activeSelf
+                || SiblingIndex != transform.GetSiblingIndex())
             {
+                changed = true;
+
                 Value = transform;
                 Depth = depth;
                 ChildCount = transform.childCount;
                 Name = transform.name;
                 Enabled = transform.gameObject.activeSelf;
-                ret = true;
+                SiblingIndex = transform.GetSiblingIndex();
             }
-            return ret;
+
+            return changed;
         }
     }
 }

src/UI/Widgets/TransformTree/TransformCell.cs

@@ -13,6 +13,7 @@ using UniverseLib.UI;
 using UniverseLib.UI.Models;
 using UniverseLib.UI.Widgets;
 using UniverseLib.UI.Widgets.ScrollView;
+using UniverseLib.Utility;
 
 namespace UnityExplorer.UI.Widgets
 {
@@ -28,7 +29,6 @@ namespace UnityExplorer.UI.Widgets
         public Action<GameObject> OnGameObjectClicked;
 
         public CachedTransform cachedTransform;
-        public int cellIndex;
 
         public GameObject UIRoot { get; set; }
         public RectTransform Rect { get; set; }
@@ -36,6 +36,7 @@ namespace UnityExplorer.UI.Widgets
         public ButtonRef ExpandButton;
         public ButtonRef NameButton;
         public Toggle EnabledToggle;
+        public InputFieldRef SiblingIndex;
 
         public LayoutElement spacer;
 
@@ -51,7 +52,7 @@ namespace UnityExplorer.UI.Widgets
             UIRoot.SetActive(false);
         }
 
-        public void ConfigureCell(CachedTransform cached, int cellIndex)
+        public void ConfigureCell(CachedTransform cached)
         {
             if (cached == null)
             {
@@ -62,7 +63,6 @@ namespace UnityExplorer.UI.Widgets
             if (!Enabled)
                 Enable();
 
-            this.cellIndex = cellIndex;
             cachedTransform = cached;
 
             spacer.minWidth = cached.Depth * 15;
@@ -77,6 +77,15 @@ namespace UnityExplorer.UI.Widgets
 
                 EnabledToggle.Set(cached.Value.gameObject.activeSelf, false);
 
+                if (!cached.Value.parent)
+                    SiblingIndex.GameObject.SetActive(false);
+                else
+                {
+                    SiblingIndex.GameObject.SetActive(true);
+                    if (!SiblingIndex.Component.isFocused)
+                        SiblingIndex.Text = cached.Value.GetSiblingIndex().ToString();
+                }
+
                 int childCount = cached.Value.childCount;
                 if (childCount > 0)
                 {
@@ -97,6 +106,8 @@ namespace UnityExplorer.UI.Widgets
             {
                 NameButton.ButtonText.text = $"[Destroyed]";
                 NameButton.ButtonText.color = Color.red;
+
+                SiblingIndex.GameObject.SetActive(false);
             }
         }
 
@@ -118,6 +129,17 @@ namespace UnityExplorer.UI.Widgets
             OnEnableToggled?.Invoke(cachedTransform);
         }
 
+        private void OnSiblingIndexEndEdit(string input)
+        {
+            if (this.cachedTransform == null || !this.cachedTransform.Value)
+                return;
+
+            if (int.TryParse(input.Trim(), out int index))
+                this.cachedTransform.Value.SetSiblingIndex(index);
+            
+            this.SiblingIndex.Text = this.cachedTransform.Value.GetSiblingIndex().ToString();
+        }
+
         public GameObject CreateContent(GameObject parent)
         {
             UIRoot = UIFactory.CreateUIObject("TransformCell", parent);
@@ -129,7 +151,7 @@ namespace UnityExplorer.UI.Widgets
             Rect.sizeDelta = new Vector2(25, 25);
             UIFactory.SetLayoutElement(UIRoot, minWidth: 100, flexibleWidth: 9999, minHeight: 25, flexibleHeight: 0);
 
-            var spacerObj = UIFactory.CreateUIObject("Spacer", UIRoot, new Vector2(0, 0));
+            GameObject spacerObj = UIFactory.CreateUIObject("Spacer", UIRoot, new Vector2(0, 0));
             UIFactory.SetLayoutElement(spacerObj, minWidth: 0, flexibleWidth: 0, minHeight: 0, flexibleHeight: 0);
             this.spacer = spacerObj.GetComponent<LayoutElement>();
 
@@ -140,22 +162,39 @@ namespace UnityExplorer.UI.Widgets
 
             // Enabled toggle
 
-            var toggleObj = UIFactory.CreateToggle(UIRoot, "BehaviourToggle", out EnabledToggle, out var behavText, default, 17, 17);
+            GameObject toggleObj = UIFactory.CreateToggle(UIRoot, "BehaviourToggle", out EnabledToggle, out Text behavText, default, 17, 17);
             UIFactory.SetLayoutElement(toggleObj, minHeight: 17, flexibleHeight: 0, minWidth: 17);
             EnabledToggle.onValueChanged.AddListener(OnEnableClicked);
 
             // Name button
 
-            NameButton = UIFactory.CreateButton(this.UIRoot, "NameButton", "Name", null);
+            GameObject nameBtnHolder = UIFactory.CreateHorizontalGroup(this.UIRoot, "NameButtonHolder", 
+                false, false, true, true, childAlignment: TextAnchor.MiddleLeft);
+            UIFactory.SetLayoutElement(nameBtnHolder, flexibleWidth: 9999, minHeight: 25, flexibleHeight: 0);
+            nameBtnHolder.AddComponent<Mask>().showMaskGraphic = false;
+
+            NameButton = UIFactory.CreateButton(nameBtnHolder, "NameButton", "Name", null);
             UIFactory.SetLayoutElement(NameButton.Component.gameObject, flexibleWidth: 9999, minHeight: 25, flexibleHeight: 0);
-            var nameLabel = NameButton.Component.GetComponentInChildren<Text>();
+            Text nameLabel = NameButton.Component.GetComponentInChildren<Text>();
             nameLabel.horizontalOverflow = HorizontalWrapMode.Overflow;
             nameLabel.alignment = TextAnchor.MiddleLeft;
 
-            Color normal = new Color(0.11f, 0.11f, 0.11f);
-            Color highlight = new Color(0.25f, 0.25f, 0.25f);
-            Color pressed = new Color(0.05f, 0.05f, 0.05f);
-            Color disabled = new Color(1, 1, 1, 0);
+            // Sibling index input
+
+            SiblingIndex = UIFactory.CreateInputField(this.UIRoot, "SiblingIndexInput", string.Empty);
+            SiblingIndex.Component.textComponent.fontSize = 11;
+            SiblingIndex.Component.textComponent.alignment = TextAnchor.MiddleRight;
+            Image siblingImage = SiblingIndex.GameObject.GetComponent<Image>();
+            siblingImage.color = new(0f, 0f, 0f, 0.25f);
+            UIFactory.SetLayoutElement(SiblingIndex.GameObject, 35, 20, 0, 0);
+            SiblingIndex.Component.GetOnEndEdit().AddListener(OnSiblingIndexEndEdit);
+
+            // Setup selectables
+
+            Color normal = new(0.11f, 0.11f, 0.11f);
+            Color highlight = new(0.25f, 0.25f, 0.25f);
+            Color pressed = new(0.05f, 0.05f, 0.05f);
+            Color disabled = new(1, 1, 1, 0);
             RuntimeHelper.SetColorBlock(ExpandButton.Component, normal, highlight, pressed, disabled);
             RuntimeHelper.SetColorBlock(NameButton.Component, normal, highlight, pressed, disabled);
 

src/UI/Widgets/TransformTree/TransformTree.cs

@@ -2,12 +2,9 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Specialized;
-using System.Linq;
-using System.Text;
+using System.Diagnostics;
 using UnityEngine;
-using UnityEngine.UI;
 using UniverseLib;
-using UniverseLib.UI.Widgets;
 using UniverseLib.UI.Widgets.ScrollView;
 using UniverseLib.Utility;
 
@@ -20,22 +17,36 @@ namespace UnityExplorer.UI.Widgets
 
         public ScrollPool<TransformCell> ScrollPool;
 
+        // IMPORTANT CAVEAT WITH OrderedDictionary:
+        // While the performance is mostly good, there are two methods we should NEVER use:
+        // - Remove(object)
+        // - set_Item[object]
+        // These two methods have extremely bad performance due to using IndexOfKey(), which iterates the whole dictionary.
+        // Currently we do not use either of these methods, so everything should be constant time lookups.
+        // We DO make use of get_Item[object], get_Item[index], Add, Insert, Contains and RemoveAt, which OrderedDictionary meets our needs for.
         /// <summary>
         /// Key: UnityEngine.Transform instance ID<br/>
         /// Value: CachedTransform
         /// </summary>
-        internal readonly OrderedDictionary cachedTransforms = new OrderedDictionary();
+        internal readonly OrderedDictionary cachedTransforms = new();
 
         // for keeping track of which actual transforms are expanded or not, outside of the cache data.
-        private readonly HashSet<int> expandedInstanceIDs = new HashSet<int>();
-        private readonly HashSet<int> autoExpandedIDs = new HashSet<int>();
+        private readonly HashSet<int> expandedInstanceIDs = new();
+        private readonly HashSet<int> autoExpandedIDs = new();
 
-        private readonly HashSet<int> visited = new HashSet<int>();
-        private bool needRefresh;
+        // state for Traverse parse
+        private readonly HashSet<int> visited = new();
+        private bool needRefreshUI;
         private int displayIndex;
+        int prevDisplayIndex;
 
-        public int ItemCount => cachedTransforms.Count;
+        private Coroutine refreshCoroutine;
+        private readonly Stopwatch traversedThisFrame = new();
 
+        // ScrollPool item count. PrevDisplayIndex is the highest index + 1 from our last traverse.
+        public int ItemCount => prevDisplayIndex;
+
+        // Search filter
         public bool Filtering => !string.IsNullOrEmpty(currentFilter);
         private bool wasFiltering;
 
@@ -62,44 +73,24 @@ namespace UnityExplorer.UI.Widgets
             GetRootEntriesMethod = getRootEntriesMethod;
         }
 
-        public void OnCellBorrowed(TransformCell cell)
-        {
-            cell.OnExpandToggled += OnCellExpandToggled;
-            cell.OnGameObjectClicked += OnGameObjectClicked;
-            cell.OnEnableToggled += OnCellEnableToggled;
-        }
-
-        private void OnGameObjectClicked(GameObject obj)
-        {
-            if (OnClickOverrideHandler != null)
-                OnClickOverrideHandler.Invoke(obj);
-            else
-                InspectorManager.Inspect(obj);
-        }
-
-        public void OnCellExpandToggled(CachedTransform cache)
-        {
-            var instanceID = cache.InstanceID;
-            if (expandedInstanceIDs.Contains(instanceID))
-                expandedInstanceIDs.Remove(instanceID);
-            else
-                expandedInstanceIDs.Add(instanceID);
-
-            RefreshData(true);
-        }
-
-        public void OnCellEnableToggled(CachedTransform cache)
-        {
-            cache.Value.gameObject.SetActive(!cache.Value.gameObject.activeSelf);
-
-            RefreshData(true);
-        }
+        // Initialize and reset
 
+        // Must be called externally from owner of this TransformTree
         public void Init()
         {
             ScrollPool.Initialize(this);
         }
 
+        // Called to completely reset the tree, ie. switching inspected GameObject
+        public void Rebuild()
+        {
+            autoExpandedIDs.Clear();
+            expandedInstanceIDs.Clear();
+
+            RefreshData(true, true, true, false);
+        }
+
+        // Called to completely wipe our data (ie, GameObject inspector returning to pool)
         public void Clear()
         {
             this.cachedTransforms.Clear();
@@ -107,14 +98,21 @@ namespace UnityExplorer.UI.Widgets
             autoExpandedIDs.Clear();
             expandedInstanceIDs.Clear();
             this.ScrollPool.Refresh(true, true);
+            if (refreshCoroutine != null)
+            {
+                RuntimeHelper.StopCoroutine(refreshCoroutine);
+                refreshCoroutine = null;
+            }
         }
 
-        public bool IsCellExpanded(int instanceID)
+        // Checks if the given Instance ID is expanded or not
+        public bool IsTransformExpanded(int instanceID)
         {
             return Filtering ? autoExpandedIDs.Contains(instanceID)
                              : expandedInstanceIDs.Contains(instanceID);
         }
 
+        // Jumps to a specific Transform in the tree and highlights it.
         public void JumpAndExpandToTransform(Transform transform)
         {
             // make sure all parents of the object are expanded
@@ -128,8 +126,9 @@ namespace UnityExplorer.UI.Widgets
                 parent = parent.parent;
             }
 
-            // Refresh cached transforms (no UI rebuild yet)
-            RefreshData(false);
+            // Refresh cached transforms (no UI rebuild yet).
+            // Stop existing coroutine and do it oneshot.
+            RefreshData(false, false, true, true);
 
             int transformID = transform.GetInstanceID();
 
@@ -162,81 +161,119 @@ namespace UnityExplorer.UI.Widgets
             button.OnDeselect(null);
         }
 
-        public void Rebuild()
+        // Perform a Traverse and optionally refresh the ScrollPool as well.
+        // If oneShot, then this happens instantly with no yield.
+        public void RefreshData(bool andRefreshUI, bool jumpToTop, bool stopExistingCoroutine, bool oneShot)
         {
-            autoExpandedIDs.Clear();
-            expandedInstanceIDs.Clear();
+            if (refreshCoroutine != null)
+            {
+                if (stopExistingCoroutine)
+                {
+                    RuntimeHelper.StopCoroutine(refreshCoroutine);
+                    refreshCoroutine = null;
+                }
+                else
+                    return;
+            }
 
-            RefreshData(true, true);
-        }
-
-        public void RefreshData(bool andReload = false, bool jumpToTop = false)
-        {
             visited.Clear();
             displayIndex = 0;
-            needRefresh = false;
+            needRefreshUI = false;
+            traversedThisFrame.Reset();
+            traversedThisFrame.Start();
 
-            var rootObjects = GetRootEntriesMethod.Invoke();
+            refreshCoroutine = RuntimeHelper.StartCoroutine(RefreshCoroutine(andRefreshUI, jumpToTop, oneShot));
+        }
 
-            //int displayIndex = 0;
-            foreach (var obj in rootObjects)
-                if (obj) Traverse(obj.transform);
+        IEnumerator RefreshCoroutine(bool andRefreshUI, bool jumpToTop, bool oneShot)
+        {
+            // Instead of doing string.IsNullOrEmpty(CurrentFilter) many times, let's just do it once per update.
+            bool filtering = Filtering;
+
+            IEnumerable<GameObject> rootObjects = GetRootEntriesMethod();
+            foreach (var gameObj in rootObjects)
+            {
+                if (!gameObj)
+                    continue;
+
+                IEnumerator enumerator = Traverse(gameObj.transform, null, 0, oneShot, filtering);
+                while (enumerator.MoveNext())
+                {
+                    if (!oneShot)
+                        yield return enumerator.Current;
+                }
+            }
 
             // Prune displayed transforms that we didnt visit in that traverse
             for (int i = cachedTransforms.Count - 1; i >= 0; i--)
             {
-                var obj = (CachedTransform)cachedTransforms[i];
-                if (!visited.Contains(obj.InstanceID))
+                var cached = (CachedTransform)cachedTransforms[i];
+                if (!visited.Contains(cached.InstanceID))
                 {
-                    cachedTransforms.Remove(obj.InstanceID);
-                    needRefresh = true;
+                    cachedTransforms.RemoveAt(i);
+                    needRefreshUI = true;
                 }
             }
 
-            if (!needRefresh)
-                return;
+            if (andRefreshUI && needRefreshUI)
+                ScrollPool.Refresh(true, jumpToTop);
 
-            //displayedObjects.Clear();
+            prevDisplayIndex = displayIndex;
+            refreshCoroutine = null;
+        }   
 
-            if (andReload)
-            {
-                if (!jumpToTop)
-                    ScrollPool.Refresh(true);
-                else
-                    ScrollPool.Refresh(true, true);
-            }
-        }
-
-        private void Traverse(Transform transform, CachedTransform parent = null, int depth = 0)
+        // Recursive method to check a Transform and its children (if expanded).
+        // Parent and depth can be null/default.
+        private IEnumerator Traverse(Transform transform, CachedTransform parent, int depth, bool oneShot, bool filtering)
         {
+            // Let's only tank 2ms of each frame (60->53fps)
+            if (traversedThisFrame.ElapsedMilliseconds > 2)
+            {
+                yield return null;
+                traversedThisFrame.Reset();
+                traversedThisFrame.Start();
+            }
+
             int instanceID = transform.GetInstanceID();
 
+            // Unlikely, but since this method is async it could theoretically happen in extremely rare circumstances
             if (visited.Contains(instanceID))
-                return;
+                yield break;
 
-            if (Filtering)
+            if (filtering)
             {
                 if (!FilterHierarchy(transform))
-                    return;
-
-                visited.Add(instanceID);
+                    yield break;
 
                 if (!autoExpandedIDs.Contains(instanceID))
                     autoExpandedIDs.Add(instanceID);
             }
-            else
-                visited.Add(instanceID);
+
+            visited.Add(instanceID);
 
             CachedTransform cached;
             if (cachedTransforms.Contains(instanceID))
             {
                 cached = (CachedTransform)cachedTransforms[(object)instanceID];
+                int prevSiblingIdx = cached.SiblingIndex;
                 if (cached.Update(transform, depth))
-                    needRefresh = true;
+                {
+                    needRefreshUI = true;
+
+                    // If the sibling index changed, we need to shuffle it in our cached transforms list.
+                    if (prevSiblingIdx != cached.SiblingIndex)
+                    {
+                        cachedTransforms.Remove(instanceID);
+                        if (cachedTransforms.Count <= displayIndex)
+                            cachedTransforms.Add(instanceID, cached);
+                        else
+                            cachedTransforms.Insert(displayIndex, instanceID, cached);
+                    }
+                }
             }
             else
             {
-                needRefresh = true;
+                needRefreshUI = true;
                 cached = new CachedTransform(this, transform, depth, parent);
                 if (cachedTransforms.Count <= displayIndex)
                     cachedTransforms.Add(instanceID, cached);
@@ -246,10 +283,19 @@ namespace UnityExplorer.UI.Widgets
 
             displayIndex++;
 
-            if (IsCellExpanded(instanceID) && cached.Value.childCount > 0)
+            if (IsTransformExpanded(instanceID) && cached.Value.childCount > 0)
             {
+                ExplorerCore.Log($"Traversing expanded transform {cached.Value.name} ({cached.InstanceID})");
+
                 for (int i = 0; i < transform.childCount; i++)
-                    Traverse(transform.GetChild(i), cached, depth + 1);
+                {
+                    var enumerator = Traverse(transform.GetChild(i), cached, depth + 1, oneShot, filtering);
+                    while (enumerator.MoveNext())
+                    {
+                        if (!oneShot)
+                            yield return enumerator.Current;
+                    }
+                }
             }
         }
 
@@ -272,17 +318,50 @@ namespace UnityExplorer.UI.Widgets
         {
             if (index < cachedTransforms.Count)
             {
-                cell.ConfigureCell((CachedTransform)cachedTransforms[index], index);
+                cell.ConfigureCell((CachedTransform)cachedTransforms[index]);
                 if (Filtering)
                 {
                     if (cell.cachedTransform.Name.ContainsIgnoreCase(currentFilter))
-                    {
                         cell.NameButton.ButtonText.color = Color.green;
-                    }
                 }
             }
             else
                 cell.Disable();
         }
+
+        public void OnCellBorrowed(TransformCell cell)
+        {
+            cell.OnExpandToggled += OnCellExpandToggled;
+            cell.OnGameObjectClicked += OnGameObjectClicked;
+            cell.OnEnableToggled += OnCellEnableToggled;
+        }
+
+        private void OnGameObjectClicked(GameObject obj)
+        {
+            if (OnClickOverrideHandler != null)
+                OnClickOverrideHandler.Invoke(obj);
+            else
+                InspectorManager.Inspect(obj);
+        }
+
+        public void OnCellExpandToggled(CachedTransform cache)
+        {
+            ExplorerCore.Log($"OnCellExpandToggled: {cache.Value.name} ({cache.InstanceID})");
+
+            var instanceID = cache.InstanceID;
+            if (expandedInstanceIDs.Contains(instanceID))
+                expandedInstanceIDs.Remove(instanceID);
+            else
+                expandedInstanceIDs.Add(instanceID);
+
+            RefreshData(true, false, true, true);
+        }
+
+        public void OnCellEnableToggled(CachedTransform cache)
+        {
+            cache.Value.gameObject.SetActive(!cache.Value.gameObject.activeSelf);
+
+            RefreshData(true, false, true, true);
+        }
     }
 }

src/UI/Widgets/UnityObjects/AudioClipWidget.cs

@@ -0,0 +1,409 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityExplorer.Config;
+using UnityExplorer.Inspectors;
+using UniverseLib;
+using UniverseLib.UI;
+using UniverseLib.UI.Models;
+using UniverseLib.UI.ObjectPool;
+using UniverseLib.Utility;
+
+namespace UnityExplorer.UI.Widgets
+{
+    public class AudioClipWidget : UnityObjectWidget
+    {
+        static GameObject AudioPlayerObject;
+        static AudioSource Source;
+        static AudioClipWidget CurrentlyPlaying;
+        static Coroutine CurrentlyPlayingCoroutine;
+        static readonly string zeroLengthString = GetLengthString(0f);
+
+        public AudioClip RefAudioClip;
+        private string fullLengthText;
+
+        private ButtonRef toggleButton;
+        private bool audioPlayerWanted;
+
+        private GameObject audioPlayerRoot;
+        private ButtonRef playStopButton;
+        private Text progressLabel;
+        private GameObject saveObjectRow;
+        private InputFieldRef savePathInput;
+        private GameObject cantSaveRow;
+
+        public override void OnBorrowed(object target, Type targetType, ReflectionInspector inspector)
+        {
+            base.OnBorrowed(target, targetType, inspector);
+
+            this.audioPlayerRoot.transform.SetParent(inspector.UIRoot.transform);
+            this.audioPlayerRoot.transform.SetSiblingIndex(inspector.UIRoot.transform.childCount - 2);
+
+            RefAudioClip = target.TryCast<AudioClip>();
+            this.fullLengthText = GetLengthString(RefAudioClip.length);
+
+            if (RefAudioClip.loadType == AudioClipLoadType.DecompressOnLoad)
+            {
+                cantSaveRow.SetActive(false);
+                saveObjectRow.SetActive(true);
+                SetDefaultSavePath();
+            }
+            else
+            {
+                cantSaveRow.SetActive(true);
+                saveObjectRow.SetActive(false);
+            }
+
+            ResetProgressLabel();
+        }
+
+        public override void OnReturnToPool()
+        {
+            RefAudioClip = null;
+
+            if (audioPlayerWanted)
+                ToggleAudioWidget();
+
+            if (CurrentlyPlaying == this)
+                StopClip();
+
+            this.audioPlayerRoot.transform.SetParent(Pool<AudioClipWidget>.Instance.InactiveHolder.transform);
+
+            base.OnReturnToPool();
+        }
+
+        private void ToggleAudioWidget()
+        {
+            if (audioPlayerWanted)
+            {
+                audioPlayerWanted = false;
+
+                toggleButton.ButtonText.text = "Show Player";
+                audioPlayerRoot.SetActive(false);
+            }
+            else
+            {
+                audioPlayerWanted = true;
+
+                toggleButton.ButtonText.text = "Hide Player";
+                audioPlayerRoot.SetActive(true);
+            }
+        }
+
+        void SetDefaultSavePath()
+        {
+            string name = RefAudioClip.name;
+            if (string.IsNullOrEmpty(name))
+                name = "untitled";
+            savePathInput.Text = Path.Combine(ConfigManager.Default_Output_Path.Value, $"{name}.wav");
+        }
+
+        static string GetLengthString(float seconds)
+        {
+            TimeSpan ts = TimeSpan.FromSeconds(seconds);
+
+            StringBuilder sb = new();
+
+            if (ts.Hours > 0)
+                sb.Append($"{ts.Hours}:");
+
+            sb.Append($"{ts.Minutes:00}:");
+            sb.Append($"{ts.Seconds:00}:");
+            sb.Append($"{ts.Milliseconds:000}");
+
+            return sb.ToString();
+        }
+
+        private void ResetProgressLabel()
+        {
+            this.progressLabel.text = $"{zeroLengthString} / {fullLengthText}";
+        }
+
+        private void OnPlayStopClicked()
+        {
+            SetupAudioPlayer();
+
+            if (CurrentlyPlaying == this)
+            {
+                // we are playing a clip. stop it.
+                StopClip();
+            }
+            else
+            {
+                // If something else is playing a clip, stop that.
+                if (CurrentlyPlaying != null)
+                    CurrentlyPlaying.StopClip();
+
+                // we want to start playing a clip.
+                CurrentlyPlayingCoroutine = RuntimeHelper.StartCoroutine(PlayClipCoroutine());
+            }
+        }
+
+        static void SetupAudioPlayer()
+        {
+            if (AudioPlayerObject)
+                return;
+
+            AudioPlayerObject = new GameObject("UnityExplorer.AudioPlayer");
+            UnityEngine.Object.DontDestroyOnLoad(AudioPlayerObject);
+            AudioPlayerObject.hideFlags = HideFlags.HideAndDontSave;
+            AudioPlayerObject.transform.position = new(int.MinValue, int.MinValue); // move it as far away as possible
+#if CPP
+            Source = AudioPlayerObject.AddComponent(UnhollowerRuntimeLib.Il2CppType.Of<AudioSource>()).TryCast<AudioSource>();
+#else
+            Source = AudioPlayerObject.AddComponent<AudioSource>();
+#endif
+            AudioPlayerObject.AddComponent<AudioListener>();
+        }
+
+        private IEnumerator PlayClipCoroutine()
+        {
+            playStopButton.ButtonText.text = "Stop Clip";
+            CurrentlyPlaying = this;
+            Source.clip = this.RefAudioClip;
+            Source.Play();
+
+            while (Source.isPlaying)
+            {
+                progressLabel.text = $"{GetLengthString(Source.time)} / {fullLengthText}";
+                yield return null;
+            }
+
+            CurrentlyPlayingCoroutine = null;
+            StopClip();
+        }
+
+        private void StopClip()
+        {
+            if (CurrentlyPlayingCoroutine != null)
+                RuntimeHelper.StopCoroutine(CurrentlyPlayingCoroutine);
+
+            Source.Stop();
+            CurrentlyPlaying = null;
+            CurrentlyPlayingCoroutine = null;
+            playStopButton.ButtonText.text = "Play Clip";
+
+            ResetProgressLabel();
+        }
+
+        public void OnSaveClipClicked()
+        {
+            if (!RefAudioClip)
+            {
+                ExplorerCore.LogWarning("AudioClip is null, maybe it was destroyed?");
+                return;
+            }
+
+            if (string.IsNullOrEmpty(savePathInput.Text))
+            {
+                ExplorerCore.LogWarning("Save path cannot be empty!");
+                return;
+            }
+
+            string path = savePathInput.Text;
+            if (!path.EndsWith(".wav", StringComparison.InvariantCultureIgnoreCase))
+                path += ".wav";
+
+            path = IOUtility.EnsureValidFilePath(path);
+
+            if (File.Exists(path))
+                File.Delete(path);
+
+            SavWav.Save(RefAudioClip, path);
+        }
+
+        public override GameObject CreateContent(GameObject uiRoot)
+        {
+            GameObject ret = base.CreateContent(uiRoot);
+
+            // Toggle Button
+
+            toggleButton = UIFactory.CreateButton(UIRoot, "AudioWidgetToggleButton", "Show Player", new Color(0.2f, 0.3f, 0.2f));
+            toggleButton.Transform.SetSiblingIndex(0);
+            UIFactory.SetLayoutElement(toggleButton.Component.gameObject, minHeight: 25, minWidth: 170);
+            toggleButton.OnClick += ToggleAudioWidget;
+
+            // Actual widget
+
+            audioPlayerRoot = UIFactory.CreateVerticalGroup(uiRoot, "AudioWidget", false, false, true, true, spacing: 5);
+            UIFactory.SetLayoutElement(audioPlayerRoot, flexibleWidth: 9999, flexibleHeight: 50);
+            audioPlayerRoot.SetActive(false);
+
+            // Player 
+
+            GameObject playerRow = UIFactory.CreateHorizontalGroup(audioPlayerRoot, "PlayerWidget", false, false, true, true,
+                spacing: 5, padding: new() { x = 3f, w = 3f, y = 3f, z = 3f });
+
+            playStopButton = UIFactory.CreateButton(playerRow, "PlayerButton", "Play", normalColor: new(0.2f, 0.4f, 0.2f));
+            playStopButton.OnClick += OnPlayStopClicked;
+            UIFactory.SetLayoutElement(playStopButton.GameObject, minWidth: 60, minHeight: 25);
+
+            progressLabel = UIFactory.CreateLabel(playerRow, "ProgressLabel", "0 / 0");
+            UIFactory.SetLayoutElement(progressLabel.gameObject, flexibleWidth: 9999, minHeight: 25);
+
+            ResetProgressLabel();
+
+            // Save helper
+
+            saveObjectRow = UIFactory.CreateHorizontalGroup(audioPlayerRoot, "SaveRow", false, false, true, true, 2, new Vector4(2, 2, 2, 2),
+                new Color(0.1f, 0.1f, 0.1f));
+
+            ButtonRef saveBtn = UIFactory.CreateButton(saveObjectRow, "SaveButton", "Save .WAV", new Color(0.2f, 0.25f, 0.2f));
+            UIFactory.SetLayoutElement(saveBtn.Component.gameObject, minHeight: 25, minWidth: 100, flexibleWidth: 0);
+            saveBtn.OnClick += OnSaveClipClicked;
+
+            savePathInput = UIFactory.CreateInputField(saveObjectRow, "SaveInput", "...");
+            UIFactory.SetLayoutElement(savePathInput.UIRoot, minHeight: 25, minWidth: 100, flexibleWidth: 9999);
+
+            // cant save label
+            cantSaveRow = UIFactory.CreateHorizontalGroup(audioPlayerRoot, "CantSaveRow", true, true, true, true);
+            UIFactory.SetLayoutElement(cantSaveRow, minHeight: 25, flexibleWidth: 9999);
+            UIFactory.CreateLabel(
+                cantSaveRow,
+                "CantSaveLabel",
+                "Cannot save this AudioClip as the data is compressed or streamed. Try a tool such as AssetRipper to unpack it.",
+                color: Color.grey);
+
+            return ret;
+        }
+    }
+
+#region SavWav
+
+    //	Copyright (c) 2012 Calvin Rien
+    //        http://the.darktable.com
+    //
+    //	This software is provided 'as-is', without any express or implied warranty. In
+    //	no event will the authors be held liable for any damages arising from the use
+    //	of this software.
+    //
+    //	Permission is granted to anyone to use this software for any purpose,
+    //	including commercial applications, and to alter it and redistribute it freely,
+    //	subject to the following restrictions:
+    //
+    //	1. The origin of this software must not be misrepresented; you must not claim
+    //	that you wrote the original software. If you use this software in a product,
+    //	an acknowledgment in the product documentation would be appreciated but is not
+    //	required.
+    //
+    //	2. Altered source versions must be plainly marked as such, and must not be
+    //	misrepresented as being the original software.
+    //
+    //	3. This notice may not be removed or altered from any source distribution.
+    //
+    //  =============================================================================
+    //
+    //  derived from Gregorio Zanon's script
+    //  http://forum.unity3d.com/threads/119295-Writing-AudioListener.GetOutputData-to-wav-problem?p=806734&viewfull=1#post806734
+
+    public static class SavWav
+    {
+        public const int HEADER_SIZE = 44;
+        public const float RESCALE_FACTOR = 32767; // to convert float to Int16
+
+        public static void Save(AudioClip clip, string filepath)
+        {
+            using FileStream fileStream = CreateEmpty(filepath);
+
+            ConvertAndWrite(fileStream, clip);
+            WriteHeader(fileStream, clip);
+        }
+
+        static FileStream CreateEmpty(string filepath)
+        {
+            FileStream fileStream = new(filepath, FileMode.Create);
+            byte emptyByte = default;
+
+            for (int i = 0; i < HEADER_SIZE; i++) //preparing the header
+                fileStream.WriteByte(emptyByte);
+
+            return fileStream;
+        }
+
+        static void ConvertAndWrite(FileStream fileStream, AudioClip clip)
+        {
+#if CPP
+            UnhollowerBaseLib.Il2CppStructArray<float> samples = new float[clip.samples * clip.channels];
+            AudioClip.GetData(clip, samples, clip.samples, 0);
+#else
+            float[] samples = new float[clip.samples * clip.channels];
+            clip.GetData(samples, 0);
+#endif
+
+            int len = samples.Length;
+
+            // converting in 2 float[] steps to Int16[], then Int16[] to Byte[]
+            short[] intData = new short[len];
+
+            // bytesData array is twice the size of dataSource array because a float converted in Int16 is 2 bytes.
+            byte[] bytesData = new byte[len * 2];
+
+            for (int i = 0; i < len; i++)
+            {
+                intData[i] = (short)(samples[i] * RESCALE_FACTOR);
+                byte[] byteArr = BitConverter.GetBytes(intData[i]);
+                byteArr.CopyTo(bytesData, i * 2);
+            }
+
+            fileStream.Write(bytesData, 0, bytesData.Length);
+        }
+
+        static void WriteHeader(FileStream stream, AudioClip clip)
+        {
+            int hz = clip.frequency;
+            int channels = clip.channels;
+            int samples = clip.samples;
+
+            stream.Seek(0, SeekOrigin.Begin);
+
+            byte[] riff = Encoding.UTF8.GetBytes("RIFF");
+            stream.Write(riff, 0, 4);
+
+            byte[] chunkSize = BitConverter.GetBytes(stream.Length - 8);
+            stream.Write(chunkSize, 0, 4);
+
+            byte[] wave = Encoding.ASCII.GetBytes("WAVE");
+            stream.Write(wave, 0, 4);
+
+            byte[] fmt = Encoding.ASCII.GetBytes("fmt ");
+            stream.Write(fmt, 0, 4);
+
+            byte[] subChunk1 = BitConverter.GetBytes(16);
+            stream.Write(subChunk1, 0, 4);
+
+            byte[] audioFormat = BitConverter.GetBytes(1);
+            stream.Write(audioFormat, 0, 2);
+
+            byte[] numChannels = BitConverter.GetBytes(channels);
+            stream.Write(numChannels, 0, 2);
+
+            byte[] sampleRate = BitConverter.GetBytes(hz);
+            stream.Write(sampleRate, 0, 4);
+
+            byte[] byteRate = BitConverter.GetBytes(hz * channels * 2); // sampleRate * bytesPerSample*number of channels, here 44100*2*2
+            stream.Write(byteRate, 0, 4);
+
+            ushort blockAlign = (ushort)(channels * 2);
+            stream.Write(BitConverter.GetBytes(blockAlign), 0, 2);
+
+            ushort bps = 16;
+            byte[] bitsPerSample = BitConverter.GetBytes(bps);
+            stream.Write(bitsPerSample, 0, 2);
+
+            byte[] datastring = Encoding.UTF8.GetBytes("data");
+            stream.Write(datastring, 0, 4);
+
+            byte[] subChunk2 = BitConverter.GetBytes(samples * channels * 2);
+            stream.Write(subChunk2, 0, 4);
+
+            stream.Seek(0, SeekOrigin.Begin);
+        }
+
+#endregion
+    }
+}

src/UI/Widgets/UnityObjects/Texture2DWidget.cs

@@ -0,0 +1,244 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityExplorer.Config;
+using UnityExplorer.Inspectors;
+using UnityExplorer.UI.Panels;
+using UniverseLib;
+using UniverseLib.Runtime;
+using UniverseLib.UI;
+using UniverseLib.UI.Models;
+using UniverseLib.UI.ObjectPool;
+using UniverseLib.Utility;
+
+namespace UnityExplorer.UI.Widgets
+{
+    public class Texture2DWidget : UnityObjectWidget
+    {
+        private Texture2D TextureRef;
+        private float realWidth;
+        private float realHeight;
+
+        private bool textureViewerWanted;
+        private ButtonRef toggleButton;
+
+        private GameObject textureViewerRoot;
+        private InputFieldRef savePathInput;
+        private Image image;
+        private LayoutElement imageLayout;
+
+        public override void OnBorrowed(object target, Type targetType, ReflectionInspector inspector)
+        {
+            base.OnBorrowed(target, targetType, inspector);
+
+            TextureRef = target.TryCast<Texture2D>();
+
+            realWidth = TextureRef.width;
+            realHeight = TextureRef.height;
+
+            if (this.textureViewerRoot)
+                this.textureViewerRoot.transform.SetParent(inspector.UIRoot.transform);
+
+            InspectorPanel.Instance.Dragger.OnFinishResize += OnInspectorFinishResize;
+        }
+
+        public override void OnReturnToPool()
+        {
+            InspectorPanel.Instance.Dragger.OnFinishResize -= OnInspectorFinishResize;
+
+            TextureRef = null;
+
+            if (image.sprite)
+                GameObject.Destroy(image.sprite);
+
+            if (textureViewerWanted)
+                ToggleTextureViewer();
+
+            if (this.textureViewerRoot)
+                this.textureViewerRoot.transform.SetParent(Pool<Texture2DWidget>.Instance.InactiveHolder.transform);
+
+            base.OnReturnToPool();
+        }
+
+        private void ToggleTextureViewer()
+        {
+            if (textureViewerWanted)
+            {
+                // disable
+                textureViewerWanted = false;
+                textureViewerRoot.SetActive(false);
+                toggleButton.ButtonText.text = "View Texture";
+
+                ParentInspector.mainContentHolder.SetActive(true);
+            }
+            else
+            {
+                // enable
+                if (!image.sprite)
+                    SetupTextureViewer();
+
+                SetImageSize();
+
+                textureViewerWanted = true;
+                textureViewerRoot.SetActive(true);
+                toggleButton.ButtonText.text = "Hide Texture";
+
+                ParentInspector.mainContentHolder.gameObject.SetActive(false);
+            }
+        }
+
+        private void SetupTextureViewer()
+        {
+            if (!this.TextureRef)
+                return;
+
+            string name = TextureRef.name;
+            if (string.IsNullOrEmpty(name))
+                name = "untitled";
+            savePathInput.Text = Path.Combine(ConfigManager.Default_Output_Path.Value, $"{name}.png");
+
+            Sprite sprite = TextureHelper.CreateSprite(TextureRef);
+            image.sprite = sprite;
+        }
+
+        private void OnInspectorFinishResize(RectTransform _)
+        {
+            SetImageSize();
+        }
+
+        private void SetImageSize()
+        {
+            if (!imageLayout)
+                return;
+
+            RuntimeHelper.StartCoroutine(SetImageSizeCoro());
+        }
+
+        IEnumerator SetImageSizeCoro()
+        {
+            // let unity rebuild layout etc
+            yield return null;
+
+            RectTransform imageRect = InspectorPanel.Instance.Rect;
+
+            float rectWidth = imageRect.rect.width - 25;
+            float rectHeight = imageRect.rect.height - 196;
+
+            // If our image is smaller than the viewport, just use 100% scaling
+            if (realWidth < rectWidth && realHeight < rectHeight)
+            {
+                imageLayout.minWidth = realWidth;
+                imageLayout.minHeight = realHeight;
+            }
+            else // we will need to scale down the image to fit
+            {
+                // get the ratio of our viewport dimensions to width and height
+                float viewWidthRatio = (float)((decimal)rectWidth / (decimal)realWidth);
+                float viewHeightRatio = (float)((decimal)rectHeight / (decimal)realHeight);
+
+                // if width needs to be scaled more than height
+                if (viewWidthRatio < viewHeightRatio)
+                {
+                    imageLayout.minWidth = realWidth * viewWidthRatio;
+                    imageLayout.minHeight = realHeight * viewWidthRatio;
+                }
+                else // if height needs to be scaled more than width
+                {
+                    imageLayout.minWidth = realWidth * viewHeightRatio;
+                    imageLayout.minHeight = realHeight * viewHeightRatio;
+                }
+            }
+        }
+
+        private void OnSaveTextureClicked()
+        {
+            if (!TextureRef)
+            {
+                ExplorerCore.LogWarning("Texture is null, maybe it was destroyed?");
+                return;
+            }
+
+            if (string.IsNullOrEmpty(savePathInput.Text))
+            {
+                ExplorerCore.LogWarning("Save path cannot be empty!");
+                return;
+            }
+
+            string path = savePathInput.Text;
+            if (!path.EndsWith(".png", StringComparison.InvariantCultureIgnoreCase))
+                path += ".png";
+
+            path = IOUtility.EnsureValidFilePath(path);
+
+            if (File.Exists(path))
+                File.Delete(path);
+
+            Texture2D tex = TextureRef;
+            if (!TextureHelper.IsReadable(tex))
+                tex = TextureHelper.ForceReadTexture(tex);
+
+            byte[] data = TextureHelper.EncodeToPNG(tex);
+            File.WriteAllBytes(path, data);
+
+            if (tex != TextureRef)
+            {
+                // cleanup temp texture if we had to force-read it.
+                GameObject.Destroy(tex);
+            }
+        }
+
+        public override GameObject CreateContent(GameObject uiRoot)
+        {
+            GameObject ret = base.CreateContent(uiRoot);
+
+            // Button
+
+            toggleButton = UIFactory.CreateButton(UIRoot, "TextureButton", "View Texture", new Color(0.2f, 0.3f, 0.2f));
+            toggleButton.Transform.SetSiblingIndex(0);
+            UIFactory.SetLayoutElement(toggleButton.Component.gameObject, minHeight: 25, minWidth: 150);
+            toggleButton.OnClick += ToggleTextureViewer;
+
+            // Texture viewer
+
+            textureViewerRoot = UIFactory.CreateVerticalGroup(uiRoot, "TextureViewer", false, false, true, true, 2, new Vector4(5, 5, 5, 5),
+                new Color(0.1f, 0.1f, 0.1f), childAlignment: TextAnchor.UpperLeft);
+            UIFactory.SetLayoutElement(textureViewerRoot, flexibleWidth: 9999, flexibleHeight: 9999);
+
+            // Save helper
+
+            GameObject saveRowObj = UIFactory.CreateHorizontalGroup(textureViewerRoot, "SaveRow", false, false, true, true, 2, new Vector4(2, 2, 2, 2),
+                new Color(0.1f, 0.1f, 0.1f));
+
+            ButtonRef saveBtn = UIFactory.CreateButton(saveRowObj, "SaveButton", "Save .PNG", new Color(0.2f, 0.25f, 0.2f));
+            UIFactory.SetLayoutElement(saveBtn.Component.gameObject, minHeight: 25, minWidth: 100, flexibleWidth: 0);
+            saveBtn.OnClick += OnSaveTextureClicked;
+
+            savePathInput = UIFactory.CreateInputField(saveRowObj, "SaveInput", "...");
+            UIFactory.SetLayoutElement(savePathInput.UIRoot, minHeight: 25, minWidth: 100, flexibleWidth: 9999);
+
+            // Actual texture viewer
+
+            GameObject imageViewport = UIFactory.CreateVerticalGroup(textureViewerRoot, "ImageViewport", false, false, true, true, 
+                bgColor: new(1,1,1,0), childAlignment: TextAnchor.MiddleCenter);
+            UIFactory.SetLayoutElement(imageViewport, flexibleWidth: 9999, flexibleHeight: 9999);
+
+            GameObject imageHolder = UIFactory.CreateUIObject("ImageHolder", imageViewport);
+            imageLayout = UIFactory.SetLayoutElement(imageHolder, 1, 1, 0, 0);
+
+            var actualImageObj = UIFactory.CreateUIObject("ActualImage", imageHolder);
+            var actualRect = actualImageObj.GetComponent<RectTransform>();
+            actualRect.anchorMin = new(0, 0);
+            actualRect.anchorMax = new(1, 1);
+            image = actualImageObj.AddComponent<Image>();
+
+            textureViewerRoot.SetActive(false);
+
+            return ret;
+        }
+    }
+}

src/UI/Widgets/UnityObjects/UnityObjectWidget.cs

@@ -0,0 +1,131 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityExplorer.Inspectors;
+using UniverseLib;
+using UniverseLib.UI;
+using UniverseLib.UI.Models;
+using UniverseLib.UI.ObjectPool;
+
+namespace UnityExplorer.UI.Widgets
+{
+    public class UnityObjectWidget : IPooledObject
+    {
+        public UnityEngine.Object UnityObjectRef;
+        public Component ComponentRef;
+        public ReflectionInspector ParentInspector;
+
+        protected ButtonRef gameObjectButton;
+        protected InputFieldRef nameInput;
+        protected InputFieldRef instanceIdInput;
+
+        // IPooledObject
+        public GameObject UIRoot { get; set; }
+        public float DefaultHeight => -1;
+
+        public static UnityObjectWidget GetUnityWidget(object target, Type targetType, ReflectionInspector inspector)
+        {
+            if (!typeof(UnityEngine.Object).IsAssignableFrom(targetType))
+                return null;
+
+            UnityObjectWidget widget = target switch
+            {
+                Texture2D => Pool<Texture2DWidget>.Borrow(),
+                AudioClip => Pool<AudioClipWidget>.Borrow(),
+                _ => Pool<UnityObjectWidget>.Borrow()
+            };
+
+            widget.OnBorrowed(target, targetType, inspector);
+
+            return widget;
+        }
+
+        public virtual void OnBorrowed(object target, Type targetType, ReflectionInspector inspector)
+        {
+            this.ParentInspector = inspector ?? throw new ArgumentNullException(nameof(inspector));
+
+            if (!this.UIRoot)
+                CreateContent(inspector.UIRoot);
+            else
+                this.UIRoot.transform.SetParent(inspector.UIRoot.transform);
+
+            this.UIRoot.transform.SetSiblingIndex(inspector.UIRoot.transform.childCount - 2);
+
+            UnityObjectRef = target.TryCast<UnityEngine.Object>();
+            UIRoot.SetActive(true);
+
+            nameInput.Text = UnityObjectRef.name;
+            instanceIdInput.Text = UnityObjectRef.GetInstanceID().ToString();
+
+            if (typeof(Component).IsAssignableFrom(targetType))
+            {
+                ComponentRef = (Component)target.TryCast(typeof(Component));
+                gameObjectButton.Component.gameObject.SetActive(true);
+            }
+            else
+                gameObjectButton.Component.gameObject.SetActive(false);
+        }
+
+        public virtual void OnReturnToPool()
+        {
+            UnityObjectRef = null;
+            ComponentRef = null;
+            ParentInspector = null;
+        }
+
+        // Update
+
+        public virtual void Update()
+        {
+            if (this.UnityObjectRef)
+            {
+                nameInput.Text = UnityObjectRef.name;
+                ParentInspector.Tab.TabText.text = $"{ParentInspector.currentBaseTabText} \"{UnityObjectRef.name}\"";
+            }
+        }
+
+        // UI Listeners
+
+        private void OnGameObjectButtonClicked()
+        {
+            if (!ComponentRef)
+            {
+                ExplorerCore.LogWarning("Component reference is null or destroyed!");
+                return;
+            }
+
+            InspectorManager.Inspect(ComponentRef.gameObject);
+        }
+
+        // UI construction
+
+        public virtual GameObject CreateContent(GameObject uiRoot)
+        {
+            UIRoot = UIFactory.CreateUIObject("UnityObjectRow", uiRoot);
+            UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(UIRoot, false, false, true, true, 5);
+            UIFactory.SetLayoutElement(UIRoot, minHeight: 25, flexibleHeight: 0, flexibleWidth: 9999);
+
+            var nameLabel = UIFactory.CreateLabel(UIRoot, "NameLabel", "Name:", TextAnchor.MiddleLeft, Color.grey);
+            UIFactory.SetLayoutElement(nameLabel.gameObject, minHeight: 25, minWidth: 45, flexibleWidth: 0);
+
+            nameInput = UIFactory.CreateInputField(UIRoot, "NameInput", "untitled");
+            UIFactory.SetLayoutElement(nameInput.UIRoot, minHeight: 25, minWidth: 100, flexibleWidth: 1000);
+            nameInput.Component.readOnly = true;
+
+            gameObjectButton = UIFactory.CreateButton(UIRoot, "GameObjectButton", "Inspect GameObject", new Color(0.2f, 0.2f, 0.2f));
+            UIFactory.SetLayoutElement(gameObjectButton.Component.gameObject, minHeight: 25, minWidth: 160);
+            gameObjectButton.OnClick += OnGameObjectButtonClicked;
+
+            var instanceLabel = UIFactory.CreateLabel(UIRoot, "InstanceLabel", "Instance ID:", TextAnchor.MiddleRight, Color.grey);
+            UIFactory.SetLayoutElement(instanceLabel.gameObject, minHeight: 25, minWidth: 100, flexibleWidth: 0);
+
+            instanceIdInput = UIFactory.CreateInputField(UIRoot, "InstanceIDInput", "ERROR");
+            UIFactory.SetLayoutElement(instanceIdInput.UIRoot, minHeight: 25, minWidth: 100, flexibleWidth: 0);
+            instanceIdInput.Component.readOnly = true;
+
+            UIRoot.SetActive(false);
+
+            return UIRoot;
+        }
+    }
+}

src/UnityExplorer.csproj

@@ -175,13 +175,13 @@
       <Private>False</Private>
     </Reference>
     <Reference Include="UniverseLib.Mono">
-      <HintPath>packages\UniverseLib.1.2.1\lib\net35\UniverseLib.Mono.dll</HintPath>
+      <HintPath>packages\UniverseLib.1.2.18\lib\net35\UniverseLib.Mono.dll</HintPath>
     </Reference>
   </ItemGroup>
   <!-- Il2Cpp refs -->
   <ItemGroup Condition="'$(IsCpp)'=='true'">
     <Reference Include="UniverseLib.IL2CPP">
-      <HintPath>packages\UniverseLib.1.2.1\lib\net472\UniverseLib.IL2CPP.dll</HintPath>
+      <HintPath>packages\UniverseLib.1.2.18\lib\net472\UniverseLib.IL2CPP.dll</HintPath>
     </Reference>
     <Reference Include="UnhollowerBaseLib, Version=0.4.22.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>packages\Il2CppAssemblyUnhollower.BaseLib.0.4.22\lib\net472\UnhollowerBaseLib.dll</HintPath>
@@ -199,6 +199,10 @@
       <HintPath>..\lib\unhollowed\UnityEngine.dll</HintPath>
       <Private>False</Private>
     </Reference>
+    <Reference Include="UnityEngine.AudioModule">
+      <HintPath>..\lib\unhollowed\UnityEngine.AudioModule.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
     <Reference Include="UnityEngine.CoreModule">
       <HintPath>..\lib\unhollowed\UnityEngine.CoreModule.dll</HintPath>
       <Private>False</Private>
@@ -225,6 +229,8 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CacheObject\CacheConstructor.cs" />
+    <Compile Include="CacheObject\CacheMemberFactory.cs" />
     <Compile Include="Hooks\HookCell.cs" />
     <Compile Include="Hooks\HookInstance.cs" />
     <Compile Include="Hooks\HookManager.cs" />
@@ -246,7 +252,7 @@
     <Compile Include="Inspectors\GameObjectWidgets\ComponentCell.cs" />
     <Compile Include="Inspectors\GameObjectWidgets\ComponentList.cs" />
     <Compile Include="Inspectors\GameObjectWidgets\GameObjectControls.cs" />
-    <Compile Include="Inspectors\InspectUnderMouse.cs" />
+    <Compile Include="Inspectors\MouseInspector.cs" />
     <Compile Include="CSConsole\ConsoleController.cs" />
     <Compile Include="CacheObject\CacheField.cs" />
     <Compile Include="CacheObject\CacheKeyValuePair.cs" />
@@ -259,6 +265,9 @@
     <Compile Include="CacheObject\Views\CacheListEntryCell.cs" />
     <Compile Include="CacheObject\Views\CacheMemberCell.cs" />
     <Compile Include="CacheObject\Views\CacheObjectCell.cs" />
+    <Compile Include="Loader\Standalone\Editor\ExplorerEditorBehaviour.cs" />
+    <Compile Include="Loader\Standalone\Editor\ExplorerEditorLoader.cs" />
+    <Compile Include="Runtime\UnityCrashPrevention.cs" />
     <Compile Include="UI\DisplayManager.cs" />
     <Compile Include="UI\Notification.cs" />
     <Compile Include="UI\Panels\ClipboardPanel.cs" />
@@ -311,7 +320,7 @@
     <Compile Include="UI\Panels\ObjectExplorerPanel.cs" />
     <Compile Include="UI\UIManager.cs" />
     <Compile Include="UI\Panels\PanelDragger.cs" />
-    <Compile Include="UI\Widgets\AutoComplete\AutoCompleteModal.cs" />
+    <Compile Include="UI\Panels\AutoCompleteModal.cs" />
     <Compile Include="UI\Widgets\AutoComplete\TypeCompleter.cs" />
     <Compile Include="ObjectExplorer\ObjectSearch.cs" />
     <Compile Include="ObjectExplorer\SceneExplorer.cs" />
@@ -321,9 +330,13 @@
     <Compile Include="UI\Widgets\TransformTree\CachedTransform.cs" />
     <Compile Include="UI\Widgets\TransformTree\TransformCell.cs" />
     <Compile Include="UI\Widgets\TransformTree\TransformTree.cs" />
+    <Compile Include="UI\Widgets\UnityObjects\AudioClipWidget.cs" />
+    <Compile Include="UI\Widgets\UnityObjects\Texture2DWidget.cs" />
+    <Compile Include="UI\Widgets\UnityObjects\UnityObjectWidget.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="ILRepack.targets" />
+    <None Include="nuget.config" />
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>

src/nuget.config

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <config>
+        <add key="dependencyVersion" value="Lowest" />
+    </config>
+
+    <packageRestore>
+        <!-- Allow NuGet to download missing packages -->
+        <add key="enabled" value="True" />
+
+        <!-- Automatically check for missing packages during build in Visual Studio -->
+        <add key="automatic" value="True" />
+    </packageRestore>
+
+    <packageSources>
+        <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+        <add key="BepInEx" value="https://nuget.bepinex.dev/v3/index.json" />
+    </packageSources>
+</configuration>

src/packages.config

@@ -6,6 +6,6 @@
   <package id="ILRepack.Lib.MSBuild.Task" version="2.0.18.2" targetFramework="net35" />
   <package id="Mono.Cecil" version="0.10.4" targetFramework="net35" />
   <package id="Samboy063.Tomlet" version="3.1.3" targetFramework="net472" />
-  <package id="UniverseLib" version="1.2.1" targetFramework="net35" />
+  <package id="UniverseLib" version="1.2.18" targetFramework="net35" />
   <package id="UniverseLib.Analyzers" version="1.0.3" targetFramework="net35" developmentDependency="true" />
 </packages>