Update CppExplorer.cs

* Fix for failed unstrip with RectOffset(int, int, int, int) ctor
* Cleanups

README.md

@@ -1,4 +1,4 @@
-# CppExplorer [![Version](https://img.shields.io/badge/MelonLoader-0.2.7.1-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://sinai-dev.github.io/images/thumbs/02.png">
@@ -14,10 +14,9 @@
   <img src="https://img.shields.io/github/downloads/sinai-dev/CppExplorer/total.svg" />
 </p>
 
-### Known issue
+### Known issues
-Some games are experiencing `MissingMethodException`s or exceptions about failed unstripping, which prevent the CppExplorer menu from showing properly or at all. This is a bug with [Il2CppAssemblyUnhollower](https://github.com/knah/Il2CppAssemblyUnhollower) and there isn't much I can do about it myself. 
+* 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.
-If you're familiar with C# and Unity, one possibility for now is making a fork of this repo and manually fixing all the broken methods to ones which aren't broken (if possible). There may be another overload of the same method which wasn't stripped or was unstripped successfully, which you can use instead.
 
 ## Features
 * Scene hierarchy explorer
@@ -45,20 +44,22 @@ Requires [MelonLoader](https://github.com/HerpDerpinstine/MelonLoader) to be ins
 * 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.
 
-[![](https://i.imgur.com/2b0q0jL.png)](https://i.imgur.com/2b0q0jL.png)
+[![](https://i.imgur.com/BzTOCvp.png)](https://i.imgur.com/BzTOCvp.png)
 
 ### Inspectors
 
 CppExplorer has two main inspector modes: <b>GameObject Inspector</b>, and <b>Reflection Inspector</b>.
 
-<b>Tip:</b> when in Tab View, GameObjects are denoted by a [G] prefix, and Reflection objects are denoted by a [R] prefix.
+<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.
 
 ### GameObject Inspector
 
 * 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/JTxqlx4.png)](https://i.imgur.com/JTxqlx4.png)
+[![](https://i.imgur.com/DiDvl0Q.png)](https://i.imgur.com/DiDvl0Q.png)
 
 ### Reflection Inspector
 
@@ -66,7 +67,7 @@ CppExplorer has two main inspector modes: <b>GameObject Inspector</b>, and <b>Re
 * 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/iq92m0l.png)](https://i.imgur.com/iq92m0l.png)
+[![](https://i.imgur.com/Pq127XD.png)](https://i.imgur.com/Pq127XD.png)
 
 ### Object Search
 

src/CachedObjects/CacheDictionary.cs

@@ -1,34 +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 CacheDictionary : CacheObjectBase
-    {
-
-
-        public override void Init()
-        {
-            //base.Init();
-
-            Value = "Unsupported";
-        }
-
-        public override void UpdateValue()
-        {
-            //base.UpdateValue();
-
-
-        }
-
-        public override void DrawValue(Rect window, float width)
-        {
-            GUILayout.Label("<color=red>Dictionary (unsupported)</color>", null);
-        }
-    }
-}

src/CachedObjects/CacheObjectBase.cs

@@ -14,6 +14,7 @@ namespace Explorer
     {
         public object Value;
         public string ValueTypeName;
+        public Type ValueType;
 
         // Reflection Inspector only
         public MemberInfo MemInfo { get; set; }
@@ -79,11 +80,7 @@ namespace Explorer
         {
             Type type = null;
 
-            if (obj != null)
+            if (memberInfo != null)
-            {
-                type = ReflectionHelpers.GetActualType(obj);
-            }
-            else if (memberInfo != null)
             {
                 if (memberInfo is FieldInfo fi)
                 {
@@ -98,6 +95,10 @@ namespace Explorer
                     type = mi.ReturnType;
                 }
             }
+            else if (obj != null)
+            {
+                type = ReflectionHelpers.GetActualType(obj);
+            }
 
             if (type == null)
             {
@@ -114,6 +115,11 @@ namespace Explorer
         {
             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))
@@ -137,20 +143,38 @@ namespace Explorer
             {
                 holder = new CacheEnum();
             }
-            else if (ReflectionHelpers.IsArray(valueType) || ReflectionHelpers.IsList(valueType))
+            else if (valueType == typeof(Vector2) || valueType == typeof(Vector3) || valueType == typeof(Vector4))
             {
-                holder = new CacheList();
+                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)

src/CachedObjects/Object/CacheDictionary.cs

@@ -0,0 +1,278 @@
+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
+    {
+        public bool IsExpanded { get; set; }
+        public PageHelper Pages = new PageHelper();
+
+        public float WhiteSpace = 215f;
+        public float ButtonWidthOffset = 290f;
+
+        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;
+
+        // 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;
+        }
+
+        // ========== Methods ==========
+
+        private void GetGenericArguments()
+        {
+            if (m_keysType == null || m_valuesType == 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_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];
+                    }
+                }
+            }
+
+            return;
+        }
+
+        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.BeginHorizontal(new GUILayoutOption[] { GUILayout.MinWidth((window.width / 3) - 60f) });
+                        GUILayout.Label("Key:", new GUILayoutOption[] { GUILayout.Width(40) });
+                        key.DrawValue(window, (window.width / 2) - 30f);
+                        GUILayout.EndHorizontal();
+
+                        GUILayout.BeginHorizontal(null);
+                        GUILayout.Label("Value:", new GUILayoutOption[] { GUILayout.Width(40) });
+                        val.DrawValue(window, (window.width / 2) - 30f);
+                        GUILayout.EndHorizontal();
+                    }
+
+                }
+
+                GUI.skin.label.alignment = TextAnchor.UpperLeft;
+            }
+        }
+    }
+}

