Merge branch 'master' of https://github.com/knah/VRCMods

Author: xAstroBoy

AdvancedSafety/AdvancedSafety.csproj

@@ -5,7 +5,7 @@
         <VrcReferences>true</VrcReferences>
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
         <LangVersion>latest</LangVersion>
-        <Version>1.6.0.0</Version>
+        <Version>1.6.1.0</Version>
         <UsesNativePatches>true</UsesNativePatches>
     </PropertyGroup>
 

AdvancedSafety/AdvancedSafetyMod.cs

@@ -19,7 +19,7 @@
 using Object = UnityEngine.Object;
 
 [assembly:MelonGame("VRChat", "VRChat")]
-[assembly:MelonInfo(typeof(AdvancedSafetyMod), "Advanced Safety", "1.6.0", "knah, Requi, Ben", "https://github.com/xAstroBoy/VRCMods-Unchained")]
+[assembly:MelonInfo(typeof(AdvancedSafetyMod), "Advanced Safety", "1.6.1", "knah, Requi, Ben", "https://github.com/knah/VRCMods")]
 [assembly:MelonOptionalDependencies("UIExpansionKit")]
 
 namespace AdvancedSafety
@@ -32,32 +32,9 @@ internal partial class AdvancedSafetyMod : MelonMod
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         private delegate void VoidDelegate(IntPtr thisPtr, IntPtr nativeMethodInfo);
 
