Allow texture preload to be skipped for some textures

This is a far cry from a proper resource tracking system, but it's something to avoid a ton of otherwise-unused parallax textures being loaded at game start and consuming VRAM.

Robust.Client/ResourceManagement/ResourceCache.Preload.cs

@@ -59,7 +59,14 @@ namespace Robust.Client.ResourceManagement
             {
                 try
                 {
-                    TextureResource.LoadPreTexture(_manager, data);
+                    TextureResource.LoadTextureParameters(_manager, data);
+                    if (!data.LoadParameters.Preload)
+                    {
+                        data.Skip = true;
+                        return;
+                    }
+
+                    TextureResource.LoadPreTextureData(_manager, data);
                 }
                 catch (Exception e)
                 {
@@ -72,7 +79,7 @@ namespace Robust.Client.ResourceManagement
 
             foreach (var data in texList)
             {
-                if (data.Bad)
+                if (data.Bad || data.Skip)
                     continue;
 
                 try
@@ -87,6 +94,7 @@ namespace Robust.Client.ResourceManagement
             }
 
             var errors = 0;
+            var skipped = 0;
             foreach (var data in texList)
             {
                 if (data.Bad)
@@ -95,6 +103,12 @@ namespace Robust.Client.ResourceManagement
                     continue;
                 }
 
+                if (data.Skip)
+                {
+                    skipped += 1;
+                    continue;
+                }
+
                 try
                 {
                     var texResource = new TextureResource();
@@ -110,9 +124,10 @@ namespace Robust.Client.ResourceManagement
             }
 
             sawmill.Debug(
-                "Preloaded {CountLoaded} textures ({CountErrored} errored) in {LoadTime}",
-                texList.Length,
+                "Preloaded {CountLoaded} textures ({CountErrored} errored, {CountSkipped} skipped) in {LoadTime}",
+                texList.Length - skipped - errors,
                 errors,
+                skipped,
                 sw.Elapsed);
         }
 

Robust.Client/ResourceManagement/ResourceTypes/TextureResource.cs

@@ -32,18 +32,22 @@ namespace Robust.Client.ResourceManagement
 
             var data = new LoadStepData {Path = path};
 
-            LoadPreTexture(dependencies.Resolve<IResourceManager>(), data);
+            LoadTextureParameters(dependencies.Resolve<IResourceManager>(), data);
+            LoadPreTextureData(dependencies.Resolve<IResourceManager>(), data);
             LoadTexture(dependencies.Resolve<IClyde>(), data);
             LoadFinish(dependencies.Resolve<IResourceCache>(), data);
         }
 
-        internal static void LoadPreTexture(IResourceManager cache, LoadStepData data)
+        internal static void LoadPreTextureData(IResourceManager cache, LoadStepData data)
         {
             using (var stream = cache.ContentFileRead(data.Path))
             {
                 data.Image = Image.Load<Rgba32>(stream);
             }
+        }
 
+        internal static void LoadTextureParameters(IResourceManager cache, LoadStepData data)
+        {
             data.LoadParameters = TryLoadTextureParameters(cache, data.Path) ?? TextureLoadParameters.Default;
         }
 
@@ -95,7 +99,8 @@ namespace Robust.Client.ResourceManagement
         {
             var data = new LoadStepData {Path = path};
 
-            LoadPreTexture(dependencies.Resolve<IResourceManager>(), data);
+            LoadTextureParameters(dependencies.Resolve<IResourceManager>(), data);
+            LoadPreTextureData(dependencies.Resolve<IResourceManager>(), data);
 
             if (data.Image.Width == Texture.Width && data.Image.Height == Texture.Height)
             {
@@ -119,6 +124,7 @@ namespace Robust.Client.ResourceManagement
             public Image<Rgba32> Image = default!;
             public TextureLoadParameters LoadParameters;
             public OwnedTexture Texture = default!;
+            public bool Skip;
             public bool Bad;
         }
 

Robust.Shared/Graphics/TextureLoadParameters.cs

@@ -21,6 +21,11 @@ public struct TextureLoadParameters : IEquatable<TextureLoadParameters>
     /// </summary>
     public bool Srgb { get; set; }
 
+    /// <summary>
+    /// If false, this texture should not be preloaded on game startup.
+    /// </summary>
+    public bool Preload { get; set; }
+
     public static TextureLoadParameters FromYaml(YamlMappingNode yaml)
     {
         var loadParams = Default;
@@ -34,18 +39,24 @@ public struct TextureLoadParameters : IEquatable<TextureLoadParameters>
             loadParams.Srgb = srgb.AsBool();
         }
 
+        if (yaml.TryGetNode("preload", out var preload))
+        {
+            loadParams.Preload = preload.AsBool();
+        }
+
         return loadParams;
     }
 
     public static readonly TextureLoadParameters Default = new()
     {
         SampleParameters = TextureSampleParameters.Default,
-        Srgb = true
+        Srgb = true,
+        Preload = true
     };
 
     public bool Equals(TextureLoadParameters other)
     {
-        return SampleParameters.Equals(other.SampleParameters) && Srgb == other.Srgb;
+        return SampleParameters.Equals(other.SampleParameters) && Srgb == other.Srgb && Preload == other.Preload;
     }
 
     public override bool Equals(object? obj)