Parse emojis from strings

Author: emyfops

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

@@ -10,8 +10,31 @@ import com.lambda.module.modules.client.FontSettings
 import com.lambda.util.math.Vec2d
 import java.awt.Color
 
-class FontRenderer(private val font: LambdaFont) : Renderer(VertexMode.TRIANGLES, VertexAttrib.Group.FONT) {
+class FontRenderer(
+    private val font: LambdaFont,
+    private val emojis: LambdaMoji,
+) : Renderer(VertexMode.TRIANGLES, VertexAttrib.Group.FONT) {
     var scaleMultiplier = 1.0
+    private val emojiRegex = Regex(":[a-zA-Z0-9_]+:")
+
+    /**
+     * Parses the emojis in the given text.
+     *
+     * @param text The text to parse.
+     * @return A list of triples containing the emoji text, start index, and end index.
+     */
+    private fun parseEmojis(text: String): List<
+            Triple<CharInfo, Int, Int>> {
+        val result = mutableListOf<Triple<CharInfo, Int, Int>>()
+        val matches = emojiRegex.findAll(text)
+
+        matches.forEach {
+            val index = it.value.substring(1, it.value.length - 1)
+            result.add(Triple(emojis[index] ?: return@forEach, it.range.first, it.range.last))
+        }
+
+        return result
+    }
 
     fun build(
         text: String,
@@ -28,7 +51,25 @@ class FontRenderer(private val font: LambdaFont) : Renderer(VertexMode.TRIANGLES
         var posX = 0.0
         val posY = getHeight(scale) * -0.5 + baselineOffset * actualScale
 
-        text.toCharArray().forEach { char ->
+        val emojis = parseEmojis(text)
+
+        val subText = emojis.asReversed().fold(text) { acc, (
+            charInfo, start, end
+        ) ->
+            val emojiWidth = charInfo.size.x * actualScale
+            val emojiHeight = charInfo.size.y * actualScale
+
+            val startPos = Vec2d(posX, posY)
+            val endPos = startPos + Vec2d(emojiWidth, emojiHeight)
+
+            putChar(position, startPos, endPos, color, charInfo)
+
+            posX += emojiWidth + scaledGap
+
+            acc.replaceRange(start, end, " ")
+        }
+
+        subText.toCharArray().forEach { char ->
             val charInfo = font[char] ?: return@forEach
             val scaledSize = charInfo.size * actualScale
 
@@ -50,8 +91,20 @@ class FontRenderer(private val font: LambdaFont) : Renderer(VertexMode.TRIANGLES
     fun getWidth(text: String, scale: Double = 1.0): Double {
         var width = 0.0
 
-        text.forEach { char ->
-            val glyph = font[char] ?: return@forEach
+        val emojis = parseEmojis(text)
+
+        val subText = emojis.asReversed().fold(text) { acc, (
+            charInfo, start, end
+        ) ->
+            val emojiWidth = charInfo.size.x
+
+            width += emojiWidth + gap
+
+            acc.replaceRange(start, end, " ")
+        }
+
+        subText.forEach {
+            val glyph = font[it] ?: return@forEach
             width += glyph.size.x + gap
         }
 
@@ -88,6 +141,7 @@ class FontRenderer(private val font: LambdaFont) : Renderer(VertexMode.TRIANGLES
     override fun render() {
         shader.use()
         font.glyphs.bind()
+        //emojis.glyphs.bind() // You have to modify the uniform in the shader to use the correct texture
         super.render()
     }
 
@@ -98,4 +152,4 @@ class FontRenderer(private val font: LambdaFont) : Renderer(VertexMode.TRIANGLES
         private val baselineOffset get() = FontSettings.baselineOffset * 2.0f - 10f
         private val gap get() = FontSettings.gapSetting * 0.5f - 0.8f
     }
-}
+}

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

@@ -1,18 +1,19 @@
 package com.lambda.graphics.renderer.gui.font.glyph
 
+import com.lambda.Lambda.LOG
 import com.lambda.graphics.texture.MipmapTexture
 import com.lambda.module.modules.client.FontSettings
 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.nio.file.Files
 import java.util.zip.ZipFile
 import javax.imageio.ImageIO
 import kotlin.math.ceil
 import kotlin.math.sqrt
+import kotlin.system.measureTimeMillis
 
 class EmojiGlyphs(zipUrl: String) {
     private val emojiMap = mutableMapOf<String, CharInfo>()
@@ -40,25 +41,29 @@ class EmojiGlyphs(zipUrl: String) {
             var x = 0
             var y = 0
 
-            zip.entries().asSequence().forEach { entry ->
-                val name = entry.name.substringAfterLast("/").substringBeforeLast(".")
-                val emoji = ImageIO.read(zip.getInputStream(entry))
+            val time = measureTimeMillis {
+                zip.entries().asSequence().forEach { entry ->
+                    val name = entry.name.substringAfterLast("/").substringBeforeLast(".")
+                    val emoji = ImageIO.read(zip.getInputStream(entry))
 
-                if (x + emoji.width >= width) {
-                    y += emoji.height
-                    x = 0
-                }
+                    if (x + emoji.width >= width) {
+                        y += emoji.height
+                        x = 0
+                    }
 
-                graphics.drawImage(emoji, x, y, null)
+                    graphics.drawImage(emoji, x, y, null)
 
-                val uv1 = Vec2d(x.toDouble(), y.toDouble()) * texelSize
-                val uv2 = Vec2d(x, y).plus(dimensions) * texelSize
-                emojiMap[name] = CharInfo(dimensions, uv1, uv2)
+                    val uv1 = Vec2d(x.toDouble(), y.toDouble()) * texelSize
+                    val uv2 = Vec2d(x, y).plus(dimensions) * texelSize
+                    emojiMap[name] = CharInfo(dimensions, uv1, uv2)
 
-                x += emoji.width
+                    x += emoji.width
+                }
             }
 
             fontTexture = MipmapTexture(image)
+
+            LOG.info("Emoji loaded with ${emojiMap.size} characters (${time}ms)")
         }
     }
 

common/src/main/kotlin/com/lambda/gui/api/RenderLayer.kt

@@ -2,17 +2,21 @@ package com.lambda.gui.api
 
 import com.lambda.graphics.renderer.gui.font.FontRenderer
 import com.lambda.graphics.renderer.gui.font.LambdaFont
+import com.lambda.graphics.renderer.gui.font.LambdaMoji
 import com.lambda.graphics.renderer.gui.rect.FilledRectRenderer
 import com.lambda.graphics.renderer.gui.rect.OutlineRectRenderer
 
 class RenderLayer {
     val filled = FilledRectRenderer()
     val outline = OutlineRectRenderer()
-    val font = FontRenderer(LambdaFont.FiraSansRegular)
+    val font = FontRenderer(
+        LambdaFont.FiraSansRegular,
+        LambdaMoji.Twemoji,
+    )
 
     fun render() {
         filled.render()
         outline.render()
         font.render()
     }
-}
+}