The Fast Texture Loading Rewrite

Celeste.Mod.mm/Celeste.Mod.mm.csproj

@@ -5,7 +5,7 @@
     <AssemblyName>Celeste.Mod.mm</AssemblyName>
     <RootNamespace>Celeste</RootNamespace>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <LangVersion>11</LangVersion>
+    <LangVersion>12.0</LangVersion>
     <ShouldIncludeNativeLua>false</ShouldIncludeNativeLua>
   </PropertyGroup>
 

Celeste.Mod.mm/Mod/Core/CoreModule.cs

@@ -58,7 +58,8 @@ public override void LoadSettings() {
             }
 
             // If we're running in an environment that prefers this flag, forcibly enable them.
-            Settings.LazyLoading |= Everest.Flags.PreferLazyLoading;
+            // Used to be used by android, which is not supported currently.
+            // Settings.LazyLoading |= Everest.Flags.PreferLazyLoading;
         }
 
         public override void SaveSettings() {

Celeste.Mod.mm/Mod/Core/CoreModuleSettings.cs

@@ -182,6 +182,11 @@ public bool? FastTextureLoading {
         [SettingIgnore] // TODO: Show as advanced setting.
         public float FastTextureLoadingMaxMB { get; set; } = 0;
 
+        [SettingNeedsRelaunch]
+        [SettingInGame(false)]
+        [SettingIgnore] // TODO: Show as advanced setting.
+        public bool? FastTextureLoadingPoolUseGC { get; set; } = null;
+
         [SettingNeedsRelaunch]
         [SettingInGame(false)]
         [SettingIgnore] // TODO: Show as advanced setting.

Celeste.Mod.mm/Mod/Everest/ContentExtensions.cs

@@ -204,220 +204,37 @@ public static void UnloadTextureRaw(IntPtr dataPtr) {
             _UnloadTextureRaw(dataPtr);
         }
 
-        [MonoModIgnore]
-        private static extern void _SetTextureDataPtr(Texture2D tex, IntPtr ptr);
-
-        [MonoModIgnore]
-        private static extern Texture2D _LoadTextureLazyPremultiplyFull(GraphicsDevice gd, Stream stream);
-
-        [MonoModIgnore]
-        private static extern void _LoadTextureRaw(GraphicsDevice gd, Stream stream, out int w, out int h, out byte[] data, out IntPtr dataPtr, bool gc);
-
-        [MonoModIgnore]
-        private static extern void _LoadTextureLazyPremultiply(GraphicsDevice gd, Stream stream, out int w, out int h, out byte[] data, out IntPtr dataPtr, bool gc);
-
-        [MonoModIgnore]
-        private static extern void _UnloadTextureRaw(IntPtr dataPtr);
-
-        [MonoModIfFlag("XNA")]
-        [MonoModPatch("_SetTextureDataPtr")]
-        [MonoModReplace]
-        private static unsafe void _SetTextureDataPtrXNA(Texture2D tex, IntPtr ptr) {
-            if(!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                throw new PlatformNotSupportedException();
-
-            byte[] copy = new byte[tex.Width * tex.Height * 4];
-            Marshal.Copy(ptr, copy, 0, copy.Length);
-            tex.SetData(copy);
-        }
-
-        [MonoModIfFlag("XNA")]
-        [MonoModPatch("_LoadTextureLazyPremultiplyFull")]
-        [MonoModReplace]
-        private static unsafe Texture2D _LoadTextureLazyPremultiplyFullXNA(GraphicsDevice gd, Stream stream) {
-            if(!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                throw new PlatformNotSupportedException();
-
-            _LoadTextureLazyPremultiply(gd, stream, out int w, out int h, out byte[] data, out _, true);
-            Texture2D tex = new Texture2D(gd, w, h, false, SurfaceFormat.Color);
-            tex.SetData(data);
-            return tex;
-        }
-
-        [MonoModIfFlag("XNA")]
-        [MonoModPatch("_LoadTextureRaw")]
-        [MonoModReplace]
-        private static unsafe void _LoadTextureRawXNA(GraphicsDevice gd, Stream stream, out int w, out int h, out byte[] data, out IntPtr dataPtr, bool gc) {
-            if(!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                throw new PlatformNotSupportedException();
-
-            using (SD.Bitmap bmp = new SD.Bitmap(stream)) {
-                w = bmp.Width;
-                h = bmp.Height;
-                int depth = SD.Image.GetPixelFormatSize(bmp.PixelFormat);
-
-                SD.Bitmap copy = null;
-                if (depth != 32)
-                    copy = bmp.Clone(new SD.Rectangle(0, 0, w, h), SDI.PixelFormat.Format32bppArgb);
-                using (copy) {
-
-                    SD.Bitmap src = copy ?? bmp;
-
-                    SDI.BitmapData srcData = src.LockBits(
-                        new SD.Rectangle(0, 0, w, h),
-                        SDI.ImageLockMode.ReadOnly,
-                        src.PixelFormat
-                    );
-
-                    int length = w * h * 4;
-                    if (gc) {
-                        data = new byte[length];
-                        dataPtr = IntPtr.Zero;
-                    } else {
-                        data = Array.Empty<byte>();
-                        dataPtr = Marshal.AllocHGlobal(length);
-                    }
-
-                    byte* from = (byte*) srcData.Scan0;
-                    fixed (byte* dataPin = data) {
-                        byte* to = gc ? dataPin : (byte*) dataPtr;
-                        for (int i = length - 1 - 3; i > -1; i -= 4) {
-                            to[i + 0] = from[i + 2];
-                            to[i + 1] = from[i + 1];
-                            to[i + 2] = from[i + 0];
-                            to[i + 3] = from[i + 3];
-                        }
-                    }
-
-                    src.UnlockBits(srcData);
-                }
-            }
-        }
-
-        [MonoModIfFlag("XNA")]
-        [MonoModPatch("_LoadTextureLazyPremultiply")]
-        [MonoModReplace]
-        private static unsafe void _LoadTextureLazyPremultiplyXNA(GraphicsDevice gd, Stream stream, out int w, out int h, out byte[] data, out IntPtr dataPtr, bool gc) {
-            if(!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                throw new PlatformNotSupportedException();
-
-            using (SD.Bitmap bmp = new SD.Bitmap(stream)) {
-                w = bmp.Width;
-                h = bmp.Height;
-                int depth = SD.Image.GetPixelFormatSize(bmp.PixelFormat);
-
-                SD.Bitmap copy = null;
-                if (depth != 32)
-                    copy = bmp.Clone(new SD.Rectangle(0, 0, w, h), SDI.PixelFormat.Format32bppArgb);
-                using (copy) {
-
-                    SD.Bitmap src = copy ?? bmp;
-
-                    SDI.BitmapData srcData = src.LockBits(
-                        new SD.Rectangle(0, 0, w, h),
-                        SDI.ImageLockMode.ReadOnly,
-                        src.PixelFormat
-                    );
-
-                    int length = w * h * 4;
-                    if (gc) {
-                        data = new byte[length];
-                        dataPtr = IntPtr.Zero;
-                    } else {
-                        data = Array.Empty<byte>();
-                        dataPtr = Marshal.AllocHGlobal(length);
-                    }
-
-                    byte* from = (byte*) srcData.Scan0;
-                    fixed (byte* dataPin = data) {
-                        byte* to = gc ? dataPin : (byte*) dataPtr;
-                        for (int i = length - 1 - 3; i > -1; i -= 4) {
-                            byte r = from[i + 2];
-                            byte g = from[i + 1];
-                            byte b = from[i + 0];
-                            byte a = from[i + 3];
-
-                            if (a == 0) {
-                                to[i + 0] = 0;
-                                to[i + 1] = 0;
-                                to[i + 2] = 0;
-                                to[i + 3] = 0;
-                                continue;
-                            }
-
-                            if (a == 255) {
-                                to[i + 0] = r;
-                                to[i + 1] = g;
-                                to[i + 2] = b;
-                                to[i + 3] = a;
-                                continue;
-                            }
-
-                            to[i + 0] = (byte) (r * a / 255D);
-                            to[i + 1] = (byte) (g * a / 255D);
-                            to[i + 2] = (byte) (b * a / 255D);
-                            to[i + 3] = a;
-                        }
-                    }
-
-                    src.UnlockBits(srcData);
-                }
-            }
-        }
-
-        [MonoModIfFlag("XNA")]
-        [MonoModPatch("_UnloadTextureRaw")]
-        [MonoModReplace]
-        private static unsafe void _UnloadTextureRawXNA(IntPtr dataPtr) {
-            if(!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                throw new PlatformNotSupportedException();
-
-            Marshal.FreeHGlobal(dataPtr);
-        }
-
-        [MonoModIfFlag("FNA")]
-        [MonoModPatch("_SetTextureDataPtr")]
-        [MonoModReplace]
-        private static unsafe void _SetTextureDataPtrFNA(Texture2D tex, IntPtr ptr) {
+        private static unsafe void _SetTextureDataPtr(Texture2D tex, IntPtr ptr) {
             tex.SetDataPointerEXT(0, null, ptr, tex.Width * tex.Height * 4);
         }
 
-        [MonoModIfFlag("FNA")]
-        [MonoModPatch("_LoadTextureLazyPremultiplyFull")]
-        [MonoModReplace]
-        private static unsafe Texture2D _LoadTextureLazyPremultiplyFullFNA(GraphicsDevice gd, Stream stream) {
+        private static unsafe Texture2D _LoadTextureLazyPremultiplyFull(GraphicsDevice gd, Stream stream) {
             _LoadTextureLazyPremultiply(gd, stream, out int w, out int h, out _, out IntPtr dataPtr, false);
             Texture2D tex = new Texture2D(gd, w, h, false, SurfaceFormat.Color);
             tex.SetDataPointerEXT(0, null, dataPtr, w * h * 4);
             _UnloadTextureRaw(dataPtr);
             return tex;
         }
 
-        [MonoModIfFlag("FNA")]
-        [MonoModPatch("_LoadTextureRaw")]
-        [MonoModReplace]
-        private static unsafe void _LoadTextureRawFNA(GraphicsDevice gd, Stream stream, out int w, out int h, out byte[] data, out IntPtr dataPtr, bool gc) {
+        private static unsafe void _LoadTextureRaw(GraphicsDevice gd, Stream stream, out int w, out int h, out byte[] data, out IntPtr dataPtr, bool gc) {
             if (gc) {
                 Texture2D.TextureDataFromStreamEXT(stream, out w, out h, out data);
                 dataPtr = IntPtr.Zero;
             } else {
-                data = Array.Empty<byte>();
+                data = [];
                 dataPtr = FNA3D_ReadImageStream(stream, out w, out h, out _);
             }
         }
 
 
-        [MonoModIfFlag("FNA")]
-        [MonoModPatch("_LoadTextureLazyPremultiply")]
-        [MonoModReplace]
-        private static unsafe void _LoadTextureLazyPremultiplyFNA(GraphicsDevice gd, Stream stream, out int w, out int h, out byte[] data, out IntPtr dataPtr, bool gc) {
+        private static unsafe void _LoadTextureLazyPremultiply(GraphicsDevice gd, Stream stream, out int w, out int h, out byte[] data, out IntPtr dataPtr, bool gc) {
             int length;
             if (gc) {
                 Texture2D.TextureDataFromStreamEXT(stream, out w, out h, out data);
                 dataPtr = IntPtr.Zero;
                 length = data.Length;
             } else {
-                data = Array.Empty<byte>();
+                data = [];
                 dataPtr = FNA3D_ReadImageStream(stream, out w, out h, out length);
             }
 
@@ -438,10 +255,7 @@ private static unsafe void _LoadTextureLazyPremultiplyFNA(GraphicsDevice gd, Str
             }
         }
 
-        [MonoModIfFlag("FNA")]
-        [MonoModPatch("_UnloadTextureRaw")]
-        [MonoModReplace]
-        private static unsafe void _UnloadTextureRawFNA(IntPtr dataPtr) {
+        private static unsafe void _UnloadTextureRaw(IntPtr dataPtr) {
             FNA3D_Image_Free(dataPtr);
         }
 

Celeste.Mod.mm/Mod/Everest/Everest.Events.cs

@@ -382,6 +382,22 @@ public static class SubHudRenderer {
                 internal static void BeforeRender(_SubHudRenderer renderer, Scene scene)
                     => OnBeforeRender?.Invoke(renderer, scene);
             }
+
+            public static class VirtualTexture {
+                public delegate bool ForceLazyLoadHandler(Monocle.VirtualTexture self);
+
+                public static event ForceLazyLoadHandler ShouldForceLazyLoad;
+
+                internal static bool OnShouldForceLazyLoad(Monocle.VirtualTexture self) {
+                    return ShouldForceLazyLoad.InvokeWhileFalse(self);
+                }
+
+                public delegate void LazyLoadHandler(Monocle.VirtualTexture self);
+
+                public static event LazyLoadHandler OnLazyLoad;
+                internal static void LazyLoad(Monocle.VirtualTexture tex)
+                    => OnLazyLoad?.Invoke(tex);
+            }
         }
     }
 }

Celeste.Mod.mm/Mod/Everest/Everest.Flags.cs

@@ -48,8 +48,10 @@ public static class Flags {
             public static bool AvoidRenderTargets { get; private set; }
             /// <summary>
             /// Does the environment (platform, ...) prefer lazy loading?
+            /// Used to be used by android, which is not supported currently.
             /// </summary>
-            public static bool PreferLazyLoading { get; private set; }
+            [Obsolete("`PreferLazyLoading` is always false on Everest Core")]
+            public static bool PreferLazyLoading => false;
 
             /// <summary>
             /// Does the environment (renderer, framework ,...) prefer threaded GL?
@@ -80,7 +82,6 @@ internal static void Initialize() {
                 }
 
                 AvoidRenderTargets = Environment.GetEnvironmentVariable("EVEREST_NO_RT") == "1";
-                PreferLazyLoading = false;
 
                 SupportRuntimeMods = true;
                 SupportUpdatingEverest = true;

Celeste.Mod.mm/Mod/Helpers/MainThreadHelper.cs

@@ -42,12 +42,13 @@ public void ExecuteTasksFor(int timeSlice) {
                     return;
 
                 // Execute tasks during our allocated time slice
-                _Stopwatch.Reset();
+                _Stopwatch.Restart();
                 while (_Stopwatch.ElapsedMilliseconds < timeSlice) {
                     if (!_TasksQueue.TryDequeue(out Task task))
                         break;
                     TryExecuteTask(task);
                 }
+                _Stopwatch.Stop();
             }
 
         }
@@ -84,7 +85,7 @@ public static ValueTask Schedule(Action act, bool forceQueue = false) {
             if (forceQueue && IsMainThread) {
                 try {
                     TaskScheduler.TaskIsForceQueued = true;
-                    return Schedule(act);
+                    return new ValueTask(TaskFactory.StartNew(act));
                 } finally {
                     TaskScheduler.TaskIsForceQueued = false;
                 }
@@ -101,7 +102,7 @@ public static ValueTask<T> Schedule<T>(Func<T> act, bool forceQueue = false) {
             if (forceQueue && IsMainThread) {
                 try {
                     TaskScheduler.TaskIsForceQueued = true;
-                    return Schedule(act);
+                    return new ValueTask<T>(TaskFactory.StartNew(act));
                 } finally {
                     TaskScheduler.TaskIsForceQueued = false;
                 }
@@ -117,7 +118,7 @@ public static Task Schedule(Func<Task> act, bool forceQueue = false) {
             if (forceQueue && IsMainThread) {
                 try {
                     TaskScheduler.TaskIsForceQueued = true;
-                    return Schedule(act);
+                    return TaskFactory.StartNew(act).Unwrap();
                 } finally {
                     TaskScheduler.TaskIsForceQueued = false;
                 }
@@ -133,7 +134,7 @@ public static Task<T> Schedule<T>(Func<Task<T>> act, bool forceQueue = false) {
             if (forceQueue && IsMainThread) {
                 try {
                     TaskScheduler.TaskIsForceQueued = true;
-                    return Schedule(act);
+                    return TaskFactory.StartNew(act).Unwrap();
                 } finally {
                     TaskScheduler.TaskIsForceQueued = false;
                 }

Celeste.Mod.mm/Mod/Helpers/SynchronizedZipEntryStream.cs

@@ -11,7 +11,7 @@ namespace Celeste.Mod.Helpers {
     /// </summary>
     public class SynchronizedZipEntryStream : Stream {
         private readonly ZipArchive archive;
-        private readonly ZipArchiveEntry entry;
+        internal readonly ZipArchiveEntry entry;
         private Stream wrappedStream;
         private long position;