├── VRCExtended
    ├── ExtendedServer.cs
    ├── GameScripts
    │   ├── LocalCollider.cs
    │   └── PauseDetection.cs
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── VolumeControl.cs
    ├── Patches
    │   ├── PortalInternal.cs
    │   └── PageUserInfo.cs
    ├── VRChat
    │   ├── UI
    │   │   ├── VRCEUiText.cs
    │   │   ├── VRCEUiButton.cs
    │   │   ├── VRCEUiVolumeControl.cs
    │   │   └── VRCEUi.cs
    │   ├── Obfuscation
    │   │   └── OBFUnityActionInternal.cs
    │   ├── VRCEPlayer.cs
    │   └── VRCPlayerManager.cs
    ├── AntiCrasherConfig.cs
    ├── ExtendedLogger.cs
    ├── VRCExtended.csproj
    ├── ExtendedUser.cs
    └── VRCExtended.cs
├── LICENSE
├── VRCExtended.sln
├── ShaderBlacklist.txt
├── README.md
└── .gitignore


/VRCExtended/ExtendedServer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | 
 6 | namespace VRCExtended
 7 | {
 8 |     internal static class ExtendedServer
 9 |     {
10 |         public static List<ExtendedUser> Users = new List<ExtendedUser>();
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/VRCExtended/GameScripts/LocalCollider.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | 
 6 | using VRChat;
 7 | 
 8 | using UnityEngine;
 9 | 
10 | namespace VRCExtended.GameScripts
11 | {
12 |     public class LocalCollider : MonoBehaviour
13 |     {
14 |         void OnTriggerEnter(Collider collider)
15 |         {
16 |             if (collider.tag != "handCollider")
17 |                 return;
18 |             /*if (VRCEPlayer.Instance.Avatar == collider.gameObject)
19 |                 return;*/
20 | 
21 |             ExtendedLogger.Log("Entered collider!");
22 |         }
23 |         void OnTriggerExit(Collider collider)
24 |         {
25 |             if (collider.tag != "handCollider")
26 |                 return;
27 |             /*if (VRCEPlayer.Instance.Avatar == collider.gameObject)
28 |                 return;*/
29 | 
30 |             ExtendedLogger.Log("Exited collider!");
31 |         }
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/VRCExtended/GameScripts/PauseDetection.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | 
 6 | using UnityEngine;
 7 | 
 8 | using VRCTools;
 9 | 
10 | namespace VRCExtended.GameScripts
11 | {
12 |     public class PauseDetection : MonoBehaviour
13 |     {
14 |         void OnApplicationFocus(bool hasFocus)
15 |         {
16 |             if (!ModPrefs.GetBool("vrcextended", "fpsManagement"))
17 |                 return;
18 | 
19 |             if (!hasFocus)
20 |             {
21 |                 Application.targetFrameRate = 5;
22 |                 ExtendedLogger.Log("Game out of focus, setting FPS to " + Application.targetFrameRate);
23 |             }
24 |             else
25 |             {
26 |                 if (ModPrefs.GetBool("vrcextended", "unlimitedFPS"))
27 |                     Application.targetFrameRate = 0;
28 |                 else
29 |                     Application.targetFrameRate = VRCExtended.FrameRate;
30 |                 ExtendedLogger.Log("Game in focus, setting FPS to " + Application.targetFrameRate);
31 |             }
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 AtiLion
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/VRCExtended.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 16
 4 | VisualStudioVersion = 16.0.29009.5
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VRCExtended", "VRCExtended\VRCExtended.csproj", "{7DF0802E-DB23-417B-A5CD-949B0471D3C4}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{7DF0802E-DB23-417B-A5CD-949B0471D3C4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{7DF0802E-DB23-417B-A5CD-949B0471D3C4}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{7DF0802E-DB23-417B-A5CD-949B0471D3C4}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{7DF0802E-DB23-417B-A5CD-949B0471D3C4}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | 	GlobalSection(ExtensibilityGlobals) = postSolution
23 | 		SolutionGuid = {E8021B1F-1141-4C18-99AC-C52B4A136F9F}
24 | 	EndGlobalSection
25 | EndGlobal
26 | 


--------------------------------------------------------------------------------
/ShaderBlacklist.txt:
--------------------------------------------------------------------------------
 1 | pretty
 2 | bluescreen
 3 | tesselation
 4 | tesselated
 5 | crasher
 6 | instant crash paralyzer
 7 | worldkill
 8 | tessellation
 9 | tessellated
10 | oofer
11 | xxx
12 | dbtc
13 | kyuzu
14 | distancebased
15 | waifuserp
16 | loops
17 | diebitch
18 | thotdestroyer
19 | niggathishurts
20 | izzyrfc
21 | izzyfrag
22 | izzycdf
23 | flat lite toon
24 | shadowschoolbully
25 | school shooter
26 | okbuddy
27 | basically private
28 | no sharing please
29 | hdjegbhuaj276312378632785678324547354t2egdy
30 | custom/oof
31 | custom/lag
32 | custom/killer
33 | custom/kyscotty
34 | kysautismoñoño
35 | .star/bacon
36 | god's children/holy water shader
37 | stonapse/worldkill
38 | stonapse/worldhit
39 | worldkill
40 | 9874654876468d46as5d46as5d7a98we7a84d65as468w7e9q6as8d6s4d5as4d5as6da4s6546a8ew76a8w4e687eq89e7
41 | lorplefoncondominiumlistile14141414
42 | be careful
43 | 7345687/6482375wer
44 | swisscheeseistasty99999999999/swisscheeseistasty99999999999
45 | undertaker/will ban you
46 | g͓̽l͓̽o͓̽m͓̽e͓̽e͓̽/
47 | yikersdudeǧ͂̒o̓ͧ̅o͆͆̃d͋ͪ̌ ̃ͨ̉l̀̔̚u̅̅̽c̾̾͊k͗ͤ͌ ̉͒̔ṡ͗̽t̔͋ͬeͣͪͨå̊ͧl̈̅̆҉̣̰͡iͦ̔͛nͬ̈ͤĝͨ͋ ̈́̒̍tͨͣ̇h͋ͭ̋i̒̽̑s̆ͦͫ ͫͮͨ҉̫͈̠b͗ͩͣu̐ͮ̏d̓́̓d̂̎̇y͐ͬ͗
48 | 卍アイアンウィルが最高卍
49 | randomname     1eg4ww
50 | custo5455245m
51 | 565416541651
52 | üõõüõaseio1
53 | duäöü
54 | ggo login body
55 | u go home
56 | no this is mine now
57 | poiyomi/imeatingmymic
58 | instant yeeet
59 | niggie
60 | ebola
61 | undetected
62 | got em
63 | retard
64 | retrd
65 | 11h2hh3hjej3
66 | ????????0????/???????/????
67 | standard on cylnder
68 | almgp/nuke
69 | hello <3                                    
70 | 


--------------------------------------------------------------------------------
/VRCExtended/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("VRCExtended")]
 9 | [assembly: AssemblyDescription("Adds extra features to VRChat as well as some useful API functions")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("AtiLion")]
12 | [assembly: AssemblyProduct("VRCExtended")]
13 | [assembly: AssemblyCopyright("Copyright © AtiLion 2019")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible
18 | // to COM components.  If you need to access a type in this assembly from
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("7df0802e-db23-417b-a5cd-949b0471d3c4")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("0.0.4.3")]
36 | [assembly: AssemblyFileVersion("0.0.4.3")]
37 | 


--------------------------------------------------------------------------------
/VRCExtended/VolumeControl.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.IO;
 3 | using System.Collections.Generic;
 4 | using System.Linq;
 5 | using System.Text;
 6 | 
 7 | using Newtonsoft.Json;
 8 | using Newtonsoft.Json.Linq;
 9 | 
10 | namespace VRCExtended
11 | {
12 |     internal static class VolumeControl
13 |     {
14 |         #region VolumeControl Variables
15 |         private static JObject _volumes;
16 |         #endregion
17 | 
18 |         #region VolumeControl Properties
19 |         public static Dictionary<string, float[]> Volumes { get; private set; } = new Dictionary<string, float[]>();
20 |         #endregion
21 | 
22 |         public static void Setup()
23 |         {
24 |             if (!File.Exists("volumes.json"))
25 |                 return;
26 | 
27 |             try
28 |             {
29 |                 _volumes = JObject.Parse(File.ReadAllText("volumes.json"));
30 | 
31 |                 foreach(JProperty property in _volumes.Properties())
32 |                 {
33 |                     float[] volumes = new float[2] { 1f, 1f }; // 0 = User, 1 = Avatar
34 |                     JArray jaVol = property.Value as JArray;
35 | 
36 |                     Volumes.Add(property.Name, volumes);
37 |                     volumes[0] = (float)jaVol[0];
38 |                     volumes[1] = (float)jaVol[1];
39 |                 }
40 |                 ExtendedLogger.Log("Successfully parsed volumes.json!");
41 |             }
42 |             catch(Exception ex)
43 |             {
44 |                 ExtendedLogger.LogError("Failed to parse JSON volumes.json!", ex);
45 |                 return;
46 |             }
47 |         }
48 | 
49 |         #region VolumeControl Properties
50 |         #endregion
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/VRCExtended/Patches/PortalInternal.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Reflection;
 3 | using System.Collections.Generic;
 4 | using System.Linq;
 5 | using System.Text;
 6 | 
 7 | using Harmony;
 8 | 
 9 | using VRCTools;
10 | 
11 | namespace VRCExtended.Patches
12 | {
13 |     internal class Patch_PortalInternal
14 |     {
15 |         #region Continuation Variables
16 |         private static PortalInternal portalEnter = null;
17 |         #endregion
18 | 
19 |         public static void Setup()
20 |         {
21 |             // Setup harmony instances
22 |             HarmonyInstance iEnter = HarmonyInstance.Create("vrcextended.portalinternal.enter");
23 | 
24 |             // Patch
25 |             try
26 |             {
27 |                 iEnter.Patch(typeof(PortalInternal).GetMethod("Enter", BindingFlags.Public | BindingFlags.Instance),
28 |                              new HarmonyMethod(typeof(Patch_PortalInternal).GetMethod("Enter", BindingFlags.Static | BindingFlags.NonPublic)));
29 |                 ExtendedLogger.Log("Patched PortalInternal.Enter");
30 |             }
31 |             catch (Exception ex)
32 |             {
33 |                 ExtendedLogger.LogError("Failed to patch PortalInternal: " + ex);
34 |                 return;
35 |             }
36 |         }
37 | 
38 |         private static bool Enter(PortalInternal __instance, MethodInfo __originalMethod)
39 |         {
40 |             if (ModPrefs.GetBool("vrcextended", "disablePortal"))
41 |                 return false;
42 |             if (portalEnter == __instance)
43 |                 return true;
44 | 
45 |             if (ModPrefs.GetBool("vrcextended", "askUsePortal"))
46 |             {
47 |                 VRCUiPopupManagerUtils.ShowPopup("Enter Portal", "Do you really want to enter the portal?", "No", delegate ()
48 |                 {
49 |                     VRCUiPopupManagerUtils.GetVRCUiPopupManager().HideCurrentPopup();
50 |                 }, "Yes", delegate ()
51 |                 {
52 |                     portalEnter = __instance;
53 |                     VRCUiPopupManagerUtils.GetVRCUiPopupManager().HideCurrentPopup();
54 |                     __originalMethod.Invoke(__instance, new object[] { });
55 |                 });
56 |                 return false;
57 |             }
58 |             return true;
59 |         }
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/VRCExtended/VRChat/UI/VRCEUiText.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | 
 6 | using UnityEngine;
 7 | using UnityEngine.UI;
 8 | 
 9 | using VRCExtended;
10 | 
11 | namespace VRChat.UI
12 | {
13 |     public class VRCEUiText
14 |     {
15 |         #region VRChatExtended Properties
16 |         public bool Success { get; private set; }
17 |         #endregion
18 | 
19 |         #region UI Properties
20 |         public Transform Control { get; private set; }
21 |         public Transform TextControl { get; private set; }
22 | 
23 |         public RectTransform Position { get; private set; }
24 |         #endregion
25 | 
26 |         #region Control Properties
27 |         public Text Text { get; private set; }
28 |         #endregion
29 | 
30 |         public VRCEUiText(string name, Vector2 position, string text, Transform parent = null)
31 |         {
32 |             // Get required information
33 |             Transform orgControl = VRCEUi.InternalUserInfoScreen.UsernameText;
34 |             if (orgControl == null)
35 |             {
36 |                 ExtendedLogger.LogError("Could not find Username text!");
37 |                 Success = false;
38 |                 return;
39 |             }
40 | 
41 |             // Duplicate object
42 |             GameObject goControl = GameObject.Instantiate(orgControl.gameObject);
43 |             if (goControl == null)
44 |             {
45 |                 ExtendedLogger.LogError("Could not duplicate Favorite button!");
46 |                 Success = false;
47 |                 return;
48 |             }
49 | 
50 |             // Set UI properties
51 |             Control = goControl.transform;
52 |             TextControl = Control.GetComponent<Text>().transform;
53 | 
54 |             // Remove components that may cause issues
55 |             GameObject.DestroyImmediate(Control.GetComponent<RectTransform>());
56 | 
57 |             // Set control properties
58 |             Text = TextControl.GetComponent<Text>();
59 | 
60 |             // Set required parts
61 |             if (parent != null)
62 |                 Control.SetParent(parent);
63 |             goControl.name = name;
64 | 
65 |             // Modify RectTransform
66 |             Position = Control.GetComponent<RectTransform>();
67 |             RectTransform tmpRT = orgControl.GetComponent<RectTransform>();
68 | 
69 |             Position.localScale = tmpRT.localScale;
70 |             Position.anchoredPosition = tmpRT.anchoredPosition;
71 |             Position.sizeDelta = tmpRT.sizeDelta;
72 |             Position.localPosition = new Vector3(position.x, position.y, 0f);
73 |             Position.localRotation = tmpRT.localRotation;
74 | 
75 |             // Change UI properties
76 |             Text.text = text;
77 | 
78 |             // Finish
79 |             Success = true;
80 |         }
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/VRCExtended/VRChat/Obfuscation/OBFUnityActionInternal.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Reflection;
 3 | using System.Collections.Generic;
 4 | using System.Linq;
 5 | using System.Text;
 6 | 
 7 | using UnityEngine.Events;
 8 | 
 9 | using VRCExtended;
10 | 
11 | namespace VRChat.Obfuscation
12 | {
13 |     public class OBFUnityActionInternal<T>
14 |     {
15 |         #region OBFUnityActionInternal Properties
16 |         public MethodInfo MethodAdd { get; private set; }
17 |         public MethodInfo MethodExecute { get; private set; }
18 |         public MethodInfo MethodRemove { get; private set; }
19 | 
20 |         public object Instance { get; private set; }
21 |         #endregion
22 | 
23 |         public OBFUnityActionInternal(Type type, object instance)
24 |         {
25 |             MethodInfo[] addRemoveMethods = type.GetMethods().Where(a => a.GetParameters().Length > 0 && a.GetParameters()[0].ParameterType == typeof(UnityAction<T>)).ToArray();
26 |             if(addRemoveMethods.Length < 2)
27 |             {
28 |                 ExtendedLogger.LogError("Failed to find required UnityActionInternal functions for type: " + type.Name + "!");
29 |                 return;
30 |             }
31 | 
32 |             if(addRemoveMethods[0].GetMethodBody().GetILAsByteArray().Length > addRemoveMethods[1].GetMethodBody().GetILAsByteArray().Length)
33 |             {
34 |                 MethodAdd = addRemoveMethods[0];
35 |                 MethodRemove = addRemoveMethods[1];
36 |             }
37 |             else
38 |             {
39 |                 MethodAdd = addRemoveMethods[1];
40 |                 MethodRemove = addRemoveMethods[0];
41 |             }
42 |             MethodExecute = type.GetMethods().First(a => a.GetParameters()[0].ParameterType == typeof(T));
43 | 
44 |             ExtendedLogger.Log("Found Execute method in " + type.Name + " with name: " + MethodExecute.Name + "!");
45 |             ExtendedLogger.Log("Found Add method in " + type.Name + " with name: " + MethodAdd.Name + "!");
46 |             ExtendedLogger.Log("Found Remove method in " + type.Name + " with name: " + MethodRemove.Name + "!");
47 | 
48 |             Instance = instance;
49 |         }
50 | 
51 |         #region UnityActionInternal Functions
52 |         public void Add(UnityAction<T> action)
53 |         {
54 |             if (Instance == null)
55 |                 return;
56 | 
57 |             MethodAdd.Invoke(Instance, new object[] { action });
58 |         }
59 |         public void Remove(UnityAction<T> action)
60 |         {
61 |             if (Instance == null)
62 |                 return;
63 | 
64 |             MethodRemove.Invoke(Instance, new object[] { action });
65 |         }
66 | 
67 |         public void Execute(T val)
68 |         {
69 |             if (Instance == null)
70 |                 return;
71 | 
72 |             MethodExecute.Invoke(Instance, new object[] { val });
73 |         }
74 |         #endregion
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/VRCExtended/VRChat/VRCEPlayer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Reflection;
 3 | using System.Collections.Generic;
 4 | using System.Linq;
 5 | using System.Text;
 6 | 
 7 | using VRC;
 8 | using VRC.Core;
 9 | 
10 | using VRCExtended;
11 | 
12 | using UnityEngine;
13 | 
14 | namespace VRChat
15 | {
16 |     public class VRCEPlayer
17 |     {
18 |         #region Reflection Variables
19 |         private static MethodInfo _player_get_user;
20 |         private static MethodInfo _player_get_Instance;
21 | 
22 |         private static MethodInfo _vrcplayer_get_AvatarManager;
23 | #if DEBUG
24 |         private static MethodInfo _vrcplayer_get_uSpeaker;
25 | 
26 |         private static FieldInfo _uspeaker_AudioSource;
27 | #endif
28 |         #endregion
29 | 
30 |         #region VRCEPlayer Properties
31 |         public Player Player { get; private set; }
32 |         public VRCPlayer VRCPlayer => Player.vrcPlayer;
33 |         public APIUser APIUser => _player_get_user.Invoke(Player, new object[0]) as APIUser;
34 | 
35 |         public VRCAvatarManager AvatarManager => _vrcplayer_get_AvatarManager.Invoke(VRCPlayer, new object[0]) as VRCAvatarManager;
36 | #if DEBUG
37 |         public USpeaker uSpeaker => _vrcplayer_get_uSpeaker.Invoke(VRCPlayer, new object[0]) as USpeaker;
38 | #endif
39 | 
40 |         public bool IsSelf => APIUser.id == APIUser.CurrentUser.id;
41 |         public static VRCEPlayer Instance => new VRCEPlayer(_player_get_Instance.Invoke(null, new object[] { }) as Player);
42 |         #endregion
43 | 
44 |         #region Avatar Properties
45 |         public GameObject Avatar => AvatarManager.currentAvatarObject;
46 |         public Animator Animator => VRCPlayer.avatarAnimator;
47 | 
48 | #if DEBUG
49 |         public AudioSource Voice => _uspeaker_AudioSource.GetValue(uSpeaker) as AudioSource;
50 |         public AudioSource[] Sounds => Avatar.GetComponentsInChildren<AudioSource>().Where(a => a != Voice).ToArray();
51 | #endif
52 |         #endregion
53 | 
54 |         #region User Properties
55 |         public string UniqueID => APIUser.id;
56 |         #endregion
57 | 
58 |         public VRCEPlayer(Player player)
59 |         {
60 |             Player = player;
61 |         }
62 |         public VRCEPlayer()
63 |         {
64 |             Player = _player_get_Instance.Invoke(null, new object[] { }) as Player;
65 |         }
66 | 
67 |         internal static void Setup()
68 |         {
69 |             _player_get_user = typeof(Player).GetMethod("get_user", BindingFlags.Public | BindingFlags.Instance);
70 |             _player_get_Instance = typeof(Player).GetMethod("get_Instance", BindingFlags.Public | BindingFlags.Static);
71 | 
72 |             _vrcplayer_get_AvatarManager = typeof(VRCPlayer).GetMethod("get_AvatarManager", BindingFlags.Public | BindingFlags.Instance);
73 | #if DEBUG
74 |             _vrcplayer_get_uSpeaker = typeof(VRCPlayer).GetMethod("get_uSpeaker", BindingFlags.Public | BindingFlags.Instance);
75 | 
76 |             _uspeaker_AudioSource = typeof(USpeaker).GetFields(BindingFlags.NonPublic | BindingFlags.Instance).First(a => a.FieldType == typeof(AudioSource));
77 |             ExtendedLogger.Log("Found user voice AudioSource: " + _uspeaker_AudioSource.Name);
78 | #endif
79 |         }
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/VRCExtended/AntiCrasherConfig.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Reflection;
 3 | using System.Collections.Generic;
 4 | using System.Linq;
 5 | using System.Text;
 6 | 
 7 | namespace VRCExtended
 8 | {
 9 |     internal class AntiCrasherConfig
10 |     {
11 |         #region AntiCrasherConfig Properties
12 |         public static AntiCrasherConfig Instance { get; private set; }
13 |         #endregion
14 | 
15 |         #region Polygon Crasher
16 |         public bool? PolyLimit { get; set; }
17 |         public int? MaxPolygons { get; set; }
18 |         #endregion
19 | 
20 |         #region Particle Crasher
21 |         public bool? ParticleLimit { get; set; }
22 |         //public bool DetectPotentialCrasher { get; set; }
23 |         public int? MaxParticles { get; set; }
24 |         #endregion
25 | 
26 |         #region Shader Crasher
27 |         public bool? ShaderBlacklist { get; set; }
28 |         public bool? UseOnlineBlacklist { get; set; }
29 |         public bool? RemoveUnsupportedShaders { get; set; }
30 |         public string[] BlacklistedShaders { get; set; }
31 |         #endregion
32 | 
33 |         public AntiCrasherConfig() =>
34 |             Instance = this;
35 | 
36 |         public bool CheckBackwardsCompatibility()
37 |         {
38 |             bool rebuilt = false;
39 |             foreach(PropertyInfo property in typeof(AntiCrasherConfig).GetProperties(BindingFlags.Public | BindingFlags.Instance))
40 |                 if(property.GetValue(this, null) == null)
41 |                     rebuilt = true;
42 | 
43 |             if (PolyLimit == null)
44 |                 PolyLimit = true;
45 |             if (MaxPolygons == null)
46 |                 MaxPolygons = 150000;
47 | 
48 |             if (ParticleLimit == null)
49 |                 ParticleLimit = true;
50 |             if (MaxParticles == null)
51 |                 MaxParticles = 200;
52 | 
53 |             if (ShaderBlacklist == null)
54 |                 ShaderBlacklist = true;
55 |             if (UseOnlineBlacklist == null)
56 |                 UseOnlineBlacklist = true;
57 |             if (RemoveUnsupportedShaders == null)
58 |                 RemoveUnsupportedShaders = false;
59 |             if(BlacklistedShaders == null)
60 |             {
61 |                 BlacklistedShaders = new string[]
62 |                 {
63 |                     "pretty",
64 |                     "bluescreen",
65 |                     "tesselation",
66 |                     "tesselated",
67 |                     "crasher",
68 |                     "instant crash paralyzer",
69 |                     "worldkill",
70 |                     "tessellation",
71 |                     "tessellated",
72 |                     "oofer",
73 |                     "xxx",
74 |                     "dbtc",
75 |                     "kyuzu",
76 |                     "distancebased",
77 |                     "waifuserp",
78 |                     "loops",
79 |                     "diebitch",
80 |                     "thotdestroyer" // Thanks Herp Derpinstine
81 |                 };
82 |             }
83 | 
84 |             if (rebuilt)
85 |                 ExtendedLogger.LogWarning("Anti-crasher configuration has been updated!");
86 |             return rebuilt;
87 |         }
88 |         public static void CreateDefault()
89 |         {
90 |             AntiCrasherConfig acc = new AntiCrasherConfig();
91 | 
92 |             acc.CheckBackwardsCompatibility();
93 |         }
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/VRCExtended/VRChat/UI/VRCEUiButton.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | 
 6 | using UnityEngine;
 7 | using UnityEngine.UI;
 8 | 
 9 | using VRCExtended;
10 | 
11 | namespace VRChat.UI
12 | {
13 |     public class VRCEUiButton
14 |     {
15 |         #region VRChatExtended Properties
16 |         public bool Success { get; private set; }
17 |         #endregion
18 | 
19 |         #region UI Properties
20 |         public Transform Control { get; private set; }
21 |         public Transform ButtonControl { get; private set; }
22 |         public Transform ImageControl { get; private set; }
23 |         public Transform TextControl { get; private set; }
24 | 
25 |         public RectTransform Position { get; private set; }
26 |         #endregion
27 | 
28 |         #region Control Properties
29 |         public Button Button { get; private set; }
30 |         public Text Text { get; private set; }
31 |         #endregion
32 | 
33 |         public VRCEUiButton(string name, Vector2 position, string text, Transform parent = null)
34 |         {
35 |             // Get required information
36 |             Transform orgControl = VRCEUi.InternalUserInfoScreen.FavoriteButton;
37 |             if(orgControl == null)
38 |             {
39 |                 ExtendedLogger.LogError("Could not find Favorite button!");
40 |                 Success = false;
41 |                 return;
42 |             }
43 | 
44 |             // Duplicate object
45 |             GameObject goControl = GameObject.Instantiate(orgControl.gameObject);
46 |             if(goControl == null)
47 |             {
48 |                 ExtendedLogger.LogError("Could not duplicate Favorite button!");
49 |                 Success = false;
50 |                 return;
51 |             }
52 | 
53 |             // Set UI properties
54 |             Control = goControl.transform;
55 |             ButtonControl = Control.Find("FavoriteButton");
56 |             ImageControl = ButtonControl.Find("Image");
57 |             TextControl = Control.GetComponentInChildren<Text>().transform;
58 | 
59 |             // Remove components that may cause issues
60 |             GameObject.DestroyImmediate(Control.GetComponent<RectTransform>());
61 |             GameObject.DestroyImmediate(ButtonControl.GetComponent<VRCUiButton>());
62 | 
63 |             // Set control properties
64 |             Button = ButtonControl.GetComponent<Button>();
65 |             Text = TextControl.GetComponent<Text>();
66 | 
67 |             // Set required parts
68 |             if (parent != null)
69 |                 Control.SetParent(parent);
70 |             goControl.name = name;
71 |             ButtonControl.name = name + "Button";
72 | 
73 |             // Modify RectTransform
74 |             Position = Control.GetComponent<RectTransform>();
75 |             RectTransform tmpRT = orgControl.GetComponent<RectTransform>();
76 | 
77 |             Position.localScale = tmpRT.localScale;
78 |             Position.anchoredPosition = tmpRT.anchoredPosition;
79 |             Position.sizeDelta = tmpRT.sizeDelta;
80 |             Position.localPosition = new Vector3(position.x, position.y, 0f);
81 |             Position.localRotation = tmpRT.localRotation;
82 | 
83 |             // Change UI properties
84 |             Text.text = text;
85 |             Button.onClick = new Button.ButtonClickedEvent();
86 | 
87 |             // Finish
88 |             Success = true;
89 |         }
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/VRCExtended/VRChat/UI/VRCEUiVolumeControl.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | 
 6 | using UnityEngine;
 7 | using UnityEngine.UI;
 8 | 
 9 | using VRCExtended;
10 | 
11 | namespace VRChat.UI
12 | {
13 |     public class VRCEUiVolumeControl
14 |     {
15 |         #region VRChatExtended Properties
16 |         public bool Success { get; private set; }
17 |         #endregion
18 | 
19 |         #region UI Properties
20 |         public Transform VolumeControl { get; private set; }
21 |         public Transform FillArea { get; private set; }
22 |         public Transform SliderLabel { get; private set; }
23 |         public Transform Label { get; private set; }
24 | 
25 |         public RectTransform Position { get; private set; }
26 |         #endregion
27 | 
28 |         #region Control Properties
29 |         public Text Text { get; private set; }
30 |         public Slider Slider { get; private set; }
31 |         #endregion
32 | 
33 |         public VRCEUiVolumeControl(string name, Vector2 position, string text, float value = 1f, Transform parent = null)
34 |         {
35 |             // Get required information
36 |             Transform orgVolumeMaster = VRCEUi.InternalSettingsScreen.VolumeMaster;
37 |             if(orgVolumeMaster == null)
38 |             {
39 |                 ExtendedLogger.LogError("Could not find VolumeMaster!");
40 |                 Success = false;
41 |                 return;
42 |             }
43 | 
44 |             // Duplicate object
45 |             GameObject goVolumeControl = GameObject.Instantiate(orgVolumeMaster.gameObject);
46 |             if (goVolumeControl == null)
47 |             {
48 |                 ExtendedLogger.LogError("Could not duplicate VolumeMaster!");
49 |                 Success = false;
50 |                 return;
51 |             }
52 | 
53 |             // Set UI properties
54 |             VolumeControl = goVolumeControl.transform;
55 |             FillArea = VolumeControl.Find("FillArea");
56 |             SliderLabel = VolumeControl.Find("SliderLabel");
57 |             Label = VolumeControl.Find("Label");
58 | 
59 |             // Remove components that may cause issues
60 |             GameObject.DestroyImmediate(VolumeControl.GetComponent<UiSettingConfig>());
61 |             GameObject.DestroyImmediate(VolumeControl.GetComponent<RectTransform>());
62 | 
63 |             // Set control properties
64 |             Text = Label.GetComponent<Text>();
65 |             Slider = VolumeControl.GetComponent<Slider>();
66 | 
67 |             // Set required parts
68 |             if (parent != null)
69 |                 VolumeControl.SetParent(parent);
70 |             goVolumeControl.name = name;
71 | 
72 |             // Modify RectTransform
73 |             Position = VolumeControl.GetComponent<RectTransform>();
74 |             RectTransform tmpRT = orgVolumeMaster.GetComponent<RectTransform>();
75 | 
76 |             Position.localScale = tmpRT.localScale;
77 |             Position.anchoredPosition = tmpRT.anchoredPosition;
78 |             Position.sizeDelta = tmpRT.sizeDelta;
79 |             Position.localPosition = new Vector3(position.x, position.y, 0f);
80 |             Position.localRotation = tmpRT.localRotation;
81 |             Label.GetComponent<RectTransform>().localPosition = Label.GetComponent<RectTransform>().localPosition + new Vector3(50f, 0f, 0f);
82 | 
83 |             // Change UI properties
84 |             Text.text = text;
85 |             Slider.value = value;
86 | 
87 |             // Finish
88 |             Success = true;
89 |         }
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/VRCExtended/Patches/PageUserInfo.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Reflection;
 3 | using System.Collections.Generic;
 4 | using System.Linq;
 5 | using System.Text;
 6 | 
 7 | using VRChat.UI;
 8 | 
 9 | using VRC;
10 | using VRC.UI;
11 | using VRC.Core;
12 | 
13 | using Harmony;
14 | 
15 | using VRCTools;
16 | 
17 | namespace VRCExtended.Patches
18 | {
19 |     internal class Patch_PageUserInfo
20 |     {
21 |         private Dictionary<APIUser, ExtendedUser> _volume = new Dictionary<APIUser, ExtendedUser>();
22 |         
23 |         public static APIUser SelectedAPI { get; private set; }
24 | 
25 |         public static void Setup()
26 |         {
27 |             // Setup harmony instances
28 |             HarmonyInstance iSetupUserInfo = HarmonyInstance.Create("vrcextended.pageuserinfo.setupuserinfo");
29 | 
30 |             // Patch
31 |             try
32 |             {
33 |                 iSetupUserInfo.Patch(typeof(PageUserInfo).GetMethods(BindingFlags.Public | BindingFlags.Instance).First(a => a.Name == "SetupUserInfo" && a.GetParameters().Length > 1), null,
34 |                                      new HarmonyMethod(typeof(Patch_PageUserInfo).GetMethod("SetupUserInfo", BindingFlags.NonPublic | BindingFlags.Static)));
35 |                 ExtendedLogger.Log("Patched PageUserInfo.SetupUserInfo");
36 |             }
37 |             catch (Exception ex)
38 |             {
39 |                 ExtendedLogger.LogError("Failed to patch PageUserInfo!", ex);
40 |                 return;
41 |             }
42 |         }
43 | 
44 |         private static void SetupUserInfo(PageUserInfo __instance)
45 |         {
46 |             SelectedAPI = __instance.user;
47 |             ExtendedUser eUser = ExtendedServer.Users.FirstOrDefault(a => a.UniqueID == SelectedAPI.id);
48 | 
49 |             VRCExtended.ToggleUserInfoMore(false);
50 |             VRCEUi.InternalUserInfoScreen.Moderator.gameObject.SetActive(false);
51 |             if (APIUser.CurrentUser.id == __instance.user.id)
52 |             {
53 |                 VRCExtended.UserInfoLastLogin.Text.text = "";
54 |                 VRCExtended.UserInfoMore.Button.interactable = false;
55 |             }
56 |             else
57 |             {
58 |                 APIUser.FetchUser(__instance.user.id, (APIUser user) =>
59 |                 {
60 |                     if (string.IsNullOrEmpty(user.last_login))
61 |                         return;
62 |                     DateTime dt = DateTime.Parse(user.last_login);
63 | 
64 |                     if (ModPrefs.GetBool("vrcextended", "useDTFormat"))
65 |                         VRCExtended.UserInfoLastLogin.Text.text = "Last login: " + dt.ToString("MM.dd.yyyy hh:mm tt");
66 |                     else
67 |                         VRCExtended.UserInfoLastLogin.Text.text = "Last login: " + dt.ToString("dd.MM.yyyy hh:mm");
68 |                 },
69 |                 (string error) =>
70 |                 {
71 |                     ExtendedLogger.LogError(error);
72 |                 });
73 |                 VRCExtended.UserInfoMore.Button.interactable = true;
74 | 
75 |                 if(eUser != null)
76 |                 {
77 |                     VRCExtended.UserInfoColliderControl.Button.interactable = true;
78 |                     VRCExtended.UserInfoColliderControl.Text.text = (eUser.HasColliders ? "Disable colliders" : "Enable colliders");
79 |                 }
80 |                 else
81 |                 {
82 |                     VRCExtended.UserInfoColliderControl.Button.interactable = false;
83 |                     VRCExtended.UserInfoColliderControl.Text.text = "Not in world!";
84 |                 }
85 |             }
86 |         }
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/VRCExtended/ExtendedLogger.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | 
 6 | using VRCModLogger = VRCModLoader.VRCModLogger;
 7 | 
 8 | namespace VRCExtended
 9 | {
10 |     internal static class ExtendedLogger
11 |     {
12 |         public static void Log(string text)
13 |         {
14 |             ConsoleColor oldColor = Console.ForegroundColor;
15 |             if (oldColor == ConsoleColor.Black)
16 |                 oldColor = ConsoleColor.Gray;
17 | 
18 |             if (Console.CursorLeft > 1)
19 |                 Console.WriteLine();
20 |             Console.ForegroundColor = ConsoleColor.Green;
21 |             VRCModLogger.Log("[VRCExtended] " + text);
22 |             Console.ForegroundColor = oldColor;
23 |         }
24 |         public static void Log(object obj)
25 |         {
26 |             ConsoleColor oldColor = Console.ForegroundColor;
27 |             if (oldColor == ConsoleColor.Black)
28 |                 oldColor = ConsoleColor.Gray;
29 | 
30 |             if (Console.CursorLeft > 1)
31 |                 Console.WriteLine();
32 |             Console.ForegroundColor = ConsoleColor.Green;
33 |             VRCModLogger.Log("[VRCExtended] " + obj.ToString());
34 |             Console.ForegroundColor = oldColor;
35 |         }
36 | 
37 |         public static void LogWarning(string text)
38 |         {
39 |             ConsoleColor oldColor = Console.ForegroundColor;
40 |             if (oldColor == ConsoleColor.Black)
41 |                 oldColor = ConsoleColor.Gray;
42 | 
43 |             if (Console.CursorLeft > 1)
44 |                 Console.WriteLine();
45 |             Console.ForegroundColor = ConsoleColor.Yellow;
46 |             VRCModLogger.Log("[VRCExtended] " + text);
47 |             Console.ForegroundColor = oldColor;
48 |         }
49 |         public static void LogWarning(object obj)
50 |         {
51 |             ConsoleColor oldColor = Console.ForegroundColor;
52 |             if (oldColor == ConsoleColor.Black)
53 |                 oldColor = ConsoleColor.Gray;
54 | 
55 |             if (Console.CursorLeft > 1)
56 |                 Console.WriteLine();
57 |             Console.ForegroundColor = ConsoleColor.Yellow;
58 |             VRCModLogger.Log("[VRCExtended] " + obj.ToString());
59 |             Console.ForegroundColor = oldColor;
60 |         }
61 | 
62 |         public static void LogError(string text, Exception exception = null)
63 |         {
64 |             ConsoleColor oldColor = Console.ForegroundColor;
65 |             if (oldColor == ConsoleColor.Black)
66 |                 oldColor = ConsoleColor.Gray;
67 | 
68 |             if (Console.CursorLeft > 1)
69 |                 Console.WriteLine();
70 |             Console.ForegroundColor = ConsoleColor.Red;
71 |             VRCModLogger.LogError("[VRCExtended] " + text);
72 |             if (exception != null)
73 |                 VRCModLogger.LogError(exception.ToString());
74 |             Console.ForegroundColor = oldColor;
75 |         }
76 |         public static void LogError(object obj, Exception exception = null)
77 |         {
78 |             ConsoleColor oldColor = Console.ForegroundColor;
79 |             if (oldColor == ConsoleColor.Black)
80 |                 oldColor = ConsoleColor.Gray;
81 | 
82 |             if (Console.CursorLeft > 1)
83 |                 Console.WriteLine();
84 |             Console.ForegroundColor = ConsoleColor.Red;
85 |             VRCModLogger.LogError("[VRCExtended] " + obj.ToString());
86 |             if (exception != null)
87 |                 VRCModLogger.LogError(exception.ToString());
88 |             Console.ForegroundColor = oldColor;
89 |         }
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/VRCExtended/VRChat/VRCPlayerManager.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Reflection;
 3 | using System.Collections.Generic;
 4 | using System.Linq;
 5 | using System.Text;
 6 | 
 7 | using VRCExtended;
 8 | using VRChat.Obfuscation;
 9 | 
10 | using UnityEngine.Events;
11 | 
12 | using VRC;
13 | using VRC.Core;
14 | 
15 | namespace VRChat
16 | {
17 |     public static class VRCPlayerManager
18 |     {
19 |         #region Reflection Variables
20 |         // Network Manager
21 |         private static Type _networkManagerType;
22 | 
23 |         private static FieldInfo _networkManagerInstance;
24 |         private static OBFUnityActionInternal<Player> _networkManager_OnPlayerJoinedEvent;
25 |         private static OBFUnityActionInternal<Player> _networkManager_OnPlayerLeftEvent;
26 |         #endregion
27 | 
28 |         #region PlayerManager Event Delegates
29 |         public delegate void PlayerChangeHandle(VRCEPlayer player);
30 |         #endregion
31 | 
32 |         #region PlayerManager Events
33 |         public static event PlayerChangeHandle OnPlayerJoined;
34 |         public static event PlayerChangeHandle OnPlayerLeft;
35 |         #endregion
36 | 
37 |         internal static void Setup()
38 |         {
39 |             // Network manager setup
40 |             _networkManagerType = typeof(PlayerManager).Assembly.GetType("NetworkManager");
41 |             if(_networkManagerType == null)
42 |             {
43 |                 ExtendedLogger.LogError("Failed to get NetworkManager!");
44 |                 return;
45 |             }
46 |             ExtendedLogger.Log("Found NetworkManager!");
47 | 
48 |             _networkManagerInstance = _networkManagerType.GetField("Instance", BindingFlags.Public | BindingFlags.Static);
49 |             if (_networkManagerInstance == null)
50 |             {
51 |                 ExtendedLogger.LogError("Failed to get NetworkManager Instance!");
52 |                 return;
53 |             }
54 |             ExtendedLogger.Log("Found NetworkManager Instance!");
55 | 
56 |             FieldInfo onPlayerJoinedEvent = _networkManagerType.GetField("OnPlayerJoinedEvent", BindingFlags.Public | BindingFlags.Instance);
57 |             if (onPlayerJoinedEvent == null)
58 |             {
59 |                 ExtendedLogger.LogError("Failed to get NetworkManager OnPlayerJoinedEvent!");
60 |                 return;
61 |             }
62 |             ExtendedLogger.Log("Found NetworkManager OnPlayerJoinedEvent!");
63 | 
64 |             FieldInfo onPlayerLeftEvent = _networkManagerType.GetField("OnPlayerLeftEvent", BindingFlags.Public | BindingFlags.Instance);
65 |             if (onPlayerLeftEvent == null)
66 |             {
67 |                 ExtendedLogger.LogError("Failed to get NetworkManager OnPlayerLeftEvent!");
68 |                 return;
69 |             }
70 |             ExtendedLogger.Log("Found NetworkManager OnPlayerLeftEvent!");
71 | 
72 |             Type unityActionInternalType = onPlayerJoinedEvent.FieldType;
73 |             if (unityActionInternalType == null)
74 |             {
75 |                 ExtendedLogger.LogError("Failed to get UnityActionInternal!");
76 |                 return;
77 |             }
78 |             ExtendedLogger.Log("Found UnityActionInternal named " + unityActionInternalType.Name + "!");
79 | 
80 |             _networkManager_OnPlayerJoinedEvent = new OBFUnityActionInternal<Player>(unityActionInternalType, onPlayerJoinedEvent.GetValue(_networkManagerInstance.GetValue(null)));
81 |             _networkManager_OnPlayerLeftEvent = new OBFUnityActionInternal<Player>(unityActionInternalType, onPlayerLeftEvent.GetValue(_networkManagerInstance.GetValue(null)));
82 | 
83 |             _networkManager_OnPlayerJoinedEvent.Add(new UnityAction<Player>(delegate(Player player)
84 |             {
85 |                 if (OnPlayerJoined != null)
86 |                     OnPlayerJoined(new VRCEPlayer(player));
87 |             }));
88 |             _networkManager_OnPlayerLeftEvent.Add(new UnityAction<Player>(delegate (Player player)
89 |             {
90 |                 if (OnPlayerLeft != null)
91 |                     OnPlayerLeft(new VRCEPlayer(player));
92 |             }));
93 |         }
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/VRCExtended/VRCExtended.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  4 |   <PropertyGroup>
  5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  7 |     <ProjectGuid>{7DF0802E-DB23-417B-A5CD-949B0471D3C4}</ProjectGuid>
  8 |     <OutputType>Library</OutputType>
  9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 10 |     <RootNamespace>VRCExtended</RootNamespace>
 11 |     <AssemblyName>VRCExtended</AssemblyName>
 12 |     <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
 13 |     <FileAlignment>512</FileAlignment>
 14 |     <Deterministic>true</Deterministic>
 15 |   </PropertyGroup>
 16 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 17 |     <DebugSymbols>true</DebugSymbols>
 18 |     <DebugType>full</DebugType>
 19 |     <Optimize>false</Optimize>
 20 |     <OutputPath>..\bin\Debug\</OutputPath>
 21 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 22 |     <ErrorReport>prompt</ErrorReport>
 23 |     <WarningLevel>4</WarningLevel>
 24 |   </PropertyGroup>
 25 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 26 |     <DebugType>pdbonly</DebugType>
 27 |     <Optimize>true</Optimize>
 28 |     <OutputPath>..\bin\Release\</OutputPath>
 29 |     <DefineConstants>TRACE</DefineConstants>
 30 |     <ErrorReport>prompt</ErrorReport>
 31 |     <WarningLevel>4</WarningLevel>
 32 |   </PropertyGroup>
 33 |   <ItemGroup>
 34 |     <Reference Include="Assembly-CSharp">
 35 |       <HintPath>..\lib\Assembly-CSharp.dll</HintPath>
 36 |     </Reference>
 37 |     <Reference Include="Assembly-CSharp-firstpass">
 38 |       <HintPath>..\lib\Assembly-CSharp-firstpass.dll</HintPath>
 39 |     </Reference>
 40 |     <Reference Include="Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
 41 |       <SpecificVersion>False</SpecificVersion>
 42 |       <HintPath>..\lib\Newtonsoft.Json.dll</HintPath>
 43 |     </Reference>
 44 |     <Reference Include="System" />
 45 |     <Reference Include="System.Core" />
 46 |     <Reference Include="System.Xml.Linq" />
 47 |     <Reference Include="System.Data.DataSetExtensions" />
 48 |     <Reference Include="System.Data" />
 49 |     <Reference Include="System.Xml" />
 50 |     <Reference Include="UnityEngine">
 51 |       <HintPath>..\lib\UnityEngine.dll</HintPath>
 52 |     </Reference>
 53 |     <Reference Include="UnityEngine.AnimationModule">
 54 |       <HintPath>..\lib\UnityEngine.AnimationModule.dll</HintPath>
 55 |     </Reference>
 56 |     <Reference Include="UnityEngine.AudioModule">
 57 |       <HintPath>..\lib\UnityEngine.AudioModule.dll</HintPath>
 58 |     </Reference>
 59 |     <Reference Include="UnityEngine.CoreModule">
 60 |       <HintPath>..\lib\UnityEngine.CoreModule.dll</HintPath>
 61 |     </Reference>
 62 |     <Reference Include="UnityEngine.ParticleSystemModule">
 63 |       <HintPath>..\lib\UnityEngine.ParticleSystemModule.dll</HintPath>
 64 |     </Reference>
 65 |     <Reference Include="UnityEngine.PhysicsModule">
 66 |       <HintPath>..\lib\UnityEngine.PhysicsModule.dll</HintPath>
 67 |     </Reference>
 68 |     <Reference Include="UnityEngine.TextRenderingModule">
 69 |       <HintPath>..\lib\UnityEngine.TextRenderingModule.dll</HintPath>
 70 |     </Reference>
 71 |     <Reference Include="UnityEngine.UI">
 72 |       <HintPath>..\lib\UnityEngine.UI.dll</HintPath>
 73 |     </Reference>
 74 |     <Reference Include="UnityEngine.UIModule">
 75 |       <HintPath>..\lib\UnityEngine.UIModule.dll</HintPath>
 76 |     </Reference>
 77 |     <Reference Include="UnityEngine.UnityWebRequestModule">
 78 |       <HintPath>..\lib\UnityEngine.UnityWebRequestModule.dll</HintPath>
 79 |     </Reference>
 80 |     <Reference Include="VRCCore-Standalone">
 81 |       <HintPath>..\lib\VRCCore-Standalone.dll</HintPath>
 82 |     </Reference>
 83 |     <Reference Include="VRCModLoader">
 84 |       <HintPath>..\lib\VRCModLoader.dll</HintPath>
 85 |     </Reference>
 86 |     <Reference Include="VRCSDK2">
 87 |       <HintPath>..\lib\VRCSDK2.dll</HintPath>
 88 |     </Reference>
 89 |     <Reference Include="VRCTools">
 90 |       <HintPath>..\lib\VRCTools.dll</HintPath>
 91 |     </Reference>
 92 |   </ItemGroup>
 93 |   <ItemGroup>
 94 |     <Compile Include="AntiCrasherConfig.cs" />
 95 |     <Compile Include="ExtendedLogger.cs" />
 96 |     <Compile Include="ExtendedServer.cs" />
 97 |     <Compile Include="ExtendedUser.cs" />
 98 |     <Compile Include="GameScripts\LocalCollider.cs" />
 99 |     <Compile Include="GameScripts\PauseDetection.cs" />
100 |     <Compile Include="Patches\PageUserInfo.cs" />
101 |     <Compile Include="Patches\PortalInternal.cs" />
102 |     <Compile Include="VolumeControl.cs" />
103 |     <Compile Include="VRCExtended.cs" />
104 |     <Compile Include="Properties\AssemblyInfo.cs" />
105 |     <Compile Include="VRChat\Obfuscation\OBFUnityActionInternal.cs" />
106 |     <Compile Include="VRChat\UI\VRCEUi.cs" />
107 |     <Compile Include="VRChat\UI\VRCEUiButton.cs" />
108 |     <Compile Include="VRChat\UI\VRCEUiText.cs" />
109 |     <Compile Include="VRChat\UI\VRCEUiVolumeControl.cs" />
110 |     <Compile Include="VRChat\VRCEPlayer.cs" />
111 |     <Compile Include="VRChat\VRCPlayerManager.cs" />
112 |   </ItemGroup>
113 |   <ItemGroup />
114 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
115 | </Project>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # VRCExtended
 2 | This mod offers you quality of life improvements in the game VRChat. It adds features that allow the user to have a much better experience in the game.
 3 | 
 4 | > **Disclaimer:**
 5 | > This mod uses [VRCModLoader](https://github.com/Slaynash/VRCModLoader) to work properly, so you will need to install that first.
 6 | >  
 7 | >  **Warning:**
 8 | >  The VRChat team is not very keen on modding or reverse engineering the game, while the mod does not include anything that would ruin the fun for others, using it may still be a bannable offence.
 9 | >   
10 | >  **USE IT AT YOUR OWN RISK**, I am not responsible for any bans or any punishments you may get by using this mod!
11 | 
12 | ## Installation ##
13 | Please make sure you have downloaded and installed [VRCModLoader](https://github.com/Slaynash/VRCModLoader) before continuing!
14 | > 1. Download the latest **Release** version of the mod from the [Releases](https://github.com/AtiLion/VRCExtended/releases) section
15 | > 2. Navigate to your VRChat directory *(where all the VRChat game files are located)*
16 | > 3. Drag/copy the DLL file that you have downloaded into the Mods folder
17 | > 4. That's it! Now just run the game and the mod should be installed!
18 | 
19 | ## Features ##
20 | If you wish to suggest more features that can improve everyone's lives feel free to suggest them.
21 | > - Ask use portal *[This feature asks you if you wish to enter the portal before you do]*
22 | > - Anti-crasher *[This feature removes any elements that could crash you]*
23 | >	- Online shader blacklist *[Downloads the shader blacklist from the repo each launch]*
24 | > - Local colliders *[This features let's you interact with other avatar's colliders]*
25 | >   - Others have local colliders *[You see when a user interacts with another user's colliders]*
26 | >   - Others can touch you *[You can see when someone interacts with your colliders]*
27 | >   - Target only hand colliders *[Only the hand colliders are able to interact with other colliders]*
28 | >   - Fake colliders on self *[Allows you to interact with colliders even if you don't have them]*
29 | >   - Fake colliders on others *[Allows others to interact with colliders even if they don't have them]*
30 | >	- User specific colliders *[Enable/Disable colliders per user]*
31 | >	- Ignore "Pull" colliders *[Ignores colliders set to pull]*
32 | > - Refresh user *[This feature let's you refresh the user info instantly]*
33 | > - Refresh social groups *[This feature let's you refresh the entire social screen]*
34 | > - FPS management *[Lowers your FPS to 5 when the game is out of focus]*
35 | > - Unlimited FPS *[Sets your max FPS to unlimited]*
36 | > - Disable portals *[Disables all portals]*
37 | > - Last login
38 | 
39 | ## Anti-crasher Information ##
40 | The anti-crasher configuration file is located inside your VRChat directory under the name "antiCrash.json"
41 | > - PolyLimit = Limit the amount of polygons that a mesh can have
42 | > - MaxPolygons = How many polygons can be in a single mesh before it is removed
43 | > - ParticleLimit = Limit the amount of particles an avatar can give off
44 | > - MaxParticles = How many particles an avatar can give off
45 | > - ShaderBlacklist = Remove shaders based on a blacklist
46 | > - UseOnlineBlacklist = Downloads the blacklist every launch to keep blacklisted shaders up to date
47 | > - BlacklistedShaders = The partial names of shaders that are removed if blacklist is enabled
48 | 
49 | ## Contributing ##
50 | I will try to be as active as I can in adding features and fixing bugs but I can't do everything alone, so I ask the community to also help out. Listed below are how you can help the project continue forward.
51 | > **Developers:**
52 | > Feel free to add features you may believe to be useful to other users, or if you wish you can add features that other users have request that I have not gotten to yet.
53 | > 
54 | > **Users:**
55 | > You can contribute by reporting any bugs caused by the mod, as well as requesting features that you think might be useful to others as well as you.
56 | > You can also contribute by adding crasher shaders to the [Shader blacklist](https://github.com/AtiLion/VRCExtended/blob/master/ShaderBlacklist.txt)
57 | 
58 | ## Known bugs ##
59 |  - Refresh doesn't work instantly *(This is an issue on VRChat's side)*
60 | 
61 | ## FAQ ##
62 | If you have any more questions feel free to ask them in the [Issues](https://github.com/AtiLion/VRCExtended/issues) section.
63 | > - How do I report a bug or suggest a feature? *You can create an issue report in the [Issues](https://github.com/AtiLion/VRCExtended/issues) section*
64 | > - How do I get the debug version of the mod? *Simply install the **Debug** version of the mod found in the [Releases](https://github.com/AtiLion/VRCExtended/releases) section*
65 | > - Can I suggest a feature that may affect how other's play the game? *No, any requested feature that affects the gameplay of others or is considered unfair will be ignored*
66 | > - Can I get banned using this mod? *Yes, if any of the VRChat team finds out that you are using mods you are most likely going to be banned, so I suggest you don't go advertising it*
67 | > - Does this mod work in VR? *Yes, the mod is designed to work fully with VR as well as desktop*
68 | > - Avatars are taking longer to load with local colliders. *An avatar with a ton of colliders will take longer to load as it has to register all of them*
69 | > - Sometimes all of the colliders go weird. *If an avatar has a world sized bone collider on it, it may cause things to start and look weird as the collider interacts with all of yours*
70 | > - My game takes a while to close. *Use the [QuitFix mod by HerpDerpinstine](https://github.com/HerpDerpinstine/QuitFix)*
71 | 
72 | ## How to compile ##
73 |  1. Make sure you have a program that can compile C# code
74 |  2. Create a folder called *"lib"*
75 |  3. Make sure the lib folder contains the following files:
76 | 	- Assembly-CSharp.dll
77 | 	- Assembly-CSharp-firstpass.dll
78 | 	- Newtonsoft.Json.dll
79 | 	- UnityEngine.AudioModule.dll
80 | 	- UnityEngine.CoreModule.dll
81 | 	- UnityEngine.dll
82 | 	- UnityEngine.ParticleSystemModule.dll
83 | 	- UnityEngine.PhysicsModule.dll
84 | 	- UnityEngine.TextRenderingModule.dll
85 | 	- UnityEngine.UI.dll
86 | 	- UnityEngine.UIModule.dll
87 | 	- UnityEngine.AnimationModule.dll
88 | 	- UnityEngine.UnityWebRequestModule.dll
89 | 	- VRCCore-Standalone.dll
90 | 	- VRCSDK2.dll
91 | 	- VRCModLoader.dll
92 | 	- VRCTools.dll
93 | 4. Use your compiler to compile the code
94 | 
95 | ## Credits ##
96 | - BadWolfVR - Shader blacklisting
97 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | ##
  4 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
  5 | 
  6 | # Project Specific
  7 | lib/
  8 | *.zip
  9 | 
 10 | # User-specific files
 11 | *.suo
 12 | *.user
 13 | *.userosscache
 14 | *.sln.docstates
 15 | 
 16 | # User-specific files (MonoDevelop/Xamarin Studio)
 17 | *.userprefs
 18 | 
 19 | # Build results
 20 | [Dd]ebug/
 21 | [Dd]ebugPublic/
 22 | [Rr]elease/
 23 | [Rr]eleases/
 24 | x64/
 25 | x86/
 26 | bld/
 27 | [Bb]in/
 28 | [Oo]bj/
 29 | [Ll]og/
 30 | 
 31 | # Visual Studio 2015/2017 cache/options directory
 32 | .vs/
 33 | # Uncomment if you have tasks that create the project's static files in wwwroot
 34 | #wwwroot/
 35 | 
 36 | # Visual Studio 2017 auto generated files
 37 | Generated\ Files/
 38 | 
 39 | # MSTest test Results
 40 | [Tt]est[Rr]esult*/
 41 | [Bb]uild[Ll]og.*
 42 | 
 43 | # NUNIT
 44 | *.VisualState.xml
 45 | TestResult.xml
 46 | 
 47 | # Build Results of an ATL Project
 48 | [Dd]ebugPS/
 49 | [Rr]eleasePS/
 50 | dlldata.c
 51 | 
 52 | # Benchmark Results
 53 | BenchmarkDotNet.Artifacts/
 54 | 
 55 | # .NET Core
 56 | project.lock.json
 57 | project.fragment.lock.json
 58 | artifacts/
 59 | **/Properties/launchSettings.json
 60 | 
 61 | # StyleCop
 62 | StyleCopReport.xml
 63 | 
 64 | # Files built by Visual Studio
 65 | *_i.c
 66 | *_p.c
 67 | *_i.h
 68 | *.ilk
 69 | *.meta
 70 | *.obj
 71 | *.iobj
 72 | *.pch
 73 | *.pdb
 74 | *.ipdb
 75 | *.pgc
 76 | *.pgd
 77 | *.rsp
 78 | *.sbr
 79 | *.tlb
 80 | *.tli
 81 | *.tlh
 82 | *.tmp
 83 | *.tmp_proj
 84 | *.log
 85 | *.vspscc
 86 | *.vssscc
 87 | .builds
 88 | *.pidb
 89 | *.svclog
 90 | *.scc
 91 | 
 92 | # Chutzpah Test files
 93 | _Chutzpah*
 94 | 
 95 | # Visual C++ cache files
 96 | ipch/
 97 | *.aps
 98 | *.ncb
 99 | *.opendb
100 | *.opensdf
101 | *.sdf
102 | *.cachefile
103 | *.VC.db
104 | *.VC.VC.opendb
105 | 
106 | # Visual Studio profiler
107 | *.psess
108 | *.vsp
109 | *.vspx
110 | *.sap
111 | 
112 | # Visual Studio Trace Files
113 | *.e2e
114 | 
115 | # TFS 2012 Local Workspace
116 | $tf/
117 | 
118 | # Guidance Automation Toolkit
119 | *.gpState
120 | 
121 | # ReSharper is a .NET coding add-in
122 | _ReSharper*/
123 | *.[Rr]e[Ss]harper
124 | *.DotSettings.user
125 | 
126 | # JustCode is a .NET coding add-in
127 | .JustCode
128 | 
129 | # TeamCity is a build add-in
130 | _TeamCity*
131 | 
132 | # DotCover is a Code Coverage Tool
133 | *.dotCover
134 | 
135 | # AxoCover is a Code Coverage Tool
136 | .axoCover/*
137 | !.axoCover/settings.json
138 | 
139 | # Visual Studio code coverage results
140 | *.coverage
141 | *.coveragexml
142 | 
143 | # NCrunch
144 | _NCrunch_*
145 | .*crunch*.local.xml
146 | nCrunchTemp_*
147 | 
148 | # MightyMoose
149 | *.mm.*
150 | AutoTest.Net/
151 | 
152 | # Web workbench (sass)
153 | .sass-cache/
154 | 
155 | # Installshield output folder
156 | [Ee]xpress/
157 | 
158 | # DocProject is a documentation generator add-in
159 | DocProject/buildhelp/
160 | DocProject/Help/*.HxT
161 | DocProject/Help/*.HxC
162 | DocProject/Help/*.hhc
163 | DocProject/Help/*.hhk
164 | DocProject/Help/*.hhp
165 | DocProject/Help/Html2
166 | DocProject/Help/html
167 | 
168 | # Click-Once directory
169 | publish/
170 | 
171 | # Publish Web Output
172 | *.[Pp]ublish.xml
173 | *.azurePubxml
174 | # Note: Comment the next line if you want to checkin your web deploy settings,
175 | # but database connection strings (with potential passwords) will be unencrypted
176 | *.pubxml
177 | *.publishproj
178 | 
179 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
180 | # checkin your Azure Web App publish settings, but sensitive information contained
181 | # in these scripts will be unencrypted
182 | PublishScripts/
183 | 
184 | # NuGet Packages
185 | *.nupkg
186 | # The packages folder can be ignored because of Package Restore
187 | **/[Pp]ackages/*
188 | # except build/, which is used as an MSBuild target.
189 | !**/[Pp]ackages/build/
190 | # Uncomment if necessary however generally it will be regenerated when needed
191 | #!**/[Pp]ackages/repositories.config
192 | # NuGet v3's project.json files produces more ignorable files
193 | *.nuget.props
194 | *.nuget.targets
195 | 
196 | # Microsoft Azure Build Output
197 | csx/
198 | *.build.csdef
199 | 
200 | # Microsoft Azure Emulator
201 | ecf/
202 | rcf/
203 | 
204 | # Windows Store app package directories and files
205 | AppPackages/
206 | BundleArtifacts/
207 | Package.StoreAssociation.xml
208 | _pkginfo.txt
209 | *.appx
210 | 
211 | # Visual Studio cache files
212 | # files ending in .cache can be ignored
213 | *.[Cc]ache
214 | # but keep track of directories ending in .cache
215 | !*.[Cc]ache/
216 | 
217 | # Others
218 | ClientBin/
219 | ~$*
220 | *~
221 | *.dbmdl
222 | *.dbproj.schemaview
223 | *.jfm
224 | *.pfx
225 | *.publishsettings
226 | orleans.codegen.cs
227 | 
228 | # Including strong name files can present a security risk 
229 | # (https://github.com/github/gitignore/pull/2483#issue-259490424)
230 | #*.snk
231 | 
232 | # Since there are multiple workflows, uncomment next line to ignore bower_components
233 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
234 | #bower_components/
235 | 
236 | # RIA/Silverlight projects
237 | Generated_Code/
238 | 
239 | # Backup & report files from converting an old project file
240 | # to a newer Visual Studio version. Backup files are not needed,
241 | # because we have git ;-)
242 | _UpgradeReport_Files/
243 | Backup*/
244 | UpgradeLog*.XML
245 | UpgradeLog*.htm
246 | ServiceFabricBackup/
247 | *.rptproj.bak
248 | 
249 | # SQL Server files
250 | *.mdf
251 | *.ldf
252 | *.ndf
253 | 
254 | # Business Intelligence projects
255 | *.rdl.data
256 | *.bim.layout
257 | *.bim_*.settings
258 | *.rptproj.rsuser
259 | 
260 | # Microsoft Fakes
261 | FakesAssemblies/
262 | 
263 | # GhostDoc plugin setting file
264 | *.GhostDoc.xml
265 | 
266 | # Node.js Tools for Visual Studio
267 | .ntvs_analysis.dat
268 | node_modules/
269 | 
270 | # Visual Studio 6 build log
271 | *.plg
272 | 
273 | # Visual Studio 6 workspace options file
274 | *.opt
275 | 
276 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
277 | *.vbw
278 | 
279 | # Visual Studio LightSwitch build output
280 | **/*.HTMLClient/GeneratedArtifacts
281 | **/*.DesktopClient/GeneratedArtifacts
282 | **/*.DesktopClient/ModelManifest.xml
283 | **/*.Server/GeneratedArtifacts
284 | **/*.Server/ModelManifest.xml
285 | _Pvt_Extensions
286 | 
287 | # Paket dependency manager
288 | .paket/paket.exe
289 | paket-files/
290 | 
291 | # FAKE - F# Make
292 | .fake/
293 | 
294 | # JetBrains Rider
295 | .idea/
296 | *.sln.iml
297 | 
298 | # CodeRush
299 | .cr/
300 | 
301 | # Python Tools for Visual Studio (PTVS)
302 | __pycache__/
303 | *.pyc
304 | 
305 | # Cake - Uncomment if you are using it
306 | # tools/**
307 | # !tools/packages.config
308 | 
309 | # Tabs Studio
310 | *.tss
311 | 
312 | # Telerik's JustMock configuration file
313 | *.jmconfig
314 | 
315 | # BizTalk build output
316 | *.btp.cs
317 | *.btm.cs
318 | *.odx.cs
319 | *.xsd.cs
320 | 
321 | # OpenCover UI analysis results
322 | OpenCover/
323 | 
324 | # Azure Stream Analytics local run output 
325 | ASALocalRun/
326 | 
327 | # MSBuild Binary and Structured Log
328 | *.binlog
329 | 
330 | # NVidia Nsight GPU debugger configuration file
331 | *.nvuser
332 | 
333 | # MFractors (Xamarin productivity tool) working folder 
334 | .mfractor/
335 | 


--------------------------------------------------------------------------------
/VRCExtended/VRChat/UI/VRCEUi.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Reflection;
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using System.Text;
  6 | 
  7 | using UnityEngine;
  8 | using UnityEngine.UI;
  9 | 
 10 | using VRC.UI;
 11 | 
 12 | using VRCExtended;
 13 | 
 14 | namespace VRChat.UI
 15 | {
 16 |     public static class VRCEUi
 17 |     {
 18 |         #region VRChat Menu Variables
 19 |         private static QuickMenu _quickMenu;
 20 | 
 21 |         private static GameObject _avatarScreen;
 22 |         private static GameObject _detailsScreen;
 23 |         private static GameObject _playlistsScreen;
 24 |         private static GameObject _socialScreen;
 25 |         private static GameObject _settingsScreen;
 26 |         private static GameObject _safetyScreen;
 27 |         private static GameObject _userInfoScreen;
 28 |         private static GameObject _worldsScreen;
 29 |         #endregion
 30 | 
 31 |         #region VRChat Menu Properties
 32 |         public static QuickMenu QuickMenu
 33 |         {
 34 |             get
 35 |             {
 36 |                 if (_quickMenu == null)
 37 |                     _quickMenu = (QuickMenu)typeof(QuickMenu).GetMethod("get_Instance", BindingFlags.Public | BindingFlags.Static).Invoke(null, null);
 38 |                 return _quickMenu;
 39 |             }
 40 |         }
 41 | 
 42 |         public static GameObject AvatarScreen
 43 |         {
 44 |             get
 45 |             {
 46 |                 if(_avatarScreen == null)
 47 |                     _avatarScreen = GameObject.Find(QuickMenu.avatarScreenPath);
 48 |                 return _avatarScreen;
 49 |             }
 50 |         }
 51 |         public static GameObject DetailsScreen
 52 |         {
 53 |             get
 54 |             {
 55 |                 if (_detailsScreen == null)
 56 |                     _detailsScreen = GameObject.Find(QuickMenu.detailsScreenPath);
 57 |                 return _detailsScreen;
 58 |             }
 59 |         }
 60 |         public static GameObject PlaylistsScreen
 61 |         {
 62 |             get
 63 |             {
 64 |                 if (_playlistsScreen == null)
 65 |                     _playlistsScreen = GameObject.Find(QuickMenu.playlistsScreenPath);
 66 |                 return _playlistsScreen;
 67 |             }
 68 |         }
 69 |         public static GameObject SocialScreen
 70 |         {
 71 |             get
 72 |             {
 73 |                 if (_socialScreen == null)
 74 |                     _socialScreen = GameObject.Find(QuickMenu.socialScreenPath);
 75 |                 return _socialScreen;
 76 |             }
 77 |         }
 78 |         public static GameObject SettingsScreen
 79 |         {
 80 |             get
 81 |             {
 82 |                 if (_settingsScreen == null)
 83 |                     _settingsScreen = GameObject.Find(QuickMenu.settingsScreenPath);
 84 |                 return _settingsScreen;
 85 |             }
 86 |         }
 87 |         public static GameObject SafetyScreen
 88 |         {
 89 |             get
 90 |             {
 91 |                 if (_safetyScreen == null)
 92 |                     _safetyScreen = GameObject.Find(QuickMenu.safetyScreenPath);
 93 |                 return _safetyScreen;
 94 |             }
 95 |         }
 96 |         public static GameObject UserInfoScreen
 97 |         {
 98 |             get
 99 |             {
100 |                 if (_userInfoScreen == null)
101 |                     _userInfoScreen = GameObject.Find(QuickMenu.userInfoScreenPath);
102 |                 return _userInfoScreen;
103 |             }
104 |         }
105 |         public static GameObject WorldsScreen
106 |         {
107 |             get
108 |             {
109 |                 if (_worldsScreen == null)
110 |                     _worldsScreen = GameObject.Find(QuickMenu.worldsScreenPath);
111 |                 return _worldsScreen;
112 |             }
113 |         }
114 |         #endregion
115 | 
116 |         #region VRChat UI Functions
117 |         public static Transform DuplicateButton(Transform button, string name, string text, Vector2 offset, Transform parent = null)
118 |         {
119 |             // Create new one
120 |             GameObject goButton = GameObject.Instantiate(button.gameObject);
121 |             if(goButton == null)
122 |             {
123 |                 ExtendedLogger.LogError("Could not duplicate button!");
124 |                 return null;
125 |             }
126 | 
127 |             // Get UI components
128 |             Button objButton = goButton.GetComponentInChildren<Button>();
129 |             Text objText = goButton.GetComponentInChildren<Text>();
130 | 
131 |             // Destroy broke components
132 |             GameObject.DestroyImmediate(goButton.GetComponent<RectTransform>());
133 | 
134 |             // Set required parts
135 |             if (parent != null)
136 |                 goButton.transform.SetParent(parent);
137 |             goButton.name = name;
138 | 
139 |             // Modify RectTransform
140 |             RectTransform rtOriginal = button.GetComponent<RectTransform>();
141 |             RectTransform rtNew = goButton.GetComponent<RectTransform>();
142 | 
143 |             rtNew.localScale = rtOriginal.localScale;
144 |             rtNew.anchoredPosition = rtOriginal.anchoredPosition;
145 |             rtNew.sizeDelta = rtOriginal.sizeDelta;
146 |             rtNew.localPosition = rtOriginal.localPosition + new Vector3(offset.x, offset.y, 0f);
147 |             rtNew.localRotation = rtOriginal.localRotation;
148 | 
149 |             // Change UI properties
150 |             objText.text = text;
151 |             objButton.onClick = new Button.ButtonClickedEvent();
152 | 
153 |             // Finish
154 |             return goButton.transform;
155 |         }
156 |         #endregion
157 | 
158 |         #region VRChat Menu Screen Classes
159 |         public static class InternalUserInfoScreen
160 |         {
161 |             #region UserInfo Variables
162 |             private static PageUserInfo _instance;
163 |             #endregion
164 | 
165 |             #region UserInfo UI Variables
166 |             private static Transform _userPanel;
167 |             private static Transform _avatarImage;
168 |             #endregion
169 | 
170 |             #region UserPanel Variables
171 |             private static Transform _moderator;
172 |             private static Transform _user;
173 | 
174 |             private static Transform _playlistsButton;
175 |             private static Transform _favoriteButton;
176 |             private static Transform _reportButton;
177 |             private static Transform _usernameText;
178 |             #endregion
179 | 
180 |             #region User Variables
181 |             private static Transform _userActions;
182 |             #endregion
183 | 
184 |             #region User Actions Variables
185 |             private static Transform _voteKickButton;
186 |             #endregion
187 | 
188 |             #region Moderator Variables
189 |             private static Transform _moderatorActions;
190 |             #endregion
191 | 
192 |             #region Moderator Actions Variables
193 |             private static Transform _joinButton;
194 |             #endregion
195 | 
196 |             #region UserInfo Properties
197 |             public static PageUserInfo Instance
198 |             {
199 |                 get
200 |                 {
201 |                     if(_instance == null)
202 |                     {
203 |                         if (UserInfoScreen == null)
204 |                             return null;
205 |                         _instance = UserInfoScreen.GetComponent<VRCUiPage>() as PageUserInfo;
206 |                     }
207 |                     return _instance;
208 |                 }
209 |             }
210 |             #endregion
211 | 
212 |             #region UserInfo UI Properties
213 |             public static Transform UserPanel
214 |             {
215 |                 get
216 |                 {
217 |                     if(_userPanel == null)
218 |                     {
219 |                         if (UserInfoScreen == null)
220 |                             return null;
221 |                         _userPanel = UserInfoScreen.transform.Find("User Panel");
222 |                     }
223 |                     return _userPanel;
224 |                 }
225 |             }
226 |             public static Transform AvatarImage
227 |             {
228 |                 get
229 |                 {
230 |                     if(_avatarImage == null)
231 |                     {
232 |                         if (UserInfoScreen == null)
233 |                             return null;
234 |                         _avatarImage = UserInfoScreen.transform.Find("AvatarImage");
235 |                     }
236 |                     return _avatarImage;
237 |                 }
238 |             }
239 |             #endregion
240 | 
241 |             #region UserPanel Properties
242 |             public static Transform Moderator
243 |             {
244 |                 get
245 |                 {
246 |                     if(_moderator == null)
247 |                     {
248 |                         if (UserPanel == null)
249 |                             return null;
250 |                         _moderator = UserPanel.Find("Moderator");
251 |                     }
252 |                     return _moderator;
253 |                 }
254 |             }
255 |             public static Transform User
256 |             {
257 |                 get
258 |                 {
259 |                     if(_user == null)
260 |                     {
261 |                         if (UserPanel == null)
262 |                             return null;
263 |                         _user = UserPanel.Find("User");
264 |                     }
265 |                     return _user;
266 |                 }
267 |             }
268 | 
269 |             public static Transform PlaylistsButton
270 |             {
271 |                 get
272 |                 {
273 |                     if(_playlistsButton == null)
274 |                     {
275 |                         if (UserPanel == null)
276 |                             return null;
277 |                         _playlistsButton = UserPanel.Find("Playlists");
278 |                     }
279 |                     return _playlistsButton;
280 |                 }
281 |             }
282 |             public static Transform FavoriteButton
283 |             {
284 |                 get
285 |                 {
286 |                     if (_favoriteButton == null)
287 |                     {
288 |                         if (UserPanel == null)
289 |                             return null;
290 |                         _favoriteButton = UserPanel.Find("Favorite");
291 |                     }
292 |                     return _favoriteButton;
293 |                 }
294 |             }
295 |             public static Transform ReportButton
296 |             {
297 |                 get
298 |                 {
299 |                     if(_reportButton == null)
300 |                     {
301 |                         if (UserPanel == null)
302 |                             return null;
303 |                         _reportButton = UserPanel.Find("Report");
304 |                     }
305 |                     return _reportButton;
306 |                 }
307 |             }
308 |             public static Transform UsernameText
309 |             {
310 |                 get
311 |                 {
312 |                     if(_usernameText == null)
313 |                     {
314 |                         if (UserPanel == null)
315 |                             return null;
316 |                         _usernameText = UserPanel.Find("NameText");
317 |                     }
318 |                     return _usernameText;
319 |                 }
320 |             }
321 |             #endregion
322 | 
323 |             #region User Properties
324 |             public static Transform UserActions
325 |             {
326 |                 get
327 |                 {
328 |                     if(_userActions == null)
329 |                     {
330 |                         if (User == null)
331 |                             return null;
332 |                         _userActions = User.Find("Actions");
333 |                     }
334 |                     return _userActions;
335 |                 }
336 |             }
337 |             #endregion
338 | 
339 |             #region User Actions Properties
340 |             public static Transform VoteKickButton
341 |             {
342 |                 get
343 |                 {
344 |                     if(_voteKickButton == null)
345 |                     {
346 |                         if (UserActions == null)
347 |                             return null;
348 |                         _voteKickButton = UserActions.Find("VoteKick");
349 |                     }
350 |                     return _voteKickButton;
351 |                 }
352 |             }
353 |             #endregion
354 | 
355 |             #region Moderator Properties
356 |             public static Transform ModeratorActions
357 |             {
358 |                 get
359 |                 {
360 |                     if(_moderatorActions == null)
361 |                     {
362 |                         if (Moderator == null)
363 |                             return null;
364 |                         _moderatorActions = Moderator.Find("Actions");
365 |                     }
366 |                     return _moderatorActions;
367 |                 }
368 |             }
369 |             #endregion
370 | 
371 |             #region Moderator Actions Properties
372 |             public static Transform JoinButton
373 |             {
374 |                 get
375 |                 {
376 |                     if(_joinButton == null)
377 |                     {
378 |                         if (ModeratorActions == null)
379 |                             return null;
380 |                         _joinButton = ModeratorActions.Find("Join!");
381 |                     }
382 |                     return _joinButton;
383 |                 }
384 |             }
385 |             #endregion
386 |         }
387 |         public static class InternalSettingsScreen
388 |         {
389 |             #region Settings UI Variables
390 |             private static Transform _volumePanel;
391 |             #endregion
392 | 
393 |             #region VolumePanel Variables
394 |             private static Transform _volumeMaster;
395 |             #endregion
396 | 
397 |             #region Settings UI Properties
398 |             public static Transform VolumePanel
399 |             {
400 |                 get
401 |                 {
402 |                     if (_volumePanel == null)
403 |                     {
404 |                         if (SettingsScreen == null)
405 |                             return null;
406 |                         _volumePanel = SettingsScreen.transform.Find("VolumePanel");
407 |                     }
408 |                     return _volumePanel;
409 |                 }
410 |             }
411 |             #endregion
412 | 
413 |             #region VolumePanel Properties
414 |             public static Transform VolumeMaster
415 |             {
416 |                 get
417 |                 {
418 |                     if(_volumeMaster == null)
419 |                     {
420 |                         if (VolumePanel == null)
421 |                             return null;
422 |                         _volumeMaster = VolumePanel.Find("VolumeMaster");
423 |                     }
424 |                     return _volumeMaster;
425 |                 }
426 |             }
427 |             #endregion
428 |         }
429 |         #endregion
430 |     }
431 | }
432 | 


--------------------------------------------------------------------------------
/VRCExtended/ExtendedUser.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Reflection;
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using System.Text;
  6 | 
  7 | using VRC;
  8 | 
  9 | using VRChat;
 10 | 
 11 | using VRCTools;
 12 | 
 13 | using UnityEngine;
 14 | 
 15 | using VRCExtended.GameScripts;
 16 | 
 17 | using VRC_AvatarDescriptor = VRCSDK2.VRC_AvatarDescriptor;
 18 | 
 19 | namespace VRCExtended
 20 | {
 21 |     internal class ExtendedUser : VRCEPlayer
 22 |     {
 23 | #if DEBUG
 24 |         #region Individual Volume Variables
 25 |         private float _volumeAvatar = 1f;
 26 |         private float _volumeVoice = 1f;
 27 |         #endregion
 28 | #endif
 29 | 
 30 |         #region AntiCrash Variables
 31 |         private static Shader _defaultShader;
 32 | 
 33 |         private Dictionary<Material, Shader> _fallbackShaders = new Dictionary<Material, Shader>();
 34 |         private Dictionary<ParticleSystem, int> _fallbackParticleLimits = new Dictionary<ParticleSystem, int>();
 35 |         private int _savedAllParticles = 0;
 36 |         private Dictionary<MeshRenderer, MeshFilter> _fallbackMeshes = new Dictionary<MeshRenderer, MeshFilter>();
 37 |         #endregion
 38 | 
 39 |         #region Local Colliders Variables
 40 |         private static FieldInfo fi_m_Direction = typeof(DynamicBoneCollider).GetField("m_Direction", BindingFlags.Public | BindingFlags.Instance);
 41 |         private bool _hasColliders = true;
 42 |         #endregion
 43 | 
 44 |         #region Local Colliders Properties
 45 |         public List<DynamicBoneCollider> BoneColliders { get; private set; } = new List<DynamicBoneCollider>();
 46 |         public List<DynamicBone> Bones { get; private set; } = new List<DynamicBone>();
 47 |         public LocalCollider Collider { get; private set; }
 48 |         public bool HasColliders
 49 |         {
 50 |             get => _hasColliders;
 51 |             set
 52 |             {
 53 |                 _hasColliders = value;
 54 |                 RemoveLocalColliders();
 55 |                 OnAvatarCreated();
 56 |             }
 57 |         }
 58 |         #endregion
 59 | 
 60 | #if DEBUG
 61 |         #region Individual Volume Properties
 62 |         public float VolumeAvatar
 63 |         {
 64 |             get => _volumeAvatar;
 65 |             set
 66 |             {
 67 |                 float prc = value / 100;
 68 | 
 69 |                 foreach(AudioSource audio in Sounds)
 70 |                     audio.volume -= prc * audio.volume;
 71 |             }
 72 |         }
 73 |         public float VolumeVoice
 74 |         {
 75 |             get => _volumeVoice;
 76 |             set
 77 |             {
 78 |                 AudioSource[] sources = Player.gameObject.GetComponentsInChildren<AudioSource>();
 79 | 
 80 |                 foreach(AudioSource source in sources)
 81 |                 {
 82 |                     if(source.name == "USpeak" || source.name == "Speaker")
 83 |                     {
 84 |                         ExtendedLogger.Log("Found " + source.name + " volume: " + source.volume);
 85 |                         source.volume = value;
 86 |                     }
 87 |                 }
 88 |                 _volumeVoice = value;
 89 |                 /*if (Voice == null)
 90 |                     return;
 91 |                 ExtendedLogger.Log("Test");
 92 |                 Voice.volume = value;
 93 |                 _volumeVoice = value;*/
 94 |             }
 95 |         }
 96 |         #endregion
 97 | #endif
 98 | 
 99 |         public ExtendedUser(VRCEPlayer player) : base(player.Player) => Setup();
100 |         public ExtendedUser(Player player) : base(player) => Setup();
101 |         public ExtendedUser() : base() => Setup();
102 | 
103 |         #region Setup Functions
104 |         private void Setup()
105 |         {
106 |             AvatarManager.OnAvatarCreated += (GameObject avatar, VRC_AvatarDescriptor avatarDescriptor, bool _1) => OnAvatarCreated();
107 | 
108 |             ExtendedUser self = ExtendedServer.Users.FirstOrDefault(a => a.APIUser == APIUser);
109 |             if(self != null)
110 |             {
111 | #if DEBUG
112 |                 _volumeAvatar = self._volumeAvatar;
113 |                 _volumeVoice = self._volumeVoice;
114 | #endif
115 | 
116 |                 _hasColliders = self._hasColliders;
117 |                 BoneColliders = self.BoneColliders;
118 |                 Bones = self.Bones;
119 | 
120 |                 _fallbackShaders = self._fallbackShaders;
121 |                 _fallbackParticleLimits = self._fallbackParticleLimits;
122 |                 _fallbackMeshes = self._fallbackMeshes;
123 |             }
124 |         }
125 |         #endregion
126 | 
127 |         #region Avatar Events
128 |         internal void OnAvatarCreated()
129 |         {
130 |             if (Avatar == null)
131 |                 return;
132 | #if DEBUG
133 |             if (ModPrefs.GetBool("vrcextended", "userSpecificVolume"))
134 |                 VolumeAvatar = _volumeAvatar;
135 | #endif
136 |             if(ModPrefs.GetBool("vrcextended", "localColliders") && HasColliders)
137 |             {
138 |                 foreach (ExtendedUser user in ExtendedServer.Users)
139 |                 {
140 |                     if (user.APIUser.id == APIUser.id)
141 |                         continue;
142 | 
143 |                     if (ModPrefs.GetBool("vrcextended", "multiLocalColliders") || (ModPrefs.GetBool("vrcextended", "selfLocalColliders") && IsSelf) || user.APIUser.id == Instance.APIUser.id)
144 |                         foreach (DynamicBone bone in user.Bones)
145 |                             foreach (DynamicBoneCollider collider in BoneColliders)
146 |                                 if (bone.m_Colliders.Contains(collider))
147 |                                     bone.m_Colliders.Remove(collider);
148 |                 }
149 |                 BoneColliders.Clear();
150 |                 Bones.Clear();
151 | 
152 |                 if ((ModPrefs.GetBool("vrcextended", "fakeColliders") && IsSelf) || ModPrefs.GetBool("vrcextended", "fakeCollidersOthers"))
153 |                 {
154 |                     if (Animator != null)
155 |                     {
156 |                         Transform handbone_left = Animator.GetBoneTransform(HumanBodyBones.LeftHand);
157 |                         Transform handbone_right = Animator.GetBoneTransform(HumanBodyBones.RightHand);
158 | 
159 |                         if (handbone_left != null && handbone_right != null)
160 |                         {
161 |                             if (handbone_left.GetComponent<DynamicBoneCollider>() == null && handbone_right.GetComponent<DynamicBoneCollider>() == null)
162 |                             {
163 |                                 Transform fingerbone_left = Animator.GetBoneTransform(HumanBodyBones.LeftMiddleDistal);
164 |                                 Transform fingerbone_right = Animator.GetBoneTransform(HumanBodyBones.RightMiddleDistal);
165 |                                 Transform thumbbone = Animator.GetBoneTransform(HumanBodyBones.LeftThumbProximal);
166 |                                 Transform pinkybone = Animator.GetBoneTransform(HumanBodyBones.RightRingProximal);
167 |                                 float distance_left = 0.0016f;
168 |                                 float distance_right = 0.0016f;
169 |                                 float distance_hand = 0.0006f;
170 |                                 float power = (float)Math.Pow(10, 2);
171 | 
172 |                                 if (thumbbone != null && pinkybone != null)
173 |                                 {
174 |                                     distance_hand = (Mathf.Floor(Vector3.Distance(thumbbone.position, pinkybone.position) * power) / power) / 1000f;
175 |                                     distance_hand += distance_hand / 4f;
176 |                                 }
177 |                                 if (fingerbone_left != null)
178 |                                     distance_left = ((Mathf.Floor(Vector3.Distance(handbone_left.position, fingerbone_left.position) * power) / power) / 100f) + (distance_hand * 4f);
179 |                                 if (fingerbone_right != null)
180 |                                     distance_right = ((Mathf.Floor(Vector3.Distance(handbone_right.position, fingerbone_right.position) * power) / power) / 100f) + (distance_hand * 4f);
181 |                                 ExtendedLogger.Log("Collider stats: " + distance_left + ", " + distance_right + ", " + distance_hand);
182 |                                 DynamicBoneCollider handcollider_left = handbone_left.gameObject.AddComponent<DynamicBoneCollider>();
183 |                                 DynamicBoneCollider handcollider_right = handbone_right.gameObject.AddComponent<DynamicBoneCollider>();
184 |                                 //GameObject show_left = GameObject.CreatePrimitive(PrimitiveType.Sphere);
185 |                                 //GameObject show_right = GameObject.CreatePrimitive(PrimitiveType.Sphere);
186 | 
187 |                                 handcollider_left.m_Radius = distance_hand; // 0.0006f
188 |                                 handcollider_left.m_Height = distance_left;
189 |                                 handcollider_left.m_Center = new Vector3(0f, 0f, 0f);
190 |                                 fi_m_Direction.SetValue(handcollider_left, 1);
191 |                                 handcollider_left.m_Bound = 0;
192 |                                 /*show_left.transform.localScale = new Vector3(0.006f, 0.006f, 0.0006f);
193 |                                 show_left.transform.position = handbone_left.position;
194 |                                 show_left.transform.SetParent(handbone_left);*/
195 | 
196 | 
197 |                                 handcollider_right.m_Radius = distance_hand; // 0.0006f
198 |                                 handcollider_right.m_Height = distance_right;
199 |                                 handcollider_right.m_Center = new Vector3(0f, 0f, 0f);
200 |                                 fi_m_Direction.SetValue(handcollider_right, 1);
201 |                                 handcollider_right.m_Bound = 0;
202 |                                 /*show_right.transform.localScale = new Vector3(0.006f, 0.006f, 0.0006f);
203 |                                 show_right.transform.position = handbone_right.position;
204 |                                 show_right.transform.SetParent(handbone_right);*/
205 | 
206 |                                 BoneColliders.Add(handcollider_left);
207 |                                 BoneColliders.Add(handcollider_right);
208 |                                 ExtendedLogger.Log("Added fake colliders to " + APIUser.displayName);
209 |                             }
210 |                         }
211 |                     }
212 |                 }
213 | 
214 |                 if (ModPrefs.GetBool("vrcextended", "smartColliders"))
215 |                 {
216 |                     if (Collider != null)
217 |                         GameObject.Destroy(Collider);
218 | 
219 |                     Transform handbone_left = Animator.GetBoneTransform(HumanBodyBones.LeftHand);
220 |                     Transform handbone_right = Animator.GetBoneTransform(HumanBodyBones.RightHand);
221 | 
222 |                     if (handbone_left != null && handbone_right != null && IsSelf)
223 |                     {
224 |                         SphereCollider collider_left = handbone_left.gameObject.GetOrAddComponent<SphereCollider>();
225 |                         SphereCollider collider_right = handbone_right.gameObject.GetOrAddComponent<SphereCollider>();
226 | 
227 |                         collider_left.tag = "handCollider";
228 |                         collider_left.radius = 0.002f;
229 |                         collider_left.enabled = true;
230 |                         collider_left.isTrigger = true;
231 | 
232 |                         collider_right.tag = "handCollider";
233 |                         collider_right.radius = 0.002f;
234 |                         collider_right.enabled = true;
235 |                         collider_right.isTrigger = true;
236 |                     }
237 |                     CapsuleCollider aviCollider = Avatar.GetOrAddComponent<CapsuleCollider>();
238 | 
239 |                     aviCollider.tag = "player";
240 |                     aviCollider.height = Avatar.transform.localScale.y;
241 |                     aviCollider.radius = Avatar.transform.localScale.x;
242 |                     aviCollider.enabled = true;
243 |                     aviCollider.isTrigger = true;
244 | 
245 |                     Collider = Avatar.GetOrAddComponent<LocalCollider>();
246 |                 }
247 |                 else
248 |                 {
249 |                     if (ModPrefs.GetBool("vrcextended", "targetHandColliders") && Animator != null)
250 |                     {
251 |                         Transform handbone_left = Animator.GetBoneTransform(HumanBodyBones.LeftHand);
252 |                         Transform handbone_right = Animator.GetBoneTransform(HumanBodyBones.RightHand);
253 | 
254 |                         if (handbone_left != null && handbone_right != null) // Can't be too sure
255 |                         {
256 |                             BoneColliders.AddRange(handbone_left.GetComponentsInChildren<DynamicBoneCollider>(true).Where(a => !ModPrefs.GetBool("vrcextended", "ignoreInsideColliders") || (int)a.m_Bound != 1));
257 |                             BoneColliders.AddRange(handbone_right.GetComponentsInChildren<DynamicBoneCollider>(true).Where(a => !ModPrefs.GetBool("vrcextended", "ignoreInsideColliders") || (int)a.m_Bound != 1));
258 |                         }
259 |                     }
260 |                     else
261 |                         BoneColliders.AddRange(Avatar.GetComponentsInChildren<DynamicBoneCollider>(true).Where(a => !ModPrefs.GetBool("vrcextended", "ignoreInsideColliders") || (int)a.m_Bound != 1));
262 |                     Bones.AddRange(Avatar.GetComponentsInChildren<DynamicBone>(true).Where(a => a.m_Colliders.Count > 1));
263 | 
264 |                     foreach (ExtendedUser user in ExtendedServer.Users)
265 |                     {
266 |                         if (user.APIUser.id == APIUser.id)
267 |                             continue;
268 | 
269 |                         if (ModPrefs.GetBool("vrcextended", "multiLocalColliders") || (ModPrefs.GetBool("vrcextended", "selfLocalColliders") && IsSelf) || user.APIUser == Instance.APIUser)
270 |                             foreach (DynamicBone bone in Bones)
271 |                                 foreach (DynamicBoneCollider collider in user.BoneColliders)
272 |                                     bone.m_Colliders.Add(collider);
273 |                         if (ModPrefs.GetBool("vrcextended", "multiLocalColliders") || (ModPrefs.GetBool("vrcextended", "selfLocalColliders") && user.APIUser == Instance.APIUser) || IsSelf)
274 |                             foreach (DynamicBone bone in user.Bones)
275 |                                 foreach (DynamicBoneCollider collider in BoneColliders)
276 |                                     bone.m_Colliders.Add(collider);
277 |                     }
278 |                 }
279 |                 ExtendedLogger.Log("Added local colliders to " + APIUser.displayName + "!");
280 |             }
281 |             if(ModPrefs.GetBool("vrcextended", "antiCrasher"))
282 |             {
283 |                 _fallbackShaders.Clear();
284 |                 RemoveCrashShaders();
285 | 
286 |                 _savedAllParticles = 0;
287 |                 _fallbackParticleLimits.Clear();
288 |                 LimitParticles();
289 | 
290 |                 _fallbackMeshes.Clear();
291 |                 RemoveCrashMesh();
292 |             }
293 |         }
294 |         #endregion
295 | 
296 |         #region LocalColliders Functions
297 |         public void RemoveLocalColliders()
298 |         {
299 |             DynamicBoneCollider[] colliders = Avatar.GetComponentsInChildren<DynamicBoneCollider>(true);
300 |             foreach (DynamicBone bone in Bones)
301 |                 foreach(DynamicBoneCollider collider in bone.m_Colliders.ToArray())
302 |                     if (!colliders.Contains(collider))
303 |                         bone.m_Colliders.Remove(collider);
304 |             if (Collider != null)
305 |                 GameObject.Destroy(Collider);
306 |             ExtendedLogger.Log("Removed all local colliders!");
307 |         }
308 |         #endregion
309 | 
310 |         #region AntiCrash Functions
311 |         public void RemoveCrashShaders()
312 |         {
313 |             if (!ModPrefs.GetBool("vrcextended", "antiCrasher"))
314 |                 return;
315 |             if (_defaultShader == null)
316 |                 _defaultShader = Shader.Find("Standard");
317 | 
318 |             // Change cached
319 |             if (_fallbackShaders.Count > 0)
320 |             {
321 |                 foreach(Material material in _fallbackShaders.Keys)
322 |                 {
323 |                     ExtendedLogger.LogWarning("Removed blacklisted shader " + material.shader.name + " from " + APIUser.displayName);
324 |                     material.shader = _defaultShader;
325 |                 }
326 |                 return;
327 |             }
328 | 
329 |             // Change non-cached
330 |             Renderer[] renderers = Avatar.GetComponentsInChildren<Renderer>(true);
331 |             int rLength = renderers.Length;
332 | 
333 |             for(int i = 0; i < rLength; i++)
334 |             {
335 |                 foreach(Material material in renderers[i].materials)
336 |                 {
337 |                     if (material.shader == null)
338 |                         continue;
339 | 
340 |                     if((bool)AntiCrasherConfig.Instance.RemoveUnsupportedShaders) // Maybe Unity will catch it
341 |                     {
342 |                         if(!material.shader.isSupported)
343 |                         {
344 |                             if (!_fallbackShaders.ContainsKey(material))
345 |                                 _fallbackShaders.Add(material, material.shader);
346 | 
347 |                             ExtendedLogger.LogWarning("Removed unsupported shader " + material.shader.name + " from " + APIUser.displayName);
348 |                             material.shader = _defaultShader;
349 |                             continue;
350 |                         }
351 |                     }
352 |                     if (material.shader.name == "Standard") // Stops people from naming their crash shader "Standard"
353 |                     {
354 |                         if (!_fallbackShaders.ContainsKey(material))
355 |                             _fallbackShaders.Add(material, material.shader);
356 | 
357 |                         material.shader = _defaultShader;
358 |                         continue;
359 |                     }
360 |                     foreach(string blacklistedName in AntiCrasherConfig.Instance.BlacklistedShaders)
361 |                     {
362 |                         if(material.shader.name.ToLower().Contains(blacklistedName))
363 |                         {
364 |                             if (!_fallbackShaders.ContainsKey(material))
365 |                                 _fallbackShaders.Add(material, material.shader);
366 | 
367 |                             ExtendedLogger.LogWarning("Removed blacklisted shader " + material.shader.name + " from " + APIUser.displayName);
368 |                             material.shader = _defaultShader;
369 |                             break;
370 |                         }
371 |                     }
372 |                 }
373 |             }
374 |         }
375 |         public void RestoreCrashShaders()
376 |         {
377 |             if (ModPrefs.GetBool("vrcextended", "antiCrasher"))
378 |                 return;
379 |             if (_fallbackShaders.Count < 1)
380 |                 return;
381 | 
382 |             foreach(Material material in _fallbackShaders.Keys)
383 |             {
384 |                 material.shader = _fallbackShaders[material];
385 |                 ExtendedLogger.LogWarning("Restored blacklisted shader " + material.shader.name + " to " + APIUser.displayName);
386 |             }
387 |         }
388 | 
389 |         public void LimitParticles()
390 |         {
391 |             if (!ModPrefs.GetBool("vrcextended", "antiCrasher"))
392 |                 return;
393 | 
394 |             // Change cached
395 |             if(_fallbackParticleLimits.Count > 0)
396 |             {
397 |                 foreach(ParticleSystem particleSystem in _fallbackParticleLimits.Keys)
398 |                 {
399 |                     ParticleSystem.MainModule mainModule = particleSystem.main;
400 |                     float percantage = (float)mainModule.maxParticles / _savedAllParticles;
401 |                     int maxParticles = (int)Math.Floor(percantage * (float)AntiCrasherConfig.Instance.MaxParticles);
402 | 
403 |                     if (mainModule.maxParticles > maxParticles)
404 |                         mainModule.maxParticles = maxParticles;
405 |                 }
406 |             }
407 | 
408 |             // Change non-cached
409 |             ParticleSystem[] particleSystems = Avatar.GetComponentsInChildren<ParticleSystem>(true);
410 | 
411 |             if (particleSystems.Length < 1)
412 |                 return;
413 |             particleSystems.All(a => { _savedAllParticles += a.main.maxParticles; return true; });
414 |             foreach(ParticleSystem particleSystem in particleSystems)
415 |             {
416 |                 ParticleSystem.MainModule mainModule = particleSystem.main;
417 |                 float percantage = (float)mainModule.maxParticles / _savedAllParticles;
418 |                 int maxParticles = (int)Math.Floor(percantage * (float)AntiCrasherConfig.Instance.MaxParticles);
419 | 
420 |                 if (!_fallbackParticleLimits.ContainsKey(particleSystem))
421 |                     _fallbackParticleLimits.Add(particleSystem, mainModule.maxParticles);
422 | 
423 |                 if (mainModule.maxParticles > maxParticles)
424 |                     mainModule.maxParticles = maxParticles;
425 |             }
426 |         }
427 |         public void RestoreParticleLimits()
428 |         {
429 |             if (ModPrefs.GetBool("vrcextended", "antiCrasher"))
430 |                 return;
431 |             if (_fallbackParticleLimits.Count < 1)
432 |                 return;
433 | 
434 |             foreach(ParticleSystem particleSystem in _fallbackParticleLimits.Keys)
435 |             {
436 |                 ParticleSystem.MainModule mainModule = particleSystem.main;
437 | 
438 |                 mainModule.maxParticles = _fallbackParticleLimits[particleSystem];
439 |             }
440 |         }
441 | 
442 |         public void RemoveCrashMesh()
443 |         {
444 |             if (!ModPrefs.GetBool("vrcextended", "antiCrasher"))
445 |                 return;
446 | 
447 |             // Change cached
448 |             if(_fallbackMeshes.Count > 0)
449 |             {
450 |                 foreach(MeshRenderer mesh in _fallbackMeshes.Keys)
451 |                 {
452 |                     mesh.enabled = false;
453 |                     ExtendedLogger.LogWarning("Removed crasher mesh from " + APIUser.displayName);
454 |                 }
455 |                 return;
456 |             }
457 | 
458 |             // Change non-cached
459 |             MeshRenderer[] meshes = Avatar.GetComponentsInChildren<MeshRenderer>();
460 | 
461 |             foreach(MeshRenderer mesh in meshes)
462 |             {
463 |                 MeshFilter filter = mesh.GetComponent<MeshFilter>();
464 | 
465 |                 if (filter == null)
466 |                     continue;
467 |                 List<int> triangles = new List<int>();
468 |                 uint meshCount = 0;
469 | 
470 |                 if(!filter.sharedMesh.isReadable)
471 |                 {
472 |                     if (!_fallbackMeshes.ContainsKey(mesh))
473 |                         _fallbackMeshes.Add(mesh, filter);
474 | 
475 |                     mesh.enabled = false;
476 |                     ExtendedLogger.LogWarning("Removed unreadable mesh from " + APIUser.displayName);
477 |                     continue;
478 |                 }
479 |                 for(int i = 0; i < filter.sharedMesh.subMeshCount; i++)
480 |                 {
481 |                     filter.sharedMesh.GetTriangles(triangles, i);
482 |                     meshCount += (uint)(triangles.Count / 3);
483 |                     triangles.Clear();
484 |                 }
485 | 
486 |                 if(meshCount > AntiCrasherConfig.Instance.MaxPolygons)
487 |                 {
488 |                     if (!_fallbackMeshes.ContainsKey(mesh))
489 |                         _fallbackMeshes.Add(mesh, filter);
490 | 
491 |                     mesh.enabled = false;
492 |                     ExtendedLogger.LogWarning("Removed crasher mesh from " + APIUser.displayName);
493 |                 }
494 |             }
495 |         }
496 |         public void RestoreCrashMesh()
497 |         {
498 |             if (ModPrefs.GetBool("vrcextended", "antiCrasher"))
499 |                 return;
500 |             if (_fallbackMeshes.Count < 1)
501 |                 return;
502 | 
503 |             foreach(MeshRenderer mesh in _fallbackMeshes.Keys)
504 |             {
505 |                 mesh.enabled = true;
506 |                 ExtendedLogger.LogWarning("Restored crasher mesh to " + APIUser.displayName);
507 |             }
508 |         }
509 |         #endregion
510 |     }
511 | }
512 | 


--------------------------------------------------------------------------------
/VRCExtended/VRCExtended.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.IO;
  3 | using System.Diagnostics;
  4 | using System.Collections;
  5 | using System.Collections.Generic;
  6 | using System.Linq;
  7 | using System.Text;
  8 | 
  9 | using Newtonsoft.Json;
 10 | 
 11 | using VRCModLoader;
 12 | using VRCTools;
 13 | using VRChat;
 14 | using VRChat.UI;
 15 | 
 16 | using UnityEngine;
 17 | using UnityEngine.UI;
 18 | using UnityEngine.Networking;
 19 | 
 20 | using VRCExtended.GameScripts;
 21 | using VRCExtended.Patches;
 22 | 
 23 | using VRC.Core;
 24 | using VRC.UI;
 25 | using VRCSDK2;
 26 | 
 27 | using ModPrefs = VRCTools.ModPrefs;
 28 | 
 29 | namespace VRCExtended
 30 | {
 31 |     // Crasher: 150k polygons in a mesh, tons of particles, shader blacklisting
 32 |     // Note to self: Message system is in the game, Notification | Type: message or broadcast
 33 | 
 34 |     [VRCModInfo("VRCExtended", "0.0.4.3", "AtiLion")]
 35 |     internal class VRCExtended : VRCMod
 36 |     {
 37 |         #region VRCExtended Variables
 38 |         private bool _initialized = false;
 39 |         #endregion
 40 | 
 41 |         #region Module Variables
 42 |         private bool p_anticrash;
 43 |         private bool p_localcolliders;
 44 |         private bool p_multilocalcolliders;
 45 |         private bool p_selflocalcolliders;
 46 |         private bool p_targetHandColliders;
 47 |         private bool p_fakeColliders;
 48 |         private bool p_fakeCollidersOthers;
 49 |         private bool p_smartColliders;
 50 |         private bool p_ignoreInsideColliders;
 51 |         private bool p_unlimitedFPS;
 52 |         #endregion
 53 | 
 54 | #if DEBUG
 55 |         #region VRCExtended UI Variables
 56 |         public static VRCEUiVolumeControl volVoice;
 57 |         public static VRCEUiVolumeControl volAvatar;
 58 |         #endregion
 59 | #endif
 60 | 
 61 |         #region VRCExtended Properties
 62 |         public static GameObject ScriptObject { get; private set; }
 63 |         public static int FrameRate { get; private set; } = 90;
 64 |         #endregion
 65 | 
 66 |         #region UserInfo UI
 67 |         public static VRCEUiButton UserInfoMore { get; private set; }
 68 |         public static VRCEUiButton UserInfoRefresh { get; private set; }
 69 |         public static VRCEUiButton UserInfoColliderControl { get; private set; }
 70 |         public static VRCEUiText UserInfoLastLogin { get; private set; }
 71 |         #endregion
 72 | 
 73 |         #region VRCMod Functions
 74 |         void OnApplicationStart()
 75 |         {
 76 |             ExtendedLogger.Log("Loading VRCExtended...");
 77 | 
 78 |             // Setup config
 79 |             ModPrefs.RegisterCategory("vrcextended", "VRCExtended");
 80 | 
 81 |             // VRCExtended
 82 |             ModPrefs.RegisterPrefBool("vrcextended", "useDTFormat", false, "Use American format");
 83 |             ModPrefs.RegisterPrefBool("vrcextended", "fpsManagement", false, "FPS management");
 84 |             ModPrefs.RegisterPrefBool("vrcextended", "unlimitedFPS", false, "Unlimited FPS");
 85 | 
 86 |             // Exploits
 87 |             ModPrefs.RegisterPrefBool("vrcextended", "askUsePortal", true, "Ask to use portal");
 88 |             ModPrefs.RegisterPrefBool("vrcextended", "disablePortal", false, "Disable portals");
 89 |             ModPrefs.RegisterPrefBool("vrcextended", "antiCrasher", false, "Prevent crashers");
 90 | #if DEBUG
 91 |             ModPrefs.RegisterPrefBool("vrcextended", "avatarLimiter", false, "Avatar limiter"); // TODO
 92 | #else
 93 |             ModPrefs.RegisterPrefBool("vrcextended", "avatarLimiter", false, "Avatar limiter", true);
 94 | #endif
 95 | 
 96 |             // Avatar
 97 |             ModPrefs.RegisterPrefBool("vrcextended", "localColliders", false, "Local colliders");
 98 |             ModPrefs.RegisterPrefBool("vrcextended", "multiLocalColliders", false, "Others have local colliders");
 99 |             ModPrefs.RegisterPrefBool("vrcextended", "selfLocalColliders", true, "Others can touch you");
100 |             ModPrefs.RegisterPrefBool("vrcextended", "targetHandColliders", true, "Target only hand colliders");
101 |             ModPrefs.RegisterPrefBool("vrcextended", "fakeColliders", false, "Add fake colliders to self");
102 |             ModPrefs.RegisterPrefBool("vrcextended", "fakeCollidersOthers", false, "Add fake colliders to others");
103 |             ModPrefs.RegisterPrefBool("vrcextended", "ignoreInsideColliders", true, "Ignore pull colliders");
104 | #if DEBUG
105 |             ModPrefs.RegisterPrefBool("vrcextended", "smartColliders", false, "Use smart colliders"); // TODO
106 | #else
107 |             ModPrefs.RegisterPrefBool("vrcextended", "smartColliders", false, "Use smart colliders", true);
108 | #endif
109 | 
110 |             // Players
111 | #if DEBUG
112 |             ModPrefs.RegisterPrefBool("vrcextended", "userSpecificVolume", false, "User specific volumes");
113 | #else
114 |             ModPrefs.RegisterPrefBool("vrcextended", "userSpecificVolume", false, "User specific volumes", true); // Can't get this shit to work
115 | #endif
116 | 
117 |             // Grab the previous data
118 |             p_anticrash = ModPrefs.GetBool("vrcextended", "antiCrasher");
119 |             p_localcolliders = ModPrefs.GetBool("vrcextended", "localColliders");
120 |             p_multilocalcolliders = ModPrefs.GetBool("vrcextended", "multiLocalColliders");
121 |             p_selflocalcolliders = ModPrefs.GetBool("vrcextended", "selfLocalColliders");
122 |             p_targetHandColliders = ModPrefs.GetBool("vrcextended", "targetHandColliders");
123 |             p_fakeColliders = ModPrefs.GetBool("vrcextended", "fakeColliders");
124 |             p_fakeCollidersOthers = ModPrefs.GetBool("vrcextended", "fakeCollidersOthers");
125 |             p_smartColliders = ModPrefs.GetBool("vrcextended", "smartColliders");
126 |             p_ignoreInsideColliders = ModPrefs.GetBool("vrcextended", "ignoreInsideColliders");
127 |             p_unlimitedFPS = ModPrefs.GetBool("vrcextended", "unlimitedFPS");
128 | 
129 |             // Add scripts
130 |             ScriptObject = new GameObject();
131 |             ScriptObject.AddComponent<PauseDetection>();
132 |             GameObject.DontDestroyOnLoad(ScriptObject);
133 | 
134 |             // Get AntiCrasher config
135 |             if (File.Exists("antiCrash.json"))
136 |             {
137 |                 try
138 |                 {
139 |                     if (JsonConvert.DeserializeObject<AntiCrasherConfig>(File.ReadAllText("antiCrash.json")).CheckBackwardsCompatibility())
140 |                     {
141 |                         File.WriteAllText("antiCrash.json", JsonConvert.SerializeObject(AntiCrasherConfig.Instance, Formatting.Indented));
142 |                         ExtendedLogger.Log("Saved AntiCrasher config!");
143 |                     }
144 |                     ExtendedLogger.Log("Loaded AntiCrasher config!");
145 |                 }
146 |                 catch (Exception ex)
147 |                 {
148 |                     ExtendedLogger.LogError("Failed to read/parse AntiCrasher config! Using default values...", ex);
149 | 
150 |                     AntiCrasherConfig.CreateDefault();
151 |                 }
152 |             }
153 |             else
154 |             {
155 |                 AntiCrasherConfig.CreateDefault();
156 |                 ExtendedLogger.Log("Loaded default AntiCrasher config!");
157 |             }
158 |             if (ModManager.Mods.Any(a => a.Name == "QuitFix" && a.Author == "Herp Derpinstine") && !File.Exists("antiCrash.json"))
159 |             {
160 |                 File.WriteAllText("antiCrash.json", JsonConvert.SerializeObject(AntiCrasherConfig.Instance, Formatting.Indented));
161 |                 ExtendedLogger.Log("Saved AntiCrasher config!");
162 |             }
163 | 
164 |             // Get VolumeControl config
165 |             VolumeControl.Setup();
166 | 
167 |             // Run patches
168 |             Patch_PortalInternal.Setup();
169 |             Patch_PageUserInfo.Setup();
170 | 
171 |             // Run coroutines
172 |             ModManager.StartCoroutine(WaitForUIManager());
173 |             if (ModPrefs.GetBool("vrcextended", "antiCrasher") && AntiCrasherConfig.Instance.UseOnlineBlacklist == true)
174 |                 ModManager.StartCoroutine(LoadShaderBlacklist());
175 | 
176 |             ExtendedLogger.Log("Loaded VRCExtended!");
177 |         }
178 | 
179 |         void OnLateUpdate()
180 |         {
181 |             if(p_anticrash != ModPrefs.GetBool("vrcextended", "antiCrasher"))
182 |             {
183 |                 if(ModPrefs.GetBool("vrcextended", "antiCrasher"))
184 |                 {
185 |                     foreach(ExtendedUser user in ExtendedServer.Users)
186 |                     {
187 |                         if (user == null || user.Avatar == null)
188 |                             continue;
189 | 
190 |                         try
191 |                         {
192 |                             user.RemoveCrashShaders();
193 |                             user.LimitParticles();
194 |                             user.RemoveCrashMesh();
195 |                         }
196 |                         catch (Exception ex)
197 |                         {
198 |                             ExtendedLogger.LogError("Error enabeling anti-crasher for user " + user.APIUser.displayName, ex);
199 |                         }
200 |                         
201 |                     }
202 |                     ExtendedLogger.Log("Enabled anti crasher!");
203 |                 }
204 |                 else
205 |                 {
206 |                     foreach (ExtendedUser user in ExtendedServer.Users)
207 |                     {
208 |                         if (user == null || user.Avatar == null || user.APIUser == null)
209 |                             continue;
210 | 
211 |                         try
212 |                         {
213 |                             user.RestoreCrashShaders();
214 |                             user.RestoreParticleLimits();
215 |                             user.RestoreCrashMesh();
216 |                         }
217 |                         catch (Exception ex)
218 |                         {
219 |                             ExtendedLogger.LogError("Error disabling anti-crasher for user " + user.APIUser.displayName, ex);
220 |                         }
221 |                     }
222 |                     ExtendedLogger.Log("Disabled anti crasher!");
223 |                 }
224 | 
225 |                 p_anticrash = ModPrefs.GetBool("vrcextended", "antiCrasher");
226 |             }
227 |             else if(p_localcolliders != ModPrefs.GetBool("vrcextended", "localColliders") ||
228 |                     p_multilocalcolliders != ModPrefs.GetBool("vrcextended", "multiLocalColliders") ||
229 |                     p_selflocalcolliders != ModPrefs.GetBool("vrcextended", "selfLocalColliders") ||
230 |                     p_fakeColliders != ModPrefs.GetBool("vrcextended", "fakeColliders") ||
231 |                     p_fakeCollidersOthers != ModPrefs.GetBool("vrcextended", "fakeCollidersOthers") ||
232 |                     p_smartColliders != ModPrefs.GetBool("vrcextended", "smartColliders") ||
233 |                     p_targetHandColliders != ModPrefs.GetBool("vrcextended", "targetHandColliders") ||
234 |                     p_ignoreInsideColliders != ModPrefs.GetBool("vrcextended", "ignoreInsideColliders"))
235 |             {
236 |                 // Clear colliders
237 |                 foreach (ExtendedUser user in ExtendedServer.Users)
238 |                     if (user != null && user.Avatar != null)
239 |                         user.RemoveLocalColliders();
240 |                 // Add them back settings based
241 |                 foreach (ExtendedUser user in ExtendedServer.Users)
242 |                     if (user != null && user.Avatar != null)
243 |                         user.OnAvatarCreated();
244 | 
245 |                 p_localcolliders = ModPrefs.GetBool("vrcextended", "localColliders");
246 |                 p_multilocalcolliders = ModPrefs.GetBool("vrcextended", "multiLocalColliders");
247 |                 p_selflocalcolliders = ModPrefs.GetBool("vrcextended", "selfLocalColliders");
248 |                 p_fakeColliders = ModPrefs.GetBool("vrcextended", "fakeColliders");
249 |                 p_fakeCollidersOthers = ModPrefs.GetBool("vrcextended", "fakeCollidersOthers");
250 |                 p_smartColliders = ModPrefs.GetBool("vrcextended", "smartColliders");
251 |                 p_targetHandColliders = ModPrefs.GetBool("vrcextended", "targetHandColliders");
252 |                 p_ignoreInsideColliders = ModPrefs.GetBool("vrcextended", "ignoreInsideColliders");
253 |                 ExtendedLogger.Log("Reloaded local colliders!");
254 |             }
255 |             else if(p_unlimitedFPS != ModPrefs.GetBool("vrcextended", "unlimitedFPS"))
256 |             {
257 |                 if (ModPrefs.GetBool("vrcextended", "unlimitedFPS"))
258 |                     Application.targetFrameRate = 0;
259 |                 else
260 |                     Application.targetFrameRate = FrameRate;
261 |                 p_unlimitedFPS = ModPrefs.GetBool("vrcextended", "unlimitedFPS");
262 |             }
263 |         }
264 | 
265 |         void OnLevelWasLoaded(int level) // Level 0 = Loading Screen, Level 1 = Login Screen, Level -1 = Game
266 |         {
267 |             if (level == 0)
268 |                 return;
269 | 
270 |             if(level == 1 && !_initialized)
271 |             {
272 |                 // Setup FPS manager
273 |                 FrameRate = Application.targetFrameRate;
274 |                 ExtendedLogger.Log("Captured default FPS: " + FrameRate);
275 |                 if (ModPrefs.GetBool("vrcextended", "unlimitedFPS"))
276 |                     Application.targetFrameRate = 0;
277 | 
278 |                 // Setup systems
279 |                 VRCPlayerManager.Setup();
280 |                 VRCEPlayer.Setup();
281 | 
282 |                 VRCPlayerManager.OnPlayerJoined += delegate (VRCEPlayer player)
283 |                 {
284 |                     ExtendedServer.Users.Add(new ExtendedUser(player));
285 |                     ExtendedLogger.Log("Player joined: " + player.APIUser.displayName);
286 |                 };
287 |                 VRCPlayerManager.OnPlayerLeft += delegate (VRCEPlayer player)
288 |                 {
289 |                     ExtendedServer.Users.Remove(new ExtendedUser(player));
290 |                     ExtendedLogger.Log("Player left: " + player.APIUser.displayName);
291 |                 };
292 | 
293 |                 _initialized = true;
294 |                 return;
295 |             }
296 |             ExtendedServer.Users.Clear();
297 |         }
298 | 
299 |         void OnApplicationQuit()
300 |         {
301 |             if (ModManager.Mods.Count(a => a.Name == "QuitFix" && a.Author == "Herp Derpinstine") > 1)
302 |                 return;
303 |             if (!File.Exists("antiCrash.json"))
304 |             {
305 |                 File.WriteAllText("antiCrash.json", JsonConvert.SerializeObject(AntiCrasherConfig.Instance, Formatting.Indented));
306 |                 ExtendedLogger.Log("Saved AntiCrasher config!");
307 |             }
308 |         }
309 | #endregion
310 | 
311 | #region Coroutine Functions
312 |         private IEnumerator LoadShaderBlacklist()
313 |         {
314 |             using(UnityWebRequest request = UnityWebRequest.Get("https://raw.githubusercontent.com/AtiLion/VRCExtended/master/ShaderBlacklist.txt"))
315 |             {
316 |                 yield return request.SendWebRequest();
317 | 
318 |                 if(!request.isNetworkError)
319 |                 {
320 |                     List<string> blockedShaders = new List<string>();
321 | 
322 |                     blockedShaders.AddRange(AntiCrasherConfig.Instance.BlacklistedShaders);
323 |                     foreach(string shader in request.downloadHandler.text.Split('\n'))
324 |                         if (!string.IsNullOrEmpty(shader) && !blockedShaders.Contains(shader))
325 |                             blockedShaders.Add(shader);
326 |                     AntiCrasherConfig.Instance.BlacklistedShaders = blockedShaders.ToArray();
327 |                     ExtendedLogger.Log("Downloaded shader blacklist!");
328 |                 }
329 |                 else
330 |                     ExtendedLogger.LogError("Failed to get shader blacklist! " + request.error);
331 |             }
332 |         }
333 |         private IEnumerator WaitForUIManager()
334 |         {
335 |             yield return VRCUiManagerUtils.WaitForUiManagerInit();
336 | 
337 |             // Load modules
338 | #if DEBUG
339 |             AddUserSpecificVolume();
340 | #endif
341 |             AddUserInfoButtons();
342 |             AddSocialRefresh();
343 | 
344 |             // Debug
345 |             /*Transform target = VRCEUi.InternalUserInfoScreen.UserPanel;
346 |             ExtendedLogger.Log("Transform: " + target.name);
347 |             foreach (Component component in target.GetComponents<Component>())
348 |                 ExtendedLogger.Log(" - " + component);
349 |             for (int i = 0; i < target.childCount; i++)
350 |             {
351 |                 ExtendedLogger.Log("Transform: " + target.GetChild(i).name);
352 |                 foreach (Component component in target.GetChild(i).GetComponents<Component>())
353 |                     ExtendedLogger.Log(" - " + component);
354 |             }*/
355 |         }
356 |         #endregion
357 | 
358 |         #region Module Functions
359 |         public static void ToggleUserInfoMore(bool enabled)
360 |         {
361 |             Transform btnPlaylists = VRCEUi.InternalUserInfoScreen.PlaylistsButton;
362 |             Transform btnFavorite = VRCEUi.InternalUserInfoScreen.FavoriteButton;
363 |             Transform btnReport = VRCEUi.InternalUserInfoScreen.ReportButton;
364 |             if (btnPlaylists == null || btnFavorite == null || btnReport == null)
365 |             {
366 |                 ExtendedLogger.LogError("Failed to get required button!");
367 |                 return;
368 |             }
369 | 
370 |             if (enabled)
371 |             {
372 |                 UserInfoRefresh.Control.gameObject.SetActive(true);
373 |                 UserInfoColliderControl.Control.gameObject.SetActive(true);
374 | 
375 |                 btnPlaylists.gameObject.SetActive(false);
376 |                 btnFavorite.gameObject.SetActive(false);
377 |                 btnReport.gameObject.SetActive(false);
378 |                 UserInfoMore.Text.text = "Less";
379 |             }
380 |             else
381 |             {
382 |                 UserInfoRefresh.Control.gameObject.SetActive(false);
383 |                 UserInfoColliderControl.Control.gameObject.SetActive(false);
384 | 
385 |                 btnPlaylists.gameObject.SetActive(true);
386 |                 btnFavorite.gameObject.SetActive(true);
387 |                 btnReport.gameObject.SetActive(true);
388 |                 UserInfoMore.Text.text = "More";
389 |             }
390 |         }
391 |         #endregion
392 | 
393 |         #region Module Loading
394 | #if DEBUG
395 |         private void AddUserSpecificVolume()
396 |         {
397 |             if (!ModPrefs.GetBool("vrcextended", "userSpecificVolume"))
398 |                 return;
399 |             if (VRCEUi.UserInfoScreen == null)
400 |             {
401 |                 ExtendedLogger.LogError("Failed to find UserInfo screen!");
402 |                 return;
403 |             }
404 | 
405 |             // -550 - 250f, 230f - 280f
406 |             volVoice = new VRCEUiVolumeControl("volumeVoice", new Vector2(-620f, -230f), "Voice", 1f, VRCEUi.UserInfoScreen.transform);
407 |             volAvatar = new VRCEUiVolumeControl("volumeAvatar", new Vector2(-290f, -230f), "Avatar", 1f, VRCEUi.UserInfoScreen.transform);
408 |             if (!volVoice.Success || !volAvatar.Success)
409 |             {
410 |                 ExtendedLogger.LogError("Failed to create volume sliders on UserInfo!");
411 |                 return;
412 |             }
413 | 
414 |             // Setup volume events
415 |             volVoice.Slider.onValueChanged.AddListener(delegate (float volume)
416 |             {
417 |                 if (Patch_PageUserInfo.SelectedAPI == null)
418 |                     return;
419 |                 ExtendedUser user = ExtendedServer.Users.FirstOrDefault(a => a.APIUser.id == Patch_PageUserInfo.SelectedAPI.id);
420 | 
421 |                 if (user == null)
422 |                     return;
423 |                 user.VolumeVoice = volume;
424 |             });
425 |             /*volAvatar.Slider.onValueChanged.AddListener(delegate (float volume)
426 |             {
427 |                 if (Patch_PageUserInfo.SelectedUser == null)
428 |                     return;
429 |                 Patch_PageUserInfo.SelectedUser.VolumeAvatar = volume;
430 |             });*/
431 |         }
432 | #endif
433 |         private void AddUserInfoButtons()
434 |         {
435 |             if (VRCEUi.UserInfoScreen == null)
436 |             {
437 |                 ExtendedLogger.LogError("Failed to find UserInfo screen!");
438 |                 return;
439 |             }
440 | 
441 |             Transform btnPlaylists = VRCEUi.InternalUserInfoScreen.PlaylistsButton;
442 |             Transform btnFavorite = VRCEUi.InternalUserInfoScreen.FavoriteButton;
443 |             Transform btnReport = VRCEUi.InternalUserInfoScreen.ReportButton;
444 |             if (btnPlaylists == null || btnFavorite == null || btnReport == null)
445 |             {
446 |                 ExtendedLogger.LogError("Failed to get required button!");
447 |                 return;
448 |             }
449 |             Vector3 pos = btnPlaylists.GetComponent<RectTransform>().localPosition;
450 | 
451 |             UserInfoLastLogin = new VRCEUiText("LastLoginText", new Vector2(-470f, -130f), "", VRCEUi.UserInfoScreen.transform);
452 |             UserInfoLastLogin.Text.fontSize -= 20;
453 | 
454 |             UserInfoMore = new VRCEUiButton("More", new Vector2(pos.x, pos.y + 75f), "More", VRCEUi.InternalUserInfoScreen.UserPanel);
455 |             UserInfoMore.Button.onClick.AddListener(() =>
456 |             {
457 |                 if (Patch_PageUserInfo.SelectedAPI == null)
458 |                     return;
459 |                 ToggleUserInfoMore(UserInfoMore.Text.text == "More");
460 |             });
461 | 
462 |             UserInfoColliderControl = new VRCEUiButton("ColliderControl", new Vector2(pos.x, pos.y - 75f), "Not in world!", VRCEUi.InternalUserInfoScreen.UserPanel);
463 |             UserInfoColliderControl.Control.gameObject.SetActive(false);
464 |             UserInfoColliderControl.Button.onClick.AddListener(() =>
465 |             {
466 |                 if (Patch_PageUserInfo.SelectedAPI == null)
467 |                     return;
468 |                 ExtendedUser user = ExtendedServer.Users.FirstOrDefault(a => a.APIUser.id == Patch_PageUserInfo.SelectedAPI.id);
469 | 
470 |                 if (user == null)
471 |                     return;
472 |                 user.HasColliders = !user.HasColliders;
473 |                 UserInfoColliderControl.Text.text = (user.HasColliders ? "Disable colliders" : "Enable colliders");
474 |             });
475 | 
476 |             UserInfoRefresh = new VRCEUiButton("Refresh", new Vector2(pos.x, pos.y), "Refresh", VRCEUi.InternalUserInfoScreen.UserPanel);
477 |             UserInfoRefresh.Control.gameObject.SetActive(false);
478 |             UserInfoRefresh.Button.onClick.AddListener(() =>
479 |             {
480 |                 if (Patch_PageUserInfo.SelectedAPI == null)
481 |                     return;
482 | 
483 |                 ApiCache.Invalidate<APIUser>(Patch_PageUserInfo.SelectedAPI.id);
484 |                 APIUser.FetchUser(Patch_PageUserInfo.SelectedAPI.id, (APIUser user) =>
485 |                 {
486 |                     PageUserInfo pageUserInfo = VRCEUi.UserInfoScreen.GetComponent<PageUserInfo>();
487 |                     if (pageUserInfo != null)
488 |                         pageUserInfo.SetupUserInfo(user);
489 |                 },
490 |                 (string error) =>
491 |                 {
492 |                     ExtendedLogger.LogError(error);
493 |                 });
494 |             });
495 |             ExtendedLogger.Log("Setup PageUserInfo!");
496 |         }
497 |         private void AddSocialRefresh()
498 |         {
499 |             if (VRCEUi.SocialScreen == null)
500 |                 return;
501 |             Transform currentStatus = VRCEUi.SocialScreen.transform.Find("Current Status");
502 |             Transform btnStatus = currentStatus.Find("StatusButton");
503 |             RectTransform rt_btnStatus = btnStatus.GetComponent<RectTransform>();
504 |             Transform icnStatus = currentStatus.Find("StatusIcon");
505 |             RectTransform rt_icnStatus = icnStatus.GetComponent<RectTransform>();
506 |             Transform txtStatus = currentStatus.Find("StatusText");
507 |             RectTransform rt_txtStatus = txtStatus.GetComponent<RectTransform>();
508 | 
509 |             VRCEUiButton btnRefresh = new VRCEUiButton("Refresh", new Vector2(rt_btnStatus.localPosition.x - 20f, rt_btnStatus.localPosition.y), "Refresh", currentStatus);
510 |             RectTransform rt_btnRefresh = btnRefresh.Control.GetComponent<RectTransform>();
511 | 
512 |             rt_btnStatus.localPosition += new Vector3(210f, 0f, 0f);
513 |             rt_icnStatus.localPosition += new Vector3(210f, 0f, 0f);
514 |             rt_txtStatus.localPosition += new Vector3(210f, 0f, 0f);
515 |             rt_btnRefresh.sizeDelta -= new Vector2(5f, 10f);
516 | 
517 |             btnRefresh.Button.onClick.AddListener(() =>
518 |             {
519 |                 UiUserList[] userLists = VRCEUi.SocialScreen.GetComponentsInChildren<UiUserList>(true);
520 | 
521 |                 foreach(UiUserList userList in userLists)
522 |                 {
523 |                     userList.ClearAll();
524 |                     userList.Refresh();
525 |                     userList.FetchAndRenderElementsForCurrentPage();
526 |                     userList.RefreshData();
527 |                 }
528 |                 ExtendedLogger.Log("Refreshed social lists!");
529 |             });
530 |         }
531 | #endregion
532 |     }
533 | }
534 | 


--------------------------------------------------------------------------------