further improve RuntimeTexturePacker performance by only checking against already packed textures

CHANGELOG.md

@@ -58,6 +58,7 @@ Improvements
 - Premultiply textures when using RawContentManager
 - Allow enumerating all region names of a DataTextureAtlas
 - Cache RuntimeTexturePacker texture data while packing to improve performance
+- Improve RuntimeTexturePacker performance by checking against packed textures in the same order as packing
 
 Fixes
 - Fixed SoundEffectReader incorrectly claiming it could read ogg and mp3 files

MLEM.Data/RuntimeTexturePacker.cs

@@ -34,7 +34,8 @@ namespace MLEM.Data {
         /// </summary>
         public TimeSpan LastTotalTime => this.LastCalculationTime + this.LastPackTime;
 
-        private readonly List<Request> textures = new List<Request>();
+        private readonly List<Request> texturesToPack = new List<Request>();
+        private readonly List<Request> alreadyPackedTextures = new List<Request>();
         private readonly Dictionary<Texture2D, TextureData> dataCache = new Dictionary<Texture2D, TextureData>();
         private readonly bool autoIncreaseMaxWidth;
         private readonly bool forcePowerOfTwo;
@@ -68,17 +69,27 @@ namespace MLEM.Data {
         /// <param name="result">The result callback which will receive the resulting texture regions.</param>
         /// <param name="padding">The padding that the texture should have around itself. This can be useful if texture bleeding issues occur due to texture coordinate rounding.</param>
         /// <param name="padWithPixels">Whether the texture's padding should be filled with a copy of the texture's border, rather than transparent pixels. This value only has an effect if <paramref name="padding"/> is greater than 0.</param>
+        /// <param name="ignoreTransparent">Whether completely transparent texture regions in the <paramref name="atlas"/> should be ignored. If this is true, they will not be part of the <paramref name="result"/> collection either.</param>
         /// <exception cref="InvalidOperationException">Thrown when trying to add data to a packer that has already been packed, or when trying to add a texture width a width greater than the defined max width.</exception>
-        public void Add(UniformTextureAtlas atlas, Action<Dictionary<Point, TextureRegion>> result, int padding = 0, bool padWithPixels = false) {
+        public void Add(UniformTextureAtlas atlas, Action<Dictionary<Point, TextureRegion>> result, int padding = 0, bool padWithPixels = false, bool ignoreTransparent = false) {
+            var addedRegions = new List<TextureRegion>();
             var resultRegions = new Dictionary<Point, TextureRegion>();
             for (var x = 0; x < atlas.RegionAmountX; x++) {
                 for (var y = 0; y < atlas.RegionAmountY; y++) {
                     var pos = new Point(x, y);
-                    this.Add(atlas[pos], r => {
+                    var region = atlas[pos];
+
+                    if (ignoreTransparent) {
+                        if (IsTransparent(region))
+                            continue;
+                    }
+
+                    this.Add(region, r => {
                         resultRegions.Add(pos, r);
-                        if (resultRegions.Count >= atlas.RegionAmountX * atlas.RegionAmountY)
+                        if (resultRegions.Count >= addedRegions.Count)
                             result.Invoke(resultRegions);
                     }, padding, padWithPixels);
+                    addedRegions.Add(region);
                 }
             }
         }
@@ -138,7 +149,7 @@ namespace MLEM.Data {
                     throw new InvalidOperationException($"Cannot add texture with width {texture.Width} to a texture packer with max width {this.maxWidth}");
                 }
             }
-            this.textures.Add(new Request(texture, result, padding, padWithPixels));
+            this.texturesToPack.Add(new Request(texture, result, padding, padWithPixels));
         }
 
         /// <summary>
@@ -153,15 +164,18 @@ namespace MLEM.Data {
                 throw new InvalidOperationException("Cannot pack a texture packer that is already packed");
 
             // set pack areas for each request
+            // we pack larger textures first, so that smaller textures can fit in the gaps that larger ones leave
             var stopwatch = Stopwatch.StartNew();
-            foreach (var request in this.textures.OrderByDescending(t => t.Texture.Width * t.Texture.Height))
+            foreach (var request in this.texturesToPack.OrderByDescending(t => t.Texture.Width * t.Texture.Height)) {
                 request.PackedArea = this.FindFreeArea(request);
+                this.alreadyPackedTextures.Add(request);
+            }
             stopwatch.Stop();
             this.LastCalculationTime = stopwatch.Elapsed;
 
             // figure out texture size and generate texture
-            var width = this.textures.Max(t => t.PackedArea.Right);
+            var width = this.alreadyPackedTextures.Max(t => t.PackedArea.Right);
-            var height = this.textures.Max(t => t.PackedArea.Bottom);
+            var height = this.alreadyPackedTextures.Max(t => t.PackedArea.Bottom);
             if (this.forcePowerOfTwo) {
                 width = ToPowerOfTwo(width);
                 height = ToPowerOfTwo(height);
@@ -173,21 +187,22 @@ namespace MLEM.Data {
             // copy texture data onto the packed texture
             stopwatch.Restart();
             using (var data = this.PackedTexture.GetTextureData()) {
-                foreach (var request in this.textures)
+                foreach (var request in this.alreadyPackedTextures)
                     this.CopyRegion(data, request);
             }
             stopwatch.Stop();
             this.LastPackTime = stopwatch.Elapsed;
 
             // invoke callbacks
-            foreach (var request in this.textures) {
+            foreach (var request in this.alreadyPackedTextures) {
                 var packedArea = request.PackedArea.Shrink(new Point(request.Padding));
                 request.Result.Invoke(new TextureRegion(this.PackedTexture, packedArea));
                 if (this.disposeTextures)
                     request.Texture.Texture.Dispose();
             }
 
-            this.textures.Clear();
+            this.texturesToPack.Clear();
+            this.alreadyPackedTextures.Clear();
             this.dataCache.Clear();
         }
 
@@ -197,7 +212,8 @@ namespace MLEM.Data {
         public void Reset() {
             this.PackedTexture?.Dispose();
             this.PackedTexture = null;
-            this.textures.Clear();
+            this.texturesToPack.Clear();
+            this.alreadyPackedTextures.Clear();
             this.dataCache.Clear();
             this.LastCalculationTime = TimeSpan.Zero;
             this.LastPackTime = TimeSpan.Zero;
@@ -218,7 +234,7 @@ namespace MLEM.Data {
             while (true) {
                 var intersected = false;
                 var area = new Rectangle(pos, size);
-                foreach (var tex in this.textures) {
+                foreach (var tex in this.alreadyPackedTextures) {
                     if (tex.PackedArea.Intersects(area)) {
                         pos.X = tex.PackedArea.Right;
                         // when we move down, we want to move down by the smallest intersecting texture's height
@@ -239,13 +255,7 @@ namespace MLEM.Data {
         }
 
         private void CopyRegion(TextureData destination, Request request) {
-            // we cache texture data in case multiple requests use the same underlying texture
+            var data = this.GetCachedTextureData(request.Texture.Texture);
-            // this collection doesn't need to be disposed since we don't actually edit these textures
-            if (!this.dataCache.TryGetValue(request.Texture.Texture, out var data)) {
-                data = request.Texture.Texture.GetTextureData();
-                this.dataCache.Add(request.Texture.Texture, data);
-            }
-
             var location = request.PackedArea.Location + new Point(request.Padding);
             for (var x = -request.Padding; x < request.Texture.Width + request.Padding; x++) {
                 for (var y = -request.Padding; y < request.Texture.Height + request.Padding; y++) {
@@ -263,6 +273,27 @@ namespace MLEM.Data {
             }
         }
 
+        private TextureData GetCachedTextureData(Texture2D texture) {
+            // we cache texture data in case multiple requests use the same underlying texture
+            // this collection doesn't need to be disposed since we don't actually edit these textures
+            if (!this.dataCache.TryGetValue(texture, out var data)) {
+                data = texture.GetTextureData();
+                this.dataCache.Add(texture, data);
+            }
+            return data;
+        }
+
+        private bool IsTransparent(TextureRegion region) {
+            var data = this.GetCachedTextureData(region.Texture);
+            for (var rX = 0; rX < region.Width; rX++) {
+                for (var rY = 0; rY < region.Height; rY++) {
+                    if (data[region.U + rX, region.V + rY] != Color.Transparent)
+                        return false;
+                }
+            }
+            return true;
+        }
+
         private static int ToPowerOfTwo(int value) {
             var ret = 1;
             while (ret < value)

Sandbox/GameImpl.cs

@@ -323,7 +323,7 @@ namespace Sandbox {
             packer.Add(new UniformTextureAtlas(tex, 16, 16), r => {
                 regions.AddRange(r.Values);
                 Console.WriteLine($"Returned {r.Count} regions: {string.Join(", ", r.Select(kv => kv.Key + ": " + kv.Value.Area))}");
-            }, 1, true);
+            }, 1, true, true);
             packer.Add(this.Content.LoadTextureAtlas("Textures/Furniture"), r => {
                 regions.AddRange(r.Values);
                 Console.WriteLine($"Returned {r.Count} regions: {string.Join(", ", r.Select(kv => kv.Key + ": " + kv.Value.Area))}");
@@ -342,7 +342,7 @@ namespace Sandbox {
                     x += r.Width * sc + 1;
                     if (x >= 1000) {
                         x = 0;
-                        y += 50;
+                        y += 250;
                     }
                 }
                 this.SpriteBatch.End();