src/CachedObjects/Object/CacheGameObject.cs

@@ -12,7 +12,7 @@ namespace Explorer
     {
         public override void DrawValue(Rect window, float width)
         {
-            UIHelpers.GameobjButton(Value, null, false, width);
+            UIHelpers.GOButton(Value, null, false, width);
         }
 
         public override void UpdateValue()

src/CachedObjects/Object/CacheList.cs

@@ -218,6 +218,7 @@ namespace Explorer
 
                     if (GetCacheObject(obj, t) is CacheObjectBase cached)
                     {
+                        cached.UpdateValue();
                         list.Add(cached);
                     }
                     else
@@ -262,7 +263,7 @@ namespace Explorer
             }
 
             GUI.skin.button.alignment = TextAnchor.MiddleLeft;
-            string btnLabel = "<color=yellow>[" + count + "] " + EntryType + "</color>";
+            string btnLabel = "<color=yellow>[" + count + "] " + EntryType.FullName + "</color>";
             if (GUILayout.Button(btnLabel, new GUILayoutOption[] { GUILayout.MaxWidth(window.width - ButtonWidthOffset) }))
             {
                 WindowManager.InspectObject(Value, out bool _);
@@ -279,19 +280,15 @@ namespace Explorer
                     ClampLabelWidth(window, ref whitespace);
                 }
 
-                Pages.Count = count;
+                Pages.ItemCount = count;
 
-                if (count > Pages.PageLimit)
+                if (count > Pages.ItemsPerPage)
                 {
                     GUILayout.EndHorizontal();
                     GUILayout.BeginHorizontal(null);
 
                     GUILayout.Space(whitespace);
-
+                 
-                    //int maxOffset = (int)Mathf.Ceil((float)(count / (decimal)ArrayLimit)) - 1;
-                    Pages.CalculateMaxOffset();
-
-                    //GUILayout.Label($"Page {PH.ArrayOffset + 1}/{maxOffset + 1}", new GUILayoutOption[] { GUILayout.Width(80) });                    
                     Pages.CurrentPageLabel();
 
                     // prev/next page buttons
@@ -309,15 +306,9 @@ namespace Explorer
                     GUILayout.Space(5);
                 }
 
-                //int offset = ArrayOffset * ArrayLimit;
-                //if (offset >= count)
-                //{
-                //    offset = 0;
-                //    ArrayOffset = 0;
-                //}
                 int offset = Pages.CalculateOffsetIndex();
 
-                for (int i = offset; i < offset + Pages.PageLimit && i < count; i++)
+                for (int i = offset; i < offset + Pages.ItemsPerPage && i < count; i++)
                 {
                     var entry = m_cachedEntries[i];
 

src/CachedObjects/Other/CacheMethod.cs

@@ -212,6 +212,11 @@ namespace Explorer
                     cacheList.WhiteSpace = 0f;
                     cacheList.ButtonWidthOffset += 70f;
                 }
+                else if (m_cachedReturnValue is CacheDictionary cacheDict)
+                {
+                    cacheDict.WhiteSpace = 0f;
+                    cacheDict.ButtonWidthOffset += 70f;
+                }
                 m_cachedReturnValue.UpdateValue();
             }
             else

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

@@ -51,7 +51,7 @@ namespace Explorer
                 }
             }
 
-            GUILayout.Label(Value.ToString(), null);// + "<color=yellow><i> (" + ValueType + ")</i></color>", null);
+            GUILayout.Label(Value.ToString() + "<color=yellow><i> (" + ValueType + ")</i></color>", null);
         }
 
         public void SetEnum(ref object value, int change)

src/CachedObjects/Struct/CachePrimitive.cs

