1.6.1

* Fix for when inspected object gets destroyed
* Fix for displaying Dictionaries/Lists nested inside a Dictionary
* Cleanups

README.md

@@ -1,7 +1,7 @@
-# CppExplorer [![Version](https://img.shields.io/badge/MelonLoader-0.2.6-green.svg)]()
+# CppExplorer [![Version](https://img.shields.io/badge/MelonLoader-0.2.7.1-green.svg)](https://github.com/HerpDerpinstine/MelonLoader)
 
 <p align="center">
-  <img align="center" src="https://i.imgur.com/1ZoZemW.png">
+  <img align="center" src="https://sinai-dev.github.io/images/thumbs/02.png">
 </p>
 
 <p align="center">
@@ -14,8 +14,9 @@
   <img src="https://img.shields.io/github/downloads/sinai-dev/CppExplorer/total.svg" />
 </p>
 
-### Note
-Most games running on Unity 2017 to 2019 should be supported. If you find that the GUI does not display properly and you get errors in the MelonLoader console about it, then this is likely due to a bug with Il2CppAssemblyUnhollower's unstripping. This bug is known by the developer of the tool and they will fix it as soon as they are able to.
+### Known issues
+* CppExplorer may experience a `MissingMethodException` when trying to use certain UnityEngine methods. If you experience this, please open an issue and I will do my best to fix it.
+* Scrolling with mouse wheel in the CppExplorer menu may not work on all games at the moment.
 
 ## Features
 * Scene hierarchy explorer
