Added files.

Author: RequiDev

BinaryGZipSerializer.cs

@@ -0,0 +1,35 @@
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
+using MelonLoader.ICSharpCode.SharpZipLib.GZip;
+
+namespace ReMod.Core
+{
+    public static class BinaryGZipSerializer
+    {
+        public static void Serialize(object value, string path)
+        {
+            var formatter = new BinaryFormatter();
+
+            using (var fStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None))
+            {
+                using (var gzipStream = new GZipOutputStream(fStream))
+                {
+                    formatter.Serialize(gzipStream, value);
+                }
+            }
+        }
+
+        public static object Deserialize(string path)
+        {
+            var formatter = new BinaryFormatter();
+
+            using (Stream fStream = File.OpenRead(path))
+            {
+                using (var gzipStream = new GZipInputStream(fStream))
+                {
+                    return formatter.Deserialize(gzipStream);
+                }
+            }
+        }
+    }
+}

ConfigValue.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Linq;
+using MelonLoader;
+
+namespace ReMod.Core
+{
+    public class ConfigValue<T>
+    {
+        public event Action OnValueChanged;
+
+        private readonly MelonPreferences_Entry<T> _entry;
+
+        public T Value => _entry.Value;
+
+        public ConfigValue(string name, T defaultValue, string displayName = null, string description = null, bool isHidden = false)
+        {
+            var category = MelonPreferences.CreateCategory("ReMod");
+
+            var entryName = string.Concat(name.Where(c => char.IsLetter(c) || char.IsNumber(c)));
+            _entry = category.GetEntry<T>(entryName) ?? category.CreateEntry(entryName, defaultValue, displayName, description, isHidden);
+            _entry.OnValueChangedUntyped += () => OnValueChanged?.Invoke();
+        }
+
+        public static implicit operator T(ConfigValue<T> conf)
+        {
+            return conf._entry.Value;
+        }
+
+        public void SetValue(T value)
+        {
+            _entry.Value = value;
+            MelonPreferences.Save();
+        }
+
+        public override string ToString()
+        {
+            return _entry.Value.ToString();
+        }
+    }
+}

Managers/ResourceManager.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using UnityEngine;
+
+namespace ReMod.Core.Managers
+{
+    public class ResourceManager
+    {
+        private readonly Dictionary<string, Texture2D> _textures = new Dictionary<string, Texture2D>();
+        private readonly Dictionary<string, Sprite> _sprites = new Dictionary<string, Sprite>();
+
+        private readonly Assembly _ourAssembly;
+
+        private readonly string _resourcePath;
+
+        public static ResourceManager Instance { get; private set; }
+        public ResourceManager(Assembly ourAssembly, string resourcePath)
+        {
+            if (Instance != null)
+            {
+                throw new Exception("ResourceManager already exists.");
+            }
+            Instance = this;
+
+            _ourAssembly = ourAssembly;
+            _resourcePath = resourcePath;
+        }
+
+        public Texture2D GetTexture(string resourceName)
+        {
+            if (_textures.ContainsKey(resourceName))
+            {
+                return _textures[resourceName];
+            }
+
+            var resourcePath = $"{_resourcePath}.{resourceName}.png";
+            var stream = _ourAssembly.GetManifestResourceStream(resourcePath);
+            if (stream == null)
+            {
+                throw new ArgumentException($"Resource \"{resourcePath}\" doesn't exist", nameof(resourceName));
+            }
+
+            using var ms = new MemoryStream();
+            stream.CopyTo(ms);
+
+            var texture = new Texture2D(1, 1);
+            ImageConversion.LoadImage(texture, ms.ToArray());
+            texture.hideFlags |= HideFlags.DontUnloadUnusedAsset;
+            texture.wrapMode = TextureWrapMode.Clamp;
+
+            _textures.Add(resourceName, texture);
+
+            return texture;
+        }
+
+        public Sprite GetSprite(string resourceName)
+        {
+            if (_sprites.ContainsKey(resourceName))
+            {
+                return _sprites[resourceName];
+            }
+
+            var texture = GetTexture(resourceName);
+
+            var rect = new Rect(0.0f, 0.0f, texture.width, texture.height);
+            var pivot = new Vector2(0.5f, 0.5f);
+            var border = Vector4.zero;
+            var sprite = Sprite.CreateSprite_Injected(texture, ref rect, ref pivot, 100.0f, 0, SpriteMeshType.Tight, ref border, false);
+            sprite.hideFlags |= HideFlags.DontUnloadUnusedAsset;
+
+            _sprites.Add(resourceName, sprite);
+
+            return sprite;
+        }
+    }
+}