-        private static readonly Func<VRCUiManager> ourGetUiManager;
-
-        static AdvancedSafetyMod()
-        {
-            ourGetUiManager = (Func<VRCUiManager>)Delegate.CreateDelegate(typeof(Func<VRCUiManager>), typeof(VRCUiManager)
-                .GetProperties(BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly)
-                .First(it => it.PropertyType == typeof(VRCUiManager)).GetMethod);
-        }
-
-        internal static VRCUiManager GetUiManager() => ourGetUiManager();
-
-        private static void DoAfterUiManagerInit(Action code)
-        {
-            MelonCoroutines.Start(OnUiManagerInitCoro(code));
-        }
-
-        private static IEnumerator OnUiManagerInitCoro(Action code)
-        {
-            while (GetUiManager() == null)
-                yield return null;
-            code();
-        }
-
-
         public override void OnApplicationStart()
         {
+            if (!CheckWasSuccessful || !MustStayTrue || MustStayFalse) return;
 
             AdvancedSafetySettings.RegisterSettings();
             ClassInjector.RegisterTypeInIl2Cpp<SortingOrderHammerer>();
@@ -144,6 +121,7 @@ void TaskMoveNextPatch(IntPtr taskPtr, IntPtr nativeMethodInfo)
 
             PortalHiding.OnApplicationStart();
             AvatarHiding.OnApplicationStart(HarmonyInstance);
+            FinalIkPatches.ApplyPatches(HarmonyInstance);
 
             if(MelonHandler.Mods.Any(it => it.Info.Name == "UI Expansion Kit"))
             {

AdvancedSafety/BundleVerifier/BundleDlContext.cs

@@ -100,7 +100,7 @@ internal void CompleteDownload()
             if (exitCode != 0)
             {
                 var cleanedUrl = BundleVerifierMod.SanitizeUrl(Url);
-                MelonLogger.Msg($"Verifier process failed with exit code {exitCode} for bundle uid={cleanedUrl.Item1}+{cleanedUrl.Item2}");
+                MelonLogger.Msg($"Verifier process failed with exit code {exitCode} ({VerifierExitCodes.GetExitCodeDescription(exitCode)}) for bundle uid={cleanedUrl.Item1}+{cleanedUrl.Item2}");
                 BundleVerifierMod.BadBundleCache.Add(Url);
                 MelonDebug.Msg("Reporting completion without data");
                 // feed some garbage into it, otherwise it dies

AdvancedSafety/BundleVerifier/BundleVerifier.zip

@@ -93,7 +93,7 @@ private static IEnumerator CheckInstanceType()
             MelonDebug.Msg($"Got instance, intercept state: {BundleDlInterceptor.ShouldIntercept}");
         }
 
-        private const string VerifierVersion = "1.1-2019.4.31";
+        private const string VerifierVersion = "1.2-2019.4.31";
         internal const string SettingsCategory = "ASBundleVerifier";
 
         private static void PrepareVerifierDir()
@@ -108,6 +108,8 @@ private static void PrepareVerifierDir()
                 if (existingVersion == VerifierVersion) return;
             }
 
+            BadBundleCache.Clear();
+            
             File.Copy(Path.Combine(MelonUtils.GameDirectory, "UnityPlayer.dll"), Path.Combine(baseDir, "UnityPlayer.dll"), true);
             using var zipFile = new ZipArchive(Assembly.GetExecutingAssembly().GetManifestResourceStream("AdvancedSafety.BundleVerifier.BundleVerifier.zip")!, ZipArchiveMode.Read, false);
             foreach (var zipArchiveEntry in zipFile.Entries)

AdvancedSafety/BundleVerifier/BundleVerifierMod.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+
+namespace AdvancedSafety.BundleVerifier
+{
+    public static class VerifierExitCodes
+    {
+        private static readonly Dictionary<int, string> ourCodeDescriptions = new()
+        {
+            { 179, "Generic exception (report a bug!)" },
+            { 180, "CLI argument parse error (report a bug!)" },
+            { 181, "VRChat process suddenly died" },
+            { 182, "Loaded bundle was null" },
+            { 183, "Loaded bundle did not contain a prefab" },
+            { 184, "Prefab instantiation failed" },
+            { 185, "Minimum framerate not achieved" },
+            { 186, "Over component limit" },
+            { -1073741819, "Generic crash (corrupted bundle)" }, // 0xc0000005
+            { -2147483645, "Breakpoint crash (corrupted bundle)" }, // 0x80000003
+        };
+
+        internal static string GetExitCodeDescription(int? exitCode)
+        {
+            if (!exitCode.HasValue) return "Timed out";
+
+            return ourCodeDescriptions.TryGetValue(exitCode.Value, out var result) ? result : "Unknown";
+        }
+    }
+}

AdvancedSafety/BundleVerifier/VerifierExitCodes.cs

@@ -0,0 +1,58 @@
+using System.Linq;
+using HarmonyLib;
+using RootMotion.FinalIK;
+using UnityEngine;
+
+namespace AdvancedSafety
+{
+    /**
+     * Source: FinalIkSanity (https://github.com/FenrixTheFox/FinalIKSanity, GPLv3) and Requi (contributed personally by him)
+     */
+    public static class FinalIkPatches
+    {
+        public static void ApplyPatches(HarmonyLib.Harmony harmony)
+        {
+            harmony.Patch(typeof(IKSolverHeuristic).GetMethods().First(m => m.Name.Equals("IsValid") && m.GetParameters().Length == 1),
+                new HarmonyMethod(typeof(FinalIkPatches), nameof(IkSolverIsValid)));
+
+            harmony.Patch(typeof(IKSolverAim).GetMethod(nameof(IKSolverAim.GetClampedIKPosition)),
+                new HarmonyMethod(typeof(FinalIkPatches), nameof(IkSolverAimGetClampedIKPosition)));
+
+            harmony.Patch(typeof(IKSolverFullBody).GetMethod(nameof(IKSolverFullBody.Solve)),
+                new HarmonyMethod(typeof(FinalIkPatches), nameof(IKSolverFullBodySolve)));
+            
+            harmony.Patch(typeof(IKSolverFABRIKRoot).GetMethod(nameof(IKSolverFABRIKRoot.OnUpdate)),
+                new HarmonyMethod(typeof(FinalIkPatches), nameof(IKSolverFABRIKRootOnUpdate)));
+        }
+
+        private static void IkSolverAimGetClampedIKPosition(ref IKSolverAim __instance)
+        {
+            if (__instance == null) return;
+            __instance.clampSmoothing = Mathf.Clamp(__instance.clampSmoothing, 0, 2);
+        }
+
+        private static bool IkSolverIsValid(ref IKSolverHeuristic __instance, ref bool __result, ref string message)
+        {
+            if (__instance == null) return true;
+            if (__instance.maxIterations <= 64) return true;
+
+            __result = false;
+            message = "The solver requested too many iterations.";
+
+            return false;
+        }
+
+        private static void IKSolverFullBodySolve(ref IKSolverFullBody __instance)
+        {
+            if (__instance == null) return;
+            __instance.iterations = Mathf.Clamp(__instance.iterations, 0, 10);
+        }
+
+        private static bool IKSolverFABRIKRootOnUpdate(ref IKSolverFABRIKRoot __instance)
+        {
+            if (__instance == null)
+                return true;
+            return __instance.iterations <= 10;
+        }
+    }
+}

AdvancedSafety/FinalIkPatches.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace AdvancedSafety
+{
+    // These are copypasted from Unhollower. TODO: use actual structs from unhollower once/if they become public
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct Il2CppFieldInfo_24_1
+    {
+        public IntPtr name; // const char*
+        public IntPtr typePtr; // const
+        public IntPtr parentClassPtr; // non-const?
+        public int offset; // If offset is -1, then it's thread static
+        public uint token;
+    }
+}

AdvancedSafety/NativeStructs.cs

@@ -6,6 +6,7 @@
 using System.Security.Cryptography;
 using System.Threading;
 using MelonLoader;
+using UnhollowerBaseLib;
 
 namespace AdvancedSafety
 {
@@ -27,12 +28,13 @@ public class ReaderPatches
 
         private static readonly string[] ourAllowedFields = { "m_BreakForce", "m_BreakTorque", "collisionSphereDistance", "maxDistance", "inSlope", "outSlope" };
 
-        private static readonly Dictionary<string, (int ProduceMixer, int TransferFloat, int CountNodes, int DebugAssert, int ReaderOOB, int ReallocateString)> ourOffsets = new() {
-            { "aCEmIwSIcjYriBQDFjQlpTNNW1/kA8Wlbkqelmt1USOMB09cnKwK7QWyOulz9d7DEYJh4+vO0Ldv8gdH+dZCrg==", (0x4997C0, 0xD7320, 0, 0, 0, 0) }, // U2018.4.20 non-dev
-            { "5dkhl/dWeTREXhHCIkZK17mzZkbjhTKlxb+IUSk+YaWzZrrV+G+M0ekTOEGjZ4dJuB4O3nU/oE3dycXWeJq9uA==", (0xA80660, 0xC7B40, 0, 0, 0, 0) }, // U2019.4.28 non-dev
-            { "MV6xP7theydao4ENbGi6BbiBxdZsgGOBo/WrPSeIqh6A/E00NImjUNZn+gL+ZxzpVbJms7nUb6zluLL3+aIcfg==", (0xA82350, 0xC7E50, 0, 0, 0, 0) }, // U2019.4.29 non-dev
-            { "ccZ4F7iE7a78kWdXdMekJzP7/ktzS5jOOS8IOITxa1C5Jg2TKxC0/ywY8F0o9I1vZHsxAO4eh7G2sOGzsR/+uQ==", (0xA83410, 0xC7E80, 0, 0, 0, 0) }, // U2019.4.30 non-dev
-            { "sgZUlX3+LSHKnTiTC+nXNcdtLOTrAB1fNjBLOwDdKzCyndlFLAdL0udR4S1szTC/q5pnFhG3Kdspsj5jvwLY1A==", (0xA86270, 0xC8230, 0xDF29F0, 0xDDBDC0, 0x7B9EB0, 0xC69F0) }, // U2019.4.31 non-dev
+        private static readonly Dictionary<string, (int ProduceMixer, int TransferFloat, int CountNodes, int DebugAssert, 
+            int ReaderOOB, int ReallocateString, int TransferMonoObject, int TransferUEObjectSBR)> ourOffsets = new()
+            {
+                {
+                    "sgZUlX3+LSHKnTiTC+nXNcdtLOTrAB1fNjBLOwDdKzCyndlFLAdL0udR4S1szTC/q5pnFhG3Kdspsj5jvwLY1A==",
+                    (0xA86270, 0xC8230, 0xDF29F0, 0xDDBDC0, 0x7B9EB0, 0xC69F0, 0x8D1160, 0x8E5CD0)
+                }, // U2019.4.31 non-dev
         };
 
         internal static void ApplyPatches()
@@ -73,6 +75,12 @@ internal static void ApplyPatches()
 
                     // core::StringStorageDefault<char>::reallocate, identified to be an issue by Requi&Ben
                     DoPatch(module, offsets.ReallocateString, ReallocateStringPatch, out ourOriginalRealloc);
+                    
+                    // TransferPPtrToMonoObject
+                    DoPatch(module, offsets.TransferMonoObject, TransferMonoObjectPatch, out ourOriginalTransferMonoObject);
+                    
+                    // TransferField_NonArray<SafeBinaryRead,Converter_UnityEngineObject>
+                    DoPatch(module, offsets.TransferUEObjectSBR, TransferUeObjectSbrPatch, out ourOriginalTransferUeObjectSbr);
                 }
 
                 break;
@@ -149,6 +157,63 @@ private static void ReaderOobPatch(IntPtr thisPtr, long a, long b)
             }
         }
 
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void TransferObjectSbrDelegate(IntPtr staticInfo, IntPtr runtimeInfo, IntPtr converter);
+
+        [ThreadStatic] private static Stack<IntPtr> ourCurrentSafeTransferStack;
+        private static TransferObjectSbrDelegate ourOriginalTransferUeObjectSbr;
+
+        private static void TransferUeObjectSbrPatch(IntPtr staticInfo, IntPtr runtimeInfo, IntPtr converter)
+        {
+            ourCurrentSafeTransferStack ??= new Stack<IntPtr>();
+            ourCurrentSafeTransferStack.Push(staticInfo);
+            try
+            {
+                ourOriginalTransferUeObjectSbr(staticInfo, runtimeInfo, converter);
+            }
+            finally
+            {
+                ourCurrentSafeTransferStack.Pop();
+            }
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr TransferMonoObjectDelegate(ref IntPtr hiddenThisReturn, IntPtr instanceId,
+            IntPtr il2cppClass, IntPtr dataToCreateNull, IntPtr transferFlags);
+
+        private static TransferMonoObjectDelegate ourOriginalTransferMonoObject;
+
+        private static unsafe IntPtr TransferMonoObjectPatch(ref IntPtr hiddenThisReturn, IntPtr instanceId,
+            IntPtr il2cppClass, IntPtr dataToCreateNull, IntPtr transferFlags)
+        {
+            var result = ourOriginalTransferMonoObject(ref hiddenThisReturn, instanceId, il2cppClass, dataToCreateNull, transferFlags);
+
+            if (hiddenThisReturn == IntPtr.Zero || ourCurrentSafeTransferStack == null || ourCurrentSafeTransferStack.Count == 0) return result;
+
+            var objectType = *(IntPtr*)hiddenThisReturn;
+
+            var topStaticInfo = (StaticTransferInfoPrefix*)ourCurrentSafeTransferStack.Peek();
+            var staticFieldInfoPtr = topStaticInfo->field;
+
+            var fieldType = IL2CPP.il2cpp_class_from_type(staticFieldInfoPtr->typePtr);
+            if (IL2CPP.il2cpp_class_is_assignable_from(fieldType, objectType)) return result;
+            
+            var fieldName = Marshal.PtrToStringAnsi(staticFieldInfoPtr->name);
+            
+            MelonDebug.Msg($"While deserializing field of type {RenderTypeName(fieldType)} named {fieldName} we got an object of type {RenderTypeName(objectType)}");
+            hiddenThisReturn = IntPtr.Zero;
+
+            return result;
+        }
+
+        private static string RenderTypeName(IntPtr classPtr) => Il2CppSystem.Type.internal_from_handle(IL2CPP.il2cpp_class_get_type(classPtr)).ToString();
+
+        [StructLayout(LayoutKind.Sequential)]
+        private unsafe struct StaticTransferInfoPrefix
+        {
+            public Il2CppFieldInfo_24_1* field;
+        }
+
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         private delegate void DebugAssertDelegate(IntPtr data);

AdvancedSafety/ReaderPatches.cs

@@ -1,13 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
 using FavCat.Database.Stored;
 using LiteDB;
 using MelonLoader;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
 using UIExpansionKit.API;
 using UnhollowerBaseLib;
 using UnityEngine;
@@ -40,10 +40,10 @@ public Task TrimCache(long maxSize)
                 foreach (var liteFileInfo in myFileDatabase.FileStorage.FindAll())
                 {
                     if (string.IsNullOrEmpty(liteFileInfo.Id)) continue;
-
+                    
                     allFileInfos.Add((liteFileInfo,
                         myImageInfos.FindById(liteFileInfo.Id) ?? new StoredImageInfo
-                        { LastAccessed = DateTime.MinValue, Id = liteFileInfo.Id }));
+                            {LastAccessed = DateTime.MinValue, Id = liteFileInfo.Id}));
                 }
 
                 allFileInfos.Sort((a, b) => a.Item2.LastAccessed.CompareTo(b.Item2.LastAccessed));