@@ -8,91 +8,37 @@ namespace Explorer
 {
     public class CachePrimitive : CacheObjectBase
     {
-        public enum PrimitiveTypes
+        private bool m_isBool;
-        {
+        private bool m_isString;
-            Bool,
-            Double,
-            Float,
-            Int,
-            String,
-            Char
-        }
 
         private string m_valueToString;
 
-        public PrimitiveTypes PrimitiveType;
+        public MethodInfo ParseMethod => m_parseMethod ?? (m_parseMethod = Value.GetType().GetMethod("Parse", new Type[] { typeof(string) }));
-
-        public MethodInfo ParseMethod
-        {
-            get
-            {
-                if (m_parseMethod == null)
-                {
-                    m_parseMethod = Value.GetType().GetMethod("Parse", new Type[] { typeof(string) });
-                }
-                return m_parseMethod;
-            }
-        }
-
         private MethodInfo m_parseMethod;
 
         public override void Init()
         {
-            if (Value == null)
+            if (ValueType == null)
             {
-                // this must mean it is a string. No other primitive type should be nullable.
+                ValueType = Value?.GetType();
-                PrimitiveType = PrimitiveTypes.String;
+
-                return;
+                // has to be a string at this point
+                if (ValueType == null)
+                {
+                    ValueType = typeof(string);
+                }
             }
 
-            m_valueToString = Value.ToString();
+            if (ValueType == typeof(string))
-            var type = Value.GetType();
-
-            if (type == typeof(bool))
             {
-                PrimitiveType = PrimitiveTypes.Bool;
+                m_isString = true;
             }
-            else if (type == typeof(double))
+            else if (ValueType == typeof(bool))
             {
-                PrimitiveType = PrimitiveTypes.Double;
+                m_isBool = true;
-            }
-            else if (type == typeof(float))
-            {
-                PrimitiveType = PrimitiveTypes.Float;
-            }
-            else if (IsInteger(type))
-            {
-                PrimitiveType = PrimitiveTypes.Int;
-            }
-            else if (type == typeof(char))
-            {
-                PrimitiveType = PrimitiveTypes.Char;
-            }
-            else
-            {
-                PrimitiveType = PrimitiveTypes.String;
             }
         }
 
-        private static bool IsInteger(Type type)
-        {
-            // For our purposes, all types of int can be treated the same, including IntPtr.
-            return _integerTypes.Contains(type);
-        }
-
-        private static readonly HashSet<Type> _integerTypes = new HashSet<Type>
-        {
-            typeof(int),
-            typeof(uint),
-            typeof(short),
-            typeof(ushort),
-            typeof(long),
-            typeof(ulong),
-            typeof(byte),
-            typeof(sbyte),
-            typeof(IntPtr)
-        };
-
         public override void UpdateValue()
         {
             base.UpdateValue();
@@ -102,11 +48,10 @@ namespace Explorer
 
         public override void DrawValue(Rect window, float width)
         {
-            if (PrimitiveType == PrimitiveTypes.Bool)
+            if (m_isBool)
             {
                 var b = (bool)Value;
-                var color = $"<color={(b ? "lime>" : "red>")}";
+                var label = $"<color={(b ? "lime" : "red")}>{b}</color>";
-                var label = $"{color}{b}</color>";
 
                 if (CanWrite)
                 {
@@ -123,7 +68,8 @@ namespace Explorer
             }
             else
             {
-                GUILayout.Label("<color=yellow><i>" + PrimitiveType + "</i></color>", new GUILayoutOption[] { GUILayout.Width(50) });
+                // 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;
@@ -150,7 +96,7 @@ namespace Explorer
             }
         }
 
-        public void SetValueFromInput(string value)
+        public void SetValueFromInput(string valueString)
         {
             if (MemInfo == null)
             {
@@ -158,16 +104,15 @@ namespace Explorer
                 return;
             }
 
-            if (PrimitiveType == PrimitiveTypes.String)
+            if (m_isString)
             {
-                Value = value;
+                Value = valueString;
             }
             else
             {
                 try
                 {
-                    var val = ParseMethod.Invoke(null, new object[] { value });
+                    Value = ParseMethod.Invoke(null, new object[] { valueString });
-                    Value = val;                    
                 }
                 catch (Exception e)
                 {

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

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -12,7 +13,7 @@ namespace Explorer
     public class CppExplorer : MelonMod
     {
         public const string GUID = "com.sinai.cppexplorer";
-        public const string VERSION = "1.5.2";
+        public const string VERSION = "1.6.0";
         public const string AUTHOR = "Sinai";
 
         public const string NAME = "CppExplorer"
@@ -99,6 +100,8 @@ namespace Explorer
 
         public override void OnGUI()
         {
+            if (!ShowMenu) return;
+
             MainMenu.Instance.OnGUI();
             WindowManager.Instance.OnGUI();
             InspectUnderMouse.OnGUI();

src/CppExplorer.csproj

@@ -18,8 +18,8 @@
     <DebugSymbols>false</DebugSymbols>
     <DebugType>none</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>..\Release\</OutputPath>
+    <OutputPath>..\Release\2019\</OutputPath>
-    <DefineConstants>DEBUG</DefineConstants>
+    <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>
@@ -44,7 +44,7 @@
     </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>
@@ -120,15 +120,21 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="CachedObjects\CacheDictionary.cs" />
+    <Compile Include="CachedObjects\Struct\CacheColor.cs" />
-    <Compile Include="CachedObjects\CacheEnum.cs" />
+    <Compile Include="CachedObjects\Object\CacheDictionary.cs" />
-    <Compile Include="CachedObjects\CacheGameObject.cs" />
+    <Compile Include="CachedObjects\Struct\CacheEnum.cs" />
-    <Compile Include="CachedObjects\CacheList.cs" />
+    <Compile Include="CachedObjects\Object\CacheGameObject.cs" />
-    <Compile Include="CachedObjects\CachePrimitive.cs" />
+    <Compile Include="CachedObjects\Object\CacheList.cs" />
-    <Compile Include="CachedObjects\CacheOther.cs" />
+    <Compile Include="CachedObjects\Struct\CachePrimitive.cs" />
-    <Compile Include="CachedObjects\CacheMethod.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" />
@@ -136,6 +142,8 @@
     <Compile Include="Helpers\UnityHelpers.cs" />
     <Compile Include="MainMenu\InspectUnderMouse.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" />

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/PageHelper.cs

@@ -16,13 +16,34 @@ namespace Explorer
     public class PageHelper
     {
         public int PageOffset { get; set; }
-        public int PageLimit { get; set; } = 20;
-        public int Count { get; set; }
-        public int MaxOffset { get; set; } = -1;
 
-        public int CalculateMaxOffset()
+        public int ItemsPerPage
         {
-            return MaxOffset = (int)Mathf.Ceil((float)(Count / (decimal)PageLimit)) - 1;
+            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()
@@ -30,7 +51,7 @@ namespace Explorer
             var orig = GUI.skin.label.alignment;
             GUI.skin.label.alignment = TextAnchor.MiddleCenter;
 
-            GUILayout.Label($"Page {PageOffset + 1}/{MaxOffset + 1}", new GUILayoutOption[] { GUILayout.Width(80) });
+            GUILayout.Label($"Page {PageOffset + 1}/{MaxPageOffset + 1}", new GUILayoutOption[] { GUILayout.Width(80) });
 
             GUI.skin.label.alignment = orig;
         }
@@ -53,7 +74,7 @@ namespace Explorer
             }
             else
             {
-                if (PageOffset < MaxOffset)
+                if (PageOffset < MaxPageOffset)
                 {
                     PageOffset++;
                     scroll = Vector2.zero;
@@ -63,9 +84,9 @@ namespace Explorer
 
         public int CalculateOffsetIndex()
         {
-            int offset = PageOffset * PageLimit;
+            int offset = PageOffset * ItemsPerPage;
 
-            if (offset >= Count)
+            if (offset >= ItemCount)
             {
                 offset = 0;
                 PageOffset = 0;
@@ -77,11 +98,11 @@ namespace Explorer
         public void DrawLimitInputArea()
         {
             GUILayout.Label("Limit: ", new GUILayoutOption[] { GUILayout.Width(50) });
-            var limit = this.PageLimit.ToString();
+            var limit = this.ItemsPerPage.ToString();
             limit = GUILayout.TextField(limit, new GUILayoutOption[] { GUILayout.Width(50) });
-            if (limit != PageLimit.ToString() && int.TryParse(limit, out int i))
+            if (limit != ItemsPerPage.ToString() && int.TryParse(limit, out int i))
             {
-                PageLimit = i;
+                ItemsPerPage = i;
             }
         }
     }

src/Helpers/ReflectionHelpers.cs

@@ -74,12 +74,13 @@ namespace Explorer
                 return false;
         }
 
-        public static bool IsArray(Type t)
+        public static bool IsEnumerable(Type t)
         {
             return typeof(System.Collections.IEnumerable).IsAssignableFrom(t);
         }
 
-        public static bool IsList(Type t)
+        // Only Il2Cpp List needs this check. C# List is IEnumerable.
+        public static bool IsCppList(Type t)
         {
             if (t.IsGenericType)
             {
@@ -98,21 +99,21 @@ namespace Explorer
         {
             return t.IsGenericType
                 && t.GetGenericTypeDefinition() is Type typeDef
-                && typeDef.IsAssignableFrom(typeof(Il2CppSystem.Collections.Generic.Dictionary<,>));
+                && (typeDef.IsAssignableFrom(typeof(Il2CppSystem.Collections.Generic.Dictionary<,>))
+                    || typeDef.IsAssignableFrom(typeof(Dictionary<,>)));
         }
 
         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;
@@ -137,6 +138,13 @@ namespace Explorer
             return obj.GetType();
         }
 
+        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>();

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,13 +24,13 @@ namespace Explorer
         }
 
         // helper for drawing a styled button for a GameObject or Transform
-        public static void GameobjButton(object _obj, Action<Transform> specialInspectMethod = null, bool showSmallInspectBtn = true, float width = 380)
+        public static void GOButton(object _obj, Action<Transform> specialInspectMethod = null, bool showSmallInspectBtn = true, float width = 380)
         {
             var obj = (_obj as GameObject) ?? (_obj as Transform).gameObject;
 
-            bool children = obj.transform.childCount > 0;
+            bool hasChild = obj.transform.childCount > 0;
 
-            string label = children ? "[" + obj.transform.childCount + " children] " : "";
+            string label = hasChild ? $"[{obj.transform.childCount} children] " : "";
             label += obj.name;
 
             bool enabled = obj.activeSelf;
@@ -51,10 +53,10 @@ 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(object _obj, Color activeColor, string label, bool enabled, Action<Transform> 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;
 

src/Helpers/UIStyles.cs

@@ -56,7 +56,10 @@ 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;
                 }
 
@@ -73,7 +76,10 @@ namespace Explorer
                 {
                     _horizBarSmallStyle = new GUIStyle();
                     _horizBarSmallStyle.normal.background = Texture2D.whiteTexture;
-                    _horizBarSmallStyle.margin = new RectOffset(0, 0, 2, 2);
+                    var rectOffset = new RectOffset();
+                    rectOffset.top = 2;
+                    rectOffset.bottom = 2;
+                    _horizBarSmallStyle.margin = rectOffset;
                     _horizBarSmallStyle.fixedHeight = 1;
                 }
 

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,9 +74,12 @@ namespace Explorer
             MainHeader();
 
             var page = Pages[m_currentPage];
-            page.scroll = GUILayout.BeginScrollView(page.scroll, GUI.skin.scrollView);
+
+            page.scroll = GUIUnstrip.BeginScrollView(page.scroll);
+
             page.DrawWindow();
-            GUILayout.EndScrollView();
+
+            GUIUnstrip.EndScrollView();
 
             MainRect = ResizeDrag.ResizeWindow(MainRect, MainWindowID);
 

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();

src/MainMenu/Pages/ScenePage.cs

@@ -12,27 +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"; }
 
         public PageHelper Pages = new PageHelper();
 
         private float m_timeOfLastUpdate = -1f;
+        private const int PASSIVE_UPDATE_INTERVAL = 1;
 
-    // ----- Holders for GUI elements ----- //
+        private static bool m_getRootObjectsFailed;
 
-    private string m_currentScene = "";
+        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;
@@ -44,59 +43,6 @@ namespace Explorer
             SetTransformTarget(null);
         }
 
-        //public void CheckOffset(ref int offset, int childCount)
-        //{
-        //    if (offset >= childCount)
-        //    {
-        //        offset = 0;
-        //        m_pageOffset = 0;
-        //    }
-        //}
-
-        public override void Update()
-        {
-            if (m_searching) return;
-
-            if (Time.time - m_timeOfLastUpdate < 1f) return;
-            m_timeOfLastUpdate = Time.time;
-
-            m_objectList = new List<GameObjectCache>();
-
-            var 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
-            {
-                var scene = SceneManager.GetSceneByName(m_currentScene);
-                var rootObjects = scene.GetRootGameObjects();
-
-                foreach (var obj in rootObjects)
-                {
-                    allTransforms.Add(obj.transform);
-                }
-            }
-
-            Pages.Count = allTransforms.Count;
-
-            int offset = Pages.CalculateOffsetIndex();
-
-            // sort by childcount
-            allTransforms.Sort((a, b) => b.childCount.CompareTo(a.childCount));
-
-            for (int i = offset; i < offset + Pages.PageLimit && i < Pages.Count; i++)
-            {
-                var child = allTransforms[i];
-                m_objectList.Add(new GameObjectCache(child.gameObject));
-            }
-        }
-
         public void SetTransformTarget(Transform t)
         {
             m_currentTransform = t;
@@ -104,8 +50,7 @@ namespace Explorer
             if (m_searching)
                 CancelSearch();
 
-            m_timeOfLastUpdate = -1f;
+            Update_Impl(true);
-            Update();
         }
 
         public void TraverseUp()
@@ -124,29 +69,129 @@ namespace Explorer
         {
             m_searchResults = SearchSceneObjects(m_searchInput);
             m_searching = true;
-            Pages.Count = m_searchResults.Count;
+            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()
@@ -240,12 +285,13 @@ namespace Explorer
 
             Pages.DrawLimitInputArea();
 
-            if (Pages.Count > Pages.PageLimit)
+            if (Pages.ItemCount > Pages.ItemsPerPage)
             {
                 if (GUILayout.Button("< Prev", new GUILayoutOption[] { GUILayout.Width(80) }))
                 {
                     Pages.TurnPage(Turn.Left, ref this.scroll);
-                    Update();
+
+                    Update_Impl(true);
                 }
 
                 Pages.CurrentPageLabel();
@@ -253,7 +299,8 @@ namespace Explorer
                 if (GUILayout.Button("Next >", new GUILayoutOption[] { GUILayout.Width(80) }))
                 {
                     Pages.TurnPage(Turn.Right, ref this.scroll);
-                    Update();
+
+                    Update_Impl(true);
                 }
             }
 
@@ -283,12 +330,24 @@ namespace Explorer
             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)
             {
-                foreach (var obj in m_objectList)
+                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";
@@ -303,7 +362,7 @@ namespace Explorer
                     }
                     else
                     {
-                        UIHelpers.FastGameobjButton(obj.RefGameObject,
+                        UIHelpers.GOButton_Impl(obj.RefGameObject,
                         obj.EnabledColor,
                         obj.Label,
                         obj.RefGameObject.activeSelf,
@@ -328,13 +387,13 @@ namespace Explorer
             {
                 int offset = Pages.CalculateOffsetIndex();
 
-                for (int i = offset; i < offset + Pages.PageLimit && i < m_searchResults.Count; i++)
+                for (int i = offset; i < offset + Pages.ItemsPerPage && i < m_searchResults.Count; i++)
                 {
                     var obj = m_searchResults[i];
 
                     if (obj.RefGameObject)
                     {
-                        UIHelpers.FastGameobjButton(obj.RefGameObject,
+                        UIHelpers.GOButton_Impl(obj.RefGameObject,
                         obj.EnabledColor,
                         obj.Label,
                         obj.RefGameObject.activeSelf,

src/MainMenu/Pages/SearchPage.cs

@@ -13,7 +13,7 @@ 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 = "";
@@ -75,7 +75,7 @@ namespace Explorer
                 m_searchResults.Add(cache);
             }
 
-            Pages.Count = m_searchResults.Count; 
+            Pages.ItemCount = m_searchResults.Count; 
             Pages.PageOffset = 0;
         }
 
@@ -104,17 +104,16 @@ namespace Explorer
                 GUI.skin.label.alignment = TextAnchor.UpperLeft;
 
                 int count = m_searchResults.Count;
-                Pages.CalculateMaxOffset();
 
                 GUILayout.BeginHorizontal(null);
 
                 Pages.DrawLimitInputArea();
 
-                if (count > Pages.PageLimit)
+                if (count > Pages.ItemsPerPage)
                 {
                     // prev/next page buttons
 
-                    if (Pages.Count > Pages.PageLimit)
+                    if (Pages.ItemCount > Pages.ItemsPerPage)
                     {
                         if (GUILayout.Button("< Prev", new GUILayoutOption[] { GUILayout.Width(80) }))
                         {
@@ -132,20 +131,17 @@ namespace Explorer
 
                 GUILayout.EndHorizontal();
 
-                resultsScroll = GUILayout.BeginScrollView(resultsScroll, GUI.skin.scrollView);
+                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 + Pages.PageLimit && 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
@@ -153,7 +149,7 @@ namespace Explorer
                     GUILayout.Label("<color=red><i>No results found!</i></color>", null);
                 }
 
-                GUILayout.EndScrollView();
+                GUIUnstrip.EndScrollView();
                 GUILayout.EndVertical();
             }
             catch
@@ -176,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);
@@ -267,7 +253,7 @@ namespace Explorer
             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;
 
@@ -275,13 +261,18 @@ namespace Explorer
             {
                 try
                 {
-                    var findType = ReflectionHelpers.GetTypeByName(_type);
+                    if (ReflectionHelpers.GetTypeByName(typeName) is Type t)
-                    searchType = Il2CppSystem.Type.GetType(findType.AssemblyQualifiedName);
+                    {
-                    //MelonLogger.Log("Search type: " + findType.AssemblyQualifiedName);
+                        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)
@@ -299,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>();
             }
 
@@ -314,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.
@@ -377,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(ReflectionHelpers.GetTypesSafe)
-                .SelectMany(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);
+                    var pi = type.GetProperty("Instance", flags);
-                }
+
-                catch
+                    if (pi == null)
-                {
-                    try
                     {
-                        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

@@ -29,9 +29,17 @@ namespace Explorer
         private Vector2 m_compScroll = Vector2.zero;
         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;
 
         private readonly List<Component> m_cachedDestroyList = new List<Component>();
         //private string m_addComponentInput = "";
@@ -73,12 +81,29 @@ namespace Explorer
 
             m_name = m_object.name;
             m_scene = string.IsNullOrEmpty(m_object.scene.name) 
-                ? "None" 
+                        ? "None (Asset/Resource)" 
-                : m_object.scene.name;
+                        : m_object.scene.name;
+
+            CacheTransformValues();
 
             Update();
         }
 
+        private void CacheTransformValues()
+        {
+            if (m_localContext)
+            {
+                m_cachedInput[0] = m_object.transform.localPosition;
+                m_cachedInput[1] = m_object.transform.localEulerAngles;
+            }
+            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()
         {
             try
@@ -88,30 +113,39 @@ namespace Explorer
                     throw new Exception("Object is null!");
                 }
 
-                var list = new List<Transform>();
+                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++)
                 {
-                    list.Add(m_object.transform.GetChild(i));
+                    childList.Add(m_object.transform.GetChild(i));
                 }
-                list.Sort((a, b) => b.childCount.CompareTo(a.childCount));
+                childList.Sort((a, b) => b.childCount.CompareTo(a.childCount));
-                m_children = list.ToArray();
+                m_children = childList.ToArray();
 
-                ChildPages.Count = m_children.Length;
+                ChildPages.ItemCount = m_children.Length;
 
-                var list2 = new List<Component>();
+                // update components
-                foreach (var comp in m_object.GetComponents(ReflectionHelpers.ComponentType))
+                var compList = new Il2CppSystem.Collections.Generic.List<Component>();
-                {
+                m_object.GetComponentsInternal(ReflectionHelpers.ComponentType, true, false, true, false, compList);
-                    var ilType = comp.GetIl2CppType();
-                    if (ilType == ReflectionHelpers.TransformType)
-                    {
-                        continue;
-                    }
 
-                    list2.Add(comp);
+                m_components = compList.ToArray();
-                }
-                m_components = list2.ToArray();
 
-                CompPages.Count = m_components.Length;
+                CompPages.ItemCount = m_components.Length;
             }
             catch (Exception e)
             {
@@ -121,7 +155,7 @@ namespace Explorer
 
         private void DestroyOnException(Exception e)
         {
-            MelonLogger.Log($"{e.GetType()}, {e.Message}");
+            MelonLogger.Log($"Exception drawing GameObject Window: {e.GetType()}, {e.Message}");
             DestroyWindow();
         }
 
@@ -169,7 +203,7 @@ namespace Explorer
                     GUILayout.BeginArea(new Rect(5, 25, rect.width - 10, rect.height - 35), GUI.skin.box);
                 }
 
-                scroll = GUILayout.BeginScrollView(scroll, GUI.skin.scrollView);
+                scroll = GUIUnstrip.BeginScrollView(scroll);
 
                 GUILayout.BeginHorizontal(null);
                 GUILayout.Label("Scene: <color=cyan>" + (m_scene == "" ? "n/a" : m_scene) + "</color>", null);
@@ -220,7 +254,7 @@ namespace Explorer
 
                 GameObjectControls();
 
-                GUILayout.EndScrollView();
+                GUIUnstrip.EndScrollView();
 
                 if (!WindowManager.TabView)
                 {
@@ -237,18 +271,16 @@ namespace Explorer
 
         private void TransformList(Rect m_rect)
         {
-            GUILayout.BeginVertical(GUI.skin.box, null); // new GUILayoutOption[] { GUILayout.Height(250) });
+            GUILayout.BeginVertical(GUI.skin.box, null);
-            m_transformScroll = GUILayout.BeginScrollView(m_transformScroll, GUI.skin.scrollView);
+            m_transformScroll = GUIUnstrip.BeginScrollView(m_transformScroll);
 
             GUILayout.Label("<b><size=15>Children</size></b>", null);
 
             GUILayout.BeginHorizontal(null);
             ChildPages.DrawLimitInputArea();
 
-            if (ChildPages.Count > ChildPages.PageLimit)
+            if (ChildPages.ItemCount > ChildPages.ItemsPerPage)
             {
-                ChildPages.CalculateMaxOffset();
-
                 ChildPages.CurrentPageLabel();
 
                 GUILayout.EndHorizontal();
@@ -269,7 +301,7 @@ namespace Explorer
             {
                 int start = ChildPages.CalculateOffsetIndex();
 
-                for (int j = start; (j < start + ChildPages.PageLimit && j < ChildPages.Count); j++)
+                for (int j = start; (j < start + ChildPages.ItemsPerPage && j < ChildPages.ItemCount); j++)
                 {
                     var obj = m_children[j];
 
@@ -279,7 +311,7 @@ namespace Explorer
                         continue;
                     }
 
-                    UIHelpers.GameobjButton(obj.gameObject, InspectGameObject, false, m_rect.width / 2 - 80);
+                    UIHelpers.GOButton(obj.gameObject, InspectGameObject, false, m_rect.width / 2 - 80);
                 }
             }
             else
@@ -287,23 +319,21 @@ namespace Explorer
                 GUILayout.Label("<i>None</i>", null);
             }
 
-            GUILayout.EndScrollView();
+            GUIUnstrip.EndScrollView();
             GUILayout.EndVertical();
         }
 
         private void ComponentList(Rect m_rect)
         {
-            GUILayout.BeginVertical(GUI.skin.box, null); // new GUILayoutOption[] { GUILayout.Height(250) });
+            GUILayout.BeginVertical(GUI.skin.box, null);
-            m_compScroll = GUILayout.BeginScrollView(m_compScroll, GUI.skin.scrollView);
+            m_compScroll = GUIUnstrip.BeginScrollView(m_compScroll);
             GUILayout.Label("<b><size=15>Components</size></b>", null);
 
             GUILayout.BeginHorizontal(null);
             CompPages.DrawLimitInputArea();
 
-            if (CompPages.Count > CompPages.PageLimit)
+            if (CompPages.ItemCount > CompPages.ItemsPerPage)
             {
-                CompPages.CalculateMaxOffset();
-
                 CompPages.CurrentPageLabel();
 
                 GUILayout.EndHorizontal();
@@ -330,7 +360,7 @@ namespace Explorer
             {
                 int start = CompPages.CalculateOffsetIndex();
 
-                for (int j = start; (j < start + CompPages.PageLimit && j < CompPages.Count); j++)
+                for (int j = start; (j < start + CompPages.ItemsPerPage && j < CompPages.ItemCount); j++)
                 {
                     var component = m_components[j];
 
@@ -369,7 +399,7 @@ namespace Explorer
                 }
             }
 
-            GUILayout.EndScrollView();
+            GUIUnstrip.EndScrollView();
 
             GUILayout.EndVertical();
         }
@@ -416,6 +446,16 @@ namespace Explorer
                 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);
 
@@ -440,10 +480,52 @@ namespace Explorer
 
             GUILayout.BeginVertical(GUI.skin.box, null);
 
-            var t = m_object.transform;
+            m_cachedInput[0] = TranslateControl(TranslateType.Position, ref m_translateAmount,  false);
-            TranslateControl(t, TranslateType.Position, ref m_translateAmount,  false);
+            m_cachedInput[1] = TranslateControl(TranslateType.Rotation, ref m_rotateAmount,     true);
-            TranslateControl(t, TranslateType.Rotation, ref m_rotateAmount,     true);
+            m_cachedInput[2] = TranslateControl(TranslateType.Scale,    ref m_scaleAmount,      false);
-            TranslateControl(t, 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();
 
@@ -457,6 +539,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,
@@ -464,50 +570,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.Position:
-                case TranslateType.Rotation: vector = transform.localRotation.eulerAngles; break;
+                    var pos = m_localContext ? transform.localPosition : transform.position;
-                case TranslateType.Scale:    vector = transform.localScale; break;
+                    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);
+            PlusMinusFloat(ref input.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;
-            }
 
             GUILayout.Label("+/-:", new GUILayoutOption[] { GUILayout.Width(30) });
-            var input = amount.ToString("F3");
+            var amountInput = amount.ToString("F3");
-            input = GUILayout.TextField(input, new GUILayoutOption[] { GUILayout.Width(40) });
+            amountInput = GUILayout.TextField(amountInput, new GUILayoutOption[] { GUILayout.Width(60) });
-            if (float.TryParse(input, out float f))
+            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)
@@ -527,7 +638,5 @@ namespace Explorer
                 f += multByTime ? amount * Time.deltaTime : amount;
             }
         }
-
-        
     }
 }

src/Windows/ReflectionWindow.cs

@@ -256,17 +256,15 @@ namespace Explorer
 
                 GUILayout.Space(10);
 
-                Pages.Count = m_cachedMembersFiltered.Length;
+                Pages.ItemCount = m_cachedMembersFiltered.Length;
 
                 // prev/next page buttons
                 GUILayout.BeginHorizontal(null);
 
                 Pages.DrawLimitInputArea();
 
-                if (Pages.Count > Pages.PageLimit)
+                if (Pages.ItemCount > Pages.ItemsPerPage)
                 {
-                    Pages.CalculateMaxOffset();
-
                     if (GUILayout.Button("< Prev", new GUILayoutOption[] { GUILayout.Width(80) }))
                     {
                         Pages.TurnPage(Turn.Left, ref this.scroll);
@@ -283,7 +281,7 @@ namespace Explorer
 
                 // ====== BODY ======
 
-                scroll = GUILayout.BeginScrollView(scroll, GUI.skin.scrollView);
+                scroll = GUIUnstrip.BeginScrollView(scroll);
 
                 GUILayout.Space(10);
 
@@ -294,7 +292,7 @@ namespace Explorer
                 var members = this.m_cachedMembersFiltered;
                 int start = Pages.CalculateOffsetIndex();
 
-                for (int j = start; (j < start + Pages.PageLimit && j < members.Length); j++)
+                for (int j = start; (j < start + Pages.ItemsPerPage && j < members.Length); j++)
                 {
                     var holder = members[j];
 
@@ -311,12 +309,12 @@ namespace Explorer
                     GUILayout.EndHorizontal();
 
                     // if not last element
-                    if (!(j == (start + Pages.PageLimit - 1) || j == (members.Length - 1)))
+                    if (!(j == (start + Pages.ItemsPerPage - 1) || j == (members.Length - 1)))
                         UIStyles.HorizontalLine(new Color(0.07f, 0.07f, 0.07f), true);
                 }
 
                 GUILayout.EndVertical();
-                GUILayout.EndScrollView();
+                GUIUnstrip.EndScrollView();
 
                 if (!WindowManager.TabView)
                 {

src/Windows/ResizeDrag.cs

@@ -31,7 +31,8 @@ namespace Explorer
                     GUI.skin.label.alignment = TextAnchor.MiddleCenter;
                     GUILayout.Button(gcDrag, GUI.skin.label, new GUILayoutOption[] { GUILayout.Height(15) });
 
-                    var r = GUILayoutUtility.GetLastRect();
+                    //var r = GUILayoutUtility.GetLastRect();
+                    var r = GUIUnstrip.GetLastRect();
 
                     Vector2 mouse = GUIUtility.ScreenToGUIPoint(new Vector2(Input.mousePosition.x, Screen.height - Input.mousePosition.y));
 
@@ -65,6 +66,7 @@ namespace Explorer
                 {
                     RESIZE_FAILED = true;
                     MelonLogger.Log("Exception on GuiResize: " + e.GetType() + ", " + e.Message);
+                    MelonLogger.Log(e.StackTrace);
                     return origRect;
                 }
 

src/Windows/TabViewWindow.cs

@@ -26,6 +26,7 @@ namespace Explorer
         }
 
         public override void Init() { }
+
         public override void Update() 
         {
             while (TargetTabID >= WindowManager.Windows.Count)

src/Windows/WindowManager.cs

@@ -109,7 +109,7 @@ namespace Explorer
 
                     if (!equals && iObj is Il2CppSystem.Object iCurrent && window.Target is Il2CppSystem.Object iTarget)
                     {
-                        if (iCurrent.GetIl2CppType() != iTarget.GetIl2CppType())
+                        if (iCurrent.GetIl2CppType().FullName != iTarget.GetIl2CppType().FullName)
                         {
                             if (iCurrent is Transform transform)
                             {