Managers/UiManager.cs

@@ -0,0 +1,78 @@
+using System;
+using ReMod.Core.UI;
+using ReMod.Core.VRChat;
+using UnityEngine;
+using UnityEngine.UI;
+using VRC.UI.Elements;
+
+namespace ReMod.Core.Managers
+{
+    public class UiManager
+    {
+        public ReMenuPage MainMenu { get; }
+        public ReMenuCategory TargetMenu { get; }
+
+        private static UiManager _instance;
+        public UiManager(string menuName, Sprite menuSprite)
+        {
+            if (_instance != null)
+            {
+                throw new Exception("UiManager already exists.");
+            }
+            _instance = this;
+
+            FixLaunchpadScrolling();
+
+            var resourceManager = ResourceManager.Instance;
+            MainMenu = new ReMenuPage(menuName, true);
+            ReTabButton.Create(menuName, $"Open the {menuName} menu.", menuName, menuSprite);
+
+            MainMenu.AddCategoryPage("Movement", sprite: resourceManager.GetSprite("running"));
+
+            var visualCatPage = MainMenu.AddCategoryPage("Visuals", sprite: resourceManager.GetSprite("eye"));
+
+            visualCatPage.AddCategory("ESP/Highlights");
+            visualCatPage.AddCategory("Flashlight");
+            visualCatPage.AddCategory("Wireframe");
+            visualCatPage.AddCategory("Bone ESP");
+            visualCatPage.AddCategory("Nametags");
+
+            MainMenu.AddMenuPage("Dynamic Bones", sprite: resourceManager.GetSprite("bone"));
+            MainMenu.AddMenuPage("Avatars", sprite: resourceManager.GetSprite("hanger"));
+
+            var utilCatPage = MainMenu.AddCategoryPage("Utility", sprite: resourceManager.GetSprite("tools"));
+
+            utilCatPage.AddCategory("Quality of Life");
+            utilCatPage.AddCategory("Local Clone");
+            utilCatPage.AddCategory("Objects");
+            utilCatPage.AddCategory("Spoofing");
+            utilCatPage.AddCategory("Protection");
+            utilCatPage.AddCategory("Emojis");
+            utilCatPage.AddCategory("Media Controls");
+            utilCatPage.AddCategory("Staff Alerts");
+            utilCatPage.AddCategory("Near Clipping Plane");
+            utilCatPage.AddCategory("Application");
+
+            MainMenu.AddMenuPage("Logging", sprite: resourceManager.GetSprite("log"));
+            MainMenu.AddMenuPage("FBT", sprite: resourceManager.GetSprite("arms-up"));
+            MainMenu.AddMenuPage("Hotkeys", sprite: resourceManager.GetSprite("keyboard"));
+
+            TargetMenu = new ReMenuCategory($"{menuName}", ExtendedQuickMenu.Instance.field_Private_UIPage_1.transform.Find("ScrollRect").GetComponent<ScrollRect>().content);
+        }
+
+        private void FixLaunchpadScrolling()
+        {
+            var dashboard = ExtendedQuickMenu.Instance.field_Public_Transform_0.Find("Window/QMParent/Menu_Dashboard").GetComponent<UIPage>();
+            var scrollRect = dashboard.GetComponentInChildren<ScrollRect>();
+            var dashboardScrollbar = scrollRect.transform.Find("Scrollbar").GetComponent<Scrollbar>();
+
+            var dashboardContent = scrollRect.content;
+            dashboardContent.GetComponent<VerticalLayoutGroup>().childControlHeight = true;
+            dashboardContent.Find("Carousel_Banners").gameObject.SetActive(false);
+
+            scrollRect.enabled = true;
+            scrollRect.verticalScrollbar = dashboardScrollbar;
+            scrollRect.viewport.GetComponent<RectMask2D>().enabled = true;
+        }
+    }
+}

