various performance tweaks (3x faster load time)

Author: emyfops

common/build.gradle.kts

@@ -23,6 +23,7 @@ dependencies {
     // Add dependencies on the required Kotlin modules.
     implementation("org.reflections:reflections:0.10.2")
     implementation("com.github.Edouard127:KDiscordIPC:$discordIPCVersion")
+    implementation("com.pngencoder:pngencoder:0.15.0")
 
     // Add Kotlin
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinxCoroutinesVersion")

common/src/main/kotlin/com/lambda/graphics/renderer/gui/font/LambdaEmoji.kt

@@ -17,7 +17,7 @@ enum class LambdaEmoji(private val zipUrl: String) {
     object Loader : Loadable {
         override fun load(): String {
             entries.forEach(LambdaEmoji::loadGlyphs)
-            return "Loaded ${entries.size} emoji pools"
+            return "Loaded ${entries.size} emoji sets"
         }
     }
 }

common/src/main/kotlin/com/lambda/graphics/renderer/gui/font/glyph/EmojiGlyphs.kt

@@ -3,23 +3,22 @@ package com.lambda.graphics.renderer.gui.font.glyph
 import com.google.common.math.IntMath.pow
 import com.lambda.Lambda.LOG
 import com.lambda.graphics.texture.MipmapTexture
+import com.lambda.http.Method
+import com.lambda.http.request
 import com.lambda.module.modules.client.RenderSettings
-import com.lambda.threading.runGameScheduled
-import com.lambda.threading.runIO
 import com.lambda.util.math.Vec2d
 import java.awt.Color
 import java.awt.Graphics2D
 import java.awt.image.BufferedImage
 import java.io.File
-import java.net.URL
 import java.util.zip.ZipFile
 import javax.imageio.ImageIO
 import kotlin.math.ceil
 import kotlin.math.log2
 import kotlin.math.sqrt
 import kotlin.system.measureTimeMillis
+import kotlin.time.Duration.Companion.days
 
-// TODO: AbstractGlyphs to use for both Font & Emoji glyphs?
 class EmojiGlyphs(zipUrl: String) {
     private val emojiMap = mutableMapOf<String, GlyphInfo>()
     private lateinit var fontTexture: MipmapTexture
@@ -29,9 +28,7 @@ class EmojiGlyphs(zipUrl: String) {
 
     init {
         runCatching {
-            val time = measureTimeMillis {
-                downloadAndProcessZip(zipUrl)
-            }
+            val time = measureTimeMillis { downloadAndProcessZip(zipUrl) }
             LOG.info("Loaded ${emojiMap.size} emojis in $time ms")
         }.onFailure {
             LOG.error("Failed to load emojis: ${it.message}", it)
@@ -40,14 +37,20 @@ class EmojiGlyphs(zipUrl: String) {
     }
 
     private fun downloadAndProcessZip(zipUrl: String) {
-        val file = File.createTempFile("emoji", ".zip").apply { deleteOnExit() }
+        val file = request(zipUrl) {
+            method(Method.GET)
+        }.maybeDownload("emojis.zip", maxAge = 30.days)
 
-        URL(zipUrl).openStream().use { input ->
-            file.outputStream().use { output ->
-                input.copyTo(output)
-            }
-        }
+        fontTexture = MipmapTexture(processZip(file))
+    }
 
+    /**
+     * Processes the given zip file and loads the emojis into the texture.
+     *
+     * @param file The zip file containing the emojis.
+     * @return The texture containing the emojis.
+     */
+    private fun processZip(file: File): BufferedImage {
         ZipFile(file).use { zip ->
             val firstImage = ImageIO.read(zip.getInputStream(zip.entries().nextElement()))
             val length = zip.size().toDouble()
@@ -90,7 +93,7 @@ class EmojiGlyphs(zipUrl: String) {
             }
         }
 
-        fontTexture = MipmapTexture(image)
+        return image
     }
 
     fun bind() {

common/src/main/kotlin/com/lambda/graphics/renderer/gui/font/glyph/FontGlyphs.kt

@@ -1,6 +1,6 @@
 package com.lambda.graphics.renderer.gui.font.glyph
 
-import com.lambda.Lambda
+import com.lambda.Lambda.LOG
 import com.lambda.graphics.texture.MipmapTexture
 import com.lambda.graphics.texture.TextureUtils.getCharImage
 import com.lambda.module.modules.client.RenderSettings
@@ -13,52 +13,60 @@ import java.awt.image.BufferedImage
 import kotlin.math.max
 import kotlin.system.measureTimeMillis
 
-class FontGlyphs(font: Font) {
+class FontGlyphs(
+    private val font: Font
+) {
     private val charMap = Int2ObjectOpenHashMap<GlyphInfo>()
-    private val fontTexture: MipmapTexture
+    private lateinit var fontTexture: MipmapTexture
 
     var fontHeight = 0.0; private set
 
     init {
-        val time = measureTimeMillis {
-            val image = BufferedImage(TEXTURE_SIZE, TEXTURE_SIZE, BufferedImage.TYPE_INT_ARGB)
+        runCatching {
+            val time = measureTimeMillis { processGlyphs() }
+            LOG.info("Font ${font.fontName} loaded with ${charMap.size} characters in $time ms")
+        }.onFailure {
+            LOG.error("Failed to load font glyphs: ${it.message}", it)
+            fontTexture = MipmapTexture(BufferedImage(1024, 1024, BufferedImage.TYPE_INT_ARGB))
+        }
+    }
 
-            val graphics = image.graphics as Graphics2D
-            graphics.background = Color(0, 0, 0, 0)
+    private fun processGlyphs() {
+        val image = BufferedImage(TEXTURE_SIZE, TEXTURE_SIZE, BufferedImage.TYPE_INT_ARGB)
 
-            var x = 0
-            var y = 0
-            var rowHeight = 0
+        val graphics = image.graphics as Graphics2D
+        graphics.background = Color(0, 0, 0, 0)
 
-            (Char.MIN_VALUE..<CHAR_AMOUNT.toChar()).forEach { char ->
-                val charImage = getCharImage(font, char) ?: return@forEach
+        var x = 0
+        var y = 0
+        var rowHeight = 0
 
-                rowHeight = max(rowHeight, charImage.height + STEP)
+        (Char.MIN_VALUE..<CHAR_AMOUNT.toChar()).forEach { char ->
+            val charImage = getCharImage(font, char) ?: return@forEach
 
-                if (x + charImage.width >= TEXTURE_SIZE) {
-                    y += rowHeight
-                    x = 0
-                    rowHeight = 0
-                }
+            rowHeight = max(rowHeight, charImage.height + STEP)
 
-                check(y + charImage.height <= TEXTURE_SIZE) { "Can't load font glyphs. Texture size is too small" }
+            if (x + charImage.width >= TEXTURE_SIZE) {
+                y += rowHeight
+                x = 0
+                rowHeight = 0
+            }
 
-                graphics.drawImage(charImage, x, y, null)
+            check(y + charImage.height <= TEXTURE_SIZE) { "Can't load font glyphs. Texture size is too small" }
 
-                val size = Vec2d(charImage.width, charImage.height)
-                val uv1 = Vec2d(x, y) * ONE_TEXEL_SIZE
-                val uv2 = Vec2d(x, y).plus(size) * ONE_TEXEL_SIZE
+            graphics.drawImage(charImage, x, y, null)
 
-                charMap[char.code] = GlyphInfo(size, uv1, uv2)
-                fontHeight = max(fontHeight, size.y)
+            val size = Vec2d(charImage.width, charImage.height)
+            val uv1 = Vec2d(x, y) * ONE_TEXEL_SIZE
+            val uv2 = Vec2d(x, y).plus(size) * ONE_TEXEL_SIZE
 
-                x += charImage.width + STEP
-            }
+            charMap[char.code] = GlyphInfo(size, uv1, uv2)
+            fontHeight = max(fontHeight, size.y)
 
-            fontTexture = MipmapTexture(image)
+            x += charImage.width + STEP
         }
 
-        Lambda.LOG.info("Font ${font.fontName} loaded with ${charMap.size} characters in $time ms")
+        fontTexture = MipmapTexture(image)
     }
 
     fun bind() {

common/src/main/kotlin/com/lambda/graphics/texture/MipmapTexture.kt

@@ -36,7 +36,13 @@ class MipmapTexture(image: BufferedImage, levels: Int = 4) : Texture() {
     }
 
     companion object {
+        /**
+         * Retrieves an image from the resources folder and generates a mipmap texture.
+         *
+         * @param path The path to the image.
+         * @param levels The number of mipmap levels.
+         */
         fun fromResource(path: String, levels: Int = 4): MipmapTexture =
             MipmapTexture(ImageIO.read(LambdaResource(path).stream), levels)
     }
-}
+}

common/src/main/kotlin/com/lambda/graphics/texture/TextureUtils.kt

@@ -1,19 +1,22 @@
 package com.lambda.graphics.texture
 
+import com.lambda.module.modules.client.RenderSettings
 import com.mojang.blaze3d.systems.RenderSystem
+import com.pngencoder.PngEncoder
 import net.minecraft.client.texture.NativeImage
 import org.lwjgl.BufferUtils
-import org.lwjgl.opengl.GL13C.*
+import org.lwjgl.opengl.GL45C.*
 import java.awt.*
 import java.awt.image.BufferedImage
 import java.io.ByteArrayOutputStream
-import javax.imageio.ImageIO
 import kotlin.math.roundToInt
 import kotlin.math.sqrt
 
 object TextureUtils {
     private val metricCache = mutableMapOf<Font, FontMetrics>()
-
+    private val encoderPreset = PngEncoder()
+        .withCompressionLevel(RenderSettings.textureCompression)
+        .withMultiThreadedCompressionEnabled(RenderSettings.threadedCompression)
 
     fun bindTexture(id: Int, slot: Int = 0) {
         RenderSystem.activeTexture(GL_TEXTURE0 + slot)
@@ -35,21 +38,6 @@ object TextureUtils {
         // Array of floats normalized to [0.0, 1.0] -> [R, G, B, A]
         glTexImage2D(GL_TEXTURE_2D, lod, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, readImage(bufferedImage))
 
-        // I'd also like to use glTexSubImage2D, but we have an issue where the function
-        // would return an error about an invalid texture format.
-        //
-        // It would allow us to upload texture data asynchronously and is more efficient
-        // from testing we gain approximately 20% runtime performance.
-        // If someone with advanced OpenGL knowledge could help us out, that would be great.
-        // (Very unlikely to happen, but I can hope)
-        //
-        // I've also read online that glTexStorage2D can be used for the same purpose as
-        // glTexImage2D with NULL data.
-        // However, some users may have ancient hardware that does not support this function.
-        // as it was implemented in OpenGL 4.2 and ES 3.0.
-        //
-        // glTexSubImage2D(GL_TEXTURE_2D, lod, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, readImage(bufferedImage))
-
         setupTexture(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR)
     }
 
@@ -73,10 +61,10 @@ object TextureUtils {
     }
 
     private fun readImage(bufferedImage: BufferedImage): Long {
-        val stream = ByteArrayOutputStream()
-        ImageIO.write(bufferedImage, "png", stream)
+        val bytes = encoderPreset
+            .withBufferedImage(bufferedImage)
+            .toBytes()
 
-        val bytes = stream.toByteArray()
         val buffer = BufferUtils
             .createByteBuffer(bytes.size)
             .put(bytes)

common/src/main/kotlin/com/lambda/http/Request.kt

@@ -2,10 +2,12 @@ package com.lambda.http
 
 import com.lambda.Lambda
 import com.lambda.util.FolderRegister.cache
+import com.lambda.util.FolderRegister.createFileIfNotExists
+import com.lambda.util.FolderRegister.createIfNotExists
 import java.io.File
+import java.io.OutputStream
 import java.net.HttpURLConnection
 import java.net.URL
-import java.time.Instant
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.days
 
@@ -33,14 +35,21 @@ data class Request(
     /**
      * Downloads the resource at the specified path and caches it for future use.
      *
-     * @param path The path to the resource.
+     * @param name The full name of the file to be cached.
      * @param maxAge The maximum age of the cached resource. Default is 4 days.
+     *
+     * @return A pair containing the cached file and a boolean indicating whether the file was downloaded.
      */
-    fun maybeDownload(path: String, maxAge: Duration = 4.days): ByteArray {
-        val file = File("${cache}/${path.substringAfterLast("/").hashCode()}")
+    fun maybeDownload(
+        name: String,
+        maxAge: Duration = 7.days,
+    ): File {
+        val (file, wasCreated) = createFileIfNotExists(name, cache, true)
 
-        if (file.exists() && Instant.now().toEpochMilli() - file.lastModified() < maxAge.inWholeMilliseconds)
-            return file.readBytes()
+        if (System.currentTimeMillis() - file.lastModified() < maxAge.inWholeMilliseconds
+            && file.length() > 0
+            && !wasCreated)
+            return file
 
         file.writeText("") // Clear the file before writing to it.
 
@@ -64,7 +73,7 @@ data class Request(
             }
         }
 
-        return file.readBytes()
+        return file
     }
 
     /**

common/src/main/kotlin/com/lambda/module/modules/client/RenderSettings.kt

@@ -18,6 +18,10 @@ object RenderSettings : Module(
     val baselineOffset by setting("Vertical Offset", 0.0, -10.0..10.0, 0.5) { page == Page.Font }
     private val lodBiasSetting by setting("Smoothing", 0.0, -10.0..10.0, 0.5) { page == Page.Font }
 
+    // Texture
+    val textureCompression by setting("Compression", 1, 1..9, 1, description = "Texture compression level, higher is slower") { page == Page.TEXTURE }
+    val threadedCompression by setting("Threaded Compression", false, description = "Use multiple threads for texture compression") { page == Page.TEXTURE }
+
     // ESP
     val uploadsPerTick by setting("Uploads", 16, 1..256, 1, unit = " chunk/tick") { page == Page.ESP }
     val rebuildsPerTick by setting("Rebuilds", 64, 1..256, 1, unit = " chunk/tick") { page == Page.ESP }
@@ -28,6 +32,7 @@ object RenderSettings : Module(
 
     private enum class Page {
         Font,
-        ESP
+        TEXTURE,
+        ESP,
     }
 }