feat: font improvements

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/render/ModuleBedPlates.kt

@@ -4,7 +4,11 @@ import net.ccbluex.liquidbounce.event.events.OverlayRenderEvent
 import net.ccbluex.liquidbounce.event.handler
 import net.ccbluex.liquidbounce.features.module.Category
 import net.ccbluex.liquidbounce.features.module.Module
+import net.ccbluex.liquidbounce.render.Fonts
+import net.ccbluex.liquidbounce.render.GUIRenderEnvironment
 import net.ccbluex.liquidbounce.render.engine.Color4b
+import net.ccbluex.liquidbounce.render.engine.font.FontRenderer
+import net.ccbluex.liquidbounce.render.engine.font.FontRendererBuffers
 import net.ccbluex.liquidbounce.render.renderEnvironmentForGUI
 import net.ccbluex.liquidbounce.utils.block.AbstractBlockLocationTracker
 import net.ccbluex.liquidbounce.utils.block.ChunkScanner
@@ -13,7 +17,6 @@ import net.ccbluex.liquidbounce.utils.render.WorldToScreen
 import net.minecraft.block.*
 import net.minecraft.client.gui.DrawContext
 import net.minecraft.item.ItemStack
-import net.minecraft.item.Items
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Vec3d
 import kotlin.math.abs