ModComponent.cs

@@ -0,0 +1,69 @@
+using ExitGames.Client.Photon;
+using HarmonyLib;
+using MelonLoader;
+using Photon.Pun;
+using Photon.Realtime;
+using ReMod.Core.Managers;
+using System;
+using System.Reflection;
+using VRC.Core;
+using VRC.DataModel;
+using VRC.SDKBase;
+using Player = VRC.Player;
+
+namespace ReMod.Core
+{
+    public class ComponentDisabled : Attribute
+    {
+    }
+
+    public class ComponentPriority : Attribute
+    {
+        public int Priority;
+        public ComponentPriority(int priority = 0) => Priority = priority;
+    }
+
+    public class ModComponent
+    {
+        public virtual void OnUiManagerInitEarly(){}
+        public virtual void OnUiManagerInit(UiManager uiManager){}
+        public virtual void OnFixedUpdate(){}
+        public virtual void OnUpdate(){}
+        public virtual void OnLateUpdate(){}
+        public virtual void OnGUI(){}
+        public virtual void OnSceneWasLoaded(int buildIndex, string sceneName){}
+        public virtual void OnSceneWasInitialized(int buildIndex, string sceneName){}
+        public virtual void OnApplicationQuit(){}
+        public virtual void OnPreferencesSaved(){}
+        public virtual void OnPreferencesLoaded(){ }
+        public virtual void OnPhotonPlayerJoined(Il2CppSystem.Collections.Hashtable propertiesTable) { }
+        public virtual void OnPhotonPlayerLeft(Photon.Realtime.Player player) { }
+        public virtual void OnPlayerJoined(Player player){}
+        public virtual void OnPlayerLeft(Player player){}
+        public virtual void OnAvatarIsReady(VRCPlayer player){}
+        public virtual void OnEnterWorld(ApiWorld world, ApiWorldInstance instance){}
+        public virtual void OnSelectUser(IUser user, bool isRemote){ }
+
+        // return value determines whether it found something malicious and should block the original function
+        public virtual bool ExecuteEvent(Player player, VRC_EventHandler.VrcEvent evt, VRC_EventHandler.VrcBroadcastType broadcastType, int instagatorId, float fastForward) { return false; }
+        public virtual bool OnPhotonEvent(LoadBalancingClient loadBalancingClient, ref EventData eventData) { return false; }
+        public virtual bool VRCNetworkingClientOnPhotonEvent(EventData eventData) { return false; }
+        public virtual bool VRC_EventLogOnPhotonEvent(EventData eventData) { return false; }
+        public virtual bool OnDownloadAvatar(ApiAvatar apiAvatar) { return false; }
+        public virtual bool OnRaiseEvent(byte eventCode, ref Il2CppSystem.Object content, RaiseEventOptions raiseEventOptions, SendOptions sendOptions) { return false; }
+        
+        public virtual void OnOwnershipTransfered(Photon.Realtime.Player player, PhotonView photonView, bool isMaster, bool isRequest){}
+        public virtual void OnBlockStateChange(Photon.Realtime.Player instigator, bool blocked){ }
+        public virtual void OnMuteStateChange(Photon.Realtime.Player instigator, bool muted) { }
+        public virtual void OnModUserListUpdated() { }
+        public virtual void OnRenderObject() { }
+        public virtual void OnOperationResponse(LoadBalancingClient loadBalancingClient, OperationResponse operationResponse) { }
+        public virtual void OnJoinedRoom() { }
+        public virtual void OnLeftRoom() { }
+
+        protected HarmonyMethod GetLocalPatch(string methodName)
+        {
+            return GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static).ToNewHarmonyMethod();
+        }
+    }
+}

Properties/AssemblyInfo.cs

@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("ReMod.Core")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("ReMod.Core")]
+[assembly: AssemblyCopyright("Copyright ©  2021")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("c87fe758-acb9-4fa2-af6f-10aa9aa0023c")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]