Merge branch 'develop' into stable

1 files changed, 121 insertions, 52 deletions

diff --git a/src/SMAPI/Framework/Content/AssetDataForImage.cs b/src/SMAPI/Framework/Content/AssetDataForImage.cs
index 97729c95..3393b22f 100644
--- a/src/SMAPI/Framework/Content/AssetDataForImage.cs
+++ b/src/SMAPI/Framework/Content/AssetDataForImage.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using StardewValley;
@@ -29,86 +30,154 @@ namespace StardewModdingAPI.Framework.Content
             : base(locale, assetName, data, getNormalizedPath, onDataReplaced) { }
 
         /// <inheritdoc />
-        public void PatchImage(Texture2D source, Rectangle? sourceArea = null, Rectangle? targetArea = null, PatchMode patchMode = PatchMode.Replace)
+        public void PatchImage(IRawTextureData source, Rectangle? sourceArea = null, Rectangle? targetArea = null, PatchMode patchMode = PatchMode.Replace)
         {
-            // get texture
+            this.GetPatchBounds(ref sourceArea, ref targetArea, source.Width, source.Height);
+
+            // validate source data
             if (source == null)
-                throw new ArgumentNullException(nameof(source), "Can't patch from a null source texture.");
-            Texture2D target = this.Data;
+                throw new ArgumentNullException(nameof(source), "Can't patch from null source data.");
 
-            // get areas
-            sourceArea ??= new Rectangle(0, 0, source.Width, source.Height);
-            targetArea ??= new Rectangle(0, 0, Math.Min(sourceArea.Value.Width, target.Width), Math.Min(sourceArea.Value.Height, target.Height));
+            // get the pixels for the source area
+            Color[] sourceData;
+            {
+                int areaX = sourceArea.Value.X;
+                int areaY = sourceArea.Value.Y;
+                int areaWidth = sourceArea.Value.Width;
+                int areaHeight = sourceArea.Value.Height;
 
-            // validate
+                if (areaX == 0 && areaY == 0 && areaWidth == source.Width && areaHeight == source.Height)
+                    sourceData = source.Data;
+                else
+                {
+                    sourceData = new Color[areaWidth * areaHeight];
+                    int i = 0;
+                    for (int y = areaY, maxY = areaY + areaHeight - 1; y <= maxY; y++)
+                    {
+                        for (int x = areaX, maxX = areaX + areaWidth - 1; x <= maxX; x++)
+                        {
+                            int targetIndex = (y * source.Width) + x;
+                            sourceData[i++] = source.Data[targetIndex];
+                        }
+                    }
+                }
+            }
+
+            // apply
+            this.PatchImageImpl(sourceData, source.Width, source.Height, sourceArea.Value, targetArea.Value, patchMode);
+        }
+
+        /// <inheritdoc />
+        public void PatchImage(Texture2D source, Rectangle? sourceArea = null, Rectangle? targetArea = null, PatchMode patchMode = PatchMode.Replace)
+        {
+            this.GetPatchBounds(ref sourceArea, ref targetArea, source.Width, source.Height);
+
+            // validate source texture
+            if (source == null)
+                throw new ArgumentNullException(nameof(source), "Can't patch from a null source texture.");
             if (!source.Bounds.Contains(sourceArea.Value))
                 throw new ArgumentOutOfRangeException(nameof(sourceArea), "The source area is outside the bounds of the source texture.");
-            if (!target.Bounds.Contains(targetArea.Value))
-                throw new ArgumentOutOfRangeException(nameof(targetArea), "The target area is outside the bounds of the target texture.");
-            if (sourceArea.Value.Size != targetArea.Value.Size)
-                throw new InvalidOperationException("The source and target areas must be the same size.");
 
             // get source data
             int pixelCount = sourceArea.Value.Width * sourceArea.Value.Height;
             Color[] sourceData = GC.AllocateUninitializedArray<Color>(pixelCount);
             source.GetData(0, sourceArea, sourceData, 0, pixelCount);
 
-            // merge data in overlay mode
+            // apply
+            this.PatchImageImpl(sourceData, source.Width, source.Height, sourceArea.Value, targetArea.Value, patchMode);
+        }
+
+        /// <inheritdoc />
+        public bool ExtendImage(int minWidth, int minHeight)
+        {
+            if (this.Data.Width >= minWidth && this.Data.Height >= minHeight)
+                return false;
+
+            Texture2D original = this.Data;
+            Texture2D texture = new(Game1.graphics.GraphicsDevice, Math.Max(original.Width, minWidth), Math.Max(original.Height, minHeight));
+            this.ReplaceWith(texture);
+            this.PatchImage(original);
+            return true;
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>Get the bounds for an image patch.</summary>
+        /// <param name="sourceArea">The source area to set if needed.</param>
+        /// <param name="targetArea">The target area to set if needed.</param>
+        /// <param name="sourceWidth">The width of the full source image.</param>
+        /// <param name="sourceHeight">The height of the full source image.</param>
+        private void GetPatchBounds([NotNull] ref Rectangle? sourceArea, [NotNull] ref Rectangle? targetArea, int sourceWidth, int sourceHeight)
+        {
+            sourceArea ??= new Rectangle(0, 0, sourceWidth, sourceHeight);
+            targetArea ??= new Rectangle(0, 0, Math.Min(sourceArea.Value.Width, this.Data.Width), Math.Min(sourceArea.Value.Height, this.Data.Height));
+        }
+
+        /// <summary>Overwrite part of the image.</summary>
+        /// <param name="sourceData">The image data to patch into the content.</param>
+        /// <param name="sourceWidth">The pixel width of the source image.</param>
+        /// <param name="sourceHeight">The pixel height of the source image.</param>
+        /// <param name="sourceArea">The part of the <paramref name="sourceData"/> to copy (or <c>null</c> to take the whole texture). This must be within the bounds of the <paramref name="sourceData"/> texture.</param>
+        /// <param name="targetArea">The part of the content to patch (or <c>null</c> to patch the whole texture). The original content within this area will be erased. This must be within the bounds of the existing spritesheet.</param>
+        /// <param name="patchMode">Indicates how an image should be patched.</param>
+        /// <exception cref="ArgumentNullException">One of the arguments is null.</exception>
+        /// <exception cref="ArgumentOutOfRangeException">The <paramref name="targetArea"/> is outside the bounds of the spritesheet.</exception>
+        /// <exception cref="InvalidOperationException">The content being read isn't an image.</exception>
+        private void PatchImageImpl(Color[] sourceData, int sourceWidth, int sourceHeight, Rectangle sourceArea, Rectangle targetArea, PatchMode patchMode)
+        {
+            // get texture
+            Texture2D target = this.Data;
+            int pixelCount = sourceArea.Width * sourceArea.Height;
+
+            // validate
+            if (sourceArea.X < 0 || sourceArea.Y < 0 || sourceArea.Right > sourceWidth || sourceArea.Bottom > sourceHeight)
+                throw new ArgumentOutOfRangeException(nameof(sourceArea), "The source area is outside the bounds of the source texture.");
+            if (!target.Bounds.Contains(targetArea))
+                throw new ArgumentOutOfRangeException(nameof(targetArea), "The target area is outside the bounds of the target texture.");
+            if (sourceArea.Size != targetArea.Size)
+                throw new InvalidOperationException("The source and target areas must be the same size.");
+
+            // merge data
             if (patchMode == PatchMode.Overlay)
             {
                 // get target data
-                Color[] targetData = GC.AllocateUninitializedArray<Color>(pixelCount);
-                target.GetData(0, targetArea, targetData, 0, pixelCount);
+                Color[] mergedData = GC.AllocateUninitializedArray<Color>(pixelCount);
+                target.GetData(0, targetArea, mergedData, 0, pixelCount);
 
                 // merge pixels
-                for (int i = 0; i < sourceData.Length; i++)
+                for (int i = 0; i < pixelCount; i++)
                 {
                     Color above = sourceData[i];
-                    Color below = targetData[i];
+                    Color below = mergedData[i];
 
                     // shortcut transparency
                     if (above.A < MinOpacity)
-                    {
-                        sourceData[i] = below;
                         continue;
-                    }
                     if (below.A < MinOpacity)
-                    {
-                        sourceData[i] = above;
-                        continue;
-                    }
+                        mergedData[i] = above;
 
                     // merge pixels
-                    // This performs a conventional alpha blend for the pixels, which are already
-                    // premultiplied by the content pipeline. The formula is derived from
-                    // https://blogs.msdn.microsoft.com/shawnhar/2009/11/06/premultiplied-alpha/.
-                    // Note: don't use named arguments here since they're different between
-                    // Linux/macOS and Windows.
-                    float alphaBelow = 1 - (above.A / 255f);
-                    sourceData[i] = new Color(
-                        (int)(above.R + (below.R * alphaBelow)), // r
-                        (int)(above.G + (below.G * alphaBelow)), // g
-                        (int)(above.B + (below.B * alphaBelow)), // b
-                        Math.Max(above.A, below.A) // a
-                    );
+                    else
+                    {
+                        // This performs a conventional alpha blend for the pixels, which are already
+                        // premultiplied by the content pipeline. The formula is derived from
+                        // https://blogs.msdn.microsoft.com/shawnhar/2009/11/06/premultiplied-alpha/.
+                        float alphaBelow = 1 - (above.A / 255f);
+                        mergedData[i] = new Color(
+                            r: (int)(above.R + (below.R * alphaBelow)),
+                            g: (int)(above.G + (below.G * alphaBelow)),
+                            b: (int)(above.B + (below.B * alphaBelow)),
+                            alpha: Math.Max(above.A, below.A)
+                        );
+                    }
                 }
-            }
-
-            // patch target texture
-            target.SetData(0, targetArea, sourceData, 0, pixelCount);
-        }
-
-        /// <inheritdoc />
-        public bool ExtendImage(int minWidth, int minHeight)
-        {
-            if (this.Data.Width >= minWidth && this.Data.Height >= minHeight)
-                return false;
 
-            Texture2D original = this.Data;
-            Texture2D texture = new(Game1.graphics.GraphicsDevice, Math.Max(original.Width, minWidth), Math.Max(original.Height, minHeight));
-            this.ReplaceWith(texture);
-            this.PatchImage(original);
-            return true;
+                target.SetData(0, targetArea, mergedData, 0, pixelCount);
+            }
+            else
+                target.SetData(0, targetArea, sourceData, 0, pixelCount);
         }
     }
 }