@@ -46,27 +49,53 @@ object ModuleBedPlates : Module("BedPlates", Category.RENDER) {
     val maxLayers by int("MaxLayers", 5, 1..5)
     val scale by float("Scale", 1.5f, 0.5f..3.0f)
 
+    val fontRenderer: FontRenderer
+        get() = Fonts.DEFAULT_FONT.get()
+
     val renderHandler = handler<OverlayRenderEvent> {
+        val fontBuffers = FontRendererBuffers()
+
         renderEnvironmentForGUI {
-            synchronized(BlockTracker.trackedBlockMap) {
-                val trackedBlockMap = BlockTracker.trackedBlockMap
-
-                for ((_, trackState) in trackedBlockMap) {
-                    val bedPlates = trackState.bedPlates
-                    with(matrixStack) {
-                        push()
-                        try {
-                            renderBedPlates(trackState, bedPlates)
-                        } finally {
-                            pop()
+            val playerPos = player.blockPos
+
+            try {
+                synchronized(BlockTracker.trackedBlockMap) {
+                    val trackedBlockMap = BlockTracker.trackedBlockMap.entries.sortedByDescending {
+                        val bp = BlockPos(it.key.x, it.key.y, it.key.z)
+
+                        bp.getSquaredDistance(playerPos)
+                    }
+
+                    val env = this
+
+                    trackedBlockMap.forEachIndexed { idx, (_, trackState) ->
+                        val bedPlates = trackState.bedPlates
+                        with(matrixStack) {
+                            push()
+                            try {
+                                val z = idx.toFloat() / trackedBlockMap.size.toFloat()
+
+                                renderBedPlates(env, trackState, fontBuffers, bedPlates, z * 1000.0F)
+                            } finally {
+                                pop()
+                            }
                         }
+
                     }
                 }
+            } finally {
+                fontBuffers.draw(fontRenderer)
             }
         }
     }
 
-    private fun renderBedPlates(trackState: TrackedState, bedPlates: List<Block>) {
+    private fun renderBedPlates(
+        env: GUIRenderEnvironment,
+        trackState: TrackedState,
+        fontBuffers: FontRendererBuffers,
+        bedPlates: List<Block>,
+        z: Float
+    ) {
         val screenPos = WorldToScreen.calculateScreenPos(
             pos = trackState.centerPos,
         ) ?: return
@@ -81,28 +110,42 @@ object ModuleBedPlates : Module("BedPlates", Category.RENDER) {
         val bedDistance = mc.player?.pos?.distanceTo(trackState.centerPos) ?: 0.0
         val text = "Bed (${bedDistance.roundToInt()}m)"
 
-        val width = max(bedPlates.size * ITEM_SIZE + ITEM_SIZE, mc.textRenderer.getWidth(text))
-        val height = ITEM_SIZE + mc.textRenderer.fontHeight
-        dc.matrices.translate(-width / 2f, -height / 2f, 0.0f)
+        val c = Fonts.DEFAULT_FONT_SIZE.toFloat()
+
+        val scale = 1.0F / (c * 0.15F) * scale
+
+        val processedText = fontRenderer.process(text, defaultColor = Color4b.WHITE)
+        val stringWidth = fontRenderer.getStringWidth(processedText)
+
+        val width = max(bedPlates.size * ITEM_SIZE + ITEM_SIZE, (stringWidth * scale * 0.75f).toInt())
+        val height = ITEM_SIZE + fontRenderer.height * scale
+        dc.matrices.translate(-width / 2f, -height / 2f, z)
 
         // draw background
         dc.fill(
             -BACKGROUND_PADDING,
             -BACKGROUND_PADDING,
             width + BACKGROUND_PADDING,
-            height + BACKGROUND_PADDING,
+            (height + BACKGROUND_PADDING).toInt(),
             Color4b(0, 0, 0, 128).toRGBA()
         )
 
-        // draw text
-        dc.drawTextWithShadow(
-            mc.textRenderer,
-            text,
-            width / 2 - mc.textRenderer.getWidth(text) / 2,
-            0,
-            Color4b.WHITE.toRGBA()
+        fontRenderer.draw(
+            processedText,
+            -stringWidth / 2.0f,
+            0.0f
         )
 
+        env.matrixStack.push()
+
+        env.matrixStack.translate(screenPos.x, screenPos.y, z)
+        env.matrixStack.translate(0.0f, -height + fontRenderer.height * scale - 6.0F, 0.0f)
+        env.matrixStack.scale(scale, scale, 1.0F)
+
+        fontRenderer.commit(env, fontBuffers)
+
+        env.matrixStack.pop()
+
         // draw items
         val itemStartX = width / 2 - (bedPlates.size + 1) * ITEM_SIZE / 2
         dc.drawItem(

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/render/nametags/ModuleNametags.kt

@@ -81,7 +81,7 @@ object ModuleNametags : Module("Nametags", Category.RENDER) {
 
         nametagsToRender.forEachIndexed { index, (pos, nametagInfo) ->
             // We want nametags that are closer to the player to be rendered above nametags that are further away.
-            val renderZ = index / nametagsToRender.size.toFloat()
+            val renderZ = index / nametagsToRender.size.toFloat() * 1000.0F
 
             nametagRenderer.drawNametag(this, nametagInfo, Vec3(pos.x, pos.y, renderZ))
         }

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/render/nametags/NametagInfo.kt

@@ -22,12 +22,13 @@ import net.ccbluex.liquidbounce.utils.item.isNothing
 import net.minecraft.entity.Entity
 import net.minecraft.entity.LivingEntity
 import net.minecraft.item.ItemStack
+import net.minecraft.text.Text
 
 class NametagInfo(
     /**
      * The text to render as nametag
      */
-    val text: String,
+    val text: Text,
     /**
      * The items that should be rendered above the name tag
      */

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/render/nametags/NametagRenderer.kt

@@ -64,7 +64,7 @@ class NametagRenderer {
 
         val x =
             ModuleNametags.fontRenderer.draw(
-                info.text,
+                ModuleNametags.fontRenderer.process(info.text),
                 0.0F,
                 0.0F,
                 shadow = true,
@@ -102,6 +102,16 @@ class NametagRenderer {
         dc.matrices.scale(ITEM_SCALE * ModuleNametags.scale, ITEM_SCALE * ModuleNametags.scale, 1.0F)
         dc.matrices.translate(-itemsToRender.size * ITEM_SIZE / 2.0F, -ITEM_SIZE.toFloat(), 0.0F)
 
+        dc.fill(
+            0,
+            0,
+            itemsToRender.size * ITEM_SIZE,
+            ITEM_SIZE,
+            Color4b.BLACK.alpha(0).toRGBA()
+        )
+
+        dc.matrices.translate(0.0F, 0.0F, 100.0F)
+
         itemsToRender.forEachIndexed { index, itemStack ->
             dc.drawItem(itemStack, index * ITEM_SIZE, 0)
         }

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/render/nametags/NametagTextFormatter.kt

@@ -18,101 +18,115 @@
  */
 package net.ccbluex.liquidbounce.features.module.modules.render.nametags
 
-import net.ccbluex.liquidbounce.features.module.modules.misc.ModuleNameProtect
-import net.ccbluex.liquidbounce.features.module.modules.misc.ModuleTeams
 import net.ccbluex.liquidbounce.features.module.modules.misc.antibot.ModuleAntiBot
-import net.ccbluex.liquidbounce.features.module.modules.render.ModuleESP
+import net.ccbluex.liquidbounce.features.module.modules.misc.sanitizeWithNameProtect
+import net.ccbluex.liquidbounce.utils.client.asText
 import net.ccbluex.liquidbounce.utils.client.mc
+import net.ccbluex.liquidbounce.utils.client.regular
+import net.ccbluex.liquidbounce.utils.client.withColor
+import net.ccbluex.liquidbounce.utils.combat.EntityTaggingManager
 import net.ccbluex.liquidbounce.utils.entity.getActualHealth
 import net.ccbluex.liquidbounce.utils.entity.ping
 import net.minecraft.entity.Entity
 import net.minecraft.entity.LivingEntity
 import net.minecraft.entity.player.PlayerEntity
+import net.minecraft.text.MutableText
+import net.minecraft.text.Text
+import net.minecraft.text.TextColor
+import net.minecraft.util.Formatting
 import kotlin.math.roundToInt
 
 class NametagTextFormatter(private val entity: Entity) {
-    fun format(): String {
-        val outputBuilder = StringBuilder()
+    fun format(): Text {
+        val outputText = Text.empty()
 
         if (ModuleNametags.distance) {
-            outputBuilder.append(this.distanceText).append(" ")
+            outputText.append(this.distanceText).append(" ")
         }
         if (ModuleNametags.ping) {
-            outputBuilder.append(this.pingText).append(" ")
+            outputText.append(this.pingText).append(" ")
         }
 
-        outputBuilder.append("${this.nameColor}${ModuleNameProtect.replace(entity.displayName!!.string)}")
+        val nameString = entity.displayName!!.sanitizeWithNameProtect().string
+
+        outputText.append(nameString.asText().styled { it.withColor(this.nameColor) })
 
         if (ModuleNametags.Health.enabled) {
-            outputBuilder.append(" ").append(this.healthText)
+            outputText.append(" ").append(this.healthText)
         }
 
         if (this.isBot) {
-            outputBuilder.append(" §c§lBot")
+            outputText.append(" ").append("Bot".asText().styled { it.withColor(Formatting.RED).withBold(true) })
         }
 
-        return outputBuilder.toString()
+        return outputText
     }
 
     private val isBot = ModuleAntiBot.isBot(entity)
 
-    private val nameColor: String
+    private val nameColor: TextColor
         get() {
-            val teamColor = if (ModuleTeams.enabled) {
-                ModuleTeams.getTeamColor(this.entity)
-            } else {
-                null
-            }
+            val tagColor = EntityTaggingManager.getTag(this.entity).color
 
             return when {
-                isBot -> "§3"
-                entity.isInvisible -> "§6"
-                entity.isSneaking -> "§4"
-                teamColor != null -> "§${teamColor.closestFormattingCode()}"
-                else -> "§7"
+                isBot -> Formatting.DARK_AQUA.toTextColor()
+                entity.isInvisible -> Formatting.GOLD.toTextColor()
+                entity.isSneaking -> Formatting.DARK_RED.toTextColor()
+                tagColor != null -> TextColor.fromRgb(tagColor.toRGBA())
+                else -> Formatting.GRAY.toTextColor()
             }
         }
 
-    private val distanceText: String
+    private val distanceText: Text
         get() {
             val playerDistanceRounded = mc.player!!.distanceTo(entity).roundToInt()
 
-            return "§7${playerDistanceRounded}m"
+            return withColor("${playerDistanceRounded}m", Formatting.GRAY)
         }
 
     private fun getPing(entity: Entity): Int? {
         return (entity as? PlayerEntity)?.ping
     }
 
-    private val pingText: String
+    private val pingText: Text
         get() {
-            val playerPing = getPing(entity) ?: return ""
+            val playerPing = getPing(entity) ?: return Text.of("")
 
             val coloringBasedOnPing = when {
-                playerPing > 200 -> "§c"
-                playerPing > 100 -> "§e"
-                else -> "§a"
+                playerPing > 200 -> Formatting.RED
+                playerPing > 100 -> Formatting.YELLOW
+                else -> Formatting.GREEN
             }
 
-            return " §7[" + coloringBasedOnPing + playerPing + "ms§7]"
+            return regular(" [") + withColor(playerPing.toString() + "ms", coloringBasedOnPing) + regular("]")
         }
 
-    private val healthText: String
+    private val healthText: Text
         get() {
             if (entity !is LivingEntity) {
-                return ""
+                return regular("")
             }
 
             val actualHealth = entity.getActualHealth(ModuleNametags.Health.fromScoreboard).toInt()
 
             val healthColor = when {
                 // Perhaps you should modify the values here
-                actualHealth >= 14 -> "§a"
-                actualHealth >= 8 -> "§e"
-                else -> "§c"
+                actualHealth >= 14 -> Formatting.GREEN
+                actualHealth >= 8 -> Formatting.YELLOW
+                else -> Formatting.RED
             }
 
-            return "$healthColor$actualHealth HP"
+            return withColor("$actualHealth HP", healthColor)
 
         }
 }
+
+private fun Formatting.toTextColor(): TextColor {
+    return TextColor(this.colorValue!!, this.name)
+}
+
+operator fun MutableText.plus(text: MutableText): MutableText {
+    this.append(text)
+
+    return this
+}

src/main/kotlin/net/ccbluex/liquidbounce/render/AbstractFontRenderer.kt

@@ -20,8 +20,12 @@ package net.ccbluex.liquidbounce.render
 
 import net.ccbluex.liquidbounce.render.engine.Color4b
 import net.ccbluex.liquidbounce.render.engine.font.FontRendererBuffers
+import net.ccbluex.liquidbounce.render.engine.font.processor.LegacyTextProcessor
+import net.ccbluex.liquidbounce.render.engine.font.processor.TextProcessor
+import net.minecraft.text.Text
+import kotlin.random.Random
 
-abstract class AbstractFontRenderer {
+abstract class AbstractFontRenderer<T> {
     abstract val size: Float
     abstract val height: Float
 
@@ -39,15 +43,18 @@ abstract class AbstractFontRenderer {
      */
     @Suppress("LongParameterList")
     abstract fun draw(
-        text: String,
+        text: T,
         x0: Float,
         y0: Float,
-        defaultColor: Color4b = Color4b.WHITE,
         shadow: Boolean = false,
         z: Float = 0.0f,
         scale: Float = 1.0f
     ): Float
 
+    abstract fun process(text: String, defaultColor: Color4b = Color4b.WHITE): T
+    abstract fun process(text: Text, defaultColor: Color4b = Color4b.WHITE): T
+
+
     /**
      */
     abstract fun commit(
@@ -59,7 +66,7 @@ abstract class AbstractFontRenderer {
      * Approximates the width of a text. Accurate except for obfuscated (`§k`) formatting
      */
     abstract fun getStringWidth(
-        text: String,
+        text: TextProcessor.ProcessedText,
         shadow: Boolean = false
     ): Float
 }