ref: textures

Author: emyfops

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

@@ -25,10 +25,8 @@ import com.lambda.graphics.pipeline.UIPipeline
 import com.lambda.graphics.renderer.gui.font.core.GlyphInfo
 import com.lambda.graphics.renderer.gui.font.core.LambdaAtlas.get
 import com.lambda.graphics.renderer.gui.font.core.LambdaAtlas.height
-import com.lambda.graphics.renderer.gui.font.core.LambdaAtlas.slot
-import com.lambda.graphics.renderer.gui.font.sdf.DistanceFieldTexture
 import com.lambda.graphics.shader.Shader
-import com.lambda.graphics.texture.TextureOwner.texture
+import com.lambda.graphics.texture.TextureOwner.bind
 import com.lambda.module.modules.client.LambdaMoji
 import com.lambda.module.modules.client.RenderSettings
 import com.lambda.util.math.Vec2d
@@ -44,8 +42,6 @@ object FontRenderer {
     private val chars = RenderSettings.textFont
     private val emojis = RenderSettings.emojiFont
 
-    private val charsSDF = DistanceFieldTexture(chars.texture)
-
     private val shader = Shader("font/font")
     private val pipeline = VertexPipeline(VertexMode.TRIANGLES, VertexAttrib.Group.FONT)
 
@@ -241,12 +237,11 @@ object FontRenderer {
     fun render() {
         shader.use()
         shader["u_FontTexture"] = 0
-        shader["u_EmojiTexture"] = emojis.slot
+        shader["u_EmojiTexture"] = 1
         shader["u_SDFMin"] = 0.3
         shader["u_SDFMax"] = 1.0
 
-        charsSDF.frame.bind()
-        //emojis.bind()
+        bind(chars, emojis)
 
         pipeline.immediateDraw()
     }

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

@@ -19,20 +19,16 @@ package com.lambda.graphics.renderer.gui.font.core
 
 import com.google.common.math.IntMath
 import com.lambda.core.Loadable
-import com.lambda.graphics.texture.TextureOwner.texture
-import com.lambda.graphics.texture.TextureOwner.upload
+import com.lambda.graphics.texture.TextureOwner.uploadField
 import com.lambda.http.Method
 import com.lambda.http.request
 import com.lambda.threading.runGameScheduled
 import com.lambda.util.math.Vec2d
 import com.lambda.util.stream
-import it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap
 import it.unimi.dsi.fastutil.objects.Object2DoubleArrayMap
-import it.unimi.dsi.fastutil.objects.Object2IntArrayMap
 import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap
 import java.awt.*
 import java.awt.image.BufferedImage
-import java.util.function.ToIntFunction
 import java.util.zip.ZipFile
 import javax.imageio.ImageIO
 import kotlin.math.ceil
@@ -66,10 +62,8 @@ import kotlin.time.Duration.Companion.days
  * ```
  */
 object LambdaAtlas : Loadable {
-    private val fontMap = Object2ObjectOpenHashMap<Any, Int2ObjectArrayMap<GlyphInfo>>()
-    private val emojiMap = Object2ObjectOpenHashMap<Any, Object2ObjectOpenHashMap<String, GlyphInfo>>()
-    private val slotReservation =
-        Object2IntArrayMap<Any>() // Will cause undefined behavior if someone is trying to allocate more than 32 slots, unlikely
+    private val fontMap = mutableMapOf<Any, Map<Char, GlyphInfo>>()
+    private val emojiMap = mutableMapOf<Any, Map<String, GlyphInfo>>()
 
     private val bufferPool =
         mutableMapOf<Any, BufferedImage>() // This array is nuked once the data is dispatched to OpenGL
@@ -78,16 +72,9 @@ object LambdaAtlas : Loadable {
     private val metricCache = mutableMapOf<Font, FontMetrics>()
     private val heightCache = Object2DoubleArrayMap<Font>()
 
-    operator fun LambdaFont.get(char: Char): GlyphInfo? = fontMap.getValue(this)[char.code]
+    operator fun LambdaFont.get(char: Char): GlyphInfo? = fontMap.getValue(this)[char]
     operator fun LambdaEmoji.get(string: String): GlyphInfo? = emojiMap.getValue(this)[string]
 
-    // Allow binding any valid font definition enums
-    fun <T : Enum<T>> T.bind() =
-        this@bind.texture.bind(slot = slotReservation.computeIfAbsent(this@bind, ToIntFunction { slotReservation.size }))
-
-    val <T : Enum<T>> T.slot: Int
-        get() = slotReservation.getInt(this@slot)
-
     val LambdaFont.height: Double
         get() = heightCache.getDouble(fontCache[this@height])
 
@@ -154,10 +141,10 @@ object LambdaAtlas : Loadable {
                 x += emoji.width + 2
             }
 
-            emojiMap[this] = constructed
+            emojiMap[this@buildBuffer] = constructed
         }
 
-        bufferPool[this] = image
+        bufferPool[this@buildBuffer] = image
     }
 
     fun LambdaFont.buildBuffer(
@@ -179,7 +166,7 @@ object LambdaAtlas : Loadable {
         var y = CHAR_SPACE
         var rowHeight = 0
 
-        val constructed = Int2ObjectArrayMap<GlyphInfo>()
+        val constructed = mutableMapOf<Char, GlyphInfo>()
         (Char.MIN_VALUE..<characters.toChar()).forEach { char ->
             val charImage = getCharImage(font, char) ?: return@forEach
 
@@ -201,14 +188,14 @@ object LambdaAtlas : Loadable {
             val uv1 = Vec2d(x, y) * oneTexelSize
             val uv2 = Vec2d(x, y).plus(size) * oneTexelSize
 
-            constructed[char.code] = GlyphInfo(size, uv1, uv2)
+            constructed[char] = GlyphInfo(size, uv1, uv2)
             heightCache[font] = max(heightCache.getDouble(font), size.y) // No compare set unfortunately
 
             x += charWidth
         }
 
-        fontMap[this] = constructed
-        bufferPool[this] = image
+        fontMap[this@buildBuffer] = constructed
+        bufferPool[this@buildBuffer] = image
     }
 
     // TODO: Change this when we've refactored the loadables
@@ -219,7 +206,7 @@ object LambdaAtlas : Loadable {
         val str = "Loaded ${bufferPool.size} fonts" // avoid race condition
 
         runGameScheduled {
-            bufferPool.forEach { (owner, image) -> owner.upload(image) }
+            bufferPool.forEach { (owner, image) -> owner.uploadField(image) }
             bufferPool.clear()
         }
 
@@ -255,4 +242,4 @@ object LambdaAtlas : Loadable {
 
         return charImage
     }
-}
+}

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

@@ -22,19 +22,20 @@ import com.lambda.graphics.buffer.frame.FrameBuffer
 import com.lambda.graphics.shader.Shader
 import com.lambda.graphics.texture.Texture
 import com.lambda.util.math.Vec2d
+import java.awt.image.BufferedImage
 
 /**
  * A class that represents a distance field texture, which is created by rendering a given texture
  * onto a framebuffer with specific shader operations.
  *
  * The texture is used to create a signed distance field (SDF) for rendering operations.
  *
- * @param texture The texture to be used for creating the distance field.
+ * @param image Image data to upload
  */
-class DistanceFieldTexture(texture: Texture) {
-    val frame = CachedFrame(texture.width, texture.height).write {
+class DistanceFieldTexture(image: BufferedImage) : Texture(image) {
+    private val frame = CachedFrame(width, height).write {
         FrameBuffer.pipeline.use {
-            val (pos1, pos2) = Vec2d.ZERO to Vec2d(texture.width, texture.height)
+            val (pos1, pos2) = Vec2d.ZERO to Vec2d(width, height)
 
             grow(4)
             putQuad(
@@ -46,13 +47,17 @@ class DistanceFieldTexture(texture: Texture) {
 
             shader.use()
             shader["u_TexelSize"] = Vec2d.ONE / pos2
-            texture.bind()
+            super.bind(0)
 
             immediateDraw()
         }
     }
 
+    override fun bind(slot: Int) {
+        frame.bind(slot)
+    }
+
     companion object {
         private val shader = Shader("signed_distance_field", "renderer/pos_tex")
     }
-}
+}

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

@@ -58,7 +58,7 @@ class AnimatedTexture(path: LambdaResource) : Texture(image = null, forceConsist
 
             gif.clear()
 
-            currentFrame = (currentFrame+1) % frames
+            currentFrame = (currentFrame + 1) % frames
             lastUpload = System.currentTimeMillis()
         }
     }

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

@@ -109,7 +109,8 @@ open class Texture(
 
     init {
         image?.let {
-            bind()
+            // Don't use bind() because if a child class overrides the function we're screwed
+            bindTexture(id)
             upload(it)
         }
     }

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

@@ -17,36 +17,96 @@
 
 package com.lambda.graphics.texture
 
+import com.lambda.graphics.renderer.gui.font.sdf.DistanceFieldTexture
 import com.lambda.util.readImage
-import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap
 import java.awt.image.BufferedImage
 
+/**
+ * The [TextureOwner] object is responsible for managing textures owned by various objects in the render pipeline
+ */
 object TextureOwner {
-    private val textureMap = Object2ObjectOpenHashMap<Any, Texture>()
+    private val textureMap = HashMap<Any, MutableList<Texture>>()
 
     /**
-     * Returns the texture owned by a specific object
+     * Retrieves the first texture owned by the object
      */
     val Any.texture: Texture
-        get() = textureMap.getValue(this@texture)
+        get() = textureMap.getValue(this@texture)[0]
+
+    /**
+     * Retrieves a specific texture owned by the object by its index
+     *
+     * @param index The index of the texture to retrieve
+     * @return The texture [T] at the given index
+     */
+    @Suppress("unchecked_cast")
+    fun <T : Texture> Any.texture(index: Int) =
+        textureMap.getValue(this@texture)[index] as T
 
     /**
-     * Generate mipmap texture from data and associate it with its owner
+     * Binds a list of textures to texture slots, ensuring no more than 32 textures
+     * are bound at once (to fit within the typical GPU limitations)
+     *
+     * @param textures The list of objects that own textures to be bound.
+     * @throws IllegalArgumentException If more than 32 textures are provided.
+     */
+    fun bind(vararg textures: Any) {
+        check(textures.size < 33) { "Texture slot overflow, expected to use less than 33 slots, got ${textures.size} slots" }
+
+        textures.forEachIndexed { index, texture -> texture.texture.bind(index) }
+    }
+
+    /**
+     * Binds a list of textures to texture slots, ensuring no more than 32 textures
+     * are bound at once (to fit within the typical GPU limitations)
+     *
+     * @param textures The list of textures to be bound
+     * @throws IllegalArgumentException If more than 32 textures are provided
+     */
+    fun bind(vararg textures: Texture) {
+        check(textures.size < 33) { "Texture slot overflow, expected to use less than 33 slots, got ${textures.size} slots" }
+
+        textures.forEachIndexed { index, texture -> texture.bind(index) }
+    }
+
+    /**
+     * Uploads a texture from image data and associates it with the object,
+     * optionally generating mipmaps for the texture
+     *
+     * @param data The image data as a [BufferedImage] to create the texture
+     * @param mipmaps The number of mipmaps to generate for the texture (default is 1)
+     * @return The created texture object
      */
     fun Any.upload(data: BufferedImage, mipmaps: Int = 1) =
-        Texture(data, levels = mipmaps).also { textureMap[this@upload] = it }
+        Texture(data, levels = mipmaps).also { textureMap.computeIfAbsent(this@upload) { mutableListOf() }.add(it) }
 
     /**
-     * Generate mipmap texture from data and associate it with its owner
+     * Uploads a texture from an image file path and associates it with the object,
+     * optionally generating mipmaps for the texture
      *
-     * @param path  Lambda resource path containing the image data
+     * @param path The resource path to the image file
+     * @param mipmaps The number of mipmaps to generate for the texture (default is 1)
+     * @return The created texture object
      */
     fun Any.upload(path: String, mipmaps: Int = 1) =
-        Texture(path.readImage(), levels = mipmaps).also { textureMap[this@upload] = it }
+        Texture(path.readImage(), levels = mipmaps).also { textureMap.computeIfAbsent(this@upload) { mutableListOf() }.add(it) }
 
     /**
-     * Loads a gif and associate it with its owner
+     * Uploads a distance field texture from image data and associates it with the object
+     * Distance field textures are commonly used for rendering fonts.
+     *
+     * @param data The image data as a [BufferedImage] to create the distance field texture
+     * @return The created distance field texture object
+     */
+    fun Any.uploadField(data: BufferedImage) =
+        DistanceFieldTexture(data).also { textureMap.computeIfAbsent(this@uploadField) { mutableListOf() }.add(it) }
+
+    /**
+     * Uploads a GIF and associates it with the object as an animated texture
+     *
+     * @param path The resource path to the GIF file
+     * @return The created animated texture object
      */
     fun Any.uploadGif(path: String) =
-        AnimatedTexture(path).also { textureMap[this@uploadGif] = it }
+        AnimatedTexture(path).also { textureMap.computeIfAbsent(this@uploadGif) { mutableListOf() }.add(it) }
 }