@@ -71,12 +71,12 @@ public Task TrimCache(long maxSize)
                 }
 
                 await TaskUtilities.YieldToMainThread();
-
+                
                 MelonLogger.Msg($"Removed {cutoffPoint} images from cache");
             }).ContinueWith(task =>
             {
                 if (!task.IsFaulted) return;
-
+                
                 MelonLogger.Warning("Image cache trim failed; assuming cache corrupted, clearing collections. Exception: " + task.Exception);
                 myFileDatabase.GetCollection<LiteFileInfo<string>>("_files").DeleteAll();
                 myFileDatabase.GetCollection("_chunks").DeleteAll();
@@ -98,7 +98,7 @@ public async Task LoadImageAsync(string url, Action<Texture2D?> onDone)
                 using var imageStream = myFileDatabase.FileStorage.OpenRead(url);
                 using var image = await Image.LoadAsync<Rgba32>(imageStream).ConfigureAwait(false);
 
-                var newImageInfo = new StoredImageInfo { Id = url, LastAccessed = DateTime.UtcNow };
+                var newImageInfo = new StoredImageInfo {Id = url, LastAccessed = DateTime.UtcNow};
                 myImageInfos.Upsert(newImageInfo);
 
                 await TaskUtilities.YieldToMainThread();
@@ -129,7 +129,7 @@ private static unsafe Texture2D CreateTextureFromImage(Image<Rgba32> image)
 
             var texture = new Texture2D(image.Width, image.Height, TextureFormat.RGBA32, false, false);
             fixed (void* pixelsPtr = pixels)
-                texture.LoadRawTextureData((IntPtr)pixelsPtr, pixels.Length * 4);
+                texture.LoadRawTextureData((IntPtr) pixelsPtr, pixels.Length * 4);
 
             texture.Apply(false, true);
 
@@ -140,16 +140,19 @@ public Task StoreImageAsync(string url, Il2CppStructArray<byte> data)
         {
             if (string.IsNullOrEmpty(url)) return Task.CompletedTask;
 
+            // copy the byte[] on calling thread to avoid issues
+            var stream = new MemoryStream(data);
+            
             return Task.Run(() =>
             {
                 try
                 {
                     if (myFileDatabase.FileStorage.Exists(url))
                         return;
 
-                    myFileDatabase.FileStorage.Upload(url, url, new MemoryStream(data));
+                    myFileDatabase.FileStorage.Upload(url, url, stream);
 
-                    var newImageInfo = new StoredImageInfo { Id = url, LastAccessed = DateTime.MinValue };
+                    var newImageInfo = new StoredImageInfo {Id = url, LastAccessed = DateTime.MinValue};
                     myImageInfos.Upsert(newImageInfo);
                 }
                 catch (LiteException ex)