TexturePacker in Gradle plugin can detect and merge duplicate tiles (#2346)

- Refactor packImages and add packTilesets function
- Implement removing of duplicate tiles in TexturePacker
- Write unit tests for packTilesets in NewTexturePacker

Author: jobe-m

korge-gradle-plugin/src/main/kotlin/korlibs/korge/gradle/texpacker/NewTexturePacker.kt

@@ -40,11 +40,62 @@ object NewTexturePacker {
         } }
     }
 
+    /**
+     * Packs tilesets from the given folders into texture atlases.
+     *
+     * Each tileset image is split into individual tiles of the specified size.
+     * These tiles are checked for duplicates and then packed into atlases.
+     *
+     * @param folders The folders containing tilesets to be packed.
+     * @param padding The padding to apply around each tile in the atlas.
+     * @param tileSize The size of each tile in the tilesets.
+     * @return A list of AtlasInfo objects representing the packed atlases.
+     */
+    fun packTilesets(
+        vararg folders: File,
+        padding: Int = 1,
+        tileSize: Int = 16
+    ): List<AtlasInfo> {
+        // Load all tilesets and create SimpleBitmap instances
+        val tilesets: List<Pair<File, SimpleBitmap>> = getAllFiles(*folders).mapNotNull {
+            try {
+                it.relative to SimpleBitmap(it.file)
+            } catch (e: Throwable) {
+                e.printStackTrace()
+                null
+            }
+        }
+        // Split each tileset into tiles
+        val images = arrayListOf<Pair<File, SimpleBitmap>>()
+        tilesets.forEach { tileset ->
+            val (file, image) = tileset
+            if (image.width % tileSize != 0 || image.height % tileSize != 0) {
+                throw IllegalArgumentException("Tileset image size must be multiple of tileSize ($tileSize): $file with size ${image.width}x${image.height}")
+            }
+            images += image.splitInListOfTiles(file.nameWithoutExtension, tileSize)
+        }
+
+        return packImages(images, enableRotation = false, enableTrimming = false, padding = padding, trimFileName = true, removeDuplicates = true)
+    }
+
+    /**
+     * Packs images from the given folders into texture atlases.
+     *
+     * @param folders The folders containing images to be packed.
+     * @param enableRotation Whether to allow rotation of images for better packing.
+     * @param enableTrimming Whether to trim transparent pixels from images.
+     * @param padding The padding to apply around each image in the atlas.
+     * @param trimFileName Whether to trim the file name in the output info.
+     * @param removeDuplicates Whether to remove duplicate images and map duplicates in atlas info.
+     * @return A list of AtlasInfo objects representing the packed atlases.
+     */
     fun packImages(
         vararg folders: File,
         enableRotation: Boolean = true,
         enableTrimming: Boolean = true,
         padding: Int = 2,
+        trimFileName: Boolean = false,
+        removeDuplicates: Boolean = false
     ): List<AtlasInfo> {
         val images: List<Pair<File, SimpleBitmap>> = getAllFiles(*folders).mapNotNull {
             try {
@@ -54,68 +105,100 @@ object NewTexturePacker {
                 null
             }
         }
+        return packImages(images, enableRotation, enableTrimming, padding, trimFileName, removeDuplicates)
+    }
 
+    private fun packImages(
+        images: List<Pair<File, SimpleBitmap>>,
+        enableRotation: Boolean,
+        enableTrimming: Boolean,
+        padding: Int,
+        trimFileName: Boolean,
+        removeDuplicates: Boolean
+    ): List<AtlasInfo> {
         val packer = NewBinPacker.MaxRectsPacker(4096, 4096, padding * 2, NewBinPacker.IOption(
             smart = true,
             pot = true,
             square = false,
             allowRotation = enableRotation,
-            //allowRotation = false,
             tag = false,
             border = padding
         ))
 
-        packer.addArray(images.map { (file, image) ->
+        // Handle duplicate images if requested
+        val tileMapping = linkedMapOf<File, File>()  // In case of duplicates, map duplicate file to original file
+        val mappedImages = if (removeDuplicates) {   // mappedImages will contain only unique images if removeDuplicates is true
+            // Remove duplicate images
+            val uniqueMap = linkedMapOf<Int, Pair<File, SimpleBitmap>>()
+            for ((fileName, image) in images) {
+                val file = if (trimFileName) File(fileName.nameWithoutExtension) else fileName
+                val hash = image.hashCode()
+                val existing = uniqueMap[hash]
+                if (existing == null) {
+                    uniqueMap[hash] = file to image
+                    tileMapping[file] = file
+                } else tileMapping[file] = existing.first
+            }
+            uniqueMap.values.toList()
+        } else {
+            // No duplicate removal, use all images
+            for ((fileName, _) in images) {
+                val file = if (trimFileName) File(fileName.nameWithoutExtension) else fileName
+                tileMapping[file] = file
+            }
+            images
+        }
+
+        // Add images to the packer (possibly without duplicates)
+        packer.addArray(mappedImages.map { (file, image) ->
             val fullArea = Rectangle(0, 0, image.width, image.height)
             val trimArea = if (enableTrimming) image.trim() else fullArea
             val trimmedImage = image.slice(trimArea)
             //println(trimArea == fullArea)
+            val fileName = if (trimFileName) File(file.nameWithoutExtension) else file
             NewBinPacker.Rectangle(width = trimmedImage.width, height = trimmedImage.height, raw = Info(
-                file, fullArea, trimArea, trimmedImage
+                fileName, fullArea, trimArea, trimmedImage
             ))
         })
 
+        // Building atlas info which includes mapping duplicates
         val outAtlases = arrayListOf<AtlasInfo>()
         for (bin in packer.bins) {
-            //val rwidth = bin.rects.maxOf { it.right }
-            //val rheight = bin.rects.maxOf { it.bottom }
-            //val maxWidth = bin.maxWidth
-            //val maxHeight = bin.maxHeight
-            //val out = SimpleBitmap(rwidth, rheight)
             val out = SimpleBitmap(bin.width, bin.height)
-            //println("${bin.width}x${bin.height}")
-
             val frames = linkedMapOf<String, Any?>()
 
             for (rect in bin.rects) {
                 val info = rect.raw as Info
-                val fileName = info.file.name
-                //println("$rect :: info=$info")
 
-                val chunk = if (rect.rot) info.trimmedImage.flipY().rotate90() else info.trimmedImage
-                out.put(rect.x - padding, rect.y - padding, chunk.extrude(padding))
-                //out.put(rect.x, rect.y, chunk)
+                // Check if this rect (image) is used by any duplicate files - if so, map them all to the same rect area in the atlas
+                val files = tileMapping.filterValues { it == info.file }.keys
+                for (file in files) {
+                    val fileName = file.name
 
-                val obj = LinkedHashMap<String, Any?>()
+                    val chunk = if (rect.rot) info.trimmedImage.flipY().rotate90() else info.trimmedImage
+                    out.put(rect.x - padding, rect.y - padding, chunk.extrude(padding))
 
-                fun Dimension.toObj(rot: Boolean): Map<String, Any?> {
-                    val w = if (!rot) width else height
-                    val h = if (!rot) height else width
-                    return mapOf("w" to w, "h" to h)
-                }
-                fun Rectangle.toObj(rot: Boolean): Map<String, Any?> {
-                    return mapOf("x" to x, "y" to y) + this.size.toObj(rot)
-                }
+                    val obj = LinkedHashMap<String, Any?>()
 
-                obj["frame"] = Rectangle(rect.x, rect.y, rect.width, rect.height).toObj(rect.rot)
-                obj["rotated"] = rect.rot
-                obj["trimmed"] = info.trimArea != info.fullArea
-                obj["spriteSourceSize"] = info.trimArea.toObj(false)
-                obj["sourceSize"] = info.fullArea.size.toObj(false)
+                    fun Dimension.toObj(rot: Boolean): Map<String, Any?> {
+                        val w = if (!rot) width else height
+                        val h = if (!rot) height else width
+                        return mapOf("w" to w, "h" to h)
+                    }
 
-                frames[fileName] = obj
-            }
+                    fun Rectangle.toObj(rot: Boolean): Map<String, Any?> {
+                        return mapOf("x" to x, "y" to y) + this.size.toObj(rot)
+                    }
 
+                    obj["frame"] = Rectangle(rect.x, rect.y, rect.width, rect.height).toObj(rect.rot)
+                    obj["rotated"] = rect.rot
+                    obj["trimmed"] = info.trimArea != info.fullArea
+                    obj["spriteSourceSize"] = info.trimArea.toObj(false)
+                    obj["sourceSize"] = info.fullArea.size.toObj(false)
+
+                    frames[fileName] = obj
+                }
+            }
 
             val atlasOut = linkedMapOf<String, Any?>(
                 "frames" to frames,
@@ -138,3 +221,23 @@ object NewTexturePacker {
         return outAtlases
     }
 }
+
+/**
+ * Split the bitmap into tiles of given size and return them as a list of pairs (File, SimpleBitmap).
+ * The File is named as "${name}_${index} without extension."
+ */
+fun SimpleBitmap.splitInListOfTiles(name: String, tileSize: Int): List<Pair<File, SimpleBitmap>> {
+    val tiles = arrayListOf<Pair<File, SimpleBitmap>>()
+    val tilesX = this.width / tileSize
+    val tilesY = this.height / tileSize
+    var index = 0
+    for (ty in 0 until tilesY) {
+        for (tx in 0 until tilesX) {
+            val tileBitmap = this.slice(Rectangle(tx * tileSize, ty * tileSize, tileSize, tileSize))
+            val tileFile = File("${name}_${index}")
+            tiles.add(tileFile to tileBitmap)
+            index++
+        }
+    }
+    return tiles
+}

korge-gradle-plugin/src/test/kotlin/korlibs/korge/gradle/texpacker/NewTexturePackerTest.kt

@@ -0,0 +1,51 @@
+package korlibs.korge.gradle.texpacker
+
+import korlibs.korge.gradle.typedresources.getResourceURL
+import org.junit.Assert
+import org.junit.Test
+import java.io.File
+
+
+class NewTexturePackerTest {
+    @Test
+    fun testPackTilesets() {
+        val atlasInfos = NewTexturePacker.packTilesets(File(getResourceURL("tilesets").file))
+
+        // Check if duplicate tiles were detected and merged into one tile rect area in the tileset atlas
+        val atlasInfo = atlasInfos.first()
+        val frames = atlasInfo.info["frames"] as Map<String, Any>
+
+        val tile_1 = frames["test_tileset_1"] as Map<String, Any>
+        val tile_2 = frames["test_tileset_4"] as Map<String, Any>
+        val tile_3 = frames["test_tileset_2_0"] as Map<String, Any>  // This tile is in the second tileset but is a duplicate of test_tileset_1
+
+        // Check that all three tiles point to the same frame data (i.e., they are duplicates)
+        val tileFrame_1 = tile_1["frame"] as Map<String, Int>
+        val tileFrame_2 = tile_2["frame"] as Map<String, Int>
+        val tileFrame_3 = tile_3["frame"] as Map<String, Int>
+        Assert.assertEquals(tileFrame_1["x"], tileFrame_2["x"])
+        Assert.assertEquals(tileFrame_1["y"], tileFrame_2["y"])
+        Assert.assertEquals(tileFrame_1["w"], tileFrame_2["w"])
+        Assert.assertEquals(tileFrame_1["h"], tileFrame_2["h"])
+        Assert.assertEquals(tileFrame_1["x"], tileFrame_3["x"])
+        Assert.assertEquals(tileFrame_1["y"], tileFrame_3["y"])
+        Assert.assertEquals(tileFrame_1["w"], tileFrame_3["w"])
+        Assert.assertEquals(tileFrame_1["h"], tileFrame_3["h"])
+
+        // Check that tiles are not rotated or trimmed
+        val rotated_1 = tile_1["rotated"] as Boolean
+        val rotated_2 = tile_2["rotated"] as Boolean
+        val rotated_3 = tile_3["rotated"] as Boolean
+        Assert.assertFalse(rotated_1)
+        Assert.assertFalse(rotated_2)
+        Assert.assertFalse(rotated_3)
+        val trimmed_1 = tile_1["trimmed"] as Boolean
+        val trimmed_2 = tile_2["trimmed"] as Boolean
+        val trimmed_3 = tile_3["trimmed"] as Boolean
+        Assert.assertFalse(trimmed_1)
+        Assert.assertFalse(trimmed_2)
+        Assert.assertFalse(trimmed_3)
+
+        //println("Atlas Info: $atlasInfos")
+    }
+}

…e/gradle/typedresources/AseSpriteTest.kt …korlibs/korge/gradle/util/AseInfoTest.ktkorge-gradle-plugin/src/test/kotlin/korlibs/korge/gradle/typedresources/AseSpriteTest.kt renamed to korge-gradle-plugin/src/test/kotlin/korlibs/korge/gradle/util/AseInfoTest.kt korge-gradle-plugin/src/test/kotlin/korlibs/korge/gradle/typedresources/AseSpriteTest.kt renamed to korge-gradle-plugin/src/test/kotlin/korlibs/korge/gradle/util/AseInfoTest.kt

@@ -1,10 +1,10 @@
-package korlibs.korge.gradle.typedresources
+package korlibs.korge.gradle.util
 
-import korlibs.korge.gradle.util.*
+import korlibs.korge.gradle.typedresources.getResourceBytes
 import org.junit.Assert
 import org.junit.Test
 
-class AseSpriteTest {
+class AseInfoTest {
     @Test
     fun test() {
         val info = ASEInfo.Companion.getAseInfo(getResourceBytes("sprites.ase"))