@@ -36,34 +37,65 @@ Requires [MelonLoader](https://github.com/HerpDerpinstine/MelonLoader) to be ins
 ## How to use
 
 * Press F7 to show or hide the menu.
-* Simply browse through the scene, search for objects, etc, it's pretty self-explanatory.
+* Simply browse through the scene, search for objects, etc, most of it is pretty self-explanatory.
 
-### Help! I can't use the mouse!
+### Scene Explorer
 
-It is fairly common for games to override mouse control with their own mouse behaviour. Unfortunately, it's not feasible for CppExplorer to handle this due to how differently every game will go about it.
+* A simple menu which allows you to traverse the Transform heirarchy of the scene.
+* Click on a GameObject to set it as the current path, or <b>Inspect</b> it to send it to an Inspector Window.
 
-In order to fix this problem, you can:
-* Use [VRCExplorerMouseControl](https://github.com/sinaioutlander/VRCExplorerMouseControl) (for VRChat)
-* Use [HPExplorerMouseControl](https://github.com/sinaioutlander/Hellpoint-Mods/tree/master/HPExplorerMouseControl/HPExplorerMouseControl) (for Hellpoint)
-* In general, pressing Escape (to open a menu) will usually give you temporary control over the mouse.
-* Create your own mini-plugin using one of the two plugins above as an example. Usually only 1 or 2 simple Harmony patches are needed to fix the problem.
+[![](https://i.imgur.com/BzTOCvp.png)](https://i.imgur.com/BzTOCvp.png)
 
-## Images
+### Inspectors
 
-<i>Note: images may be slightly outdated, taken from version 1.2</i>.
+CppExplorer has two main inspector modes: <b>GameObject Inspector</b>, and <b>Reflection Inspector</b>.
 
-Scene explorer, and inspection of a MonoBehaviour object:
+<b>Tips:</b> 
+* When in Tab View, GameObjects are denoted by a [G] prefix, and Reflection objects are denoted by a [R] prefix.
+* Hold <b>Left Shift</b> when you click the Inspect button to force Reflection mode for GameObjects and Transforms.
 
-[![](https://i.imgur.com/Yxizwcz.png)](https://i.imgur.com/Yxizwcz.png)
+### GameObject Inspector
 
-Search feature:
+* Allows you to see the children and components on a GameObject.
+* Can use some basic GameObject Controls such as translating and rotating the object, destroy it, clone it, etc.
 
-[![](https://i.imgur.com/F9ZfMvz.png)](https://i.imgur.com/F9ZfMvz.png)
+[![](https://i.imgur.com/DiDvl0Q.png)](https://i.imgur.com/DiDvl0Q.png)
 
+### Reflection Inspector
 
-C# REPL console:
+* The Reflection Inspector is used for all other supported objects.
+* Allows you to inspect Properties, Fields and basic Methods, as well as set primitive values and evaluate primitive methods.
+* Can search and filter members for the ones you are interested in.
 
-[![](https://i.imgur.com/14Dbtf8.png)](https://i.imgur.com/14Dbtf8.png)
+[![](https://i.imgur.com/Pq127XD.png)](https://i.imgur.com/Pq127XD.png)
+
+### Object Search
+
+* You can search for an `UnityEngine.Object` with the Object Search feature.
+* Filter by name, type, etc.
+* For GameObjects and Transforms you can filter which scene they are found in too.
+
+[![](https://i.imgur.com/lK2RthM.png)](https://i.imgur.com/lK2RthM.png)
+
+### C# REPL console
+
+* A simple C# REPL console, allows you to execute a method body on the fly.
+
+[![](https://i.imgur.com/5U4D1a8.png)](https://i.imgur.com/5U4D1a8.png)
+
+### Inspect-under-mouse
+
+* Press Shift+RMB (Right Mouse Button) while the CppExplorer menu is open to begin Inspect-Under-Mouse.
+* Hover over your desired object, if you see the name appear then you can click on it to inspect it.
+* Only objects with Colliders are supported.
+
+### Mouse Control
+
+CppExplorer can force the mouse to be visible and unlocked when the menu is open, if you have enabled "Force Unlock Mouse" (Left-Alt toggle). However, you may also want to prevent the mouse clicking-through onto the game behind CppExplorer, this is possible but it requires specific patches for that game.
+
+* For VRChat, use [VRCExplorerMouseControl](https://github.com/sinai-dev/VRCExplorerMouseControl)
+* For Hellpoint, use [HPExplorerMouseControl](https://github.com/sinai-dev/Hellpoint-Mods/tree/master/HPExplorerMouseControl/HPExplorerMouseControl)
+* You can create your own plugin using one of the two plugins above as an example. Usually only a few simple Harmony patches are needed to fix the problem.
 
 ## Credits
 

src/CachedObjects/CacheGameObject.cs

@@ -1,53 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using MelonLoader;
-using UnityEngine;
-
-namespace Explorer
-{
-    public class CacheGameObject : CacheObject
-    {
-        private GameObject m_gameObject;
-
-        public CacheGameObject(object obj)
-        {
-            if (obj != null)
-                m_gameObject = GetGameObject(obj);
-        }
-
-        private GameObject GetGameObject(object obj)
-        {
-            if (obj is Il2CppSystem.Object ilObj)
-            {
-                var ilType = ilObj.GetIl2CppType();
-
-                if (ilType == ReflectionHelpers.GameObjectType || ilType == ReflectionHelpers.TransformType)
-                {
-                    return ilObj.TryCast<GameObject>() ?? ilObj.TryCast<Transform>()?.gameObject;
-                }
-            }
-
-            return null;
-        }
-
-        public override void DrawValue(Rect window, float width)
-        {
-            UIHelpers.GameobjButton(m_gameObject, null, false, width);
-        }
-
-        public override void SetValue()
-        {
-            throw new NotImplementedException("TODO");
-        }
-
-        public override void UpdateValue()
-        {
-            base.UpdateValue();
-
-            m_gameObject = GetGameObject(Value);
-        }
-    }
-}

src/CachedObjects/CacheList.cs

@@ -1,170 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
-using Mono.CSharp;
-using UnityEngine;
-
-namespace Explorer
-{
-    public partial class CacheList : CacheObject
-    {
-        public bool IsExpanded { get; set; }
-        public int ArrayOffset { get; set; }
-        
-        public Type EntryType 
-        { 
-            get 
-            {
-                if (m_entryType == null)
-                {
-                    m_entryType = Value?.GetType().GetGenericArguments()[0];
-                }
-                return m_entryType;
-            }
-            set
-            {
-                m_entryType = value;
-            } 
-        }
-        private Type m_entryType;
-
-        public IEnumerable Enumerable
-        {
-            get
-            {
-                if (m_enumerable == null && Value != null)
-                {
-                    m_enumerable = Value as IEnumerable ?? CppListToEnumerable(Value);
-                }
-                return m_enumerable;
-            }
-        }
-
-        private IEnumerable m_enumerable;
-        private CacheObject[] m_cachedEntries;
-
-        public CacheList(object obj)
-        {
-            if (obj != null)
-            {
-                Value = obj;
-                EntryType = obj.GetType().GetGenericArguments()[0];
-            }
-        }
-
-        private IEnumerable CppListToEnumerable(object list)
-        {
-            if (EntryType == null) return null;
-
-            return (IEnumerable)typeof(Il2CppSystem.Collections.Generic.List<>)
-                                .MakeGenericType(new Type[] { EntryType })
-                                .GetMethod("ToArray")
-                                .Invoke(list, new object[0]);
-        }
-
-        public override void DrawValue(Rect window, float width)
-        {
-            int count = m_cachedEntries.Length;
-
-            if (!IsExpanded)
-            {
-                if (GUILayout.Button("v", new GUILayoutOption[] { GUILayout.Width(25) }))
-                {
-                    IsExpanded = true;
-                }
-            }
-            else
-            {
-                if (GUILayout.Button("^", new GUILayoutOption[] { GUILayout.Width(25) }))
-                {
-                    IsExpanded = false;
-                }
-            }
-
-            GUI.skin.button.alignment = TextAnchor.MiddleLeft;
-            string btnLabel = "<color=yellow>[" + count + "] " + EntryType + "</color>";
-            if (GUILayout.Button(btnLabel, new GUILayoutOption[] { GUILayout.MaxWidth(window.width - 260) }))
-            {
-                WindowManager.InspectObject(Value, out bool _);
-            }
-            GUI.skin.button.alignment = TextAnchor.MiddleCenter;
-
-            if (IsExpanded)
-            {
-                if (count > CppExplorer.ArrayLimit)
-                {
-                    GUILayout.EndHorizontal();
-                    GUILayout.BeginHorizontal(null);
-                    GUILayout.Space(190);
-                    int maxOffset = (int)Mathf.Ceil((float)(count / (decimal)CppExplorer.ArrayLimit)) - 1;
-                    GUILayout.Label($"Page {ArrayOffset + 1}/{maxOffset + 1}", new GUILayoutOption[] { GUILayout.Width(80) });
-                    // prev/next page buttons
-                    if (GUILayout.Button("< Prev", null))
-                    {
-                        if (ArrayOffset > 0) ArrayOffset--;
-                    }
-                    if (GUILayout.Button("Next >", null))
-                    {
-                        if (ArrayOffset < maxOffset) ArrayOffset++;
-                    }
-                }
-
-                int offset = ArrayOffset * CppExplorer.ArrayLimit;
-
-                if (offset >= count) offset = 0;
-
-                for (int i = offset; i < offset + CppExplorer.ArrayLimit && i < count; i++)
-                {
-                    var entry = m_cachedEntries[i];
-
-                    //collapsing the BeginHorizontal called from ReflectionWindow.WindowFunction or previous array entry
-                    GUILayout.EndHorizontal();
-                    GUILayout.BeginHorizontal(null);
-                    GUILayout.Space(190);
-
-                    if (entry.Value == null)
-                    {
-                        GUILayout.Label("<i><color=grey>null</color></i>", null);
-                    }
-                    else
-                    {
-                        GUILayout.Label(i.ToString(), new GUILayoutOption[] { GUILayout.Width(30) });
-
-                        entry.DrawValue(window, window.width - 250);
-                    }
-                }
-            }
-        }
-
-        public override void SetValue()
-        {
-            throw new NotImplementedException("TODO");
-        }
-
-        /// <summary>
-        /// Called when the user presses the "Update" button, or if AutoUpdate is on.
-        /// </summary>
-        public override void UpdateValue()
-        {
-            base.UpdateValue();
-
-            if (Value == null) return;
-
-            var enumerator = Enumerable?.GetEnumerator();
-
-            if (enumerator == null) return;
-
-            var list = new List<CacheObject>();
-            while (enumerator.MoveNext())
-            {
-                list.Add(GetCacheObject(enumerator.Current));
-            }
-
-            m_cachedEntries = list.ToArray();
-        }
-    }
-}

src/CachedObjects/CacheObject.cs

@@ -1,194 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
-using MelonLoader;
-using UnhollowerBaseLib;
-using UnityEngine;
-
-namespace Explorer
-{
-    public abstract class CacheObject
-    {
-        public object Value;
-        public string ValueType;
-
-        // Reflection window only
-        public MemberInfo MemberInfo { get; set; }
-        public ReflectionWindow.MemberInfoType MemberInfoType { get; set; }
-        public Type DeclaringType { get; set; }
-        public object DeclaringInstance { get; set; }
-        public string FullName => $"{MemberInfo.DeclaringType.Name}.{MemberInfo.Name}"; 
-        public string ReflectionException;
-
-        // methods
-        public abstract void DrawValue(Rect window, float width);
-        public abstract void SetValue();
-
-        public static CacheObject GetCacheObject(object obj)
-        {
-            return GetCacheObject(obj, null, null);
-        }
-
-        /// <summary>
-        /// Gets the CacheObject subclass for an object or MemberInfo
-        /// </summary>
-        /// <param name="obj">The current value (can be null if memberInfo is not null)</param>
-        /// <param name="memberInfo">The MemberInfo (can be null if obj is not null)</param>
-        /// <param name="declaringInstance">If MemberInfo is not null, the declaring class instance. Can be null if static.</param>
-        /// <returns></returns>
-        public static CacheObject GetCacheObject(object obj, MemberInfo memberInfo, object declaringInstance)
-        {
-            CacheObject holder;
-
-            var type = ReflectionHelpers.GetActualType(obj) ?? (memberInfo as FieldInfo)?.FieldType ?? (memberInfo as PropertyInfo)?.PropertyType;
-
-            if ((obj is Il2CppSystem.Object || typeof(Il2CppSystem.Object).IsAssignableFrom(type))
-                && (type.FullName.Contains("UnityEngine.GameObject") || type.FullName.Contains("UnityEngine.Transform")))
-            {
-                holder = new CacheGameObject(obj);
-            }
-            else if (type.IsPrimitive || type == typeof(string))
-            {
-                holder = new CachePrimitive(obj);
-            }
-            else if (type.IsEnum)
-            {
-                holder = new CacheEnum(obj);
-            }
-            else if (typeof(System.Collections.IEnumerable).IsAssignableFrom(type) || ReflectionHelpers.IsList(type))
-            {
-                holder = new CacheList(obj);
-            }
-            else
-            {
-                holder = new CacheOther();
-            }
-
-            if (memberInfo != null)
-            {
-                holder.MemberInfo = memberInfo;                
-                holder.DeclaringType = memberInfo.DeclaringType;
-                holder.DeclaringInstance = declaringInstance;
-
-                //if (declaringInstance is Il2CppSystem.Object ilInstance && ilInstance.GetType() != memberInfo.DeclaringType)
-                //{
-                //    try
-                //    {
-                //        holder.DeclaringInstance = ilInstance.Il2CppCast(holder.DeclaringType);
-                //    }
-                //    catch (Exception e)
-                //    {
-                //        holder.ReflectionException = ReflectionHelpers.ExceptionToString(e);
-                //        holder.DeclaringInstance = declaringInstance;
-                //    }
-                //}
-                //else
-                //{
-                //    holder.DeclaringInstance = declaringInstance;
-                //}
-
-                if (memberInfo.MemberType == MemberTypes.Field)
-                {
-                    holder.MemberInfoType = ReflectionWindow.MemberInfoType.Field;
-                }
-                else if (memberInfo.MemberType == MemberTypes.Property)
-                {
-                    holder.MemberInfoType = ReflectionWindow.MemberInfoType.Property;
-                }
-                else if (memberInfo.MemberType == MemberTypes.Method)
-                {
-                    holder.MemberInfoType = ReflectionWindow.MemberInfoType.Method;
-                }
-            }
-
-            holder.Value = obj;
-            holder.ValueType = type.FullName;
-
-            return holder;
-        }
-
-        public void Draw(Rect window, float labelWidth = 180f)
-        {
-            if (MemberInfo != null)
-            {
-                GUILayout.Label("<color=cyan>" + FullName + ":</color>", new GUILayoutOption[] { GUILayout.Width(labelWidth) });
-            }
-            else
-            {
-                GUILayout.Space(labelWidth);
-            }
-
-            if (!string.IsNullOrEmpty(ReflectionException))
-            {
-                GUILayout.Label("<color=red>Reflection failed!</color> (" + ReflectionException + ")", null);
-            }
-            else if (Value == null)
-            {
-                GUILayout.Label("<i>null (" + this.ValueType + ")</i>", null);
-            }
-            else
-            {
-                DrawValue(window, window.width - labelWidth - 90);
-            }
-        }
-
-        public virtual void UpdateValue()
-        {
-            if (MemberInfo == null || !string.IsNullOrEmpty(ReflectionException))
-            {
-                return;
-            }
-
-            try
-            {
-                if (MemberInfo.MemberType == MemberTypes.Field)
-                {
-                    var fi = MemberInfo as FieldInfo;
-                    Value = fi.GetValue(fi.IsStatic ? null : DeclaringInstance);
-                }
-                else if (MemberInfo.MemberType == MemberTypes.Property)
-                {
-                    var pi = MemberInfo as PropertyInfo;
-                    bool isStatic = pi.GetAccessors()[0].IsStatic;
-                    var target = isStatic ? null : DeclaringInstance;
-                    Value = pi.GetValue(target, null);
-                }
-                //ReflectionException = null;
-            }
-            catch (Exception e)
-            {
-                ReflectionException = ReflectionHelpers.ExceptionToString(e);
-            }
-        }
-
-        public void SetValue(object value, MemberInfo memberInfo, object declaringInstance)
-        {
-            try
-            {
-                if (memberInfo.MemberType == MemberTypes.Field)
-                {
-                    var fi = memberInfo as FieldInfo;
-                    if (!(fi.IsLiteral && !fi.IsInitOnly))
-                    {
-                        fi.SetValue(fi.IsStatic ? null : declaringInstance, value);
-                    }
-                }
-                else if (memberInfo.MemberType == MemberTypes.Property)
-                {
-                    var pi = memberInfo as PropertyInfo;
-                    if (pi.CanWrite)
-                    {
-                        pi.SetValue(pi.GetAccessors()[0].IsStatic ? null : declaringInstance, value);
-                    }
-                }
-            }
-            catch (Exception e)
-            {
-                MelonLogger.LogWarning($"Error setting value: {e.GetType()}, {e.Message}");
-            }
-        }
-    }
-}

src/CachedObjects/CacheObjectBase.cs

@@ -0,0 +1,368 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using MelonLoader;
+using UnhollowerBaseLib;
+using UnityEngine;
+
+namespace Explorer
+{
+    public abstract class CacheObjectBase
+    {
+        public object Value;
+        public string ValueTypeName;
+        public Type ValueType;
+
+        public MemberInfo MemInfo { get; set; }
+        public Type DeclaringType { get; set; }
+        public object DeclaringInstance { get; set; }
+        public int PropertyIndex { get; private set; }
+        private string m_propertyIndexInput = "0";
+
+        public string ReflectionException { get; set; }
+
+        public string RichTextName => m_richTextName ?? GetRichTextName();
+        private string m_richTextName;
+
+        public bool CanWrite
+        {
+            get
+            {
+                if (MemInfo is FieldInfo fi)
+                    return !(fi.IsLiteral && !fi.IsInitOnly);
+                else if (MemInfo is PropertyInfo pi)
+                    return pi.CanWrite;
+                else
+                    return false;
+            }
+        }
+
+        // ===== Abstract/Virtual Methods ===== //
+
+        public virtual void Init() { }
+
+        public abstract void DrawValue(Rect window, float width);
+
+        // ===== Static Methods ===== //
+
+        /// <summary>
+        /// Get CacheObject from only an object instance
+        /// Calls GetCacheObject(obj, memberInfo, declaringInstance) with (obj, null, null)</summary>
+        public static CacheObjectBase GetCacheObject(object obj)
+        {
+            return GetCacheObject(obj, null, null);
+        }
+
+        /// <summary>
+        /// Get CacheObject from an object instance and provide the value type
+        /// Calls GetCacheObjectImpl directly</summary>
+        public static CacheObjectBase GetCacheObject(object obj, Type valueType)
+        {
+            return GetCacheObjectImpl(obj, null, null, valueType);
+        }
+
+        /// <summary>
+        /// Get CacheObject from only a MemberInfo and declaring instance
+        /// Calls GetCacheObject(obj, memberInfo, declaringInstance) with (null, memberInfo, declaringInstance)</summary>
+        public static CacheObjectBase GetCacheObject(MemberInfo memberInfo, object declaringInstance)
+        {
+            return GetCacheObject(null, memberInfo, declaringInstance);
+        }
+
+        /// <summary>
+        /// Get CacheObject from either an object or MemberInfo, and don't provide the type.
+        /// This gets the type and then calls GetCacheObjectImpl</summary>
+        public static CacheObjectBase GetCacheObject(object obj, MemberInfo memberInfo, object declaringInstance)
+        {
+            Type type = null;
+
+            if (memberInfo != null)
+            {
+                if (memberInfo is FieldInfo fi)
+                {
+                    type = fi.FieldType;
+                }
+                else if (memberInfo is PropertyInfo pi)
+                {
+                    type = pi.PropertyType;
+                }
+                else if (memberInfo is MethodInfo mi)
+                {
+                    type = mi.ReturnType;
+                }
+            }
+            else if (obj != null)
+            {
+                type = ReflectionHelpers.GetActualType(obj);
+            }
+
+            if (type == null)
+            {
+                return null;
+            }
+
+            return GetCacheObjectImpl(obj, memberInfo, declaringInstance, type);
+        }
+
+        /// <summary>
+        /// Actual GetCacheObject implementation (private)
+        /// </summary>
+        private static CacheObjectBase GetCacheObjectImpl(object obj, MemberInfo memberInfo, object declaringInstance, Type valueType)
+        {
+            CacheObjectBase holder;
+
+            // This is pretty ugly, could probably make a cleaner implementation.
+            // However, the only cleaner ways I can think of are slower and probably not worth it. 
+
+            // Note: the order is somewhat important.
+
+            if (memberInfo is MethodInfo mi)
+            {
+                if (CacheMethod.CanEvaluate(mi))
+                {
+                    holder = new CacheMethod();
+                }
+                else
+                {
+                    return null;
+                }
+            }
+            else if (valueType == typeof(GameObject) || valueType == typeof(Transform))
+            {
+                holder = new CacheGameObject();
+            }
+            else if (valueType.IsPrimitive || valueType == typeof(string))
+            {
+                holder = new CachePrimitive();
+            }
+            else if (valueType.IsEnum)
+            {
+                holder = new CacheEnum();
+            }
+            else if (valueType == typeof(Vector2) || valueType == typeof(Vector3) || valueType == typeof(Vector4))
+            {
+                holder = new CacheVector();
+            }
+            else if (valueType == typeof(Quaternion))
+            {
+                holder = new CacheQuaternion();
+            }
+            else if (valueType == typeof(Color))
+            {
+                holder = new CacheColor();
+            }
+            else if (valueType == typeof(Rect))
+            {
+                holder = new CacheRect();
+            }
+            // must check this before IsEnumerable
+            else if (ReflectionHelpers.IsDictionary(valueType))
+            {
+                holder = new CacheDictionary();
+            }
+            else if (ReflectionHelpers.IsEnumerable(valueType) || ReflectionHelpers.IsCppList(valueType))
+            {
+                holder = new CacheList();
+            }
+            else
+            {
+                holder = new CacheOther();
+            }
+
+            holder.Value = obj;
+            holder.ValueType = valueType;
+            holder.ValueTypeName = valueType.FullName;
+
+            if (memberInfo != null)
+            {
+                holder.MemInfo = memberInfo;
+                holder.DeclaringType = memberInfo.DeclaringType;
+                holder.DeclaringInstance = declaringInstance;
+
+                holder.UpdateValue();
+            }
+
+            holder.Init();
+
+            return holder;
+        }
+
+        // ======== Instance Methods =========
+
+        public virtual void UpdateValue()
+        {
+            if (MemInfo == null || !string.IsNullOrEmpty(ReflectionException))
+            {
+                return;
+            }
+
+            try
+            {
+                if (MemInfo.MemberType == MemberTypes.Field)
+                {
+                    var fi = MemInfo as FieldInfo;
+                    Value = fi.GetValue(fi.IsStatic ? null : DeclaringInstance);
+                }
+                else if (MemInfo.MemberType == MemberTypes.Property)
+                {
+                    var pi = MemInfo as PropertyInfo;
+                    bool isStatic = pi.GetAccessors()[0].IsStatic;
+                    var target = isStatic ? null : DeclaringInstance;
+
+                    if (pi.GetIndexParameters().Length > 0)
+                    {
+                        var indexes = new object[] { PropertyIndex };
+                        Value = pi.GetValue(target, indexes);
+                    }
+                    else
+                    {
+                        Value = pi.GetValue(target, null);
+                    }
+                }
+
+                ReflectionException = null;
+            }
+            catch (Exception e)
+            {
+                ReflectionException = ReflectionHelpers.ExceptionToString(e);
+            }
+        }
+
+        public void SetValue()
+        {
+            try
+            {
+                if (MemInfo.MemberType == MemberTypes.Field)
+                {
+                    var fi = MemInfo as FieldInfo;
+                    fi.SetValue(fi.IsStatic ? null : DeclaringInstance, Value);
+                }
+                else if (MemInfo.MemberType == MemberTypes.Property)
+                {
+                    var pi = MemInfo as PropertyInfo;
+
+                    if (pi.GetIndexParameters().Length > 0)
+                    {
+                        var indexes = new object[] { PropertyIndex };
+                        pi.SetValue(pi.GetAccessors()[0].IsStatic ? null : DeclaringInstance, Value, indexes);
+                    }
+                    else
+                    {
+                        pi.SetValue(pi.GetAccessors()[0].IsStatic ? null : DeclaringInstance, Value);
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                MelonLogger.LogWarning($"Error setting value: {e.GetType()}, {e.Message}");
+            }
+        }
+
+        // ========= Instance Gui Draw ==========
+
+        public const float MAX_LABEL_WIDTH = 400f;
+
+        public static void ClampLabelWidth(Rect window, ref float labelWidth)
+        {
+            float min = window.width * 0.37f;
+            if (min > MAX_LABEL_WIDTH) min = MAX_LABEL_WIDTH;
+
+            labelWidth = Mathf.Clamp(labelWidth, min, MAX_LABEL_WIDTH);
+        }
+
+        public void Draw(Rect window, float labelWidth = 215f)
+        {
+            if (labelWidth > 0)
+            {
+                ClampLabelWidth(window, ref labelWidth);
+            }
+
+            if (MemInfo != null)
+            {
+                var name = RichTextName;
+                if (MemInfo is PropertyInfo pi && pi.GetIndexParameters().Length > 0)
+                {
+                    name += $"[{PropertyIndex}]";
+                }
+
+                GUILayout.Label(name, new GUILayoutOption[] { GUILayout.Width(labelWidth) });
+            }
+            else
+            {
+                GUILayout.Space(labelWidth);
+            }
+
+            if (!string.IsNullOrEmpty(ReflectionException))
+            {
+                GUILayout.Label("<color=red>Reflection failed!</color> (" + ReflectionException + ")", null);
+            }
+            else if (Value == null && MemInfo?.MemberType != MemberTypes.Method)
+            {
+                GUILayout.Label("<i>null (" + ValueTypeName + ")</i>", null);
+            }
+            else
+            {
+                if (MemInfo is PropertyInfo pi && pi.GetIndexParameters().Length > 0)
+                {
+                    GUILayout.Label("index:", new GUILayoutOption[] { GUILayout.Width(50) });
+
+                    m_propertyIndexInput = GUILayout.TextField(m_propertyIndexInput, new GUILayoutOption[] { GUILayout.Width(100) });
+                    if (GUILayout.Button("Set", new GUILayoutOption[] { GUILayout.Width(60) }))
+                    {
+                        if (int.TryParse(m_propertyIndexInput, out int i))
+                        {
+                            PropertyIndex = i;
+                            UpdateValue();
+                        }
+                        else
+                        {
+                            MelonLogger.Log($"Could not parse '{m_propertyIndexInput}' to an int!");
+                        }
+                    }
+
+                    // new line and space
+                    GUILayout.EndHorizontal();
+                    GUILayout.BeginHorizontal(null);
+                    GUILayout.Space(labelWidth);
+                }
+
+                DrawValue(window, window.width - labelWidth - 90);
+            }
+        }
+
+        private string GetRichTextName()
+        {
+            string memberColor = "";
+            switch (MemInfo.MemberType)
+            {
+                case MemberTypes.Field:
+                    memberColor = "#c266ff"; break;
+                case MemberTypes.Property:
+                    memberColor = "#72a6a6"; break;
+                case MemberTypes.Method:
+                    memberColor = "#ff8000"; break;
+            };
+
+            m_richTextName = $"<color=#2df7b2>{MemInfo.DeclaringType.Name}</color>.<color={memberColor}>{MemInfo.Name}</color>";
+
+            if (MemInfo is MethodInfo mi)
+            {
+                m_richTextName += "(";
+                var _params = "";
+                foreach (var param in mi.GetParameters())
+                {
+                    if (_params != "") _params += ", ";
+
+                    _params += $"<color=#a6e9e9>{param.Name}</color>";
+                }
+                m_richTextName += _params;
+                m_richTextName += ")";
+            }
+
+            return m_richTextName;
+        }
+    }
+}

src/CachedObjects/CacheOther.cs

@@ -1,78 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Reflection;
-using UnityEngine;
-
-namespace Explorer
-{
-    public class CacheOther : CacheObject
-    {
-        private MethodInfo m_toStringMethod;
-        private bool m_triedToGetMethod;
-
-        public MethodInfo ToStringMethod
-        {
-            get
-            {
-                if (m_toStringMethod == null && !m_triedToGetMethod)
-                {
-                    if (Value == null) return null;
-
-                    m_triedToGetMethod = true;
-
-                    try
-                    {
-                        var methods = ReflectionHelpers.GetActualType(Value)
-                                .GetMethods(ReflectionHelpers.CommonFlags)
-                                .Where(x => x.Name == "ToString")
-                                .GetEnumerator();
-
-                        while (methods.MoveNext())
-                        {
-                            // just get the first (top-most level) method, then break.
-                            m_toStringMethod = methods.Current;
-                            break;
-                        }
-                    }
-                    catch { }
-                }
-                return m_toStringMethod;
-            }
-        }
-
-        public override void DrawValue(Rect window, float width)
-        {
-            string label = (string)ToStringMethod?.Invoke(Value, null) ?? Value.ToString();
-            
-            if (!label.Contains(ValueType))
-            {
-                label += $" ({ValueType})";
-            }
-            if (Value is UnityEngine.Object unityObj && !label.Contains(unityObj.name))
-            {
-                label = unityObj.name + " | " + label;
-            }
-
-            GUI.skin.button.alignment = TextAnchor.MiddleLeft;
-            if (GUILayout.Button("<color=yellow>" + label + "</color>", new GUILayoutOption[] { GUILayout.MaxWidth(width) }))
-            {
-                WindowManager.InspectObject(Value, out bool _);
-            }
-            GUI.skin.button.alignment = TextAnchor.MiddleCenter;
-        }
-
-        public override void SetValue()
-        {
-            throw new NotImplementedException("TODO");
-        }
-
-        //public override void UpdateValue(object obj)
-        //{
-            
-        //}
-    }
-}

src/CachedObjects/CachePrimitive.cs

@@ -1,107 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using MelonLoader;
-using UnityEngine;
-
-namespace Explorer
-{
-    public class CachePrimitive : CacheObject
-    {
-        public enum PrimitiveType
-        {
-            Bool,
-            Double,
-            Float,
-            Int,
-            String
-        }
-
-        private readonly PrimitiveType m_primitiveType;
-
-        public CachePrimitive(object obj)
-        {
-            if (obj == null) return;
-
-            if (obj is bool)
-            {
-                m_primitiveType = PrimitiveType.Bool;
-            }
-            else if (obj is double)
-            {
-                m_primitiveType = PrimitiveType.Double;
-            }
-            else if (obj is float)
-            {
-                m_primitiveType = PrimitiveType.Float;
-            }
-            else if (obj is int || obj is IntPtr || obj is uint)
-            {
-                m_primitiveType = PrimitiveType.Int;
-            }
-            else if (obj is string)
-            {
-                m_primitiveType = PrimitiveType.String;
-            }
-        }
-
-        public override void DrawValue(Rect window, float width)
-        {
-            if (m_primitiveType == PrimitiveType.Bool && Value is bool b)
-            {
-                var color = "<color=" + (b ? "lime>" : "red>");
-                Value = GUILayout.Toggle((bool)Value, color + Value.ToString() + "</color>", null);
-
-                if (b != (bool)Value)
-                {
-                    SetValue();
-                }
-            }
-            else
-            {
-                var toString = Value.ToString();
-                if (toString.Length > 37)
-                {
-                    Value = GUILayout.TextArea(toString, new GUILayoutOption[] { GUILayout.MaxWidth(window.width - 260) });
-                }
-                else
-                {
-                    Value = GUILayout.TextField(toString, new GUILayoutOption[] { GUILayout.MaxWidth(window.width - 260) });
-                }
-                
-                if (MemberInfo != null)
-                {
-                    if (GUILayout.Button("<color=#00FF00>Apply</color>", new GUILayoutOption[] { GUILayout.Width(60) }))
-                    {
-                        SetValue();
-                    }
-                }
-            }
-        }
-
-        public override void SetValue()
-        {
-            if (MemberInfo == null)
-            {
-                MelonLogger.Log("Trying to SetValue but the MemberInfo is null!");
-                return;
-            }
-
-            switch (m_primitiveType)
-            {
-                case PrimitiveType.Bool:
-                    SetValue(bool.Parse(Value.ToString()), MemberInfo, DeclaringInstance); return;
-                case PrimitiveType.Double:
-                    SetValue(double.Parse(Value.ToString()), MemberInfo, DeclaringInstance); return;
-                case PrimitiveType.Float:
-                    SetValue(float.Parse(Value.ToString()), MemberInfo, DeclaringInstance); return;
-                case PrimitiveType.Int:
-                    SetValue(int.Parse(Value.ToString()), MemberInfo, DeclaringInstance); return;
-                case PrimitiveType.String:
-                    SetValue(Value.ToString(), MemberInfo, DeclaringInstance); return;
-            }
-        }
-    }
-}

src/CachedObjects/Object/CacheDictionary.cs

@@ -0,0 +1,269 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using MelonLoader;
+using UnityEngine;
+using System.Reflection;
+
+namespace Explorer
+{
+    public class CacheDictionary : CacheObjectBase, IExpandHeight
+    {
+        public bool IsExpanded { get; set; }
+        public float WhiteSpace { get; set; } = 215f;
+        public float ButtonWidthOffset { get; set; } = 290f;
+
+        public PageHelper Pages = new PageHelper();
+
+        private CacheObjectBase[] m_cachedKeys;
+        private CacheObjectBase[] m_cachedValues;
+
+        public Type TypeOfKeys
+        {
+            get
+            {
+                if (m_keysType == null) GetGenericArguments();
+                return m_keysType;
+            }
+        }
+        private Type m_keysType;
+
+        public Type TypeOfValues
+        {
+            get
+            {
+                if (m_valuesType == null) GetGenericArguments();
+                return m_valuesType;
+            }
+        }
+        private Type m_valuesType;
+
+        public IDictionary IDict
+        {
+            get => m_iDictionary ?? (m_iDictionary = Value as IDictionary) ?? Il2CppDictionaryToMono();
+            set => m_iDictionary = value;
+        }
+        private IDictionary m_iDictionary;
+
+        // ========== Methods ==========
+
+        // This is a bit janky due to Il2Cpp Dictionary not implementing IDictionary.
+        private IDictionary Il2CppDictionaryToMono()
+        {
+            // note: "ValueType" is the Dictionary itself, TypeOfValues is the 'Dictionary.Values' type.
+
+            // make generic dictionary from key and value type
+            var dict = (IDictionary)Activator.CreateInstance(typeof(Dictionary<,>)
+                                             .MakeGenericType(TypeOfKeys, TypeOfValues));
+
+            // get keys and values
+            var keys   = ValueType.GetProperty("Keys")  .GetValue(Value);
+            var values = ValueType.GetProperty("Values").GetValue(Value);
+
+            // create lists to hold them
+            var keyList   = new List<object>();
+            var valueList = new List<object>();
+
+            // get keys enumerator and store keys
+            var keyEnumerator = keys.GetType().GetMethod("GetEnumerator").Invoke(keys, null);
+            var keyCollectionType = keyEnumerator.GetType();
+            var keyMoveNext = keyCollectionType.GetMethod("MoveNext");
+            var keyCurrent = keyCollectionType.GetProperty("Current");
+            while ((bool)keyMoveNext.Invoke(keyEnumerator, null))
+            {
+                keyList.Add(keyCurrent.GetValue(keyEnumerator));
+            }
+
+            // get values enumerator and store values
+            var valueEnumerator = values.GetType().GetMethod("GetEnumerator").Invoke(values, null);
+            var valueCollectionType = valueEnumerator.GetType();
+            var valueMoveNext = valueCollectionType.GetMethod("MoveNext");
+            var valueCurrent = valueCollectionType.GetProperty("Current");
+            while ((bool)valueMoveNext.Invoke(valueEnumerator, null))
+            {
+                valueList.Add(valueCurrent.GetValue(valueEnumerator));
+            }
+
+            // finally iterate into actual dictionary
+            for (int i = 0; i < keyList.Count; i++)
+            {
+                dict.Add(keyList[i], valueList[i]);
+            }
+
+            return dict;
+        }
+
+        private void GetGenericArguments()
+        {
+            if (this.MemInfo != null)
+            {
+                Type memberType = null;
+                switch (this.MemInfo.MemberType)
+                {
+                    case MemberTypes.Field:
+                        memberType = (MemInfo as FieldInfo).FieldType;
+                        break;
+                    case MemberTypes.Property:
+                        memberType = (MemInfo as PropertyInfo).PropertyType;
+                        break;
+                }
+
+                if (memberType != null && memberType.IsGenericType)
+                {
+                    m_keysType = memberType.GetGenericArguments()[0];
+                    m_valuesType = memberType.GetGenericArguments()[1];
+                }
+            }
+            else if (Value != null)
+            {
+                var type = Value.GetType();
+                if (type.IsGenericType)
+                {
+                    m_keysType = type.GetGenericArguments()[0];
+                    m_valuesType = type.GetGenericArguments()[1];
+                }
+            }
+        }
+
+        public override void UpdateValue()
+        {
+            base.UpdateValue();
+
+            // reset
+            IDict = null;
+
+            if (Value == null || IDict == null)
+            {
+                return;
+            }
+
+            var keys = new List<CacheObjectBase>();
+            foreach (var key in IDict.Keys)
+            {
+                var cache = GetCacheObject(key, TypeOfKeys);
+                cache.UpdateValue();
+                keys.Add(cache);
+            }
+
+            var values = new List<CacheObjectBase>();
+            foreach (var val in IDict.Values)
+            {
+                var cache = GetCacheObject(val, TypeOfValues);
+                cache.UpdateValue();
+                values.Add(cache);
+            }
+
+            m_cachedKeys = keys.ToArray();
+            m_cachedValues = values.ToArray();
+        }
+
+        // ============= GUI Draw =============
+
+        public override void DrawValue(Rect window, float width)
+        {
+            if (m_cachedKeys == null || m_cachedValues == null)
+            {
+                GUILayout.Label("Cached keys or values is null!", null);
+                return;
+            }
+
+            int count = m_cachedKeys.Length;
+
+            if (!IsExpanded)
+            {
+                if (GUILayout.Button("v", new GUILayoutOption[] { GUILayout.Width(25) }))
+                {
+                    IsExpanded = true;
+                }
+            }
+            else
+            {
+                if (GUILayout.Button("^", new GUILayoutOption[] { GUILayout.Width(25) }))
+                {
+                    IsExpanded = false;
+                }
+            }
+
+            GUI.skin.button.alignment = TextAnchor.MiddleLeft;
+            string btnLabel = $"<color=yellow>[{count}] Dictionary<{TypeOfKeys.FullName}, {TypeOfValues.FullName}></color>";
+            if (GUILayout.Button(btnLabel, new GUILayoutOption[] { GUILayout.MaxWidth(window.width - ButtonWidthOffset) }))
+            {
+                WindowManager.InspectObject(Value, out bool _);
+            }
+            GUI.skin.button.alignment = TextAnchor.MiddleCenter;
+
+            GUILayout.Space(5);
+
+            if (IsExpanded)
+            {
+                float whitespace = WhiteSpace;
+                if (whitespace > 0)
+                {
+                    ClampLabelWidth(window, ref whitespace);
+                }
+
+                Pages.ItemCount = count;
+
+                if (count > Pages.ItemsPerPage)
+                {
+                    GUILayout.EndHorizontal();
+                    GUILayout.BeginHorizontal(null);
+
+                    GUILayout.Space(whitespace);
+
+                    Pages.CurrentPageLabel();
+
+                    // prev/next page buttons
+                    if (GUILayout.Button("< Prev", new GUILayoutOption[] { GUILayout.Width(60) }))
+                    {
+                        Pages.TurnPage(Turn.Left);
+                    }
+                    if (GUILayout.Button("Next >", new GUILayoutOption[] { GUILayout.Width(60) }))
+                    {
+                        Pages.TurnPage(Turn.Right);
+                    }
+
+                    Pages.DrawLimitInputArea();
+
+                    GUILayout.Space(5);
+                }
+
+                int offset = Pages.CalculateOffsetIndex();
+
+                for (int i = offset; i < offset + Pages.ItemsPerPage && i < count; i++)
+                {
+                    var key = m_cachedKeys[i];
+                    var val = m_cachedValues[i];
+
+                    //collapsing the BeginHorizontal called from ReflectionWindow.WindowFunction or previous array entry
+                    GUILayout.EndHorizontal();
+                    GUILayout.BeginHorizontal(null);
+
+                    //GUILayout.Space(whitespace);
+
+                    if (key == null || val == null)
+                    {
+                        GUILayout.Label($"[{i}] <i><color=grey>(null)</color></i>", null);
+                    }
+                    else
+                    {
+                        GUI.skin.label.alignment = TextAnchor.MiddleCenter;
+                        GUILayout.Label($"[{i}]", new GUILayoutOption[] { GUILayout.Width(30) });
+
+                        GUILayout.Label("Key:", new GUILayoutOption[] { GUILayout.Width(40) });
+                        key.DrawValue(window, (window.width / 2) - 30f);
+
+                        GUILayout.Label("Value:", new GUILayoutOption[] { GUILayout.Width(40) });
+                        val.DrawValue(window, (window.width / 2) - 30f);
+                    }
+
+                }
+
+                GUI.skin.label.alignment = TextAnchor.UpperLeft;
+            }
+        }
+    }
+}

src/CachedObjects/Object/CacheGameObject.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using MelonLoader;
+using UnityEngine;
+
+namespace Explorer
+{
+    public class CacheGameObject : CacheObjectBase
+    {
+        public override void DrawValue(Rect window, float width)
+        {
+            UIHelpers.GOButton(Value, null, false, width);
+        }
+
+        public override void UpdateValue()
+        {
+            base.UpdateValue();
+        }
+    }
+}

src/CachedObjects/Object/CacheList.cs

@@ -0,0 +1,340 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using MelonLoader;
+using UnityEngine;
+
+namespace Explorer
+{
+    public class CacheList : CacheObjectBase, IExpandHeight
+    {
+        public bool IsExpanded { get; set; }
+        public float WhiteSpace { get; set; } = 215f;
+        public float ButtonWidthOffset { get; set; } = 290f;
+
+        public PageHelper Pages = new PageHelper();
+
+        private CacheObjectBase[] m_cachedEntries;
+
+        // Type of Entries in the Array
+        public Type EntryType 
+        {
+            get => GetEntryType();
+            set => m_entryType = value;
+        }
+        private Type m_entryType;
+
+        // Cached IEnumerable object
+        public IEnumerable Enumerable
+        {
+            get => GetEnumerable();
+        }
+        private IEnumerable m_enumerable;
+
+        // Generic Type Definition for Lists
+        public Type GenericTypeDef
+        {
+            get => GetGenericTypeDef();
+        }
+        private Type m_genericTypeDef;
+
+        // Cached ToArray method for Lists
+        public MethodInfo GenericToArrayMethod
+        {
+            get => GetGenericToArrayMethod();
+        }
+        private MethodInfo m_genericToArray;
+
+        // Cached Item Property for ILists
+        public PropertyInfo ItemProperty
+        {
+            get => GetItemProperty();
+        }
+
+        private PropertyInfo m_itemProperty;
+
+        // ========== Methods ==========
+
+        private IEnumerable GetEnumerable()
+        {
+            if (m_enumerable == null && Value != null)
+            {
+                m_enumerable = Value as IEnumerable ?? GetEnumerableFromIl2CppList();
+            }
+            return m_enumerable;
+        }
+
+        private Type GetGenericTypeDef()
+        {
+            if (m_genericTypeDef == null && Value != null)
+            {
+                var type = Value.GetType();
+                if (type.IsGenericType)
+                {
+                    m_genericTypeDef = type.GetGenericTypeDefinition();
+                }
+            }
+            return m_genericTypeDef;
+        }
+
+        private MethodInfo GetGenericToArrayMethod()
+        {
+            if (GenericTypeDef == null) return null;
+
+            if (m_genericToArray == null)
+            {
+                m_genericToArray = GenericTypeDef
+                                    .MakeGenericType(new Type[] { this.EntryType })
+                                    .GetMethod("ToArray");
+            }
+            return m_genericToArray;
+        }
+
+        private PropertyInfo GetItemProperty()
+        {
+            if (m_itemProperty == null)
+            {
+                m_itemProperty = Value?.GetType().GetProperty("Item");
+            }
+            return m_itemProperty;
+        }
+
+        private IEnumerable GetEnumerableFromIl2CppList()
+        {
+            if (Value == null) return null;
+
+            if (GenericTypeDef == typeof(Il2CppSystem.Collections.Generic.List<>))
+            {
+                return (IEnumerable)GenericToArrayMethod?.Invoke(Value, new object[0]);
+            }
+            else
+            {
+                return ConvertIListToMono();
+            }
+        }
+
+        private IList ConvertIListToMono()
+        {
+            try
+            {
+                var genericType = typeof(List<>).MakeGenericType(new Type[] { this.EntryType });
+                var list = (IList)Activator.CreateInstance(genericType);
+
+                for (int i = 0; ; i++)
+                {
+                    try
+                    {
+                        var itm = ItemProperty.GetValue(Value, new object[] { i });
+                        list.Add(itm);
+                    }
+                    catch { break; }
+                }
+
+                return list;
+            }
+            catch (Exception e)
+            {
+                MelonLogger.Log("Exception converting Il2Cpp IList to Mono IList: " + e.GetType() + ", " + e.Message);
+                return null;
+            }
+        }
+
+        private Type GetEntryType()
+        {
+            if (m_entryType == null)
+            {
+                if (this.MemInfo != null)
+                {
+                    Type memberType = null;
+                    switch (this.MemInfo.MemberType)
+                    {
+                        case MemberTypes.Field:
+                            memberType = (MemInfo as FieldInfo).FieldType;
+                            break;
+                        case MemberTypes.Property:
+                            memberType = (MemInfo as PropertyInfo).PropertyType;
+                            break;
+                    }
+
+                    if (memberType != null && memberType.IsGenericType)
+                    {
+                        m_entryType = memberType.GetGenericArguments()[0];
+                    }
+                }
+                else if (Value != null)
+                {
+                    var type = Value.GetType();
+                    if (type.IsGenericType)
+                    {
+                        m_entryType = type.GetGenericArguments()[0];
+                    }
+                }
+            }
+
+            // IList probably won't be able to get any EntryType.
+            if (m_entryType == null)
+            {
+                m_entryType = typeof(object);
+            }
+
+            return m_entryType;
+        }
+
+        public override void UpdateValue()
+        {
+            base.UpdateValue();
+
+            if (Value == null || Enumerable == null)
+            {
+                return;
+            }
+
+            var enumerator = Enumerable.GetEnumerator();
+            if (enumerator == null)
+            {
+                return;
+            }
+
+            var list = new List<CacheObjectBase>();
+            while (enumerator.MoveNext())
+            {
+                var obj = enumerator.Current;
+
+                if (obj != null && ReflectionHelpers.GetActualType(obj) is Type t)
+                {
+                    if (obj is Il2CppSystem.Object iObj)
+                    {
+                        try
+                        {
+                            var cast = iObj.Il2CppCast(t);
+                            if (cast != null)
+                            {
+                                obj = cast;
+                            }
+                        }
+                        catch { }
+                    }
+
+                    if (GetCacheObject(obj, t) is CacheObjectBase cached)
+                    {
+                        cached.UpdateValue();
+                        list.Add(cached);
+                    }
+                    else
+                    {
+                        list.Add(null);
+                    }
+                }
+                else
+                {
+                    list.Add(null);
+                }
+            }
+
+            m_cachedEntries = list.ToArray();
+        }
+
+        // ============= GUI Draw =============
+
+        public override void DrawValue(Rect window, float width)
+        {
+            if (m_cachedEntries == null)
+            {
+                GUILayout.Label("m_cachedEntries is null!", null);
+                return;
+            }
+
+            int count = m_cachedEntries.Length;
+
+            if (!IsExpanded)
+            {
+                if (GUILayout.Button("v", new GUILayoutOption[] { GUILayout.Width(25) }))
+                {
+                    IsExpanded = true;
+                }
+            }
+            else
+            {
+                if (GUILayout.Button("^", new GUILayoutOption[] { GUILayout.Width(25) }))
+                {
+                    IsExpanded = false;
+                }
+            }
+
+            GUI.skin.button.alignment = TextAnchor.MiddleLeft;
+            string btnLabel = "<color=yellow>[" + count + "] " + EntryType.FullName + "</color>";
+            if (GUILayout.Button(btnLabel, new GUILayoutOption[] { GUILayout.MaxWidth(window.width - ButtonWidthOffset) }))
+            {
+                WindowManager.InspectObject(Value, out bool _);
+            }
+            GUI.skin.button.alignment = TextAnchor.MiddleCenter;
+
+            GUILayout.Space(5);
+
+            if (IsExpanded)
+            {
+                float whitespace = WhiteSpace;                
+                if (whitespace > 0)
+                {
+                    ClampLabelWidth(window, ref whitespace);
+                }
+
+                Pages.ItemCount = count;
+
+                if (count > Pages.ItemsPerPage)
+                {
+                    GUILayout.EndHorizontal();
+                    GUILayout.BeginHorizontal(null);
+
+                    GUILayout.Space(whitespace);
+                 
+                    Pages.CurrentPageLabel();
+
+                    // prev/next page buttons
+                    if (GUILayout.Button("< Prev", new GUILayoutOption[] { GUILayout.Width(60) }))
+                    {
+                        Pages.TurnPage(Turn.Left);
+                    }
+                    if (GUILayout.Button("Next >", new GUILayoutOption[] { GUILayout.Width(60) }))
+                    {
+                        Pages.TurnPage(Turn.Right);
+                    }
+
+                    Pages.DrawLimitInputArea();
+
+                    GUILayout.Space(5);
+                }
+
+                int offset = Pages.CalculateOffsetIndex();
+
+                for (int i = offset; i < offset + Pages.ItemsPerPage && i < count; i++)
+                {
+                    var entry = m_cachedEntries[i];
+
+                    //collapsing the BeginHorizontal called from ReflectionWindow.WindowFunction or previous array entry
+                    GUILayout.EndHorizontal();
+                    GUILayout.BeginHorizontal(null);
+
+                    GUILayout.Space(whitespace);
+
+                    if (entry == null || entry.Value == null)
+                    {
+                        GUILayout.Label($"[{i}] <i><color=grey>(null)</color></i>", null);
+                    }
+                    else
+                    {
+                        GUI.skin.label.alignment = TextAnchor.MiddleCenter;
+                        GUILayout.Label($"[{i}]", new GUILayoutOption[] { GUILayout.Width(30) });
+
+                        entry.DrawValue(window, window.width - (whitespace + 85));                        
+                    }
+                    
+                }
+
+                GUI.skin.label.alignment = TextAnchor.UpperLeft;
+            }
+        }
+    }
+}

src/CachedObjects/Other/CacheMethod.cs

@@ -0,0 +1,209 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Reflection;
+using UnityEngine;
+using MelonLoader;
+
+namespace Explorer
+{
+    public class CacheMethod : CacheObjectBase
+    {
+        private bool m_evaluated = false;
+        private CacheObjectBase m_cachedReturnValue;
+
+        private bool m_isEvaluating;
+        private ParameterInfo[] m_arguments;
+        private string[] m_argumentInput;
+
+        public bool HasParameters => m_arguments != null && m_arguments.Length > 0;
+
+        public static bool CanEvaluate(MethodInfo mi)
+        {
+            // TODO generic args
+            if (mi.GetGenericArguments().Length > 0)
+            {
+                return false;
+            }
+
+            // primitive and string args supported
+            foreach (var param in mi.GetParameters())
+            {
+                if (!param.ParameterType.IsPrimitive && param.ParameterType != typeof(string))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public override void Init()
+        {
+            base.Init();
+
+            var mi = MemInfo as MethodInfo;
+
+            m_arguments = mi.GetParameters();
+            m_argumentInput = new string[m_arguments.Length];
+        }
+
+        public override void UpdateValue()
+        {
+            //base.UpdateValue();
+        }
+
+        private void Evaluate()
+        {
+            var mi = MemInfo as MethodInfo;
+
+            object ret = null;
+
+            if (!HasParameters)
+            {
+                ret = mi.Invoke(mi.IsStatic ? null : DeclaringInstance, new object[0]);
+                m_evaluated = true;
+            }
+            else
+            {
+                var parsedArgs = new List<object>();
+                for (int i = 0; i < m_arguments.Length; i++)
+                {
+                    var input = m_argumentInput[i];
+                    var type = m_arguments[i].ParameterType;
+
+                    if (type == typeof(string))
+                    {
+                        parsedArgs.Add(input);
+                    }
+                    else
+                    {
+                        try
+                        {
+                            if (type.GetMethod("Parse", new Type[] { typeof(string) }).Invoke(null, new object[] { input }) is object parsed)
+                            {
+                                parsedArgs.Add(parsed);
+                            }
+                            else
+                            {
+                                // try add a null arg i guess
+                                parsedArgs.Add(null);
+                            }
+
+                        }
+                        catch
+                        {
+                            MelonLogger.Log($"Unable to parse '{input}' to type '{type.Name}'");
+                            break;
+                        }
+                    }
+                }
+
+                try
+                {
+                    ret = mi.Invoke(mi.IsStatic ? null : DeclaringInstance, parsedArgs.ToArray());
+                    m_evaluated = true;
+                }
+                catch (Exception e)
+                {
+                    MelonLogger.Log($"Exception evaluating: {e.GetType()}, {e.Message}");
+                }
+            }
+
+            if (ret != null)
+            {
+                m_cachedReturnValue = GetCacheObject(ret);
+
+                if (m_cachedReturnValue is IExpandHeight expander)
+                {
+                    expander.WhiteSpace = 0f;
+                    expander.ButtonWidthOffset += 70f;
+                }
+
+                m_cachedReturnValue.UpdateValue();
+            }
+            else
+            {
+                m_cachedReturnValue = null;
+            }
+        }
+
+        // ==== GUI DRAW ====
+
+        public override void DrawValue(Rect window, float width)
+        {
+            GUILayout.BeginVertical(null);
+
+            string evaluateLabel = "<color=lime>Evaluate</color>";
+            if (HasParameters)
+            {
+                if (m_isEvaluating)
+                {
+                    for (int i = 0; i < m_arguments.Length; i++)
+                    {
+                        var name = m_arguments[i].Name;
+                        var input = m_argumentInput[i];
+                        var type = m_arguments[i].ParameterType.Name;
+
+                        GUILayout.BeginHorizontal(null);
+                        m_argumentInput[i] = GUILayout.TextField(input, new GUILayoutOption[] { GUILayout.Width(150) });
+                        GUILayout.Label(i + ": <color=cyan>" + name + "</color> <color=yellow>(" + type + ")</color>", null);
+
+                        GUILayout.EndHorizontal();
+                    }
+
+                    GUILayout.BeginHorizontal(null);
+                    if (GUILayout.Button(evaluateLabel, new GUILayoutOption[] { GUILayout.Width(70) }))
+                    {
+                        Evaluate();
+                        m_isEvaluating = false;
+                    }
+                    if (GUILayout.Button("Cancel", new GUILayoutOption[] { GUILayout.Width(70) }))
+                    {
+                        m_isEvaluating = false;
+                    }
+                }
+                else
+                {
+                    GUILayout.BeginHorizontal(null);
+                    if (GUILayout.Button($"Evaluate ({m_arguments.Length} params)", new GUILayoutOption[] { GUILayout.Width(150) }))
+                    {
+                        m_isEvaluating = true;
+                    }
+                }
+            }
+            else
+            {
+                GUILayout.BeginHorizontal(null);
+                if (GUILayout.Button(evaluateLabel, new GUILayoutOption[] { GUILayout.Width(70) }))
+                {
+                    Evaluate();
+                }
+            }
+            
+            GUILayout.EndHorizontal();
+
+            GUILayout.BeginHorizontal(null);
+            if (m_evaluated)
+            {
+                if (m_cachedReturnValue != null)
+                {
+                    m_cachedReturnValue.DrawValue(window, width);
+                }
+                else
+                {
+                    GUILayout.Label($"null (<color=yellow>{ValueTypeName}</color>)", null);
+                }
+            }
+            else
+            {
+                GUILayout.Label($"<color=grey><i>Not yet evaluated</i></color> (<color=yellow>{ValueTypeName}</color>)", null);
+            }
+            GUILayout.EndHorizontal();
+
+            GUILayout.EndVertical();
+        }
+    }
+}

src/CachedObjects/Other/CacheOther.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Reflection;
+using UnityEngine;
+
+namespace Explorer
+{
+    public class CacheOther : CacheObjectBase
+    {
+        private MethodInfo m_toStringMethod;
+
+        public MethodInfo ToStringMethod
+        {
+            get
+            {
+                if (m_toStringMethod == null)
+                {
+                    try
+                    {
+                        m_toStringMethod = ReflectionHelpers.GetActualType(Value).GetMethod("ToString", new Type[0]) 
+                                           ?? typeof(object).GetMethod("ToString", new Type[0]);
+
+                        // test invoke
+                        m_toStringMethod.Invoke(Value, null);
+                    }
+                    catch
+                    {
+                        m_toStringMethod = typeof(object).GetMethod("ToString", new Type[0]);
+                    }
+                }
+                return m_toStringMethod;
+            }
+        }
+
+        public override void DrawValue(Rect window, float width)
+        {
+            string label = (string)ToStringMethod?.Invoke(Value, null) ?? Value.ToString();
+            
+            if (!label.Contains(ValueTypeName))
+            {
+                label += $" ({ValueTypeName})";
+            }
+            if (Value is UnityEngine.Object unityObj && !label.Contains(unityObj.name))
+            {
+                label = unityObj.name + " | " + label;
+            }
+
+            GUI.skin.button.alignment = TextAnchor.MiddleLeft;
+            if (GUILayout.Button("<color=yellow>" + label + "</color>", new GUILayoutOption[] { GUILayout.Width(width) }))
+            {
+                WindowManager.InspectObject(Value, out bool _);
+            }
+            GUI.skin.button.alignment = TextAnchor.MiddleCenter;
+        }
+    }
+}

src/CachedObjects/Struct/CacheColor.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Explorer
+{
+    public class CacheColor : CacheObjectBase
+    {
+        private string r = "0";
+        private string g = "0";
+        private string b = "0";
+        private string a = "0";
+
+        public override void UpdateValue()
+        {
+            base.UpdateValue();
+
+            var color = (Color)Value;
+
+            r = color.r.ToString();
+            g = color.g.ToString();
+            b = color.b.ToString();
+            a = color.a.ToString();
+        }
+
+        public override void DrawValue(Rect window, float width)
+        {
+            GUILayout.Label($"<color=yellow>Color</color>: {((Color)Value).ToString()}", null);
+
+            if (CanWrite)
+            {
+                GUILayout.EndHorizontal();
+                var whitespace = window.width - width - 90;
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("R:", new GUILayoutOption[] { GUILayout.Width(30) });
+                r = GUILayout.TextField(r, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("G:", new GUILayoutOption[] { GUILayout.Width(30) });
+                g = GUILayout.TextField(g, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("B:", new GUILayoutOption[] { GUILayout.Width(30) });
+                b = GUILayout.TextField(b, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("A:", new GUILayoutOption[] { GUILayout.Width(30) });
+                a = GUILayout.TextField(a, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                // draw set value button
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                if (GUILayout.Button("<color=lime>Apply</color>", new GUILayoutOption[] { GUILayout.Width(155) }))
+                {
+                    SetValueFromInput();
+                }
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+            }
+        }
+
+        private void SetValueFromInput()
+        {
+            if (float.TryParse(r, out float fR)
+                && float.TryParse(g, out float fG)
+                && float.TryParse(b, out float fB)
+                && float.TryParse(a, out float fA))
+            {
+                Value = new Color(fR, fB, fG, fA);
+                SetValue();
+            }
+        }
+    }
+}

src/CachedObjects/Struct/CacheEnum.cs

@@ -3,28 +3,41 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.Reflection;
 using MelonLoader;
 using UnityEngine;
 
 namespace Explorer
 {
-    public class CacheEnum : CacheObject
+    public class CacheEnum : CacheObjectBase
     {
-        private readonly Type m_enumType;
-        private readonly string[] m_names;
+        public Type EnumType;
+        public string[] EnumNames;
 
-        public CacheEnum(object obj)
+        public override void Init()
         {
-            if (obj != null)
+            try
             {
-                m_enumType = obj.GetType();
-                m_names = Enum.GetNames(m_enumType);
+                EnumType = Value.GetType();
+            }
+            catch
+            {
+                EnumType = (MemInfo as FieldInfo)?.FieldType ?? (MemInfo as PropertyInfo).PropertyType;
+            }
+
+            if (EnumType != null)
+            {
+                EnumNames = Enum.GetNames(EnumType);
+            }
+            else
+            {
+                ReflectionException = "Unknown, could not get Enum names.";
             }
         }
 
         public override void DrawValue(Rect window, float width)
         {
-            if (MemberInfo != null)
+            if (CanWrite)
             {
                 if (GUILayout.Button("<", new GUILayoutOption[] { GUILayout.Width(25) }))
                 {
@@ -38,34 +51,18 @@ namespace Explorer
                 }
             }
 
-            GUILayout.Label(Value.ToString(), null);
-        }
-
-        public override void SetValue()
-        {
-            if (MemberInfo == null)
-            {
-                MelonLogger.Log("Trying to SetValue but the MemberInfo is null!");
-                return;
-            }
-
-            if (Enum.Parse(m_enumType, Value.ToString()) is object enumValue && enumValue != null)
-            {
-                Value = enumValue;
-            }
-
-            SetValue(Value, MemberInfo, DeclaringInstance);
+            GUILayout.Label(Value.ToString() + "<color=yellow><i> (" + ValueType + ")</i></color>", null);
         }
 
         public void SetEnum(ref object value, int change)
         {
-            var names = m_names.ToList();
+            var names = EnumNames.ToList();
 
             int newindex = names.IndexOf(value.ToString()) + change;
 
             if ((change < 0 && newindex >= 0) || (change > 0 && newindex < names.Count))
             {
-                value = Enum.Parse(m_enumType, names[newindex]);
+                value = Enum.Parse(EnumType, names[newindex]);
             }
         }
     }

src/CachedObjects/Struct/CachePrimitive.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using MelonLoader;
+using UnityEngine;
+
+namespace Explorer
+{
+    public class CachePrimitive : CacheObjectBase
+    {
+        private bool m_isBool;
+        private bool m_isString;
+
+        private string m_valueToString;
+
+        public MethodInfo ParseMethod => m_parseMethod ?? (m_parseMethod = Value.GetType().GetMethod("Parse", new Type[] { typeof(string) }));
+        private MethodInfo m_parseMethod;
+
+        public override void Init()
+        {
+            if (ValueType == null)
+            {
+                ValueType = Value?.GetType();
+
+                // has to be a string at this point
+                if (ValueType == null)
+                {
+                    ValueType = typeof(string);
+                }
+            }
+
+            if (ValueType == typeof(string))
+            {
+                m_isString = true;
+            }
+            else if (ValueType == typeof(bool))
+            {
+                m_isBool = true;
+            }
+        }
+
+        public override void UpdateValue()
+        {
+            base.UpdateValue();
+
+            m_valueToString = Value?.ToString();
+        }
+
+        public override void DrawValue(Rect window, float width)
+        {
+            if (m_isBool)
+            {
+                var b = (bool)Value;
+                var label = $"<color={(b ? "lime" : "red")}>{b}</color>";
+
+                if (CanWrite)
+                {
+                    b = GUILayout.Toggle(b, label, null);
+                    if (b != (bool)Value)
+                    {
+                        SetValueFromInput(b.ToString());
+                    }
+                }
+                else
+                {
+                    GUILayout.Label(label, null);
+                }
+            }
+            else
+            {
+                // using ValueType.Name instead of ValueTypeName, because we only want the short name.
+                GUILayout.Label("<color=yellow><i>" + ValueType.Name + "</i></color>", new GUILayoutOption[] { GUILayout.Width(50) });
+
+                int dynSize = 25 + (m_valueToString.Length * 15);
+                var maxwidth = window.width - 300f;
+                if (CanWrite) maxwidth -= 60;
+
+                if (dynSize > maxwidth)
+                {
+                    m_valueToString = GUILayout.TextArea(m_valueToString, new GUILayoutOption[] { GUILayout.MaxWidth(maxwidth) });
+                }
+                else
+                {
+                    m_valueToString = GUILayout.TextField(m_valueToString, new GUILayoutOption[] { GUILayout.MaxWidth(dynSize) });
+                }
+
+                if (CanWrite)
+                {
+                    if (GUILayout.Button("<color=#00FF00>Apply</color>", new GUILayoutOption[] { GUILayout.Width(60) }))
+                    {
+                        SetValueFromInput(m_valueToString);
+                    }
+                }
+
+                GUILayout.Space(5);
+            }
+        }
+
+        public void SetValueFromInput(string valueString)
+        {
+            if (MemInfo == null)
+            {
+                MelonLogger.Log("Trying to SetValue but the MemberInfo is null!");
+                return;
+            }
+
+            if (m_isString)
+            {
+                Value = valueString;
+            }
+            else
+            {
+                try
+                {
+                    Value = ParseMethod.Invoke(null, new object[] { valueString });
+                }
+                catch (Exception e)
+                {
+                    MelonLogger.Log("Exception parsing value: " + e.GetType() + ", " + e.Message);
+                }
+            }
+
+            SetValue();
+        }
+    }
+}

src/CachedObjects/Struct/CacheQuaternion.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Explorer
+{
+    public class CacheQuaternion : CacheObjectBase
+    {
+        private string x = "0";
+        private string y = "0";
+        private string z = "0";
+
+        public override void UpdateValue()
+        {
+            base.UpdateValue();
+
+            var euler = ((Quaternion)Value).eulerAngles;
+
+            x = euler.x.ToString();
+            y = euler.y.ToString();
+            z = euler.z.ToString();
+        }
+
+        public override void DrawValue(Rect window, float width)
+        {
+            GUILayout.Label($"<color=yellow>Quaternion</color>: {((Quaternion)Value).eulerAngles.ToString()}", null);
+
+            if (CanWrite)
+            {
+                GUILayout.EndHorizontal();
+                var whitespace = window.width - width - 90;
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("X:", new GUILayoutOption[] { GUILayout.Width(30) });
+                x = GUILayout.TextField(x, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("Y:", new GUILayoutOption[] { GUILayout.Width(30) });
+                y = GUILayout.TextField(y, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("Z:", new GUILayoutOption[] { GUILayout.Width(30) });
+                z = GUILayout.TextField(z, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                // draw set value button
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                if (GUILayout.Button("<color=lime>Apply</color>", new GUILayoutOption[] { GUILayout.Width(155) }))
+                {
+                    SetValueFromInput();
+                }
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+            }
+        }
+
+        private void SetValueFromInput()
+        {
+            if (float.TryParse(x, out float fX)
+                && float.TryParse(y, out float fY)
+                && float.TryParse(z, out float fZ))
+            {
+                Value = Quaternion.Euler(new Vector3(fX, fY, fZ));
+                SetValue();
+            }
+        }
+    }
+}

src/CachedObjects/Struct/CacheRect.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Explorer
+{
+    public class CacheRect : CacheObjectBase
+    {
+        private string x = "0";
+        private string y = "0";
+        private string w = "0";
+        private string h = "0";
+
+        public override void UpdateValue()
+        {
+            base.UpdateValue();
+
+            var rect = (Rect)Value;
+
+            x = rect.x.ToString();
+            y = rect.y.ToString();
+            w = rect.width.ToString();
+            h = rect.height.ToString();
+        }
+
+        public override void DrawValue(Rect window, float width)
+        {
+            GUILayout.Label($"<color=yellow>Rect</color>: {((Rect)Value).ToString()}", null);
+
+            if (CanWrite)
+            {
+                GUILayout.EndHorizontal();
+                var whitespace = window.width - width - 90;
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("X:", new GUILayoutOption[] { GUILayout.Width(30) });
+                x = GUILayout.TextField(x, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("Y:", new GUILayoutOption[] { GUILayout.Width(30) });
+                y = GUILayout.TextField(y, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("W:", new GUILayoutOption[] { GUILayout.Width(30) });
+                w = GUILayout.TextField(w, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("H:", new GUILayoutOption[] { GUILayout.Width(30) });
+                h = GUILayout.TextField(h, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                // draw set value button
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                if (GUILayout.Button("<color=lime>Apply</color>", new GUILayoutOption[] { GUILayout.Width(155) }))
+                {
+                    SetValueFromInput();
+                }
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+            }
+        }
+
+        private void SetValueFromInput()
+        {
+            if (float.TryParse(x, out float fX)
+                && float.TryParse(y, out float fY)
+                && float.TryParse(w, out float fW)
+                && float.TryParse(h, out float fH))
+            {
+                Value = new Rect(fX, fY, fW, fH);
+                SetValue();
+            }
+        }
+    }
+}

src/CachedObjects/Struct/CacheVector.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Reflection;
+using UnityEngine;
+
+namespace Explorer
+{
+    public class CacheVector : CacheObjectBase
+    {
+        public int VectorSize = 2;
+
+        private string x = "0";
+        private string y = "0";
+        private string z = "0";
+        private string w = "0";
+
+        private MethodInfo m_toStringMethod;
+
+        public override void Init()
+        {
+            if (Value is Vector2)
+            {
+                VectorSize = 2;
+            }
+            else if (Value is Vector3)
+            {
+                VectorSize = 3;
+            }
+            else
+            {
+                VectorSize = 4;
+            }
+
+            m_toStringMethod = Value.GetType().GetMethod("ToString", new Type[0]);
+        }
+
+        public override void UpdateValue()
+        {
+            base.UpdateValue();
+
+            if (Value is Vector2 vec2)
+            {
+                x = vec2.x.ToString();
+                y = vec2.y.ToString();
+            }
+            else if (Value is Vector3 vec3)
+            {
+                x = vec3.x.ToString();
+                y = vec3.y.ToString();
+                z = vec3.z.ToString();
+            }
+            else if (Value is Vector4 vec4)
+            {
+                x = vec4.x.ToString();
+                y = vec4.y.ToString();
+                z = vec4.z.ToString();
+                w = vec4.w.ToString();
+            }
+        }
+
+        public override void DrawValue(Rect window, float width)
+        {
+            GUILayout.Label($"<color=yellow>Vector{VectorSize}</color>: {(string)m_toStringMethod.Invoke(Value, new object[0])}", null);            
+
+            if (CanWrite)
+            {
+                GUILayout.EndHorizontal();
+                var whitespace = window.width - width - 90;
+
+                // always draw x and y
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("X:", new GUILayoutOption[] { GUILayout.Width(30) });
+                x = GUILayout.TextField(x, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                GUILayout.Label("Y:", new GUILayoutOption[] { GUILayout.Width(30) });
+                y = GUILayout.TextField(y, new GUILayoutOption[] { GUILayout.Width(120) });
+                GUILayout.EndHorizontal();
+
+                if (VectorSize > 2)
+                {
+                    // draw z
+                    GUILayout.BeginHorizontal(null);
+                    GUILayout.Space(whitespace);
+                    GUILayout.Label("Z:", new GUILayoutOption[] { GUILayout.Width(30) });
+                    z = GUILayout.TextField(z, new GUILayoutOption[] { GUILayout.Width(120) });
+                    GUILayout.EndHorizontal();
+                }
+                if (VectorSize > 3)
+                {
+                    // draw w
+                    GUILayout.BeginHorizontal(null);
+                    GUILayout.Space(whitespace);
+                    GUILayout.Label("W:", new GUILayoutOption[] { GUILayout.Width(30) });
+                    w = GUILayout.TextField(w, new GUILayoutOption[] { GUILayout.Width(120) });
+                    GUILayout.EndHorizontal();
+                }
+
+                // draw set value button
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Space(whitespace);
+                if (GUILayout.Button("<color=lime>Apply</color>", new GUILayoutOption[] { GUILayout.Width(155) }))
+                {
+                    SetValueFromInput();
+                }
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+            }
+        }
+
+        private void SetValueFromInput()
+        {
+            if (float.TryParse(x, out float fX)
+                && float.TryParse(y, out float fY)
+                && float.TryParse(z, out float fZ)
+                && float.TryParse(w, out float fW))
+            {
+                object vector = null;
+
+                switch (VectorSize)
+                {
+                    case 2: vector = new Vector2(fX, fY); break;
+                    case 3: vector = new Vector3(fX, fY, fZ); break;
+                    case 4: vector = new Vector4(fX, fY, fZ, fW); break;
+                }
+
+                if (vector != null)
+                {
+                    Value = vector;
+                    SetValue();
+                }
+            }
+        }
+    }
+}

src/CppExplorer.cs

@@ -2,18 +2,18 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using UnityEngine;
+using System.Reflection;
+using Harmony;
 using MelonLoader;
 using UnhollowerBaseLib;
+using UnityEngine;
 
 namespace Explorer
 {
     public class CppExplorer : MelonMod
     {
-        // consts
-
-        public const string ID = "com.sinai.cppexplorer";
-        public const string VERSION = "1.4.1";
+        public const string GUID = "com.sinai.cppexplorer";
+        public const string VERSION = "1.6.1";
         public const string AUTHOR = "Sinai";
 
         public const string NAME = "CppExplorer"
@@ -22,27 +22,52 @@ namespace Explorer
 #endif
         ;
 
-        // fields
+        public static CppExplorer Instance { get; private set; }
 
-        public static CppExplorer Instance;
+        public static bool ShowMenu
+        {
+            get => m_showMenu;
+            set => SetShowMenu(value);
+        }
+        private static bool m_showMenu;
 
-        // props
+        public static bool ForceUnlockMouse
+        {
+            get => m_forceUnlock;
+            set => SetForceUnlock(value);
+        }
+        private static bool m_forceUnlock;
+        private static CursorLockMode m_lastLockMode;
+        private static bool m_lastVisibleState;
+        private static bool m_currentlySettingCursor = false;
 
-        public static bool ShowMenu { get; set; } = false;
-        public static int ArrayLimit { get; set; } = 20;
+        public static bool ShouldForceMouse => ShowMenu && ForceUnlockMouse;
 
-        // methods
+        private static void SetShowMenu(bool show)
+        {
+            m_showMenu = show;
+            UpdateCursorControl();
+        }
+
+        // ========== MonoBehaviour methods ==========
 
         public override void OnApplicationStart()
         {
-            base.OnApplicationStart();
-
             Instance = this;
 
             new MainMenu();
             new WindowManager();
 
-            ShowMenu = true;
+            // Get current cursor state and enable cursor
+            m_lastLockMode = Cursor.lockState;
+            m_lastVisibleState = Cursor.visible;
+
+            // Enable ShowMenu and ForceUnlockMouse 
+            // (set m_showMenu to not call UpdateCursorState twice)
+            m_showMenu = true;
+            SetForceUnlock(true);
+
+            MelonLogger.Log($"CppExplorer {VERSION} initialized.");
         }
 
         public override void OnLevelWasLoaded(int level)
@@ -53,6 +78,7 @@ namespace Explorer
 
         public override void OnUpdate()
         {
+            // Check main toggle key input
             if (Input.GetKeyDown(KeyCode.F7))
             {
                 ShowMenu = !ShowMenu;
@@ -60,27 +86,117 @@ namespace Explorer
 
             if (ShowMenu)
             {
-                if (!Cursor.visible)
+                // Check Force-Unlock input
+                if (Input.GetKeyDown(KeyCode.LeftAlt))
                 {
-                    Cursor.visible = true;
-                    Cursor.lockState = CursorLockMode.None;
+                    ForceUnlockMouse = !ForceUnlockMouse;
                 }
 
                 MainMenu.Instance.Update();
                 WindowManager.Instance.Update();
-
                 InspectUnderMouse.Update();
             }
         }
 
         public override void OnGUI()
         {
-            base.OnGUI();
+            if (!ShowMenu) return;
 
             MainMenu.Instance.OnGUI();
             WindowManager.Instance.OnGUI();
-
             InspectUnderMouse.OnGUI();
         }
+
+        // =========== Cursor control ===========
+
+        private static void SetForceUnlock(bool unlock)
+        {
+            m_forceUnlock = unlock;
+            UpdateCursorControl();
+        }
+
+        private static void UpdateCursorControl()
+        {
+            m_currentlySettingCursor = true;
+            if (ShouldForceMouse)
+            {
+                Cursor.lockState = CursorLockMode.None;
+                Cursor.visible = true;
+            }
+            else
+            {
+                Cursor.lockState = m_lastLockMode;
+                Cursor.visible = m_lastVisibleState;
+            }
+            m_currentlySettingCursor = false;
+        }
+
+        // Force mouse to stay unlocked and visible while UnlockMouse and ShowMenu are true.
+        // Also keep track of when anything else tries to set Cursor state, this will be the
+        // value that we set back to when we close the menu or disable force-unlock.
+
+        [HarmonyPatch(typeof(Cursor), nameof(Cursor.lockState), MethodType.Setter)]
+        public class Cursor_set_lockState
+        {
+            [HarmonyPrefix]
+            public static void Prefix(ref CursorLockMode value)
+            {
+                if (!m_currentlySettingCursor)
+                {
+                    m_lastLockMode = value;
+
+                    if (ShouldForceMouse)
+                    {
+                        value = CursorLockMode.None;
+                    }
+                }                
+            }
+        }
+
+        [HarmonyPatch(typeof(Cursor), nameof(Cursor.visible), MethodType.Setter)]
+        public class Cursor_set_visible
+        {
+            [HarmonyPrefix]
+            public static void Prefix(ref bool value)
+            {
+                if (!m_currentlySettingCursor)
+                {
+                    m_lastVisibleState = value;
+
+                    if (ShouldForceMouse)
+                    {
+                        value = true;
+                    }
+                }
+            }
+        }
+
+        // Make it appear as though UnlockMouse is disabled to the rest of the application.
+
+        [HarmonyPatch(typeof(Cursor), nameof(Cursor.lockState), MethodType.Getter)]
+        public class Cursor_get_lockState
+        {
+            [HarmonyPostfix]
+            public static void Postfix(ref CursorLockMode __result)
+            {
+                if (ShouldForceMouse)
+                {
+                    __result = m_lastLockMode;
+                }
+            }
+        }
+
+        [HarmonyPatch(typeof(Cursor), nameof(Cursor.visible), MethodType.Getter)]
+        public class Cursor_get_visible
+        {
+            [HarmonyPostfix]
+            public static void Postfix(ref bool __result)
+            {
+                if (ShouldForceMouse)
+                {
+                    __result = m_lastVisibleState;
+                }
+            }
+        }
     }
 }

src/CppExplorer.csproj

@@ -18,8 +18,8 @@
     <DebugSymbols>false</DebugSymbols>
     <DebugType>none</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>..\Release\</OutputPath>
-    <DefineConstants>DEBUG</DefineConstants>
+    <OutputPath>..\Release\2019\</OutputPath>
+    <DefineConstants>Release_2019</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <PlatformTarget>x64</PlatformTarget>
@@ -30,7 +30,7 @@
     <DebugSymbols>false</DebugSymbols>
     <DebugType>none</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>..\Release\</OutputPath>
+    <OutputPath>..\Release\2018\</OutputPath>
     <DefineConstants>Release_Unity2018</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
@@ -42,13 +42,9 @@
       <HintPath>..\..\..\..\..\Steam\steamapps\common\Hellpoint\MelonLoader\Managed\Il2Cppmscorlib.dll</HintPath>
       <Private>False</Private>
     </Reference>
-    <Reference Include="Il2CppSystem.Core">
-      <HintPath>..\..\..\..\..\Steam\steamapps\common\Hellpoint\MelonLoader\Managed\Il2CppSystem.Core.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <Reference Include="mcs">
       <HintPath>..\lib\mcs.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="MelonLoader.ModHandler">
       <HintPath>..\..\..\..\..\Steam\steamapps\common\Hellpoint\MelonLoader\MelonLoader.ModHandler.dll</HintPath>
@@ -64,10 +60,6 @@
       <HintPath>..\..\..\..\..\Steam\steamapps\common\Hellpoint\MelonLoader\Managed\UnhollowerBaseLib.dll</HintPath>
       <Private>False</Private>
     </Reference>
-    <Reference Include="UnhollowerRuntimeLib">
-      <HintPath>..\..\..\..\..\Steam\steamapps\common\Hellpoint\MelonLoader\Managed\UnhollowerRuntimeLib.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <!-- Unity 2019 build (InputLegacyModule.dll) -->
     <Reference Include="UnityEngine" Condition="'$(Configuration)'=='Debug'">
       <HintPath>..\..\..\Steam\steamapps\common\Hellpoint\MelonLoader\Managed\UnityEngine.dll</HintPath>
@@ -97,10 +89,6 @@
       <HintPath>..\..\..\Steam\steamapps\common\Hellpoint\MelonLoader\Managed\UnityEngine.UI.dll</HintPath>
       <Private>False</Private>
     </Reference>
-    <Reference Include="UnityEngine.UIElementsModule" Condition="'$(Configuration)'=='Debug'">
-      <HintPath>..\..\..\Steam\steamapps\common\Hellpoint\MelonLoader\Managed\UnityEngine.UIElementsModule.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <!-- Unity 2018 build (InputModule.dll) -->
     <Reference Include="UnityEngine" Condition="'$(Configuration)'=='Release_Unity2018'">
       <HintPath>..\..\..\Steam\steamapps\common\VRChat\MelonLoader\Managed\UnityEngine.dll</HintPath>
@@ -130,25 +118,35 @@
       <HintPath>..\..\..\Steam\steamapps\common\VRChat\MelonLoader\Managed\UnityEngine.UI.dll</HintPath>
       <Private>False</Private>
     </Reference>
-    <Reference Include="UnityEngine.UIElementsModule" Condition="'$(Configuration)'=='Release_Unity2018'">
-      <HintPath>..\..\..\Steam\steamapps\common\VRChat\MelonLoader\Managed\UnityEngine.UIElementsModule.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="CachedObjects\CacheEnum.cs" />
-    <Compile Include="CachedObjects\CacheGameObject.cs" />
-    <Compile Include="CachedObjects\CacheList.cs" />
-    <Compile Include="CachedObjects\CachePrimitive.cs" />
-    <Compile Include="CachedObjects\CacheOther.cs" />
+    <Compile Include="Helpers\IExpandHeight.cs" />
+    <Compile Include="CachedObjects\Struct\CacheColor.cs" />
+    <Compile Include="CachedObjects\Object\CacheDictionary.cs" />
+    <Compile Include="CachedObjects\Struct\CacheEnum.cs" />
+    <Compile Include="CachedObjects\Object\CacheGameObject.cs" />
+    <Compile Include="CachedObjects\Object\CacheList.cs" />
+    <Compile Include="CachedObjects\Struct\CachePrimitive.cs" />
+    <Compile Include="CachedObjects\Other\CacheOther.cs" />
+    <Compile Include="CachedObjects\Other\CacheMethod.cs" />
+    <Compile Include="CachedObjects\Struct\CacheQuaternion.cs" />
+    <Compile Include="CachedObjects\Struct\CacheVector.cs" />
+    <Compile Include="CachedObjects\Struct\CacheRect.cs" />
     <Compile Include="CppExplorer.cs" />
     <Compile Include="Extensions\ReflectionExtensions.cs" />
+    <Compile Include="UnstripFixes\GUIUnstrip.cs" />
+    <Compile Include="UnstripFixes\ScrollViewStateUnstrip.cs" />
     <Compile Include="Extensions\UnityExtensions.cs" />
+    <Compile Include="Helpers\PageHelper.cs" />
     <Compile Include="Helpers\ReflectionHelpers.cs" />
     <Compile Include="Helpers\UIHelpers.cs" />
     <Compile Include="Helpers\UnityHelpers.cs" />
     <Compile Include="MainMenu\InspectUnderMouse.cs" />
-    <Compile Include="CachedObjects\CacheObject.cs" />
+    <Compile Include="CachedObjects\CacheObjectBase.cs" />
+    <Compile Include="UnstripFixes\SliderHandlerUnstrip.cs" />
+    <Compile Include="UnstripFixes\UnstripExtensions.cs" />
+    <Compile Include="Windows\ResizeDrag.cs" />
+    <Compile Include="Windows\TabViewWindow.cs" />
     <Compile Include="Windows\UIWindow.cs" />
     <Compile Include="MainMenu\Pages\ConsolePage.cs" />
     <Compile Include="MainMenu\Pages\Console\REPL.cs" />

src/Extensions/UnityExtensions.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using UnhollowerBaseLib;
 using UnityEngine;
 
 namespace Explorer

src/Helpers/IExpandHeight.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Explorer
+{
+    interface IExpandHeight
+    {
+        bool IsExpanded { get; set; }
+
+        float WhiteSpace { get; set; }
+        float ButtonWidthOffset { get; set; }
+    }
+}

src/Helpers/PageHelper.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Explorer
+{
+    public enum Turn
+    {
+        Left,
+        Right
+    }
+
+    public class PageHelper
+    {
+        public int PageOffset { get; set; }
+
+        public int ItemsPerPage
+        {
+            get => m_itemsPerPage;
+            set
+            {
+                m_itemsPerPage = value;
+                CalculateMaxOffset();
+            }
+        }
+        private int m_itemsPerPage = 20;
+
+        public int ItemCount 
+        {
+            get => m_count;
+            set
+            {
+                m_count = value;
+                CalculateMaxOffset();
+            }
+        }
+        private int m_count;
+
+        public int MaxPageOffset { get; private set; } = -1;
+
+        private int CalculateMaxOffset()
+        {
+            return MaxPageOffset = (int)Mathf.Ceil((float)(ItemCount / (decimal)ItemsPerPage)) - 1;
+        }
+
+        public void CurrentPageLabel()
+        {
+            var orig = GUI.skin.label.alignment;
+            GUI.skin.label.alignment = TextAnchor.MiddleCenter;
+
+            GUILayout.Label($"Page {PageOffset + 1}/{MaxPageOffset + 1}", new GUILayoutOption[] { GUILayout.Width(80) });
+
+            GUI.skin.label.alignment = orig;
+        }
+
+        public void TurnPage(Turn direction)
+        {
+            var _ = Vector2.zero;
+            TurnPage(direction, ref _);
+        }
+
+        public void TurnPage(Turn direction, ref Vector2 scroll)
+        {
+            if (direction == Turn.Left)
+            {
+                if (PageOffset > 0) 
+                {
+                    PageOffset--;
+                    scroll = Vector2.zero;
+                }
+            }
+            else
+            {
+                if (PageOffset < MaxPageOffset)
+                {
+                    PageOffset++;
+                    scroll = Vector2.zero;
+                }
+            }
+        }
+
+        public int CalculateOffsetIndex()
+        {
+            int offset = PageOffset * ItemsPerPage;
+
+            if (offset >= ItemCount)
+            {
+                offset = 0;
+                PageOffset = 0;
+            }
+
+            return offset;
+        }
+
+        public void DrawLimitInputArea()
+        {
+            GUILayout.Label("Limit: ", new GUILayoutOption[] { GUILayout.Width(50) });
+            var limit = this.ItemsPerPage.ToString();
+            limit = GUILayout.TextField(limit, new GUILayoutOption[] { GUILayout.Width(50) });
+            if (limit != ItemsPerPage.ToString() && int.TryParse(limit, out int i))
+            {
+                ItemsPerPage = i;
+            }
+        }
+    }
+}

src/Helpers/ReflectionHelpers.cs

@@ -8,20 +8,21 @@ using UnhollowerBaseLib;
 using UnhollowerRuntimeLib;
 using UnityEngine;
 using BF = System.Reflection.BindingFlags;
-using ILBF = Il2CppSystem.Reflection.BindingFlags;
 using MelonLoader;
+using System.Collections;
+using Mono.CSharp;
 
 namespace Explorer
 {
     public class ReflectionHelpers
     {
         public static BF CommonFlags = BF.Public | BF.Instance | BF.NonPublic | BF.Static;
-        public static ILBF CommonFlags_IL = ILBF.Public | ILBF.NonPublic | ILBF.Instance | ILBF.Static;
 
         public static Il2CppSystem.Type GameObjectType => Il2CppType.Of<GameObject>();
         public static Il2CppSystem.Type TransformType => Il2CppType.Of<Transform>();
         public static Il2CppSystem.Type ObjectType => Il2CppType.Of<UnityEngine.Object>();
         public static Il2CppSystem.Type ComponentType => Il2CppType.Of<Component>();
+        public static Il2CppSystem.Type BehaviourType => Il2CppType.Of<Behaviour>();
 
         private static readonly MethodInfo m_tryCastMethodInfo = typeof(Il2CppObjectBase).GetMethod("TryCast");
 
@@ -29,8 +30,9 @@ namespace Explorer
         {
             if (!typeof(Il2CppSystem.Object).IsAssignableFrom(castTo)) return obj;
 
-            var generic = m_tryCastMethodInfo.MakeGenericMethod(castTo);
-            return generic.Invoke(obj, null);
+            return m_tryCastMethodInfo
+                    .MakeGenericMethod(castTo)
+                    .Invoke(obj, null);
         }
 
         public static string ExceptionToString(Exception e)
@@ -74,75 +76,96 @@ namespace Explorer
                 return false;
         }
 
-        public static bool IsList(Type t)
+        public static bool IsEnumerable(Type t)
         {
-            return t.IsGenericType
-                && t.GetGenericTypeDefinition() is Type typeDef
-                && (typeDef.IsAssignableFrom(typeof(List<>)) || typeDef.IsAssignableFrom(typeof(Il2CppSystem.Collections.Generic.List<>)));
+            return typeof(IEnumerable).IsAssignableFrom(t);
+        }
+
+        // Only Il2Cpp List needs this check. C# List is IEnumerable.
+        public static bool IsCppList(Type t)
+        {
+            if (t.IsGenericType && t.GetGenericTypeDefinition() is Type g)
+            {
+                return typeof(Il2CppSystem.Collections.Generic.List<>).IsAssignableFrom(g)
+                    || typeof(Il2CppSystem.Collections.Generic.IList<>).IsAssignableFrom(g);
+            }
+            else
+            {
+                return typeof(Il2CppSystem.Collections.IList).IsAssignableFrom(t);
+            }
+        }
+
+        public static bool IsDictionary(Type t)
+        {
+            if (typeof(IDictionary).IsAssignableFrom(t))
+            {
+                return true;
+            }
+
+            if (t.IsGenericType && t.GetGenericTypeDefinition() is Type g)
+            {
+                return typeof(Il2CppSystem.Collections.Generic.Dictionary<,>).IsAssignableFrom(g)
+                    || typeof(Il2CppSystem.Collections.Generic.IDictionary<,>).IsAssignableFrom(g);
+            }
+            else
+            {
+                return typeof(Il2CppSystem.Collections.IDictionary).IsAssignableFrom(t);
+            }
         }
 
         public static Type GetTypeByName(string typeName)
         {
             foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
             {
-                try
+                foreach (var type in GetTypesSafe(asm))
                 {
-                    if (asm.GetType(typeName) is Type type)
+                    if (type.FullName == typeName)
                     {
                         return type;
                     }
                 }
-                catch { }
             }
 
             return null;
         }
 
-        public static Type GetActualType(object m_object)
+        public static Type GetActualType(object obj)
         {
-            if (m_object == null) return null;
+            if (obj == null) return null;
 
-            if (m_object is Il2CppSystem.Object ilObject)
+            if (obj is Il2CppSystem.Object ilObject)
             {
-                var iltype = ilObject.GetIl2CppType();
-                return Type.GetType(iltype.AssemblyQualifiedName);
-            }
-            else
-            {
-                return m_object.GetType();
+                var ilTypeName = ilObject.GetIl2CppType().AssemblyQualifiedName;
+
+                if (Type.GetType(ilTypeName) is Type t && !t.FullName.Contains("System.RuntimeType"))
+                {
+                    return t;
+                }
+
+                return ilObject.GetType();
             }
+
+            return obj.GetType();
         }
 
-        public static Type[] GetAllBaseTypes(object m_object)
+        public static IEnumerable<Type> GetTypesSafe(Assembly asm)
+        {
+            try { return asm.GetTypes(); }
+            catch (ReflectionTypeLoadException e) { return e.Types.Where(x => x != null); }
+            catch { return Enumerable.Empty<Type>(); }
+        }
+
+        public static Type[] GetAllBaseTypes(object obj)
         {
             var list = new List<Type>();
 
-            if (m_object is Il2CppSystem.Object ilObject)
-            {
-                var ilType = ilObject.GetIl2CppType();
-                if (Type.GetType(ilType.AssemblyQualifiedName) is Type ilTypeToManaged)
-                {
-                    list.Add(ilTypeToManaged);
+            var type = GetActualType(obj);
+            list.Add(type);
 
-                    while (ilType.BaseType != null)
-                    {
-                        ilType = ilType.BaseType;
-                        if (Type.GetType(ilType.AssemblyQualifiedName) is Type ilBaseTypeToManaged)
-                        {
-                            list.Add(ilBaseTypeToManaged);
-                        }
-                    }
-                }
-            }
-            else
+            while (type.BaseType != null)
             {
-                var type = m_object.GetType();
+                type = type.BaseType;
                 list.Add(type);
-                while (type.BaseType != null)
-                {
-                    type = type.BaseType;
-                    list.Add(type);
-                }
             }
 
             return list.ToArray();

src/Helpers/UIHelpers.cs

@@ -3,6 +3,8 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.Reflection;
+using UnhollowerRuntimeLib;
 using UnityEngine;
 using Object = UnityEngine.Object;
 
@@ -22,11 +24,13 @@ namespace Explorer
         }
 
         // helper for drawing a styled button for a GameObject or Transform
-        public static void GameobjButton(GameObject obj, Action<GameObject> specialInspectMethod = null, bool showSmallInspectBtn = true, float width = 380)
+        public static void GOButton(object _obj, Action<Transform> specialInspectMethod = null, bool showSmallInspectBtn = true, float width = 380)
         {
-            bool children = obj.transform.childCount > 0;
+            var obj = (_obj as GameObject) ?? (_obj as Transform).gameObject;
 
-            string label = children ? "[" + obj.transform.childCount + " children] " : "";
+            bool hasChild = obj.transform.childCount > 0;
+
+            string label = hasChild ? $"[{obj.transform.childCount} children] " : "";
             label += obj.name;
 
             bool enabled = obj.activeSelf;
@@ -49,11 +53,13 @@ namespace Explorer
                 color = Color.red;
             }
 
-            FastGameobjButton(obj, color, label, obj.activeSelf, specialInspectMethod, showSmallInspectBtn, width);
+            GOButton_Impl(_obj, color, label, obj.activeSelf, specialInspectMethod, showSmallInspectBtn, width);
         }
 
-        public static void FastGameobjButton(GameObject obj, Color activeColor, string label, bool enabled, Action<GameObject> specialInspectMethod = null, bool showSmallInspectBtn = true, float width = 380)
+        public static void GOButton_Impl(object _obj, Color activeColor, string label, bool enabled, Action<Transform> specialInspectMethod = null, bool showSmallInspectBtn = true, float width = 380)
         {
+            var obj = _obj as GameObject ?? (_obj as Transform).gameObject;
+
             if (!obj)
             {
                 GUILayout.Label("<i><color=red>null</color></i>", null);
@@ -79,11 +85,11 @@ namespace Explorer
             {
                 if (specialInspectMethod != null)
                 {
-                    specialInspectMethod(obj);
+                    specialInspectMethod(obj.transform);
                 }
                 else
                 {
-                    WindowManager.InspectObject(obj, out bool _);
+                    WindowManager.InspectObject(_obj, out bool _);
                 }
             }
 
@@ -94,13 +100,18 @@ namespace Explorer
 
             if (showSmallInspectBtn)
             {
-                if (GUILayout.Button("Inspect", null))
-                {
-                    WindowManager.InspectObject(obj, out bool _);
-                }
+                SmallInspectButton(_obj);
             }
 
             GUILayout.EndHorizontal();
         }
+
+        public static void SmallInspectButton(object obj)
+        {
+            if (GUILayout.Button("Inspect", null))
+            {
+                WindowManager.InspectObject(obj, out bool _);
+            }
+        }
     }
 }

src/Helpers/UIStyles.cs

@@ -33,12 +33,14 @@ namespace Explorer
             }
         }
 
-        public static void HorizontalLine(Color color)
+        public static void HorizontalLine(Color _color, bool small = false)
         {
-            var c = GUI.color;
-            GUI.color = color;
-            GUILayout.Box(GUIContent.none, HorizontalBar, null);
-            GUI.color = c;
+            var orig = GUI.color;
+
+            GUI.color = _color;
+            GUILayout.Box(GUIContent.none, !small ? HorizontalBar : HorizontalBarSmall, null);
+
+            GUI.color = orig;
         }
 
         private static GUISkin _customSkin;
@@ -46,8 +48,6 @@ namespace Explorer
         public static Texture2D m_nofocusTex;
         public static Texture2D m_focusTex;
 
-        private static GUIStyle _horizBarStyle;
-
         private static GUIStyle HorizontalBar
         {
             get
@@ -56,21 +56,45 @@ namespace Explorer
                 {
                     _horizBarStyle = new GUIStyle();
                     _horizBarStyle.normal.background = Texture2D.whiteTexture;
-                    _horizBarStyle.margin = new RectOffset(0, 0, 4, 4);
+                    var rectOffset = new RectOffset();
+                    rectOffset.top = 4;
+                    rectOffset.bottom = 4;
+                    _horizBarStyle.margin = rectOffset;
                     _horizBarStyle.fixedHeight = 2;
                 }
 
                 return _horizBarStyle;
             }
         }
+        private static GUIStyle _horizBarStyle;
+
+        private static GUIStyle HorizontalBarSmall
+        {
+            get
+            {
+                if (_horizBarSmallStyle == null)
+                {
+                    _horizBarSmallStyle = new GUIStyle();
+                    _horizBarSmallStyle.normal.background = Texture2D.whiteTexture;
+                    var rectOffset = new RectOffset();
+                    rectOffset.top = 2;
+                    rectOffset.bottom = 2;
+                    _horizBarSmallStyle.margin = rectOffset;
+                    _horizBarSmallStyle.fixedHeight = 1;
+                }
+
+                return _horizBarSmallStyle;
+            }
+        }
+        private static GUIStyle _horizBarSmallStyle;
 
         private static GUISkin CreateWindowSkin()
         {
             var newSkin = Object.Instantiate(GUI.skin);
             Object.DontDestroyOnLoad(newSkin);
 
-            m_nofocusTex = MakeTex(550, 700, new Color(0.1f, 0.1f, 0.1f, 0.7f));
-            m_focusTex = MakeTex(550, 700, new Color(0.3f, 0.3f, 0.3f, 1f));
+            m_nofocusTex = MakeTex(1, 1, new Color(0.1f, 0.1f, 0.1f, 0.7f));
+            m_focusTex = MakeTex(1, 1, new Color(0.3f, 0.3f, 0.3f, 1f));
 
             newSkin.window.normal.background = m_nofocusTex;
             newSkin.window.onNormal.background = m_focusTex;

src/MainMenu/MainMenu.cs

@@ -51,15 +51,12 @@ namespace Explorer
 
         public void OnGUI()
         {
-            if (CppExplorer.ShowMenu)
-            {
-                var origSkin = GUI.skin;
-                GUI.skin = UIStyles.WindowSkin;
+            var origSkin = GUI.skin;
+            GUI.skin = UIStyles.WindowSkin;
 
-                MainRect = GUI.Window(MainWindowID, MainRect, (GUI.WindowFunction)MainWindow, CppExplorer.NAME);
+            MainRect = GUI.Window(MainWindowID, MainRect, (GUI.WindowFunction)MainWindow, CppExplorer.NAME);
 
-                GUI.skin = origSkin;
-            }
+            GUI.skin = origSkin;
         }
 
         private void MainWindow(int id)
@@ -77,30 +74,20 @@ namespace Explorer
             MainHeader();
 
             var page = Pages[m_currentPage];
-            page.scroll = GUILayout.BeginScrollView(page.scroll, GUI.skin.scrollView);
-            page.DrawWindow();
-            GUILayout.EndScrollView();
 
-            MainRect = WindowManager.ResizeWindow(MainRect, MainWindowID);
+            page.scroll = GUIUnstrip.BeginScrollView(page.scroll);
+
+            page.DrawWindow();
+
+            GUIUnstrip.EndScrollView();
+
+            MainRect = ResizeDrag.ResizeWindow(MainRect, MainWindowID);
 
             GUILayout.EndArea();
         }
 
         private void MainHeader()
         {
-            GUILayout.BeginHorizontal(null);
-            GUILayout.Label("<b>Options:</b>", new GUILayoutOption[] { GUILayout.Width(70) });
-            GUI.skin.label.alignment = TextAnchor.MiddleRight;
-            GUILayout.Label("Array Limit:", new GUILayoutOption[] { GUILayout.Width(70) });
-            GUI.skin.label.alignment = TextAnchor.UpperLeft;
-            var _input = GUILayout.TextField(CppExplorer.ArrayLimit.ToString(), new GUILayoutOption[] { GUILayout.Width(60) });
-            if (int.TryParse(_input, out int _lim))
-            {
-                CppExplorer.ArrayLimit = _lim;
-            }
-            InspectUnderMouse.EnableInspect = GUILayout.Toggle(InspectUnderMouse.EnableInspect, "Inspect Under Mouse (Shift + RMB)", null);
-            GUILayout.EndHorizontal();
-
             GUILayout.BeginHorizontal(null);
             for (int i = 0; i < Pages.Count; i++)
             {
@@ -116,6 +103,17 @@ namespace Explorer
             }
             GUILayout.EndHorizontal();
 
+            GUILayout.BeginHorizontal(null);
+            GUI.color = Color.white;
+            InspectUnderMouse.EnableInspect = GUILayout.Toggle(InspectUnderMouse.EnableInspect, "Inspect Under Mouse (Shift + RMB)", null);
+
+            bool mouseState = CppExplorer.ForceUnlockMouse;
+            bool setMouse = GUILayout.Toggle(mouseState, "Force Unlock Mouse (Left Alt)", null);
+            if (setMouse != mouseState) CppExplorer.ForceUnlockMouse = setMouse;
+
+            WindowManager.TabView = GUILayout.Toggle(WindowManager.TabView, "Tab View", null);
+            GUILayout.EndHorizontal();
+
             GUILayout.Space(10);
             GUI.color = Color.white;
         }

src/MainMenu/Pages/ConsolePage.cs

@@ -14,7 +14,7 @@ namespace Explorer
 {
     public class ConsolePage : WindowPage
     {
-        public override string Name { get => "C# Console"; set => base.Name = value; }
+        public override string Name { get => "C# Console"; }
 
         private ScriptEvaluator _evaluator;
         private readonly StringBuilder _sb = new StringBuilder();
@@ -86,11 +86,11 @@ MelonLogger.Log(""hello world"");";
             if (!UsingDirectives.Contains(asm))
             {
                 UsingDirectives.Add(asm);
-                Evaluate(AsmToUsing(asm));
+                Evaluate(AsmToUsing(asm), true);
             }
         }
 
-        public object Evaluate(string str)
+        public object Evaluate(string str, bool suppressWarning = false)
         {
             object ret = VoidType.Value;
 
@@ -98,11 +98,19 @@ MelonLogger.Log(""hello world"");";
 
             try
             {
-                compiled?.Invoke(ref ret);
+                if (compiled == null)
+                {
+                    throw new Exception("Mono.Csharp Service was unable to compile the code provided.");
+                }
+
+                compiled.Invoke(ref ret);
             }
             catch (Exception e)
             {
-                MelonLogger.LogWarning(e.ToString());
+                if (!suppressWarning)
+                {
+                    MelonLogger.LogWarning(e.GetType() + ", " + e.Message);
+                }
             }
 
             return ret;
@@ -113,8 +121,10 @@ MelonLogger.Log(""hello world"");";
         {
             GUILayout.Label("<b><size=15><color=cyan>C# REPL Console</color></size></b>", null);
 
-            GUILayout.Label("Method:", null);
-            MethodInput = GUILayout.TextArea(MethodInput, new GUILayoutOption[] { GUILayout.Height(300) });
+            GUI.skin.label.alignment = TextAnchor.UpperLeft;
+
+            GUILayout.Label("Enter code here as though it is a method body:", null);
+            MethodInput = GUILayout.TextArea(MethodInput, new GUILayoutOption[] { GUILayout.Height(250) });
 
             if (GUILayout.Button("<color=cyan><b>Execute</b></color>", null))
             {
@@ -139,12 +149,9 @@ MelonLogger.Log(""hello world"");";
             }
 
             GUILayout.Label("<b>Using directives:</b>", null);
-            foreach (var asm in UsingDirectives)
-            {
-                GUILayout.Label(AsmToUsing(asm, true), null);
-            }
+
             GUILayout.BeginHorizontal(null);
-            GUILayout.Label("Add namespace:", new GUILayoutOption[] { GUILayout.Width(110) });
+            GUILayout.Label("Add namespace:", new GUILayoutOption[] { GUILayout.Width(105) });
             UsingInput = GUILayout.TextField(UsingInput, new GUILayoutOption[] { GUILayout.Width(150) });
             if (GUILayout.Button("<b><color=lime>Add</color></b>", new GUILayoutOption[] { GUILayout.Width(120) }))
             {
@@ -155,6 +162,11 @@ MelonLogger.Log(""hello world"");";
                 ResetConsole();
             }
             GUILayout.EndHorizontal();
+
+            foreach (var asm in UsingDirectives)
+            {
+                GUILayout.Label(AsmToUsing(asm, true), null);
+            }            
         }
 
         public override void Update() { }

src/MainMenu/Pages/ScenePage.cs

@@ -12,23 +12,26 @@ namespace Explorer
     {
         public static ScenePage Instance;
 
-        public override string Name { get => "Scene Explorer"; set => base.Name = value; }
+        public override string Name { get => "Scene Explorer"; }
 
-        // ----- Holders for GUI elements ----- //
+        public PageHelper Pages = new PageHelper();
 
-        private string m_currentScene = "";
+        private float m_timeOfLastUpdate = -1f;
+        private const int PASSIVE_UPDATE_INTERVAL = 1;
+
+        private static bool m_getRootObjectsFailed;
+
+        private static string m_currentScene = "";
 
         // gameobject list
         private Transform m_currentTransform;
-        private List<GameObjectCache> m_objectList = new List<GameObjectCache>();
+        private readonly List<GameObjectCache> m_objectList = new List<GameObjectCache>();
 
         // search bar
         private bool m_searching = false;
         private string m_searchInput = "";
         private List<GameObjectCache> m_searchResults = new List<GameObjectCache>();
 
-        // ------------ Init and Update ------------ //
-
         public override void Init()
         {
             Instance = this;
@@ -37,190 +40,28 @@ namespace Explorer
         public void OnSceneChange()
         {
             m_currentScene = UnityHelpers.ActiveSceneName;
-
-            m_currentTransform = null;
-            CancelSearch();
+            SetTransformTarget(null);
         }
 
-        public override void Update()
+        public void SetTransformTarget(Transform t)
         {
-            if (!m_searching)
-            {
-                m_objectList = new List<GameObjectCache>();
-                if (m_currentTransform)
-                {
-                    var endAppend = new List<GameObjectCache>();
-                    for (int i = 0; i < m_currentTransform.childCount; i++)
-                    {
-                        var child = m_currentTransform.GetChild(i);
+            m_currentTransform = t;
 
-                        if (child)
-                        {
-                            if (child.childCount > 0)
-                                m_objectList.Add(new GameObjectCache(child.gameObject));
-                            else
-                                endAppend.Add(new GameObjectCache(child.gameObject));
-                        }
-                    }
-                    m_objectList.AddRange(endAppend);
-                    endAppend = null;
-                }
-                else
-                {
-                    var scene = SceneManager.GetSceneByName(m_currentScene);
-                    var rootObjects = scene.GetRootGameObjects();
+            if (m_searching)
+                CancelSearch();
 
-                    // add objects with children first
-                    foreach (var obj in rootObjects.Where(x => x.transform.childCount > 0))
-                    {
-                        m_objectList.Add(new GameObjectCache(obj));
-                    }
-                    foreach (var obj in rootObjects.Where(x => x.transform.childCount == 0))
-                    {
-                        m_objectList.Add(new GameObjectCache(obj));
-                    }
-                }
-            }
-        }
-
-        // --------- GUI Draw Functions --------- //        
-
-        public override void DrawWindow()
-        {
-            try
-            {
-                GUILayout.BeginHorizontal(null);
-                // Current Scene label
-                GUILayout.Label("Current Scene:", new GUILayoutOption[] { GUILayout.Width(120) });
-                try
-                {
-                    // Need to do 'ToList()' so the object isn't cleaned up by Il2Cpp GC.
-                    var scenes = SceneManager.GetAllScenes().ToList();
-
-                    if (scenes.Count > 1)
-                    {
-                        int changeWanted = 0;
-                        if (GUILayout.Button("<", new GUILayoutOption[] { GUILayout.Width(30) }))
-                        {
-                            changeWanted = -1;
-                        }
-                        if (GUILayout.Button(">", new GUILayoutOption[] { GUILayout.Width(30) }))
-                        {
-                            changeWanted = 1;
-                        }
-                        if (changeWanted != 0)
-                        {
-                            int index = scenes.IndexOf(SceneManager.GetSceneByName(m_currentScene));
-                            index += changeWanted;
-                            if (index > scenes.Count - 1)
-                            {
-                                index = 0;
-                            }
-                            else if (index < 0)
-                            {
-                                index = scenes.Count - 1;
-                            }
-                            m_currentScene = scenes[index].name;
-                        }
-                    }
-                }
-                catch { }
-                GUILayout.Label("<color=cyan>" + m_currentScene + "</color>", null); //new GUILayoutOption[] { GUILayout.Width(250) });
-
-                GUILayout.EndHorizontal();
-
-                // ----- GameObject Search -----
-                GUILayout.BeginHorizontal(GUI.skin.box, null);
-                GUILayout.Label("<b>Search Scene:</b>", new GUILayoutOption[] { GUILayout.Width(100) });
-                m_searchInput = GUILayout.TextField(m_searchInput, null);
-                if (GUILayout.Button("Search", new GUILayoutOption[] { GUILayout.Width(80) }))
-                {
-                    Search();
-                }
-                GUILayout.EndHorizontal();
-
-                GUILayout.Space(15);
-
-                // ************** GameObject list ***************
-
-                // ----- main explorer ------
-                if (!m_searching)
-                {
-                    if (m_currentTransform != null)
-                    {
-                        GUILayout.BeginHorizontal(null);
-                        if (GUILayout.Button("<-", new GUILayoutOption[] { GUILayout.Width(35) }))
-                        {
-                            TraverseUp();
-                        }
-                        else
-                        {
-                            GUILayout.Label(m_currentTransform.GetGameObjectPath(), null);
-                        }
-                        GUILayout.EndHorizontal();
-                    }
-                    else
-                    {
-                        GUILayout.Label("Scene Root GameObjects:", null);
-                    }
-
-                    if (m_objectList.Count > 0)
-                    {
-                        foreach (var obj in m_objectList)
-                        {
-                            //UIStyles.GameobjButton(obj, SetTransformTarget, true, MainMenu.MainRect.width - 170);
-                            UIHelpers.FastGameobjButton(obj.RefGameObject, obj.EnabledColor, obj.Label, obj.RefGameObject.activeSelf, SetTransformTarget, true, MainMenu.MainRect.width - 170);
-                        }
-                    }
-                }
-                else // ------ Scene Search results ------
-                {
-                    if (GUILayout.Button("<-", new GUILayoutOption[] { GUILayout.Width(35) }))
-                    {
-                        CancelSearch();
-                    }
-
-                    GUILayout.Label("Search Results:", null);
-
-                    if (m_searchResults.Count > 0)
-                    {
-                        foreach (var obj in m_searchResults)
-                        {
-                            //UIStyles.GameobjButton(obj, SetTransformTarget, true, MainMenu.MainRect.width - 170);
-                            UIHelpers.FastGameobjButton(obj.RefGameObject, obj.EnabledColor, obj.Label, obj.RefGameObject.activeSelf, SetTransformTarget, true, MainMenu.MainRect.width - 170);
-                        }
-                    }
-                    else
-                    {
-                        GUILayout.Label("<color=red><i>No results found!</i></color>", null);
-                    }
-                }
-            }
-            catch
-            {
-                m_currentTransform = null;
-            }
-        }
-
-
-
-        // -------- Actual Methods (not drawing GUI) ---------- //
-
-        public void SetTransformTarget(GameObject obj)
-        {
-            m_currentTransform = obj.transform;
-            CancelSearch();
+            Update_Impl(true);
         }
 
         public void TraverseUp()
         {
             if (m_currentTransform.parent != null)
             {
-                m_currentTransform = m_currentTransform.parent;
+                SetTransformTarget(m_currentTransform.parent);
             }
             else
             {
-                m_currentTransform = null;
+                SetTransformTarget(null);
             }
         }
 
@@ -228,27 +69,351 @@ namespace Explorer
         {
             m_searchResults = SearchSceneObjects(m_searchInput);
             m_searching = true;
+            Pages.ItemCount = m_searchResults.Count;
         }
 
         public void CancelSearch()
         {
             m_searching = false;
+
+            if (m_getRootObjectsFailed && !m_currentTransform)
+            {
+                GetRootObjectsManual_Impl();
+            }
         }
 
         public List<GameObjectCache> SearchSceneObjects(string _search)
         {
             var matches = new List<GameObjectCache>();
 
-            foreach (var obj in Resources.FindObjectsOfTypeAll<GameObject>())
+            foreach (var obj in Resources.FindObjectsOfTypeAll(ReflectionHelpers.GameObjectType))
             {
-                if (obj.name.ToLower().Contains(_search.ToLower()) && obj.scene.name == m_currentScene)
+                var go = obj.TryCast<GameObject>();
+                if (go.name.ToLower().Contains(_search.ToLower()) && go.scene.name == m_currentScene)
                 {
-                    matches.Add(new GameObjectCache(obj));
+                    matches.Add(new GameObjectCache(go));
                 }
             }
 
             return matches;
         }
+
+        public override void Update()
+        {
+            if (m_searching) return;
+
+            if (Time.time - m_timeOfLastUpdate < PASSIVE_UPDATE_INTERVAL) return;
+            m_timeOfLastUpdate = Time.time;
+
+            Update_Impl();
+        }
+
+        private void Update_Impl(bool manual = false)
+        {
+            List<Transform> allTransforms = new List<Transform>();
+
+            // get current list of all transforms (either scene root or our current transform children)
+            if (m_currentTransform)
+            {
+                for (int i = 0; i < m_currentTransform.childCount; i++)
+                {
+                    allTransforms.Add(m_currentTransform.GetChild(i));
+                }
+            }
+            else
+            {
+                if (!m_getRootObjectsFailed)
+                {
+                    try
+                    {
+                        var scene = SceneManager.GetSceneByName(m_currentScene);
+
+                        allTransforms.AddRange(scene.GetRootGameObjects()
+                                                    .Select(it => it.transform));
+                    }
+                    catch
+                    {
+                        MelonLogger.Log("Exception getting root scene objects, falling back to backup method...");
+
+                        m_getRootObjectsFailed = true;
+                        allTransforms.AddRange(GetRootObjectsManual_Impl());
+                    }
+                }
+                else
+                {
+                    if (!manual)
+                    {
+                        return;
+                    }
+
+                    allTransforms.AddRange(GetRootObjectsManual_Impl());
+                }
+            }
+
+            Pages.ItemCount = allTransforms.Count;
+
+            int offset = Pages.CalculateOffsetIndex();
+
+            // sort by childcount
+            allTransforms.Sort((a, b) => b.childCount.CompareTo(a.childCount));
+
+            m_objectList.Clear();
+
+            for (int i = offset; i < offset + Pages.ItemsPerPage && i < Pages.ItemCount; i++)
+            {
+                var child = allTransforms[i];
+                m_objectList.Add(new GameObjectCache(child.gameObject));
+            }
+        }
+
+        private IEnumerable<Transform> GetRootObjectsManual_Impl()
+        {
+            try
+            {
+                var array = Resources.FindObjectsOfTypeAll(ReflectionHelpers.TransformType);
+
+                var list = new List<Transform>();
+                foreach (var obj in array)
+                {
+                    var transform = obj.TryCast<Transform>();
+                    if (transform.parent == null && transform.gameObject.scene.name == m_currentScene)
+                    {
+                        list.Add(transform);
+                    }
+                }
+                return list;
+            }
+            catch (Exception e)
+            {
+                MelonLogger.Log("Exception getting root scene objects (manual): " 
+                    + e.GetType() + ", " + e.Message + "\r\n" 
+                    + e.StackTrace);
+                return new Transform[0];
+            }
+        }
+
+        // --------- GUI Draw Function --------- //        
+
+        public override void DrawWindow()
+        {
+            try
+            {
+                DrawHeaderArea();
+
+                GUILayout.BeginVertical(GUI.skin.box, null);
+
+                DrawPageButtons();
+
+                if (!m_searching)
+                {
+                    DrawGameObjectList();
+                }
+                else
+                {
+                    DrawSearchResultsList();
+                }
+
+                GUILayout.EndVertical();
+            }
+            catch (Exception e)
+            {
+                MelonLogger.Log("Exception drawing ScenePage! " + e.GetType() + ", " + e.Message);
+                MelonLogger.Log(e.StackTrace);
+                m_currentTransform = null;
+            }
+        }
+
+        private void DrawHeaderArea()
+        {
+            GUILayout.BeginHorizontal(null);
+
+            // Current Scene label
+            GUILayout.Label("Current Scene:", new GUILayoutOption[] { GUILayout.Width(120) });
+            try
+            {
+                // Need to do 'ToList()' so the object isn't cleaned up by Il2Cpp GC.
+                var scenes = SceneManager.GetAllScenes().ToList();
+
+                if (scenes.Count > 1)
+                {
+                    int changeWanted = 0;
+                    if (GUILayout.Button("<", new GUILayoutOption[] { GUILayout.Width(30) }))
+                    {
+                        changeWanted = -1;
+                    }
+                    if (GUILayout.Button(">", new GUILayoutOption[] { GUILayout.Width(30) }))
+                    {
+                        changeWanted = 1;
+                    }
+                    if (changeWanted != 0)
+                    {
+                        int index = scenes.IndexOf(SceneManager.GetSceneByName(m_currentScene));
+                        index += changeWanted;
+                        if (index > scenes.Count - 1)
+                        {
+                            index = 0;
+                        }
+                        else if (index < 0)
+                        {
+                            index = scenes.Count - 1;
+                        }
+                        m_currentScene = scenes[index].name;
+                    }
+                }
+            }
+            catch { }
+            GUILayout.Label("<color=cyan>" + m_currentScene + "</color>", null); //new GUILayoutOption[] { GUILayout.Width(250) });
+
+            GUILayout.EndHorizontal();
+
+            // ----- GameObject Search -----
+            GUILayout.BeginHorizontal(GUI.skin.box, null);
+            GUILayout.Label("<b>Search Scene:</b>", new GUILayoutOption[] { GUILayout.Width(100) });
+            m_searchInput = GUILayout.TextField(m_searchInput, null);
+            if (GUILayout.Button("Search", new GUILayoutOption[] { GUILayout.Width(80) }))
+            {
+                Search();
+            }
+            GUILayout.EndHorizontal();
+
+            GUILayout.Space(5);
+        }
+
+        private void DrawPageButtons()
+        {
+            GUILayout.BeginHorizontal(null);
+
+            Pages.DrawLimitInputArea();
+
+            if (Pages.ItemCount > Pages.ItemsPerPage)
+            {
+                if (GUILayout.Button("< Prev", new GUILayoutOption[] { GUILayout.Width(80) }))
+                {
+                    Pages.TurnPage(Turn.Left, ref this.scroll);
+
+                    Update_Impl(true);
+                }
+
+                Pages.CurrentPageLabel();
+
+                if (GUILayout.Button("Next >", new GUILayoutOption[] { GUILayout.Width(80) }))
+                {
+                    Pages.TurnPage(Turn.Right, ref this.scroll);
+
+                    Update_Impl(true);
+                }
+            }
+
+            GUILayout.EndHorizontal();
+            GUI.skin.label.alignment = TextAnchor.UpperLeft;
+        }
+
+        private void DrawGameObjectList()
+        {
+            if (m_currentTransform != null)
+            {
+                GUILayout.BeginHorizontal(null);
+                if (GUILayout.Button("<-", new GUILayoutOption[] { GUILayout.Width(35) }))
+                {
+                    TraverseUp();
+                }
+                else
+                {
+                    GUILayout.Label("<color=cyan>" + m_currentTransform.GetGameObjectPath() + "</color>",
+                        new GUILayoutOption[] { GUILayout.Width(MainMenu.MainRect.width - 187f) });
+                }
+
+                UIHelpers.SmallInspectButton(m_currentTransform);
+                
+                GUILayout.EndHorizontal();
+            }
+            else
+            {
+                GUILayout.Label("Scene Root GameObjects:", null);
+
+                if (m_getRootObjectsFailed)
+                {
+                    if (GUILayout.Button("Update Root Object List (auto-update failed!)", null))
+                    {
+                        Update_Impl(true);
+                    }
+                }
+            }
+
+            if (m_objectList.Count > 0)
+            {
+                for (int i = 0; i < m_objectList.Count; i++)
+                {
+                    var obj = m_objectList[i];
+
+                    if (obj == null) continue;
+
+                    if (!obj.RefGameObject)
+                    {
+                        string label = "<color=red><i>null";
+
+                        if (obj.RefGameObject != null)
+                        {
+                            label += " (Destroyed)";
+                        }
+
+                        label += "</i></color>";
+                        GUILayout.Label(label, null);
+                    }
+                    else
+                    {
+                        UIHelpers.GOButton_Impl(obj.RefGameObject,
+                        obj.EnabledColor,
+                        obj.Label,
+                        obj.RefGameObject.activeSelf,
+                        SetTransformTarget,
+                        true,
+                        MainMenu.MainRect.width - 170);
+                    }
+                }
+            }
+        }
+
+        private void DrawSearchResultsList()
+        {
+            if (GUILayout.Button("<- Cancel Search", new GUILayoutOption[] { GUILayout.Width(150) }))
+            {
+                CancelSearch();
+            }
+
+            GUILayout.Label("Search Results:", null);
+
+            if (m_searchResults.Count > 0)
+            {
+                int offset = Pages.CalculateOffsetIndex();
+
+                for (int i = offset; i < offset + Pages.ItemsPerPage && i < m_searchResults.Count; i++)
+                {
+                    var obj = m_searchResults[i];
+
+                    if (obj.RefGameObject)
+                    {
+                        UIHelpers.GOButton_Impl(obj.RefGameObject,
+                        obj.EnabledColor,
+                        obj.Label,
+                        obj.RefGameObject.activeSelf,
+                        SetTransformTarget,
+                        true,
+                        MainMenu.MainRect.width - 170);
+                    }
+                    else
+                    {
+                        GUILayout.Label("<i><color=red>Null or destroyed!</color></i>", null);
+                    }
+                }
+            }
+            else
+            {
+                GUILayout.Label("<color=red><i>No results found!</i></color>", null);
+            }
+        }
+
+        // -------- Mini GameObjectCache class ---------- //
     
         public class GameObjectCache
         {

src/MainMenu/Pages/SearchPage.cs

@@ -5,11 +5,7 @@ using System.Linq;
 using System.Text;
 using UnityEngine;
 using System.Reflection;
-using UnityEngine.SceneManagement;
-using Object = UnityEngine.Object;
-using UnhollowerRuntimeLib;
 using MelonLoader;
-using UnhollowerBaseLib;
 
 namespace Explorer
 {
@@ -17,16 +13,16 @@ namespace Explorer
     {
         public static SearchPage Instance;
 
-        public override string Name { get => "Object Search"; set => base.Name = value; }
+        public override string Name { get => "Object Search"; }
 
         private string m_searchInput = "";
         private string m_typeInput = "";
-        private int m_limit = 20;
-        private int m_pageOffset = 0;
-        //private List<object> m_searchResults = new List<object>();
+
         private Vector2 resultsScroll = Vector2.zero;
 
-        private List<CacheObject> m_searchResults = new List<CacheObject>();
+        public PageHelper Pages = new PageHelper();
+
+        private List<CacheObjectBase> m_searchResults = new List<CacheObjectBase>();
 
         public SceneFilter SceneMode = SceneFilter.Any;
         public TypeFilter TypeMode = TypeFilter.Object;
@@ -55,7 +51,7 @@ namespace Explorer
         public void OnSceneChange()
         {
             m_searchResults.Clear();
-            m_pageOffset = 0;
+            Pages.PageOffset = 0;
         }
 
         public override void Update() 
@@ -64,7 +60,7 @@ namespace Explorer
 
         private void CacheResults(IEnumerable results)
         {
-            m_searchResults = new List<CacheObject>();
+            m_searchResults = new List<CacheObjectBase>();
 
             foreach (var obj in results)
             {
@@ -75,9 +71,12 @@ namespace Explorer
                     toCache = ilObject.TryCast<GameObject>() ?? ilObject.TryCast<Transform>()?.gameObject ?? ilObject;
                 }
 
-                var cache = CacheObject.GetCacheObject(toCache);
+                var cache = CacheObjectBase.GetCacheObject(toCache);
                 m_searchResults.Add(cache);
             }
+
+            Pages.ItemCount = m_searchResults.Count; 
+            Pages.PageOffset = 0;
         }
 
         public override void DrawWindow()
@@ -90,8 +89,7 @@ namespace Explorer
                 if (GUILayout.Button("Find Static Instances", new GUILayoutOption[] { GUILayout.Width(180) }))
                 {
                     //m_searchResults = GetInstanceClassScanner().ToList();
-                    CacheResults(GetInstanceClassScanner());
-                    m_pageOffset = 0;
+                    CacheResults(GetInstanceClassScanner());                    
                 }
                 GUILayout.EndHorizontal();
 
@@ -107,38 +105,43 @@ namespace Explorer
 
                 int count = m_searchResults.Count;
 
-                if (count > this.m_limit)
+                GUILayout.BeginHorizontal(null);
+
+                Pages.DrawLimitInputArea();
+
+                if (count > Pages.ItemsPerPage)
                 {
                     // prev/next page buttons
-                    GUILayout.BeginHorizontal(null);
-                    int maxOffset = (int)Mathf.Ceil((float)(count / (decimal)m_limit)) - 1;
-                    if (GUILayout.Button("< Prev", null))
-                    {
-                        if (m_pageOffset > 0) m_pageOffset--;
-                    }
 
-                    GUILayout.Label($"Page {m_pageOffset + 1}/{maxOffset + 1}", new GUILayoutOption[] { GUILayout.Width(80) });
-
-                    if (GUILayout.Button("Next >", null))
+                    if (Pages.ItemCount > Pages.ItemsPerPage)
                     {
-                        if (m_pageOffset < maxOffset) m_pageOffset++;
+                        if (GUILayout.Button("< Prev", new GUILayoutOption[] { GUILayout.Width(80) }))
+                        {
+                            Pages.TurnPage(Turn.Left, ref this.resultsScroll);
+                        }
+
+                        Pages.CurrentPageLabel();
+
+                        if (GUILayout.Button("Next >", new GUILayoutOption[] { GUILayout.Width(80) }))
+                        {
+                            Pages.TurnPage(Turn.Right, ref this.resultsScroll);
+                        }
                     }
-                    GUILayout.EndHorizontal();
                 }
 
-                resultsScroll = GUILayout.BeginScrollView(resultsScroll, GUI.skin.scrollView);
+                GUILayout.EndHorizontal();
+
+                resultsScroll = GUIUnstrip.BeginScrollView(resultsScroll);
 
                 var _temprect = new Rect(MainMenu.MainRect.x, MainMenu.MainRect.y, MainMenu.MainRect.width + 160, MainMenu.MainRect.height);
 
                 if (m_searchResults.Count > 0)
                 {
-                    int offset = m_pageOffset * this.m_limit;
-                    if (offset >= count) m_pageOffset = 0;
+                    int offset = Pages.CalculateOffsetIndex();
 
-                    for (int i = offset; i < offset + CppExplorer.ArrayLimit && i < count; i++)
+                    for (int i = offset; i < offset + Pages.ItemsPerPage && i < count; i++)
                     {
                         m_searchResults[i].Draw(MainMenu.MainRect, 0f);
-                        //m_searchResults[i].DrawValue(MainMenu.MainRect);
                     }
                 }
                 else
@@ -146,7 +149,7 @@ namespace Explorer
                     GUILayout.Label("<color=red><i>No results found!</i></color>", null);
                 }
 
-                GUILayout.EndScrollView();
+                GUIUnstrip.EndScrollView();
                 GUILayout.EndVertical();
             }
             catch
@@ -169,16 +172,6 @@ namespace Explorer
             GUILayout.Label("Name Contains:", new GUILayoutOption[] { GUILayout.Width(100) });
             m_searchInput = GUILayout.TextField(m_searchInput, new GUILayoutOption[] { GUILayout.Width(200) });
 
-            GUI.skin.label.alignment = TextAnchor.MiddleRight;
-            GUILayout.Label("Results per page:", new GUILayoutOption[] { GUILayout.Width(120) });
-            var resultinput = m_limit.ToString();
-            resultinput = GUILayout.TextField(resultinput, new GUILayoutOption[] { GUILayout.Width(55) });
-            if (int.TryParse(resultinput, out int _i) && _i > 0)
-            {
-                m_limit = _i;
-            }
-            GUI.skin.label.alignment = TextAnchor.UpperLeft;
-
             GUILayout.EndHorizontal();
 
             GUILayout.BeginHorizontal(null);
@@ -256,11 +249,11 @@ namespace Explorer
 
         private void Search()
         {
-            m_pageOffset = 0;
+            Pages.PageOffset = 0;
             CacheResults(FindAllObjectsOfType(m_searchInput, m_typeInput));
         }
 
-        private List<object> FindAllObjectsOfType(string _search, string _type)
+        private List<object> FindAllObjectsOfType(string searchQuery, string typeName)
         {
             Il2CppSystem.Type searchType = null;
 
@@ -268,13 +261,18 @@ namespace Explorer
             {
                 try
                 {
-                    var findType = ReflectionHelpers.GetTypeByName(_type);
-                    searchType = Il2CppSystem.Type.GetType(findType.AssemblyQualifiedName);
-                    //MelonLogger.Log("Search type: " + findType.AssemblyQualifiedName);
+                    if (ReflectionHelpers.GetTypeByName(typeName) is Type t)
+                    {
+                        searchType = Il2CppSystem.Type.GetType(t.AssemblyQualifiedName);
+                    }
+                    else
+                    {
+                        throw new Exception($"Could not find a Type by the name of '{typeName}'!");
+                    }
                 }
                 catch (Exception e)
                 {
-                    MelonLogger.Log("Exception: " + e.GetType() + ", " + e.Message + "\r\n" + e.StackTrace);
+                    MelonLogger.Log("Exception getting Search Type: " + e.GetType() + ", " + e.Message);
                 }
             }
             else if (TypeMode == TypeFilter.Object)
@@ -292,7 +290,10 @@ namespace Explorer
 
             if (!ReflectionHelpers.ObjectType.IsAssignableFrom(searchType))
             {
-                MelonLogger.LogError("Your Custom Class Type must inherit from UnityEngine.Object!");
+                if (searchType != null)
+                {
+                    MelonLogger.LogWarning("Your Custom Class Type must inherit from UnityEngine.Object!");
+                }
                 return new List<object>();
             }
 
@@ -307,12 +308,13 @@ namespace Explorer
             {
                 if (i >= 2000) break;
 
-                if (_search != "" && !obj.name.ToLower().Contains(_search.ToLower()))
+                if (searchQuery != "" && !obj.name.ToLower().Contains(searchQuery.ToLower()))
                 {
                     continue;
                 }
 
-                if (searchType == ReflectionHelpers.ComponentType && ReflectionHelpers.TransformType.IsAssignableFrom(obj.GetIl2CppType()))
+                if (searchType.FullName == ReflectionHelpers.ComponentType.FullName
+                    && ReflectionHelpers.TransformType.IsAssignableFrom(obj.GetIl2CppType()))
                 {
                     // Transforms shouldn't really be counted as Components, skip them.
                     // They're more akin to GameObjects.
@@ -370,43 +372,70 @@ namespace Explorer
 
         // ====== other ========
 
+        private static bool FilterName(string name)
+        {
+            // Don't really want these instances.
+            return !name.StartsWith("Mono") 
+                && !name.StartsWith("System") 
+                && !name.StartsWith("Il2CppSystem") 
+                && !name.StartsWith("Iced");
+        }
+
         // credit: ManlyMarco (RuntimeUnityEditor)
         public static IEnumerable<object> GetInstanceClassScanner()
         {
             var query = AppDomain.CurrentDomain.GetAssemblies()
-                .Where(x => !x.FullName.StartsWith("Mono"))
-                .SelectMany(GetTypesSafe)
+                .SelectMany(ReflectionHelpers.GetTypesSafe)
                 .Where(t => t.IsClass && !t.IsAbstract && !t.ContainsGenericParameters);
 
+            var flags = BindingFlags.Public | BindingFlags.Static;
+            var flatFlags = flags | BindingFlags.FlattenHierarchy;
+
             foreach (var type in query)
             {
                 object obj = null;
                 try
                 {
-                    obj = type.GetProperty("Instance", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)?.GetValue(null, null);
-                }
-                catch
-                {
-                    try
+                    var pi = type.GetProperty("Instance", flags);
+
+                    if (pi == null)
                     {
-                        obj = type.GetField("Instance", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)?.GetValue(null);
+                        pi = type.GetProperty("Instance", flatFlags);
                     }
-                    catch
+
+                    if (pi != null)
                     {
+                        obj = pi.GetValue(null);
+                    }
+                    else
+                    {
+                        var fi = type.GetField("Instance", flags);
+
+                        if (fi == null)
+                        {
+                            fi = type.GetField("Instance", flatFlags);
+                        }
+
+                        if (fi != null)
+                        {
+                            obj = fi.GetValue(null);
+                        }
                     }
                 }
-                if (obj != null && !obj.ToString().StartsWith("Mono"))
+                catch { }
+
+                if (obj != null)
                 {
+                    var t = ReflectionHelpers.GetActualType(obj);
+
+                    if (!FilterName(t.FullName) || ReflectionHelpers.IsEnumerable(t) || ReflectionHelpers.IsCppList(t))
+                    {
+                        continue;
+                    }
+
                     yield return obj;
                 }
             }
         }
-
-        public static IEnumerable<Type> GetTypesSafe(Assembly asm)
-        {
-            try { return asm.GetTypes(); }
-            catch (ReflectionTypeLoadException e) { return e.Types.Where(x => x != null); }
-            catch { return Enumerable.Empty<Type>(); }
-        }
     }
 }

src/MainMenu/Pages/WindowPage.cs

@@ -9,7 +9,7 @@ namespace Explorer
 {
     public abstract class WindowPage
     {
-        public virtual string Name { get; set; }
+        public virtual string Name { get; }
 
         public Vector2 scroll = Vector2.zero;
 

src/UnstripFixes/GUIUnstrip.cs

@@ -0,0 +1,412 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+using MelonLoader;
+using UnhollowerBaseLib;
+using UnhollowerRuntimeLib;
+using System.Reflection;
+using UnityEngineInternal;
+using Harmony;
+
+namespace Explorer
+{
+    public class GUIUnstrip
+    {
+        public static int s_ScrollControlId;
+
+        public static bool ScrollFailed = false;
+        public static bool ManualUnstripFailed = false;
+
+        private static GenericStack ScrollStack
+        {
+            get
+            {
+                if (m_scrollViewStatesInfo == null)
+                {
+                    try
+                    {
+                        m_scrollViewStatesInfo = typeof(GUI).GetProperty("scrollViewStates");
+                        if (m_scrollViewStatesInfo == null) throw new Exception();
+                    }
+                    catch
+                    {
+                        m_scrollViewStatesInfo = typeof(GUI).GetProperty("s_scrollViewStates");
+                    }
+                }
+
+                return (GenericStack)m_scrollViewStatesInfo?.GetValue(null, null);
+            }
+        }
+        private static PropertyInfo m_scrollViewStatesInfo;
+
+        // ======= public methods ======= //   
+
+        public static Rect GetLastRect()
+        {
+            EventType type = Event.current.type;
+            Rect last;
+            if (type != EventType.Layout && type != EventType.Used)
+            {
+                last = GUILayoutUtility.current.topLevel.GetLastUnstripped();
+            }
+            else
+            {
+                last = GUILayoutUtility.kDummyRect;
+            }
+            return last;
+        }
+
+        // Fix for BeginScrollView.
+
+        public static Vector2 BeginScrollView(Vector2 scroll, params GUILayoutOption[] options)
+        {
+            // First, just try normal way, may not have been stripped or was unstripped successfully.
+            if (!ScrollFailed)
+            {
+                try
+                {
+                    return GUILayout.BeginScrollView(scroll, options);
+                }
+                catch
+                {
+                    ScrollFailed = true;
+                    return scroll;
+                }
+            }
+
+            // Try manual implementation.
+            if (!ManualUnstripFailed)
+            {
+                try
+                {
+                    return BeginScrollView_ImplLayout(scroll, false, false, GUI.skin.horizontalScrollbar, GUI.skin.verticalScrollbar, GUI.skin.scrollView, options);
+                }
+                catch (Exception e)
+                {
+                    MelonLogger.Log("Exception on GUIUnstrip.BeginScrollView_ImplLayout: " + e.GetType() + ", " + e.Message + "\r\n" + e.StackTrace);
+
+                    ManualUnstripFailed = true;
+                    return scroll;
+                }
+            }
+
+            // Sorry! No scrolling for you.
+            return scroll;
+        }
+
+        public static void EndScrollView(bool handleScrollWheel = true)
+        {
+            // Only end the scroll view for the relevant BeginScrollView option, if any.
+
+            if (!ScrollFailed)
+            {
+                GUILayout.EndScrollView();
+            }
+            else if (!ManualUnstripFailed)
+            {
+                GUILayoutUtility.EndLayoutGroup();
+
+                EndScrollView_Impl(handleScrollWheel);
+            }
+        }
+
+        // ======= private methods ======= //
+
+        private static Vector2 BeginScrollView_ImplLayout(Vector2 scrollPosition, bool alwaysShowHorizontal, bool alwaysShowVertical, 
+            GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar, GUIStyle background, params GUILayoutOption[] options)
+        {
+            GUIUtility.CheckOnGUI();
+
+            var guiscrollGroup = GUILayoutUtility.BeginLayoutGroup(background, null, Il2CppType.Of<GUIScrollGroup>())
+                                .TryCast<GUIScrollGroup>();
+
+            EventType type = Event.current.type;
+            if (type == EventType.Layout)
+            {
+                guiscrollGroup.resetCoords = true;
+                guiscrollGroup.isVertical = true;
+                guiscrollGroup.stretchWidth = 1;
+                guiscrollGroup.stretchHeight = 1;
+                guiscrollGroup.verticalScrollbar = verticalScrollbar;
+                guiscrollGroup.horizontalScrollbar = horizontalScrollbar;
+                guiscrollGroup.needsVerticalScrollbar = alwaysShowVertical;
+                guiscrollGroup.needsHorizontalScrollbar = alwaysShowHorizontal;
+                guiscrollGroup.ApplyOptions(options);
+            }
+
+            return BeginScrollView_Impl(guiscrollGroup.rect,
+                scrollPosition,
+                new Rect(0f, 0f, guiscrollGroup.clientWidth, guiscrollGroup.clientHeight),
+                alwaysShowHorizontal,
+                alwaysShowVertical,
+                horizontalScrollbar,
+                verticalScrollbar,
+                background
+            );
+        }
+
+        private static Vector2 BeginScrollView_Impl(Rect position, Vector2 scrollPosition, Rect viewRect, bool alwaysShowHorizontal, 
+            bool alwaysShowVertical, GUIStyle horizontalScrollbar, GUIStyle verticalScrollbar, GUIStyle background)
+        {
+            GUIUtility.CheckOnGUI();
+
+            int controlID = GUIUtility.GetControlID(GUI.s_ScrollviewHash, FocusType.Passive);
+
+            var scrollViewState = GUIUtility.GetStateObject(Il2CppType.Of<ScrollViewState>(), controlID).TryCast<ScrollViewState>();
+
+            var scrollExt = ScrollViewStateUnstrip.FromPointer(scrollViewState.Pointer);
+
+            if (scrollExt == null) throw new Exception($"Could not get scrollExt for pointer '{scrollViewState.Pointer}'!");
+
+            bool apply = scrollExt.apply;
+            if (apply)
+            {
+                scrollPosition = scrollExt.scrollPosition;
+                scrollExt.apply = false;
+            }
+
+            scrollExt.position = position;
+
+            scrollExt.scrollPosition = scrollPosition;
+            scrollExt.visibleRect = scrollExt.viewRect = viewRect;
+
+            var rect = scrollExt.visibleRect;
+            rect.width = position.width;
+            rect.height = position.height;
+
+            ScrollStack.Push(scrollViewState);
+
+            Rect screenRect = new Rect(position.x, position.y, position.width, position.height);
+            EventType type = Event.current.type;
+            if (type != EventType.Layout)
+            {
+                if (type != EventType.Used)
+                {
+                    bool flag = alwaysShowVertical;
+                    bool flag2 = alwaysShowHorizontal;
+                    if (flag2 || viewRect.width > screenRect.width)
+                    {
+                        rect.height = position.height - horizontalScrollbar.fixedHeight + (float)horizontalScrollbar.margin.top;
+
+                        screenRect.height -= horizontalScrollbar.fixedHeight + (float)horizontalScrollbar.margin.top;
+                        flag2 = true;
+                    }
+                    if (flag || viewRect.height > screenRect.height)
+                    {
+                        rect.width = position.width - verticalScrollbar.fixedWidth + (float)verticalScrollbar.margin.left;
+
+                        screenRect.width -= verticalScrollbar.fixedWidth + (float)verticalScrollbar.margin.left;
+                        flag = true;
+                        if (!flag2 && viewRect.width > screenRect.width)
+                        {
+                            rect.height = position.height - horizontalScrollbar.fixedHeight + (float)horizontalScrollbar.margin.top;
+                            screenRect.height -= horizontalScrollbar.fixedHeight + (float)horizontalScrollbar.margin.top;
+                            flag2 = true;
+                        }
+                    }
+                    if (Event.current.type == EventType.Repaint && background != GUIStyle.none)
+                    {
+                        background.Draw(position, position.Contains(Event.current.mousePosition), false, flag2 && flag, false);
+                    }
+                    if (flag2 && horizontalScrollbar != GUIStyle.none)
+                    {
+                        scrollPosition.x = HorizBar_Impl(
+                            new Rect(
+                                position.x,
+                                position.yMax - horizontalScrollbar.fixedHeight,
+                                screenRect.width,
+                                horizontalScrollbar.fixedHeight),
+                            scrollPosition.x,
+                            Mathf.Min(screenRect.width, viewRect.width),
+                            0f,
+                            viewRect.width,
+                            horizontalScrollbar
+                        );
+                    }
+                    else
+                    {
+                        GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive);
+                        GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
+                        GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
+                        scrollPosition.x = ((horizontalScrollbar == GUIStyle.none) ? Mathf.Clamp(scrollPosition.x, 0f, Mathf.Max(viewRect.width - position.width, 0f)) : 0f);
+                    }
+                    if (flag && verticalScrollbar != GUIStyle.none)
+                    {
+                        scrollPosition.y = VertBar_Impl(
+                            new Rect(
+                                screenRect.xMax + (float)verticalScrollbar.margin.left,
+                                screenRect.y,
+                                verticalScrollbar.fixedWidth,
+                                screenRect.height),
+                            scrollPosition.y,
+                            Mathf.Min(screenRect.height, viewRect.height),
+                            0f,
+                            viewRect.height,
+                            verticalScrollbar
+                        );
+                    }
+                    else
+                    {
+                        GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive);
+                        GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
+                        GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
+                        scrollPosition.y = ((verticalScrollbar == GUIStyle.none) ? Mathf.Clamp(scrollPosition.y, 0f, Mathf.Max(viewRect.height - position.height, 0f)) : 0f);
+                    }
+                }
+            }
+            else
+            {
+                GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive);
+                GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
+                GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
+                GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive);
+                GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
+                GUIUtility.GetControlID(GUI.s_RepeatButtonHash, FocusType.Passive);
+            }
+            GUIClip.Push(screenRect, new Vector2(Mathf.Round(-scrollPosition.x - viewRect.x), Mathf.Round(-scrollPosition.y - viewRect.y)), Vector2.zero, false);
+
+            return scrollPosition;
+        }
+
+        public static float HorizBar_Impl(Rect position, float value, float size, float leftValue, float rightValue, GUIStyle style)
+        {
+            return Scroller_Impl(position, value, size, leftValue, rightValue, style,
+                GUI.skin.GetStyle(style.name + "thumb"),
+                GUI.skin.GetStyle(style.name + "leftbutton"),
+                GUI.skin.GetStyle(style.name + "rightbutton"),
+                true);
+        }
+
+        public static float VertBar_Impl(Rect position, float value, float size, float topValue, float bottomValue, GUIStyle style)
+        {
+            return Scroller_Impl(position, value, size, topValue, bottomValue, style,
+                GUI.skin.GetStyle(style.name + "thumb"),
+                GUI.skin.GetStyle(style.name + "upbutton"),
+                GUI.skin.GetStyle(style.name + "downbutton"),
+                false);
+        }
+
+        private static void EndScrollView_Impl(bool handleScrollWheel)
+        {
+            GUIUtility.CheckOnGUI();
+
+            if (ScrollStack.Count <= 0) return;
+
+            var state = ScrollStack.Peek().TryCast<ScrollViewState>();
+            var scrollExt = ScrollViewStateUnstrip.FromPointer(state.Pointer);
+
+            if (scrollExt == null) throw new Exception("Could not get scrollExt!");
+
+            GUIClip.Pop();
+
+            ScrollStack.Pop();
+
+            var position = scrollExt.position;
+
+            if (handleScrollWheel && Event.current.type == EventType.ScrollWheel && position.Contains(Event.current.mousePosition))
+            {
+                var pos = scrollExt.scrollPosition;
+                pos.x = Mathf.Clamp(scrollExt.scrollPosition.x + Event.current.delta.x * 20f, 0f, scrollExt.viewRect.width - scrollExt.visibleRect.width);
+                pos.y = Mathf.Clamp(scrollExt.scrollPosition.y + Event.current.delta.y * 20f, 0f, scrollExt.viewRect.height - scrollExt.visibleRect.height);
+
+                if (scrollExt.scrollPosition.x < 0f)
+                {
+                    pos.x = 0f;
+                }
+                if (pos.y < 0f)
+                {
+                    pos.y = 0f;
+                }
+
+                scrollExt.apply = true;
+
+                Event.current.Use();
+            }
+        }
+
+        private static float Scroller_Impl(Rect position, float value, float size, float leftValue, float rightValue, GUIStyle slider, GUIStyle thumb, GUIStyle leftButton, GUIStyle rightButton, bool horiz)
+        {
+            GUIUtility.CheckOnGUI();
+            int controlID = GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive, position);
+            Rect position2;
+            Rect rect;
+            Rect rect2;
+            if (horiz)
+            {
+                position2 = new Rect(position.x + leftButton.fixedWidth, position.y, position.width - leftButton.fixedWidth - rightButton.fixedWidth, position.height);
+                rect = new Rect(position.x, position.y, leftButton.fixedWidth, position.height);
+                rect2 = new Rect(position.xMax - rightButton.fixedWidth, position.y, rightButton.fixedWidth, position.height);
+            }
+            else
+            {
+                position2 = new Rect(position.x, position.y + leftButton.fixedHeight, position.width, position.height - leftButton.fixedHeight - rightButton.fixedHeight);
+                rect = new Rect(position.x, position.y, position.width, leftButton.fixedHeight);
+                rect2 = new Rect(position.x, position.yMax - rightButton.fixedHeight, position.width, rightButton.fixedHeight);
+            }
+
+            value = Slider_Impl(position2, value, size, leftValue, rightValue, slider, thumb, horiz, controlID);
+
+            bool flag = Event.current.type == EventType.MouseUp;
+            if (ScrollerRepeatButton_Impl(controlID, rect, leftButton))
+            {
+                value -= 10f * ((leftValue >= rightValue) ? -1f : 1f);
+            }
+            if (ScrollerRepeatButton_Impl(controlID, rect2, rightButton))
+            {
+                value += 10f * ((leftValue >= rightValue) ? -1f : 1f);
+            }
+            if (flag && Event.current.type == EventType.Used)
+            {
+                s_ScrollControlId = 0;
+            }
+            if (leftValue < rightValue)
+            {
+                value = Mathf.Clamp(value, leftValue, rightValue - size);
+            }
+            else
+            {
+                value = Mathf.Clamp(value, rightValue, leftValue - size);
+            }
+            return value;
+        }
+
+        public static float Slider_Impl(Rect position, float value, float size, float start, float end, GUIStyle slider, GUIStyle thumb, bool horiz, int id)
+        {
+            if (id == 0)
+            {
+                id = GUIUtility.GetControlID(GUI.s_SliderHash, FocusType.Passive, position);
+            }
+            var sliderHandler = new SliderHandlerUnstrip(position, value, size, start, end, slider, thumb, horiz, id);
+            return sliderHandler.Handle();
+        }
+
+        private static bool ScrollerRepeatButton_Impl(int scrollerID, Rect rect, GUIStyle style)
+        {
+            bool result = false;
+            if (GUI.DoRepeatButton(rect, GUIContent.none, style, FocusType.Passive))
+            {
+                bool flag = s_ScrollControlId != scrollerID;
+                s_ScrollControlId = scrollerID;
+
+                if (flag)
+                {
+                    result = true;
+                    GUI.nextScrollStepTime = Il2CppSystem.DateTime.Now.AddMilliseconds(250.0);
+                }
+                else if (Il2CppSystem.DateTime.Now >= GUI.nextScrollStepTime)
+                {
+                    result = true;
+                    GUI.nextScrollStepTime = Il2CppSystem.DateTime.Now.AddMilliseconds(30.0);
+                }
+                if (Event.current.type == EventType.Repaint)
+                {
+                    GUI.InternalRepaintEditorWindow();
+                }
+            }
+            return result;
+        }
+    }
+}

src/UnstripFixes/ScrollViewStateUnstrip.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Harmony;
+using MelonLoader;
+using UnityEngine;
+
+namespace Explorer
+{
+    public class ScrollViewStateUnstrip
+    {
+        public Rect position;
+        public Rect visibleRect;
+        public Rect viewRect;
+        public Vector2 scrollPosition;
+        public bool apply;
+
+        public static Dictionary<IntPtr, ScrollViewStateUnstrip> Dict = new Dictionary<IntPtr, ScrollViewStateUnstrip>();
+
+        public static ScrollViewStateUnstrip FromPointer(IntPtr ptr)
+        {
+            if (!Dict.ContainsKey(ptr))
+            {
+                Dict.Add(ptr, new ScrollViewStateUnstrip());
+            }
+
+            return Dict[ptr];
+        }
+    }
+}

src/UnstripFixes/SliderHandlerUnstrip.cs

@@ -0,0 +1,371 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+using UnhollowerRuntimeLib;
+
+namespace Explorer
+{
+	public struct SliderHandlerUnstrip
+	{
+		private readonly Rect position;
+		private readonly float currentValue;
+		private readonly float size;
+		private readonly float start;
+		private readonly float end;
+		private readonly GUIStyle slider;
+		private readonly GUIStyle thumb;
+		private readonly bool horiz;
+		private readonly int id;
+
+		public SliderHandlerUnstrip(Rect position, float currentValue, float size, float start, float end, GUIStyle slider, GUIStyle thumb, bool horiz, int id)
+		{
+			this.position = position;
+			this.currentValue = currentValue;
+			this.size = size;
+			this.start = start;
+			this.end = end;
+			this.slider = slider;
+			this.thumb = thumb;
+			this.horiz = horiz;
+			this.id = id;
+		}
+
+		public float Handle()
+		{
+			float result;
+			if (this.slider == null || this.thumb == null)
+			{
+				result = this.currentValue;
+			}
+			else
+			{
+				switch (this.CurrentEventType())
+				{
+					case EventType.MouseDown:
+						return this.OnMouseDown();
+					case EventType.MouseUp:
+						return this.OnMouseUp();
+					case EventType.MouseDrag:
+						return this.OnMouseDrag();
+					case EventType.Repaint:
+						return this.OnRepaint();
+				}
+				result = this.currentValue;
+			}
+			return result;
+		}
+
+		private float OnMouseDown()
+		{
+			float result;
+			if (!this.position.Contains(this.CurrentEvent().mousePosition) || this.IsEmptySlider())
+			{
+				result = this.currentValue;
+			}
+			else
+			{
+				GUI.scrollTroughSide = 0;
+				GUIUtility.hotControl = this.id;
+				this.CurrentEvent().Use();
+				if (this.ThumbSelectionRect().Contains(this.CurrentEvent().mousePosition))
+				{
+					this.StartDraggingWithValue(this.ClampedCurrentValue());
+					result = this.currentValue;
+				}
+				else
+				{
+					GUI.changed = true;
+					if (this.SupportsPageMovements())
+					{
+						this.SliderState().isDragging = false;
+						GUI.nextScrollStepTime = SystemClock.now.AddMilliseconds(250.0);
+						GUI.scrollTroughSide = this.CurrentScrollTroughSide();
+						result = this.PageMovementValue();
+					}
+					else
+					{
+						float num = this.ValueForCurrentMousePosition();
+						this.StartDraggingWithValue(num);
+						result = this.Clamp(num);
+					}
+				}
+			}
+			return result;
+		}
+
+		private float OnMouseDrag()
+		{
+			float result;
+			if (GUIUtility.hotControl != this.id)
+			{
+				result = this.currentValue;
+			}
+			else
+			{
+				SliderState sliderState = this.SliderState();
+				if (!sliderState.isDragging)
+				{
+					result = this.currentValue;
+				}
+				else
+				{
+					GUI.changed = true;
+					this.CurrentEvent().Use();
+					float num = this.MousePosition() - sliderState.dragStartPos;
+					float value = sliderState.dragStartValue + num / this.ValuesPerPixel();
+					result = this.Clamp(value);
+				}
+			}
+			return result;
+		}
+
+		private float OnMouseUp()
+		{
+			if (GUIUtility.hotControl == this.id)
+			{
+				this.CurrentEvent().Use();
+				GUIUtility.hotControl = 0;
+			}
+			return this.currentValue;
+		}
+
+		private float OnRepaint()
+		{
+			this.slider.Draw(this.position, GUIContent.none, this.id);
+			if (!this.IsEmptySlider() && this.currentValue >= this.MinValue() && this.currentValue <= this.MaxValue())
+			{
+				this.thumb.Draw(this.ThumbRect(), GUIContent.none, this.id);
+			}
+			float result;
+			if (GUIUtility.hotControl != this.id || !this.position.Contains(this.CurrentEvent().mousePosition) || this.IsEmptySlider())
+			{
+				result = this.currentValue;
+			}
+			else if (this.ThumbRect().Contains(this.CurrentEvent().mousePosition))
+			{
+				if (GUI.scrollTroughSide != 0)
+				{
+					GUIUtility.hotControl = 0;
+				}
+				result = this.currentValue;
+			}
+			else
+			{
+				GUI.InternalRepaintEditorWindow();
+				if (SystemClock.now < GUI.nextScrollStepTime)
+				{
+					result = this.currentValue;
+				}
+				else if (this.CurrentScrollTroughSide() != GUI.scrollTroughSide)
+				{
+					result = this.currentValue;
+				}
+				else
+				{
+					GUI.nextScrollStepTime = SystemClock.now.AddMilliseconds(30.0);
+					if (this.SupportsPageMovements())
+					{
+						this.SliderState().isDragging = false;
+						GUI.changed = true;
+						result = this.PageMovementValue();
+					}
+					else
+					{
+						result = this.ClampedCurrentValue();
+					}
+				}
+			}
+			return result;
+		}
+
+		private EventType CurrentEventType()
+		{
+			return this.CurrentEvent().GetTypeForControl(this.id);
+		}
+
+
+		private int CurrentScrollTroughSide()
+		{
+			float num = (!this.horiz) ? this.CurrentEvent().mousePosition.y : this.CurrentEvent().mousePosition.x;
+			float num2 = (!this.horiz) ? this.ThumbRect().y : this.ThumbRect().x;
+			return (num <= num2) ? -1 : 1;
+		}
+
+		private bool IsEmptySlider()
+		{
+			return this.start == this.end;
+		}
+
+		private bool SupportsPageMovements()
+		{
+			return this.size != 0f && GUI.usePageScrollbars;
+		}
+
+		private float PageMovementValue()
+		{
+			float num = this.currentValue;
+			int num2 = (this.start <= this.end) ? 1 : -1;
+			if (this.MousePosition() > this.PageUpMovementBound())
+			{
+				num += this.size * (float)num2 * 0.9f;
+			}
+			else
+			{
+				num -= this.size * (float)num2 * 0.9f;
+			}
+			return this.Clamp(num);
+		}
+
+		private float PageUpMovementBound()
+		{
+			float result;
+			if (this.horiz)
+			{
+				result = this.ThumbRect().xMax - this.position.x;
+			}
+			else
+			{
+				result = this.ThumbRect().yMax - this.position.y;
+			}
+			return result;
+		}
+
+		private Event CurrentEvent()
+		{
+			return Event.current;
+		}
+
+		private float ValueForCurrentMousePosition()
+		{
+			float result;
+			if (this.horiz)
+			{
+				result = (this.MousePosition() - this.ThumbRect().width * 0.5f) / this.ValuesPerPixel() + this.start - this.size * 0.5f;
+			}
+			else
+			{
+				result = (this.MousePosition() - this.ThumbRect().height * 0.5f) / this.ValuesPerPixel() + this.start - this.size * 0.5f;
+			}
+			return result;
+		}
+
+		private float Clamp(float value)
+		{
+			return Mathf.Clamp(value, this.MinValue(), this.MaxValue());
+		}
+
+		private Rect ThumbSelectionRect()
+		{
+			return this.ThumbRect();
+		}
+
+		private void StartDraggingWithValue(float dragStartValue)
+		{
+			SliderState sliderState = this.SliderState();
+			sliderState.dragStartPos = this.MousePosition();
+			sliderState.dragStartValue = dragStartValue;
+			sliderState.isDragging = true;
+		}
+
+		private SliderState SliderState()
+		{
+			return (SliderState)GUIUtility.GetStateObject(Il2CppType.Of<SliderState>(), this.id).TryCast<SliderState>();
+		}
+
+		private Rect ThumbRect()
+		{
+			return (!this.horiz) ? this.VerticalThumbRect() : this.HorizontalThumbRect();
+		}
+
+		private Rect VerticalThumbRect()
+		{
+			float num = this.ValuesPerPixel();
+			Rect result;
+			if (this.start < this.end)
+			{
+				result = new Rect(this.position.x + (float)this.slider.padding.left, (this.ClampedCurrentValue() - this.start) * num + this.position.y + (float)this.slider.padding.top, this.position.width - (float)this.slider.padding.horizontal, this.size * num + this.ThumbSize());
+			}
+			else
+			{
+				result = new Rect(this.position.x + (float)this.slider.padding.left, (this.ClampedCurrentValue() + this.size - this.start) * num + this.position.y + (float)this.slider.padding.top, this.position.width - (float)this.slider.padding.horizontal, this.size * -num + this.ThumbSize());
+			}
+			return result;
+		}
+
+		private Rect HorizontalThumbRect()
+		{
+			float num = this.ValuesPerPixel();
+			Rect result;
+			if (this.start < this.end)
+			{
+				result = new Rect((this.ClampedCurrentValue() - this.start) * num + this.position.x + (float)this.slider.padding.left, this.position.y + (float)this.slider.padding.top, this.size * num + this.ThumbSize(), this.position.height - (float)this.slider.padding.vertical);
+			}
+			else
+			{
+				result = new Rect((this.ClampedCurrentValue() + this.size - this.start) * num + this.position.x + (float)this.slider.padding.left, this.position.y, this.size * -num + this.ThumbSize(), this.position.height);
+			}
+			return result;
+		}
+
+		private float ClampedCurrentValue()
+		{
+			return this.Clamp(this.currentValue);
+		}
+
+		private float MousePosition()
+		{
+			float result;
+			if (this.horiz)
+			{
+				result = this.CurrentEvent().mousePosition.x - this.position.x;
+			}
+			else
+			{
+				result = this.CurrentEvent().mousePosition.y - this.position.y;
+			}
+			return result;
+		}
+
+		private float ValuesPerPixel()
+		{
+			float result;
+			if (this.horiz)
+			{
+				result = (this.position.width - (float)this.slider.padding.horizontal - this.ThumbSize()) / (this.end - this.start);
+			}
+			else
+			{
+				result = (this.position.height - (float)this.slider.padding.vertical - this.ThumbSize()) / (this.end - this.start);
+			}
+			return result;
+		}
+
+		private float ThumbSize()
+		{
+			float result;
+			if (this.horiz)
+			{
+				result = ((this.thumb.fixedWidth == 0f) ? ((float)this.thumb.padding.horizontal) : this.thumb.fixedWidth);
+			}
+			else
+			{
+				result = ((this.thumb.fixedHeight == 0f) ? ((float)this.thumb.padding.vertical) : this.thumb.fixedHeight);
+			}
+			return result;
+		}
+
+		private float MaxValue()
+		{
+			return Mathf.Max(this.start, this.end) - this.size;
+		}
+
+		private float MinValue()
+		{
+			return Mathf.Min(this.start, this.end);
+		}
+
+	}
+}

src/UnstripFixes/UnstripExtensions.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Explorer
+{
+    public static class UnstripExtensions
+    {
+        public static Rect GetLastUnstripped(this GUILayoutGroup group)
+        {
+            Rect result;
+            if (group.m_Cursor > 0 && group.m_Cursor <= group.entries.Count)
+            {
+                GUILayoutEntry guilayoutEntry = group.entries[group.m_Cursor - 1];
+                result = guilayoutEntry.rect;
+            }
+            else
+            {
+                result = GUILayoutEntry.kDummyRect;
+            }
+            return result;
+        }
+    }
+}

src/Windows/GameObjectWindow.cs

@@ -11,7 +11,9 @@ namespace Explorer
 {
     public class GameObjectWindow : UIWindow
     {
-        public override string Name { get => "GameObject Inspector"; set => Name = value; }
+        public override string Title => WindowManager.TabView
+            ? $"<color=cyan>[G]</color> {m_object.name}"
+            : $"GameObject Inspector ({m_object.name})";
 
         public GameObject m_object;
 
@@ -19,29 +21,33 @@ namespace Explorer
         private string m_name;
         private string m_scene;
 
-        private Vector2 m_transformScroll = Vector2.zero;
         private Transform[] m_children;
+        private Vector2 m_transformScroll = Vector2.zero;
+        private PageHelper ChildPages = new PageHelper();
 
+        private Component[] m_components;
         private Vector2 m_compScroll = Vector2.zero;
-        //private Component[] m_components;
+        private PageHelper CompPages = new PageHelper();
 
+        private readonly Vector3[] m_cachedInput = new Vector3[3];
         private float m_translateAmount = 0.3f;
         private float m_rotateAmount = 50f;
         private float m_scaleAmount = 0.1f;
+        private bool m_freeze;
+        private Vector3 m_frozenPosition;
+        private Quaternion m_frozenRotation;
+        private Vector3 m_frozenScale;
+        private bool m_autoApplyTransform;
+        private bool m_autoUpdateTransform;
+        private bool m_localContext;
 
-        List<Component> m_cachedDestroyList = new List<Component>();
+        private readonly List<Component> m_cachedDestroyList = new List<Component>();
         //private string m_addComponentInput = "";
 
-        private string m_setParentInput = "";
+        private string m_setParentInput = "Enter a GameObject name or path";
 
         public bool GetObjectAsGameObject()
         {
-            if (Target == null)
-            {
-                MelonLogger.Log("Target is null!");
-                return false;
-            }
-
             var targetType = Target.GetType();
 
             if (targetType == typeof(GameObject))
@@ -68,30 +74,102 @@ namespace Explorer
             }
 
             m_name = m_object.name;
-            m_scene = m_object.scene == null ? "null" : m_object.scene.name;
+            m_scene = string.IsNullOrEmpty(m_object.scene.name) 
+                        ? "None (Asset/Resource)" 
+                        : m_object.scene.name;
 
-            //var listComps = new Il2CppSystem.Collections.Generic.List<Component>();
-            //m_object.GetComponents(listComps);
-            //m_components = listComps.ToArray();
+            CacheTransformValues();
 
-            var list = new List<Transform>();
-            for (int i = 0; i < m_object.transform.childCount; i++)
+            Update();
+        }
+
+        private void CacheTransformValues()
+        {
+            if (m_localContext)
             {
-                list.Add(m_object.transform.GetChild(i));
+                m_cachedInput[0] = m_object.transform.localPosition;
+                m_cachedInput[1] = m_object.transform.localEulerAngles;
             }
-            m_children = list.ToArray();
+            else
+            {
+                m_cachedInput[0] = m_object.transform.position;
+                m_cachedInput[1] = m_object.transform.eulerAngles;
+            }
+            m_cachedInput[2] = m_object.transform.localScale;
         }
 
         public override void Update()
         {
-            if (!m_object && !GetObjectAsGameObject())
+            try
             {
-                MelonLogger.Log("Object is null! Destroying window...");
-                DestroyWindow();
+                if (Target == null)
+                {
+                    MelonLogger.Log("Target is null!");
+                    DestroyWindow();
+                    return;
+                }
+                else if (Target is UnityEngine.Object uObj)
+                {
+                    if (!uObj)
+                    {
+                        MelonLogger.Log("Target was destroyed!");
+                        DestroyWindow();
+                        return;
+                    }
+                }
+
+                if (!m_object && !GetObjectAsGameObject())
+                {
+                    throw new Exception("Object is null!");
+                }
+
+                if (m_freeze)
+                {
+                    if (m_localContext)
+                    {
+                        m_object.transform.localPosition = m_frozenPosition;
+                        m_object.transform.localRotation = m_frozenRotation;
+                    }
+                    else
+                    {
+                        m_object.transform.position = m_frozenPosition;
+                        m_object.transform.rotation = m_frozenRotation;
+                    }
+                    m_object.transform.localScale = m_frozenScale;
+                }
+
+                // update child objects
+                var childList = new List<Transform>();
+                for (int i = 0; i < m_object.transform.childCount; i++)
+                {
+                    childList.Add(m_object.transform.GetChild(i));
+                }
+                childList.Sort((a, b) => b.childCount.CompareTo(a.childCount));
+                m_children = childList.ToArray();
+
+                ChildPages.ItemCount = m_children.Length;
+
+                // update components
+                var compList = new Il2CppSystem.Collections.Generic.List<Component>();
+                m_object.GetComponentsInternal(ReflectionHelpers.ComponentType, true, false, true, false, compList);
+
+                m_components = compList.ToArray();
+
+                CompPages.ItemCount = m_components.Length;
+            }
+            catch (Exception e)
+            {
+                DestroyOnException(e);
             }
         }
 
-        private void InspectGameObject(GameObject obj)
+        private void DestroyOnException(Exception e)
+        {
+            MelonLogger.Log($"Exception drawing GameObject Window: {e.GetType()}, {e.Message}");
+            DestroyWindow();
+        }
+
+        private void InspectGameObject(Transform obj)
         {
             var window = WindowManager.InspectObject(obj, out bool created);
             
@@ -125,89 +203,125 @@ namespace Explorer
 
         public override void WindowFunction(int windowID)
         {
-            Header();
-
-            GUILayout.BeginArea(new Rect(5, 25, m_rect.width - 10, m_rect.height - 35), GUI.skin.box);
-
-            scroll = GUILayout.BeginScrollView(scroll, GUI.skin.scrollView);
-
-            GUILayout.BeginHorizontal(null);
-            GUILayout.Label("Scene: <color=cyan>" + (m_scene == "" ? "n/a" : m_scene) + "</color>", null);
-            if (m_scene == UnityHelpers.ActiveSceneName)
+            try
             {
-                if (GUILayout.Button("<color=#00FF00>< View in Scene Explorer</color>", new GUILayoutOption[] { GUILayout.Width(230) }))
+                var rect = WindowManager.TabView ? TabViewWindow.Instance.m_rect : this.m_rect;
+
+                if (!WindowManager.TabView)
                 {
-                    ScenePage.Instance.SetTransformTarget(m_object);
-                    MainMenu.SetCurrentPage(0);
+                    Header();
+                    GUILayout.BeginArea(new Rect(5, 25, rect.width - 10, rect.height - 35), GUI.skin.box);
+                }
+
+                scroll = GUIUnstrip.BeginScrollView(scroll);
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Label("Scene: <color=cyan>" + (m_scene == "" ? "n/a" : m_scene) + "</color>", null);
+                if (m_scene == UnityHelpers.ActiveSceneName)
+                {
+                    if (GUILayout.Button("<color=#00FF00>Send to Scene View</color>", new GUILayoutOption[] { GUILayout.Width(150) }))
+                    {
+                        ScenePage.Instance.SetTransformTarget(m_object.transform);
+                        MainMenu.SetCurrentPage(0);
+                    }
+                }
+                if (GUILayout.Button("Reflection Inspect", new GUILayoutOption[] { GUILayout.Width(150) }))
+                {
+                    WindowManager.InspectObject(Target, out _, true);
+                }
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Label("Path:", new GUILayoutOption[] { GUILayout.Width(50) });
+                string pathlabel = m_object.transform.GetGameObjectPath();
+                if (m_object.transform.parent != null)
+                {
+                    if (GUILayout.Button("<-", new GUILayoutOption[] { GUILayout.Width(35) }))
+                    {
+                        InspectGameObject(m_object.transform.parent);
+                    }
+                }
+                GUILayout.TextArea(pathlabel, null);
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal(null);
+                GUILayout.Label("Name:", new GUILayoutOption[] { GUILayout.Width(50) });
+                GUILayout.TextArea(m_name, null);
+                GUILayout.EndHorizontal();
+
+                // --- Horizontal Columns section ---
+                GUILayout.BeginHorizontal(null);
+
+                GUILayout.BeginVertical(new GUILayoutOption[] { GUILayout.Width(rect.width / 2 - 17) });
+                TransformList(rect);
+                GUILayout.EndVertical();
+
+                GUILayout.BeginVertical(new GUILayoutOption[] { GUILayout.Width(rect.width / 2 - 17) });
+                ComponentList(rect);
+                GUILayout.EndVertical();
+
+                GUILayout.EndHorizontal(); // end horiz columns
+
+                GameObjectControls();
+
+                GUIUnstrip.EndScrollView();
+
+                if (!WindowManager.TabView)
+                {
+                    m_rect = ResizeDrag.ResizeWindow(rect, windowID);
+
+                    GUILayout.EndArea();
                 }
             }
-            GUILayout.EndHorizontal();
-
-            GUILayout.BeginHorizontal(null);
-            GUILayout.Label("Path:", new GUILayoutOption[] { GUILayout.Width(50) });
-            string pathlabel = m_object.transform.GetGameObjectPath();
-            if (m_object.transform.parent != null)
+            catch (Exception e)
             {
-                if (GUILayout.Button("<-", new GUILayoutOption[] { GUILayout.Width(35) }))
-                {
-                    InspectGameObject(m_object.transform.parent.gameObject);
-                }
+                DestroyOnException(e);
             }
-            GUILayout.TextArea(pathlabel, null);
-            GUILayout.EndHorizontal();
-
-            GUILayout.BeginHorizontal(null);
-            GUILayout.Label("Name:", new GUILayoutOption[] { GUILayout.Width(50) });
-            GUILayout.TextArea(m_name, null);
-            GUILayout.EndHorizontal();
-
-            // --- Horizontal Columns section ---
-            GUILayout.BeginHorizontal(null);
-
-            GUILayout.BeginVertical(new GUILayoutOption[] { GUILayout.Width(m_rect.width / 2 - 17) });
-            TransformList();
-            GUILayout.EndVertical();
-
-            GUILayout.BeginVertical(new GUILayoutOption[] { GUILayout.Width(m_rect.width / 2 - 17) });
-            ComponentList();
-            GUILayout.EndVertical();
-
-            GUILayout.EndHorizontal(); // end horiz columns
-
-            GameObjectControls();
-
-            GUILayout.EndScrollView();
-
-            m_rect = WindowManager.ResizeWindow(m_rect, windowID);
-
-            GUILayout.EndArea();
         }
 
-        private void TransformList()
+        private void TransformList(Rect m_rect)
         {
-            GUILayout.BeginVertical(GUI.skin.box, new GUILayoutOption[] { GUILayout.Height(250) });
-            m_transformScroll = GUILayout.BeginScrollView(m_transformScroll, GUI.skin.scrollView);
+            GUILayout.BeginVertical(GUI.skin.box, null);
+            m_transformScroll = GUIUnstrip.BeginScrollView(m_transformScroll);
+
+            GUILayout.Label("<b><size=15>Children</size></b>", null);
+
+            GUILayout.BeginHorizontal(null);
+            ChildPages.DrawLimitInputArea();
+
+            if (ChildPages.ItemCount > ChildPages.ItemsPerPage)
+            {
+                ChildPages.CurrentPageLabel();
+
+                GUILayout.EndHorizontal();
+                GUILayout.BeginHorizontal(null);
+
+                if (GUILayout.Button("< Prev", new GUILayoutOption[] { GUILayout.Width(80) }))
+                {
+                    ChildPages.TurnPage(Turn.Left, ref this.m_transformScroll);
+                }
+                if (GUILayout.Button("Next >", new GUILayoutOption[] { GUILayout.Width(80) }))
+                {
+                    ChildPages.TurnPage(Turn.Right, ref this.m_transformScroll);
+                }
+            }
+            GUILayout.EndHorizontal();
 
-            GUILayout.Label("<b>Children:</b>", null);
             if (m_children != null && m_children.Length > 0)
             {
-                foreach (var obj in m_children.Where(x => x.childCount > 0))
+                int start = ChildPages.CalculateOffsetIndex();
+
+                for (int j = start; (j < start + ChildPages.ItemsPerPage && j < ChildPages.ItemCount); j++)
                 {
+                    var obj = m_children[j];
+
                     if (!obj)
                     {
                         GUILayout.Label("null", null);
                         continue;
                     }
-                    UIHelpers.GameobjButton(obj.gameObject, InspectGameObject, false, this.m_rect.width / 2 - 60);
-                }
-                foreach (var obj in m_children.Where(x => x.childCount == 0))
-                {
-                    if (!obj)
-                    {
-                        GUILayout.Label("null", null);
-                        continue;
-                    }
-                    UIHelpers.GameobjButton(obj.gameObject, InspectGameObject, false, this.m_rect.width / 2 - 60);
+
+                    UIHelpers.GOButton(obj.gameObject, InspectGameObject, false, m_rect.width / 2 - 80);
                 }
             }
             else
@@ -215,53 +329,76 @@ namespace Explorer
                 GUILayout.Label("<i>None</i>", null);
             }
 
-            GUILayout.EndScrollView();
+            GUIUnstrip.EndScrollView();
             GUILayout.EndVertical();
         }
 
-
-        private void ComponentList()
+        private void ComponentList(Rect m_rect)
         {
-            GUILayout.BeginVertical(GUI.skin.box, new GUILayoutOption[] { GUILayout.Height(250) });
-            m_compScroll = GUILayout.BeginScrollView(m_compScroll, GUI.skin.scrollView);
+            GUILayout.BeginVertical(GUI.skin.box, null);
+            m_compScroll = GUIUnstrip.BeginScrollView(m_compScroll);
             GUILayout.Label("<b><size=15>Components</size></b>", null);
 
+            GUILayout.BeginHorizontal(null);
+            CompPages.DrawLimitInputArea();
+
+            if (CompPages.ItemCount > CompPages.ItemsPerPage)
+            {
+                CompPages.CurrentPageLabel();
+
+                GUILayout.EndHorizontal();
+                GUILayout.BeginHorizontal(null);
+
+                if (GUILayout.Button("< Prev", new GUILayoutOption[] { GUILayout.Width(80) }))
+                {
+                    CompPages.TurnPage(Turn.Left, ref this.m_compScroll);
+                }
+                if (GUILayout.Button("Next >", new GUILayoutOption[] { GUILayout.Width(80) }))
+                {
+                    CompPages.TurnPage(Turn.Right, ref this.m_compScroll);
+                }
+            }
+            GUILayout.EndHorizontal();
+
             GUI.skin.button.alignment = TextAnchor.MiddleLeft;
             if (m_cachedDestroyList.Count > 0)
             {
                 m_cachedDestroyList.Clear();
             }
 
-            var m_components = new Il2CppSystem.Collections.Generic.List<Component>();
-            m_object.GetComponentsInternal(Il2CppType.Of<Component>(), false, false, true, false, m_components);
-
-            var ilTypeOfTransform = Il2CppType.Of<Transform>();
-            var ilTypeOfBehaviour = Il2CppType.Of<Behaviour>();
-            foreach (var component in m_components)
+            if (m_components != null)
             {
-                var ilType = component.GetIl2CppType();
-                if (ilType == ilTypeOfTransform)
-                {
-                    continue;
-                }
+                int start = CompPages.CalculateOffsetIndex();
 
-                GUILayout.BeginHorizontal(null);
-                if (ilTypeOfBehaviour.IsAssignableFrom(ilType))
+                for (int j = start; (j < start + CompPages.ItemsPerPage && j < CompPages.ItemCount); j++)
                 {
-                    BehaviourEnabledBtn(component.TryCast<Behaviour>());
+                    var component = m_components[j];
+
+                    if (!component) continue;
+
+                    var ilType = component.GetIl2CppType();
+
+                    GUILayout.BeginHorizontal(null);
+                    if (ReflectionHelpers.BehaviourType.IsAssignableFrom(ilType))
+                    {
+                        BehaviourEnabledBtn(component.TryCast<Behaviour>());
+                    }
+                    else
+                    {
+                        GUILayout.Space(26);
+                    }
+                    if (GUILayout.Button("<color=cyan>" + ilType.Name + "</color>", new GUILayoutOption[] { GUILayout.Width(m_rect.width / 2 - 100) }))
+                    {
+                        ReflectObject(component);
+                    }
+                    if (GUILayout.Button("<color=red>-</color>", new GUILayoutOption[] { GUILayout.Width(20) }))
+                    {
+                        m_cachedDestroyList.Add(component);
+                    }
+                    GUILayout.EndHorizontal();
                 }
-                if (GUILayout.Button("<color=cyan>" + ilType.Name + "</color>", new GUILayoutOption[] { GUILayout.Width(m_rect.width / 2 - 90) }))
-                {
-                    ReflectObject(component);
-                }
-                if (GUILayout.Button("<color=red>-</color>", new GUILayoutOption[] { GUILayout.Width(20) }))
-                {
-                    m_cachedDestroyList.Add(component);
-                }
-                GUILayout.EndHorizontal();
             }
 
-
             GUI.skin.button.alignment = TextAnchor.MiddleCenter;
             if (m_cachedDestroyList.Count > 0)
             {
@@ -272,25 +409,7 @@ namespace Explorer
                 }
             }
 
-            GUILayout.EndScrollView();
-
-            //GUILayout.BeginHorizontal(null);
-            //m_addComponentInput = GUILayout.TextField(m_addComponentInput, new GUILayoutOption[] { GUILayout.Width(m_rect.width / 2 - 150) });
-            //if (GUILayout.Button("Add Component", new GUILayoutOption[] { GUILayout.Width(120) }))
-            //{
-            //    if (HPExplorer.GetType(m_addComponentInput) is Type type && typeof(Component).IsAssignableFrom(type))
-            //    {
-            //        var comp = m_object.AddComponent(type);
-            //        var list = m_components.ToList();
-            //        list.Add(comp);
-            //        m_components = list.ToArray();
-            //    }
-            //    else
-            //    {
-            //        MelonLogger.LogWarning($"Could not get type '{m_addComponentInput}'. If it's not a typo, try the fully qualified name.");
-            //    }
-            //}
-            //GUILayout.EndHorizontal();
+            GUIUnstrip.EndScrollView();
 
             GUILayout.EndVertical();
         }
@@ -320,7 +439,7 @@ namespace Explorer
 
         private void GameObjectControls()
         {
-            GUILayout.BeginVertical(GUI.skin.box, new GUILayoutOption[] { GUILayout.Width(530) });
+            GUILayout.BeginVertical(GUI.skin.box, new GUILayoutOption[] { GUILayout.Width(520) });
             GUILayout.Label("<b><size=15>GameObject Controls</size></b>", null);
 
             GUILayout.BeginHorizontal(null);
@@ -329,17 +448,28 @@ namespace Explorer
                 new GUILayoutOption[] { GUILayout.Width(80) });
             if (m_object.activeSelf != m_active) { m_object.SetActive(m_active); }
 
-            UIHelpers.InstantiateButton(m_object, 100);            
+            UIHelpers.InstantiateButton(m_object, 100);
+
+            if (GUILayout.Button("Set DontDestroyOnLoad", new GUILayoutOption[] { GUILayout.Width(170) }))
+            {
+                GameObject.DontDestroyOnLoad(m_object);
+                m_object.hideFlags |= HideFlags.DontUnloadUnusedAsset;
+            }
+
+            var lbl = m_freeze ? "<color=lime>Unfreeze</color>" : "<color=orange>Freeze Pos/Rot</color>";
+            if (GUILayout.Button(lbl, new GUILayoutOption[] { GUILayout.Width(110) }))
+            {
+                m_freeze = !m_freeze;
+                if (m_freeze)
+                {
+                    UpdateFreeze();
+                }
+            }
 
             GUILayout.EndHorizontal();
-
             GUILayout.BeginHorizontal(null);
 
-            if (GUILayout.Button("Remove from parent", new GUILayoutOption[] { GUILayout.Width(160) }))
-            {
-                m_object.transform.parent = null;
-            }
-            m_setParentInput = GUILayout.TextField(m_setParentInput, new GUILayoutOption[] { GUILayout.Width(m_rect.width - 280) });
+            m_setParentInput = GUILayout.TextField(m_setParentInput, null);
             if (GUILayout.Button("Set Parent", new GUILayoutOption[] { GUILayout.Width(80) }))
             {
                 if (GameObject.Find(m_setParentInput) is GameObject newparent)
@@ -351,18 +481,65 @@ namespace Explorer
                     MelonLogger.LogWarning($"Could not find gameobject '{m_setParentInput}'");
                 }
             }
+
+            if (GUILayout.Button("Detach from parent", new GUILayoutOption[] { GUILayout.Width(160) }))
+            {
+                m_object.transform.parent = null;
+            }
             GUILayout.EndHorizontal();
 
             GUILayout.BeginVertical(GUI.skin.box, null);
 
-            var t = m_object.transform;
-            TranslateControl(t, TranslateType.Position, ref m_translateAmount,  false);
-            TranslateControl(t, TranslateType.Rotation, ref m_rotateAmount,     true);
-            TranslateControl(t, TranslateType.Scale,    ref m_scaleAmount,      false);
+            m_cachedInput[0] = TranslateControl(TranslateType.Position, ref m_translateAmount,  false);
+            m_cachedInput[1] = TranslateControl(TranslateType.Rotation, ref m_rotateAmount,     true);
+            m_cachedInput[2] = TranslateControl(TranslateType.Scale,    ref m_scaleAmount,      false);
+
+            GUILayout.BeginHorizontal(null);
+            if (GUILayout.Button("<color=lime>Apply to Transform</color>", null) || m_autoApplyTransform)
+            {
+                if (m_localContext)
+                {
+                    m_object.transform.localPosition = m_cachedInput[0];
+                    m_object.transform.localEulerAngles = m_cachedInput[1];
+                }
+                else
+                {
+                    m_object.transform.position = m_cachedInput[0];
+                    m_object.transform.eulerAngles = m_cachedInput[1];
+                }
+                m_object.transform.localScale = m_cachedInput[2];
+
+                if (m_freeze)
+                {
+                    UpdateFreeze();
+                }
+            }
+            if (GUILayout.Button("<color=lime>Update from Transform</color>", null) || m_autoUpdateTransform)
+            {
+                CacheTransformValues();
+            }
+            GUILayout.EndHorizontal();
+
+            GUILayout.BeginHorizontal(null);
+            BoolToggle(ref m_autoApplyTransform, "Auto-apply to Transform?");
+            BoolToggle(ref m_autoUpdateTransform, "Auto-update from transform?");
+            GUILayout.EndHorizontal();
+
+            bool b = m_localContext;
+            b = GUILayout.Toggle(b, "<color=" + (b ? "lime" : "red") + ">Use local transform values?</color>", null);
+            if (b != m_localContext)
+            {
+                m_localContext = b;
+                CacheTransformValues();
+                if (m_freeze)
+                {
+                    UpdateFreeze();
+                }
+            }
 
             GUILayout.EndVertical();
 
-            if (GUILayout.Button("<color=red><b>Destroy</b></color>", null))
+            if (GUILayout.Button("<color=red><b>Destroy</b></color>", new GUILayoutOption[] { GUILayout.Width(120) }))
             {
                 GameObject.Destroy(m_object);
                 DestroyWindow();
@@ -372,6 +549,30 @@ namespace Explorer
             GUILayout.EndVertical();
         }
 
+        private void UpdateFreeze()
+        {
+            if (m_localContext)
+            {
+                m_frozenPosition = m_object.transform.localPosition;
+                m_frozenRotation = m_object.transform.localRotation;
+            }
+            else
+            {
+                m_frozenPosition = m_object.transform.position;
+                m_frozenRotation = m_object.transform.rotation;
+            }
+            m_frozenScale = m_object.transform.localScale;
+        }
+
+        private void BoolToggle(ref bool value, string message)
+        {
+            string lbl = "<color=";
+            lbl += value ? "lime" : "red";
+            lbl += $">{message}</color>";
+
+            value = GUILayout.Toggle(value, lbl, null);
+        }
+
         public enum TranslateType
         {
             Position,
@@ -379,50 +580,55 @@ namespace Explorer
             Scale
         }
 
-        private void TranslateControl(Transform transform, TranslateType mode, ref float amount, bool multByTime)
+        private Vector3 TranslateControl(TranslateType mode, ref float amount, bool multByTime)
         {
             GUILayout.BeginHorizontal(null);
-            GUILayout.Label("<color=cyan><b>" + mode + "</b></color>:", new GUILayoutOption[] { GUILayout.Width(65) });
+            GUILayout.Label($"<color=cyan><b>{(m_localContext ? "Local " : "")}{mode}</b></color>:", 
+                new GUILayoutOption[] { GUILayout.Width(m_localContext ? 110 : 65) });
 
-            Vector3 vector = Vector3.zero;
+            var transform = m_object.transform;
             switch (mode)
             {
-                case TranslateType.Position: vector = transform.localPosition; break;
-                case TranslateType.Rotation: vector = transform.localRotation.eulerAngles; break;
-                case TranslateType.Scale:    vector = transform.localScale; break;
+                case TranslateType.Position:
+                    var pos = m_localContext ? transform.localPosition : transform.position;
+                    GUILayout.Label(pos.ToString(), new GUILayoutOption[] { GUILayout.Width(250) });
+                    break;
+                case TranslateType.Rotation:
+                    var rot = m_localContext ? transform.localEulerAngles : transform.eulerAngles;
+                    GUILayout.Label(rot.ToString(), new GUILayoutOption[] { GUILayout.Width(250) });
+                    break;
+                case TranslateType.Scale:
+                    GUILayout.Label(transform.localScale.ToString(), new GUILayoutOption[] { GUILayout.Width(250) });
+                    break;
             }
-            GUILayout.Label(vector.ToString(), new GUILayoutOption[] { GUILayout.Width(250)  });
             GUILayout.EndHorizontal();
 
+            Vector3 input = m_cachedInput[(int)mode];
+
             GUILayout.BeginHorizontal(null);
             GUI.skin.label.alignment = TextAnchor.MiddleRight;
 
             GUILayout.Label("<color=cyan>X:</color>", new GUILayoutOption[] { GUILayout.Width(20) });
-            PlusMinusFloat(ref vector.x, amount, multByTime);
+            PlusMinusFloat(ref input.x, amount, multByTime);
 
             GUILayout.Label("<color=cyan>Y:</color>", new GUILayoutOption[] { GUILayout.Width(20) });
-            PlusMinusFloat(ref vector.y, amount, multByTime);
+            PlusMinusFloat(ref input.y, amount, multByTime);
 
             GUILayout.Label("<color=cyan>Z:</color>", new GUILayoutOption[] { GUILayout.Width(20) });
-            PlusMinusFloat(ref vector.z, amount, multByTime);
-
-            switch (mode)
-            {
-                case TranslateType.Position: transform.localPosition = vector; break;
-                case TranslateType.Rotation: transform.localRotation = Quaternion.Euler(vector); break;
-                case TranslateType.Scale:    transform.localScale = vector; break;
-            }
+            PlusMinusFloat(ref input.z, amount, multByTime);            
 
             GUILayout.Label("+/-:", new GUILayoutOption[] { GUILayout.Width(30) });
-            var input = amount.ToString("F3");
-            input = GUILayout.TextField(input, new GUILayoutOption[] { GUILayout.Width(40) });
-            if (float.TryParse(input, out float f))
+            var amountInput = amount.ToString("F3");
+            amountInput = GUILayout.TextField(amountInput, new GUILayoutOption[] { GUILayout.Width(60) });
+            if (float.TryParse(amountInput, out float f))
             {
                 amount = f;
             }
 
             GUI.skin.label.alignment = TextAnchor.UpperLeft;
             GUILayout.EndHorizontal();
+
+            return input;
         }
 
         private void PlusMinusFloat(ref float f, float amount, bool multByTime)
@@ -442,7 +648,5 @@ namespace Explorer
                 f += multByTime ? amount * Time.deltaTime : amount;
             }
         }
-
-        
     }
 }

src/Windows/ReflectionWindow.cs

@@ -5,7 +5,6 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using MelonLoader;
-using Mono.CSharp;
 using UnhollowerBaseLib;
 using UnityEngine;
 
@@ -13,51 +12,76 @@ namespace Explorer
 {
     public class ReflectionWindow : UIWindow
     {
-        public override string Name { get => "Object Reflection"; set => Name = value; }
+        public override string Title => WindowManager.TabView
+            ? $"<color=cyan>[R]</color> {TargetType.Name}" 
+            : $"Reflection Inspector ({TargetType.Name})";
 
-        public Type ObjectType;
+        public Type TargetType;
 
-        private CacheObject[] m_cachedMembers;
-        private CacheObject[] m_cachedMemberFiltered;
-        private int m_pageOffset;
-        private int m_limitPerPage = 20;
+        private CacheObjectBase[] m_allCachedMembers;
+        private CacheObjectBase[] m_cachedMembersFiltered;
+
+        public PageHelper Pages = new PageHelper();
 
         private bool m_autoUpdate = false;
         private string m_search = "";
-        public MemberInfoType m_filter = MemberInfoType.Property;
-        private bool m_hideFailedReflection = true;
+        public MemberTypes m_filter = MemberTypes.Property;
+        private bool m_hideFailedReflection = false;
 
-        public enum MemberInfoType
-        {
-            Field,
-            Property,
-            Method,
-            All
-        }
+        // some extra caching
+        private UnityEngine.Object m_uObj;
+        private Component m_component;
 
         public override void Init()
         {
             var type = ReflectionHelpers.GetActualType(Target);
-            if (type == null)
-            {
-                MelonLogger.Log("Could not get underlying type for object. ToString(): " + Target.ToString());
-                return;
-            }
 
-            ObjectType = type;
+            TargetType = type;
 
             var types = ReflectionHelpers.GetAllBaseTypes(Target);
+
             CacheMembers(types);
 
-            m_filter = MemberInfoType.All;
-            m_cachedMemberFiltered = m_cachedMembers.Where(x => ShouldProcessMember(x)).ToArray();
-            UpdateValues();
-            m_filter = MemberInfoType.Property;
+            if (Target is Il2CppSystem.Object ilObject)
+            {
+                var unityObj = ilObject.TryCast<UnityEngine.Object>();
+                if (unityObj)
+                {
+                    m_uObj = unityObj;
+
+                    var component = ilObject.TryCast<Component>();
+                    if (component)
+                    {
+                        m_component = component;
+                    }
+                }
+            }
+
+            m_filter = MemberTypes.All;
+            m_autoUpdate = true;
+            Update();
+
+            m_autoUpdate = false;
+            m_filter = MemberTypes.Property;
         }
 
         public override void Update()
         {
-            m_cachedMemberFiltered = m_cachedMembers.Where(x => ShouldProcessMember(x)).ToArray();
+            if (Target == null)
+            {
+                DestroyWindow();
+                return;
+            }
+            else if (Target is UnityEngine.Object uObj)
+            {
+                if (!uObj)
+                {
+                    DestroyWindow();
+                    return;
+                }
+            }
+
+            m_cachedMembersFiltered = m_allCachedMembers.Where(x => ShouldProcessMember(x)).ToArray();
 
             if (m_autoUpdate)
             {
@@ -67,42 +91,34 @@ namespace Explorer
 
         private void UpdateValues()
         {
-            UpdateMembers();
-        }
-
-        private void UpdateMembers()
-        {
-            foreach (var member in m_cachedMemberFiltered)
+            foreach (var member in m_cachedMembersFiltered)
             {
                 member.UpdateValue();
             }
         }
 
-        private bool ShouldProcessMember(CacheObject holder)
+        private bool ShouldProcessMember(CacheObjectBase holder)
         {
-            if (m_filter != MemberInfoType.All && m_filter != holder.MemberInfoType) return false;
+            if (m_filter != MemberTypes.All && m_filter != holder.MemInfo?.MemberType) return false;
 
             if (!string.IsNullOrEmpty(holder.ReflectionException) && m_hideFailedReflection) return false;
 
-            if (m_search == "" || holder.MemberInfo == null) return true;
+            if (m_search == "" || holder.MemInfo == null) return true;
 
-            return holder.FullName
-                .ToLower()
-                .Contains(m_search.ToLower());
+            var name = holder.MemInfo.DeclaringType.Name + "." + holder.MemInfo.Name;
+
+            return name.ToLower().Contains(m_search.ToLower());
         }
 
         private void CacheMembers(Type[] types)
         {
-            var list = new List<CacheObject>();
+            var list = new List<CacheObjectBase>();
 
             var names = new List<string>();
 
             foreach (var declaringType in types)
             {
-                if (declaringType == typeof(Il2CppObjectBase)) continue;
-
                 MemberInfo[] infos;
-
                 string exception = null;
 
                 try
@@ -111,12 +127,12 @@ namespace Explorer
                 }
                 catch 
                 {
-                    MelonLogger.Log("Exception getting members for type: " + declaringType.Name);
+                    MelonLogger.Log($"Exception getting members for type: {declaringType.FullName}");
                     continue;
                 }
 
-                //object value = null;
                 object target = Target;
+
                 if (target is Il2CppSystem.Object ilObject)
                 {
                     try
@@ -131,22 +147,50 @@ namespace Explorer
 
                 foreach (var member in infos)
                 {
-                    if (member.MemberType == MemberTypes.Field || member.MemberType == MemberTypes.Property)
+                    if (member.MemberType == MemberTypes.Field || member.MemberType == MemberTypes.Property || member.MemberType == MemberTypes.Method)
                     {
-                        if (member.Name == "Il2CppType") continue;
+                        var name = $"{member.DeclaringType.Name}.{member.Name}";
 
-                        var name = member.DeclaringType.Name + "." + member.Name;
-                        if (names.Contains(name)) continue;
-                        names.Add(name);
+                        // blacklist (should probably make a proper implementation)
+                        if (name == "Type.DeclaringMethod" || member.Name.StartsWith("get_") || member.Name.StartsWith("set_")) //|| member.Name.Contains("Il2CppType")
+                        {
+                            continue;
+                        }
 
-                        var cached = CacheObject.GetCacheObject(null, member, target);
-                        list.Add(cached);
-                        cached.ReflectionException = exception;
+                        if (member is MethodInfo mi)
+                        {
+                            name += " (";
+                            foreach (var param in mi.GetParameters())
+                            {
+                                name += param.ParameterType.Name + ", ";
+                            }
+                            name += ")";
+                        }
+                        if (names.Contains(name))
+                        {
+                            continue;
+                        }
+
+                        try
+                        {
+                            var cached = CacheObjectBase.GetCacheObject(member, target);
+                            if (cached != null)
+                            {
+                                names.Add(name);
+                                list.Add(cached);
+                                cached.ReflectionException = exception;
+                            }
+                        }
+                        catch (Exception e) 
+                        {
+                            MelonLogger.LogWarning($"Exception caching member {name}!");
+                            MelonLogger.Log(e.ToString());
+                        }
                     }
                 }
             }
 
-            m_cachedMembers = list.ToArray();
+            m_allCachedMembers = list.ToArray();
         }
 
         // =========== GUI DRAW =========== //
@@ -155,40 +199,42 @@ namespace Explorer
         {
             try
             {
-                Header();
+                // ====== HEADER ======
 
-                GUILayout.BeginArea(new Rect(5, 25, m_rect.width - 10, m_rect.height - 35), GUI.skin.box);
+                var rect = WindowManager.TabView ? TabViewWindow.Instance.m_rect : this.m_rect;
+
+                if (!WindowManager.TabView)
+                {
+                    Header();
+                    GUILayout.BeginArea(new Rect(5, 25, rect.width - 10, rect.height - 35), GUI.skin.box);
+                }
 
                 GUILayout.BeginHorizontal(null);
-                GUILayout.Label("<b>Type:</b> <color=cyan>" + ObjectType.Name + "</color>", null);
-
-                bool unityObj = Target is UnityEngine.Object;
-
-                if (unityObj)
+                GUILayout.Label("<b>Type:</b> <color=cyan>" + TargetType.FullName + "</color>", new GUILayoutOption[] { GUILayout.Width(245f) });
+                if (m_uObj)
                 {
-                    GUILayout.Label("Name: " + (Target as UnityEngine.Object).name, null);
+                    GUILayout.Label("Name: " + m_uObj.name, null);
                 }
                 GUILayout.EndHorizontal();
 
-                if (unityObj)
+                if (m_uObj)
                 {
                     GUILayout.BeginHorizontal(null);
-
                     GUILayout.Label("<b>Tools:</b>", new GUILayoutOption[] { GUILayout.Width(80) });
-
-                    UIHelpers.InstantiateButton((UnityEngine.Object)Target);
-
-                    if (Target is Component comp && comp.gameObject is GameObject obj)
+                    UIHelpers.InstantiateButton(m_uObj);
+                    if (m_component && m_component.gameObject is GameObject obj)
                     {
                         GUI.skin.label.alignment = TextAnchor.MiddleRight;
-                        GUILayout.Label("GameObject:", null);
-                        if (GUILayout.Button("<color=#00FF00>" + obj.name + "</color>", new GUILayoutOption[] { GUILayout.MaxWidth(m_rect.width - 350) }))
+                        GUILayout.Label("GameObject:", new GUILayoutOption[] { GUILayout.Width(135) });
+                        var charWidth = obj.name.Length * 15;
+                        var maxWidth = rect.width - 350;
+                        var labelWidth = charWidth < maxWidth ? charWidth : maxWidth; 
+                        if (GUILayout.Button("<color=#00FF00>" + obj.name + "</color>", new GUILayoutOption[] { GUILayout.Width(labelWidth) }))
                         {
                             WindowManager.InspectObject(obj, out bool _);
                         }
                         GUI.skin.label.alignment = TextAnchor.UpperLeft;
                     }
-
                     GUILayout.EndHorizontal();
                 }
 
@@ -196,21 +242,15 @@ namespace Explorer
 
                 GUILayout.BeginHorizontal(null);
                 GUILayout.Label("<b>Search:</b>", new GUILayoutOption[] { GUILayout.Width(75) });
-                m_search = GUILayout.TextField(m_search, null);
-                GUILayout.Label("<b>Limit per page:</b>", new GUILayoutOption[] { GUILayout.Width(125) });
-                var limitString = m_limitPerPage.ToString();
-                limitString = GUILayout.TextField(limitString, new GUILayoutOption[] { GUILayout.Width(60) });
-                if (int.TryParse(limitString, out int i))
-                {
-                    m_limitPerPage = i;
-                }
+                m_search = GUILayout.TextField(m_search, null);                
                 GUILayout.EndHorizontal();
 
                 GUILayout.BeginHorizontal(null);
                 GUILayout.Label("<b>Filter:</b>", new GUILayoutOption[] { GUILayout.Width(75) });
-                FilterToggle(MemberInfoType.All, "All");
-                FilterToggle(MemberInfoType.Property, "Properties");
-                FilterToggle(MemberInfoType.Field, "Fields");
+                FilterToggle(MemberTypes.All, "All");
+                FilterToggle(MemberTypes.Property, "Properties");
+                FilterToggle(MemberTypes.Field, "Fields");
+                FilterToggle(MemberTypes.Method, "Methods");
                 GUILayout.EndHorizontal();
 
                 GUILayout.BeginHorizontal(null);
@@ -228,100 +268,89 @@ namespace Explorer
 
                 GUILayout.Space(10);
 
-                int count = m_cachedMemberFiltered.Length;
+                Pages.ItemCount = m_cachedMembersFiltered.Length;
 
-                if (count > m_limitPerPage)
+                // prev/next page buttons
+                GUILayout.BeginHorizontal(null);
+
+                Pages.DrawLimitInputArea();
+
+                if (Pages.ItemCount > Pages.ItemsPerPage)
                 {
-                    // prev/next page buttons
-                    GUILayout.BeginHorizontal(null);
-                    int maxOffset = (int)Mathf.Ceil((float)(count / (decimal)m_limitPerPage)) - 1;
-                    if (GUILayout.Button("< Prev", null))
+                    if (GUILayout.Button("< Prev", new GUILayoutOption[] { GUILayout.Width(80) }))
                     {
-                        if (m_pageOffset > 0) m_pageOffset--;
+                        Pages.TurnPage(Turn.Left, ref this.scroll);
                     }
 
-                    GUILayout.Label($"Page {m_pageOffset + 1}/{maxOffset + 1}", new GUILayoutOption[] { GUILayout.Width(80) });
+                    Pages.CurrentPageLabel();
 
-                    if (GUILayout.Button("Next >", null))
+                    if (GUILayout.Button("Next >", new GUILayoutOption[] { GUILayout.Width(80) }))
                     {
-                        if (m_pageOffset < maxOffset) m_pageOffset++;
+                        Pages.TurnPage(Turn.Right, ref this.scroll);
                     }
-                    GUILayout.EndHorizontal();
                 }
+                GUILayout.EndHorizontal();
 
-                scroll = GUILayout.BeginScrollView(scroll, GUI.skin.scrollView);
+                // ====== BODY ======
+
+                scroll = GUIUnstrip.BeginScrollView(scroll);
 
                 GUILayout.Space(10);
 
-                DrawMembers(this.m_cachedMemberFiltered);
+                UIStyles.HorizontalLine(Color.grey);
 
-                GUILayout.EndScrollView();
+                GUILayout.BeginVertical(GUI.skin.box, null);
 
-                m_rect = WindowManager.ResizeWindow(m_rect, windowID);
+                var members = this.m_cachedMembersFiltered;
+                int start = Pages.CalculateOffsetIndex();
 
-                GUILayout.EndArea();
+                for (int j = start; (j < start + Pages.ItemsPerPage && j < members.Length); j++)
+                {
+                    var holder = members[j];
+
+                    GUILayout.BeginHorizontal(new GUILayoutOption[] { GUILayout.Height(25) });
+                    try 
+                    { 
+                        holder.Draw(rect, 180f);
+                    } 
+                    catch 
+                    {
+                        GUILayout.EndHorizontal();
+                        continue;
+                    }
+                    GUILayout.EndHorizontal();
+
+                    // if not last element
+                    if (!(j == (start + Pages.ItemsPerPage - 1) || j == (members.Length - 1)))
+                        UIStyles.HorizontalLine(new Color(0.07f, 0.07f, 0.07f), true);
+                }
+
+                GUILayout.EndVertical();
+                GUIUnstrip.EndScrollView();
+
+                if (!WindowManager.TabView)
+                {
+                    m_rect = ResizeDrag.ResizeWindow(rect, windowID);
+
+                    GUILayout.EndArea();
+                }
+            }
+            catch (Il2CppException e)
+            {
+                if (!e.Message.Contains("in a group with only"))
+                {
+                    throw;
+                }
             }
             catch (Exception e)
             {
-                MelonLogger.LogWarning("Exception on window draw. Message: " + e.Message);
+                MelonLogger.LogWarning("Exception drawing ReflectionWindow: " + e.GetType() + ", " + e.Message);
                 DestroyWindow();
                 return;
             }
         }
 
-        private void DrawMembers(CacheObject[] members)
-        {
-            // todo pre-cache list based on current search, otherwise this doesnt work.
-
-            int i = 0;
-            DrawMembersInternal("Properties", MemberInfoType.Property, members, ref i);
-            DrawMembersInternal("Fields", MemberInfoType.Field, members, ref i);
-        }
-
-        private void DrawMembersInternal(string title, MemberInfoType filter, CacheObject[] members, ref int index)
-        {
-            if (m_filter != filter && m_filter != MemberInfoType.All)
-            {
-                return;
-            }
-
-            UIStyles.HorizontalLine(Color.grey);
-
-            GUILayout.Label($"<size=18><b><color=gold>{title}</color></b></size>", null);
-
-            int offset = (m_pageOffset * m_limitPerPage) + index;
-
-            if (offset >= m_cachedMemberFiltered.Length)
-            {
-                m_pageOffset = 0;
-                offset = 0;
-            }
-
-            for (int j = offset; j < offset + m_limitPerPage && j < members.Length; j++)
-            {
-                var holder = members[j];
-
-                if (holder.MemberInfoType != filter || !ShouldProcessMember(holder)) continue;
-
-                GUILayout.BeginHorizontal(new GUILayoutOption[] { GUILayout.Height(25) });
-                try
-                {
-                    holder.Draw(this.m_rect, 180f);
-                }
-                catch // (Exception e)
-                {
-                    //MelonLogger.Log("Exception drawing member " + holder.MemberInfo.Name);
-                    //MelonLogger.Log(e.GetType() + ", " + e.Message);
-                    //MelonLogger.Log(e.StackTrace);
-                }
-                GUILayout.EndHorizontal();
-
-                index++;
-                if (index >= m_limitPerPage) break;
-            }
-        }
-
-        private void FilterToggle(MemberInfoType mode, string label)
+        private void FilterToggle(MemberTypes mode, string label)
         {
             if (m_filter == mode)
             {
@@ -334,6 +363,8 @@ namespace Explorer
             if (GUILayout.Button(label, new GUILayoutOption[] { GUILayout.Width(100) }))
             {
                 m_filter = mode;
+                Pages.PageOffset = 0;
+                scroll = Vector2.zero;
             }
             GUI.color = Color.white;
         }

src/Windows/ResizeDrag.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+using MelonLoader;
+using UnhollowerBaseLib;
+
+namespace Explorer
+{
+    public class ResizeDrag
+    {
+        private static bool RESIZE_FAILED = false;
+
+        private static readonly GUIContent gcDrag = new GUIContent("<-- Drag to resize -->");
+        private static bool isResizing = false;
+        private static Rect m_currentResize;
+        private static int m_currentWindow;
+
+        public static Rect ResizeWindow(Rect _rect, int ID)
+        {
+            if (!RESIZE_FAILED)
+            {
+                var origRect = _rect;
+
+                try
+                {
+                    GUILayout.BeginHorizontal(GUI.skin.box, null);
+
+                    GUI.skin.label.alignment = TextAnchor.MiddleCenter;
+                    GUILayout.Button(gcDrag, GUI.skin.label, new GUILayoutOption[] { GUILayout.Height(15) });
+
+                    //var r = GUILayoutUtility.GetLastRect();
+                    var r = GUIUnstrip.GetLastRect();
+
+                    Vector2 mouse = GUIUtility.ScreenToGUIPoint(new Vector2(Input.mousePosition.x, Screen.height - Input.mousePosition.y));
+
+                    if (r.Contains(mouse) && Input.GetMouseButtonDown(0))
+                    {
+                        isResizing = true;
+                        m_currentWindow = ID;
+                        m_currentResize = new Rect(mouse.x, mouse.y, _rect.width, _rect.height);
+                    }
+                    else if (!Input.GetMouseButton(0))
+                    {
+                        isResizing = false;
+                    }
+
+                    if (isResizing && ID == m_currentWindow)
+                    {
+                        _rect.width = Mathf.Max(100, m_currentResize.width + (mouse.x - m_currentResize.x));
+                        _rect.height = Mathf.Max(100, m_currentResize.height + (mouse.y - m_currentResize.y));
+                        _rect.xMax = Mathf.Min(Screen.width, _rect.xMax);  // modifying xMax affects width, not x
+                        _rect.yMax = Mathf.Min(Screen.height, _rect.yMax);  // modifying yMax affects height, not y
+                    }
+
+                    GUILayout.EndHorizontal();
+                }
+                catch (Il2CppException e) when (e.Message.StartsWith("System.ArgumentException"))
+                {
+                    // suppress
+                    return origRect;
+                }
+                catch (Exception e)
+                {
+                    RESIZE_FAILED = true;
+                    MelonLogger.Log("Exception on GuiResize: " + e.GetType() + ", " + e.Message);
+                    MelonLogger.Log(e.StackTrace);
+                    return origRect;
+                }
+
+                GUI.skin.label.alignment = TextAnchor.UpperLeft;
+            }
+            else
+            {
+                GUILayout.BeginHorizontal(GUI.skin.box, null);
+
+                GUILayout.Label("Resize window:", new GUILayoutOption[] { GUILayout.Width(100) });
+
+                GUI.skin.label.alignment = TextAnchor.MiddleRight;
+                GUILayout.Label("<color=cyan>Width:</color>", new GUILayoutOption[] { GUILayout.Width(60) });
+                if (GUILayout.RepeatButton("-", new GUILayoutOption[] { GUILayout.Width(20) }))
+                {
+                    _rect.width -= 5f;
+                }
+                if (GUILayout.RepeatButton("+", new GUILayoutOption[] { GUILayout.Width(20) }))
+                {
+                    _rect.width += 5f;
+                }
+                GUILayout.Label("<color=cyan>Height:</color>", new GUILayoutOption[] { GUILayout.Width(60) });
+                if (GUILayout.RepeatButton("-", new GUILayoutOption[] { GUILayout.Width(20) }))
+                {
+                    _rect.height -= 5f;
+                }
+                if (GUILayout.RepeatButton("+", new GUILayoutOption[] { GUILayout.Width(20) }))
+                {
+                    _rect.height += 5f;
+                }
+
+                GUILayout.EndHorizontal();
+                GUI.skin.label.alignment = TextAnchor.UpperLeft;
+            }
+
+            return _rect;
+        }
+    }
+}

src/Windows/TabViewWindow.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using MelonLoader;
+using UnityEngine;
+
+namespace Explorer
+{
+    public class TabViewWindow : UIWindow
+    {
+        public override string Title => $"Tabs ({WindowManager.Windows.Count})";
+
+        public static TabViewWindow Instance => m_instance ?? (m_instance = new TabViewWindow());
+        private static TabViewWindow m_instance;
+
+        private UIWindow m_targetWindow;
+        public int TargetTabID = 0;
+
+        public override bool IsTabViewWindow => true;
+
+        public TabViewWindow()
+        {
+            m_rect = new Rect(570, 0, 550, 700);
+        }
+
+        public override void Init() { }
+
+        public override void Update() 
+        {
+            while (TargetTabID >= WindowManager.Windows.Count)
+            {
+                TargetTabID--;
+            }
+
+            if (TargetTabID == -1 && WindowManager.Windows.Count > 0)
+            {
+                TargetTabID = 0;
+            }
+
+            if (TargetTabID >= 0)
+            {
+                m_targetWindow = WindowManager.Windows[TargetTabID];                
+            }
+            else
+            {
+                m_targetWindow = null;
+            }
+
+            m_targetWindow?.Update();
+        }
+
+        public override void WindowFunction(int windowID)
+        {
+            try
+            {
+                GUI.DragWindow(new Rect(0, 0, m_rect.width - 90, 20));
+                if (GUI.Button(new Rect(m_rect.width - 90, 2, 80, 20), "<color=red>Close All</color>"))
+                {
+                    foreach (var window in WindowManager.Windows)
+                    {
+                        window.DestroyWindow();
+                    }
+                    return;
+                }
+
+                GUILayout.BeginArea(new Rect(5, 25, m_rect.width - 10, m_rect.height - 35), GUI.skin.box);
+
+                GUILayout.BeginVertical(GUI.skin.box, null);
+                GUILayout.BeginHorizontal(null);
+                GUI.skin.button.alignment = TextAnchor.MiddleLeft;
+                int tabPerRow = Mathf.FloorToInt((float)((decimal)m_rect.width / 238));
+                int rowCount = 0;
+                for (int i = 0; i < WindowManager.Windows.Count; i++)
+                {
+                    if (rowCount >= tabPerRow)
+                    {
+                        rowCount = 0;
+                        GUILayout.EndHorizontal();
+                        GUILayout.BeginHorizontal(null);
+                    }
+                    rowCount++;
+
+                    bool focused = i == TargetTabID;
+                    string color = focused ? "<color=lime>" : "<color=orange>";
+                    GUI.color = focused ? Color.green : Color.white;
+
+                    var window = WindowManager.Windows[i];
+                    if (GUILayout.Button(color + window.Title + "</color>", new GUILayoutOption[] { GUILayout.Width(200) }))
+                    {
+                        TargetTabID = i;
+                    }
+                    if (GUILayout.Button("<color=red><b>X</b></color>", new GUILayoutOption[] { GUILayout.Width(22) }))
+                    {
+                        window.DestroyWindow();
+                    }
+                }
+                GUI.color = Color.white;
+                GUILayout.EndHorizontal();
+                GUILayout.EndVertical();
+                GUI.skin.button.alignment = TextAnchor.MiddleCenter;
+
+                m_targetWindow.WindowFunction(m_targetWindow.windowID);
+
+                try
+                {
+                    m_rect = ResizeDrag.ResizeWindow(m_rect, windowID);
+                }
+                catch { }
+
+                GUILayout.EndArea();
+            }
+            catch { }
+        }
+    }
+}

src/Windows/UIWindow.cs

@@ -7,14 +7,12 @@ using MelonLoader;
 using UnhollowerBaseLib;
 using UnhollowerRuntimeLib;
 using UnityEngine;
-using UnityEngine.Events;
-using UnityEngine.EventSystems;
 
 namespace Explorer
 {
     public abstract class UIWindow
     {
-        public abstract string Name { get; set; }
+        public abstract string Title { get; }
 
         public object Target;
 
@@ -23,6 +21,8 @@ namespace Explorer
 
         public Vector2 scroll = Vector2.zero;
 
+        public virtual bool IsTabViewWindow => false;
+
         public abstract void Init();
         public abstract void WindowFunction(int windowID);
         public abstract void Update();
@@ -44,15 +44,7 @@ namespace Explorer
 
         public void DestroyWindow()
         {
-            try
-            {
-                WindowManager.Windows.Remove(this);
-            }
-            catch (Exception e)
-            {
-                MelonLogger.Log("Exception removing Window from WindowManager.Windows list!");
-                MelonLogger.Log($"{e.GetType()} : {e.Message}\r\n{e.StackTrace}");
-            }
+            WindowManager.DestroyWindow(this);
         }
 
         public void OnGUI()
@@ -62,7 +54,7 @@ namespace Explorer
                 var origSkin = GUI.skin;
 
                 GUI.skin = UIStyles.WindowSkin;
-                m_rect = GUI.Window(windowID, m_rect, (GUI.WindowFunction)WindowFunction, Name);
+                m_rect = GUI.Window(windowID, m_rect, (GUI.WindowFunction)WindowFunction, Title);
 
                 GUI.skin = origSkin;
             }
@@ -70,12 +62,15 @@ namespace Explorer
 
         public void Header()
         {
-            GUI.DragWindow(new Rect(0, 0, m_rect.width - 90, 20));
-
-            if (GUI.Button(new Rect(m_rect.width - 90, 2, 80, 20), "<color=red><b>X</b></color>"))
+            if (!WindowManager.TabView)
             {
-                DestroyWindow();
-                return;
+                GUI.DragWindow(new Rect(0, 0, m_rect.width - 90, 20));
+            
+                if (GUI.Button(new Rect(m_rect.width - 90, 2, 80, 20), "<color=red><b>X</b></color>"))
+                {
+                    DestroyWindow();
+                    return;
+                }
             }
         }
     }

src/Windows/WindowManager.cs

@@ -16,33 +16,160 @@ namespace Explorer
     {
         public static WindowManager Instance;
 
+        public static bool TabView = true;
+
         public static List<UIWindow> Windows = new List<UIWindow>();
         public static int CurrentWindowID { get; set; } = 500000;
         private static Rect m_lastWindowRect;
 
+        private static readonly List<UIWindow> m_windowsToDestroy = new List<UIWindow>();
+
         public WindowManager()
         {
             Instance = this;
         }
 
+        public static void DestroyWindow(UIWindow window)
+        {
+            m_windowsToDestroy.Add(window);
+        }
+
         public void Update()
         {
-            foreach (var window in Windows)
+            if (m_windowsToDestroy.Count > 0)
             {
-                window.Update();
+                foreach (var window in m_windowsToDestroy)
+                {
+                    if (Windows.Contains(window))
+                    {
+                        Windows.Remove(window);
+                    }
+                }
+
+                m_windowsToDestroy.Clear();
+            }
+
+            if (TabView)
+            {
+                TabViewWindow.Instance.Update();
+            }
+            else
+            {
+                for (int i = 0; i < Windows.Count; i++)
+                {
+                    var window = Windows[i];
+                    if (window != null)
+                    {
+                        window.Update();
+                    }
+                }
             }
         }
 
         public void OnGUI()
         {
-            foreach (var window in Windows)
+            if (TabView)
             {
-                window.OnGUI();
+                if (Windows.Count > 0)
+                {
+                    TabViewWindow.Instance.OnGUI();
+                }
+            }
+            else
+            {
+                foreach (var window in Windows)
+                {
+                    window.OnGUI();
+                }
             }
         }
 
         // ========= Public Helpers =========
 
+        public static UIWindow InspectObject(object obj, out bool createdNew, bool forceReflection = false)
+        {
+            createdNew = false;
+
+            if (Input.GetKey(KeyCode.LeftShift))
+            {
+                forceReflection = true;
+            }
+            
+            Il2CppSystem.Object iObj = null;
+            if (obj is Il2CppSystem.Object isObj)
+            {
+                iObj = isObj;
+            }
+
+            if (!forceReflection)
+            {
+                foreach (var window in Windows)
+                {
+                    bool equals = ReferenceEquals(obj, window.Target);
+
+                    if (!equals && iObj is Il2CppSystem.Object iCurrent && window.Target is Il2CppSystem.Object iTarget)
+                    {
+                        if (iCurrent.GetIl2CppType().FullName != iTarget.GetIl2CppType().FullName)
+                        {
+                            if (iCurrent is Transform transform)
+                            {
+                                iCurrent = transform.gameObject;
+                            }
+                        }
+
+                        equals = iCurrent.Pointer == iTarget.Pointer;
+                    }
+
+                    if (equals)
+                    {
+                        FocusWindow(window);
+                        return window;
+                    }
+                }
+            }
+
+            createdNew = true;
+            if (!forceReflection && (obj is GameObject || obj is Transform))
+            {
+                return InspectGameObject(obj as GameObject ?? (obj as Transform).gameObject);
+            }
+            else
+            {
+                return InspectReflection(obj);
+            }
+        }
+
+        private static void FocusWindow(UIWindow window)
+        {
+            if (!TabView)
+            {
+                GUI.BringWindowToFront(window.windowID);
+                GUI.FocusWindow(window.windowID);
+            }
+            else
+            {
+                TabViewWindow.Instance.TargetTabID = Windows.IndexOf(window);
+            }
+        }
+
+        private static UIWindow InspectGameObject(GameObject obj)
+        {
+            var new_window = UIWindow.CreateWindow<GameObjectWindow>(obj);
+            FocusWindow(new_window);
+
+            return new_window;
+        }
+
+        private static UIWindow InspectReflection(object obj)
+        {
+            var new_window = UIWindow.CreateWindow<ReflectionWindow>(obj);
+            FocusWindow(new_window);
+
+            return new_window;
+        }
+
+        // === Misc Helpers ===
+
         public static bool IsMouseInWindow
         {
             get
@@ -97,93 +224,5 @@ namespace Explorer
 
             return rect;
         }
-
-        public static UIWindow InspectObject(object obj, out bool createdNew)
-        {
-            createdNew = false;
-
-            foreach (var window in Windows)
-            {
-                if (obj == window.Target)
-                {
-                    GUI.BringWindowToFront(window.windowID);
-                    GUI.FocusWindow(window.windowID);
-                    return window;
-                }
-            }
-
-            createdNew = true;
-            if (obj is GameObject || obj is Transform)
-            {
-                return InspectGameObject(obj as GameObject ?? (obj as Transform).gameObject);
-            }
-            else
-            {
-                return InspectReflection(obj);
-            }
-        }
-
-        private static UIWindow InspectGameObject(GameObject obj)
-        {
-            var new_window = UIWindow.CreateWindow<GameObjectWindow>(obj);
-            GUI.FocusWindow(new_window.windowID);
-
-            return new_window;
-        }
-
-        public static UIWindow InspectReflection(object obj)
-        {
-            var new_window = UIWindow.CreateWindow<ReflectionWindow>(obj);
-            GUI.FocusWindow(new_window.windowID);
-
-            return new_window;
-        }
-
-        // ============= Resize Window Helper ============
-
-        // static readonly GUIContent gcDrag = new GUIContent("<->", "drag to resize");
-        private static readonly GUIContent gcDrag = new GUIContent("<->");
-        private static bool isResizing = false;
-        private static Rect m_currentResize;
-        private static int m_currentWindow;
-
-        public static Rect ResizeWindow(Rect _rect, int ID)
-        {
-            try
-            {
-                GUILayout.BeginHorizontal(null);
-                GUILayout.Space(_rect.width - 35);
-
-                GUILayout.Button(gcDrag, GUI.skin.label, new GUILayoutOption[] { GUILayout.Width(25), GUILayout.Height(25) });
-
-                var r = GUILayoutUtility.GetLastRect();
-
-                Vector2 mouse = GUIUtility.ScreenToGUIPoint(new Vector2(Input.mousePosition.x, Screen.height - Input.mousePosition.y));
-
-                if (r.Contains(mouse) && Input.GetMouseButtonDown(0))
-                {
-                    isResizing = true;
-                    m_currentWindow = ID;
-                    m_currentResize = new Rect(mouse.x, mouse.y, _rect.width, _rect.height);
-                }
-                else if (!Input.GetMouseButton(0))
-                {
-                    isResizing = false;
-                }
-
-                if (isResizing && ID == m_currentWindow)
-                {
-                    _rect.width = Mathf.Max(100, m_currentResize.width + (mouse.x - m_currentResize.x));
-                    _rect.height = Mathf.Max(100, m_currentResize.height + (mouse.y - m_currentResize.y));
-                    _rect.xMax = Mathf.Min(Screen.width, _rect.xMax);  // modifying xMax affects width, not x
-                    _rect.yMax = Mathf.Min(Screen.height, _rect.yMax);  // modifying yMax affects height, not y
-                }
-
-                GUILayout.EndHorizontal();
-            }
-            catch { }
-
-            return _rect;
-        }
     }
 }