feat: gif renderer

Author: emyfops

common/src/main/kotlin/com/lambda/graphics/buffer/pixel/PixelBuffer.kt

@@ -18,8 +18,6 @@
 package com.lambda.graphics.buffer.pixel
 
 import com.lambda.graphics.buffer.IBuffer
-import com.lambda.graphics.gl.padding
-import com.lambda.graphics.gl.putTo
 import com.lambda.graphics.texture.Texture
 import org.lwjgl.opengl.GL45C.*
 import java.nio.ByteBuffer
@@ -46,82 +44,52 @@ class PixelBuffer(
     private val texture: Texture,
     private val format: Int,
 ) : IBuffer {
-    override val buffers: Int = 2
+    override val buffers: Int = 1
     override val usage: Int = GL_STATIC_DRAW
     override val target: Int = GL_PIXEL_UNPACK_BUFFER
-    override val access: Int = GL_MAP_WRITE_BIT or GL_MAP_COHERENT_BIT
+    override val access: Int = GL_MAP_WRITE_BIT
     override var index = 0
     override val bufferIds = IntArray(buffers).apply { glGenBuffers(this) }
 
-    private val channels = channelMapping[format] ?: throw IllegalArgumentException("Image format unsupported")
-    private val internalFormat = reverseChannelMapping[channels] ?: throw IllegalArgumentException("Image internal format unsupported")
+    private val channels = channelMapping[format] ?: throw IllegalArgumentException("Invalid image format, expected OpenGL format, got $format instead")
+    private val internalFormat = reverseChannelMapping[channels] ?: throw IllegalArgumentException("Invalid internal image format, expected channels count, got $channels instead")
     private val size = width * height * channels * 1L
 
     override fun upload(
         data: ByteBuffer,
         offset: Long,
     ): Throwable? {
-        // Bind PBO to unpack the data into the texture
         bind()
-
-        // Bind the texture and PBO
         glBindTexture(GL_TEXTURE_2D, texture.id)
 
         // Copy pixels from PBO to texture object
         // Use offset instead of pointer
         glTexSubImage2D(
             GL_TEXTURE_2D,        // Target
-            0,                    // Mipmap level
-            0, 0,                 // x and y offset
+            0,               // Mipmap level
+            0, 0,    // x and y offset
             width, height,        // width and height of the texture (set to your size)
             format,               // Format (depends on your data)
             GL_UNSIGNED_BYTE,     // Type (depends on your data)
-            0,                    // PBO offset (for asynchronous transfer)
+            0,              // PBO offset (for asynchronous transfer)
         )
 
-        // Unbind the texture
-        glBindTexture(GL_TEXTURE_2D, 0)
-
-        // Swap the buffer
-        swap()
-
-        // Bind PBO to update pixel source
-        bind()
-
-        // Map the buffer into the client's memory
-        val error = map(offset, size, data::putTo)
+        val error = update(data, offset)
 
-        // Unbind
         bind(0)
 
         return error
     }
 
     init {
-        // Bind the texture
         glBindTexture(GL_TEXTURE_2D, texture.id)
 
-        // Calculate memory padding in the case we are using tightly
-        // packed data in order to save memory and satisfy the computer's
-        // architecture memory alignment
-        // https://en.wikipedia.org/wiki/Data_structure_alignment
-        // In this case we calculate the padding and subtract this to 4
-        // in order to tell the padding size
-        glPixelStorei(GL_UNPACK_ALIGNMENT, 4 - padding(channels))
-
         // Allocate texture storage
-        // TODO: Might want to figure out the data type based on the input
         glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, format, GL_UNSIGNED_BYTE, 0)
-
-        // Set the texture parameters
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
 
-        // Unbind the texture
-        glBindTexture(GL_TEXTURE_2D, 0)
-
-        // Fill the storage with null
-        storage(size)
+        allocate(size)
     }
 
     companion object {

common/src/main/kotlin/com/lambda/graphics/gl/Memory.kt

@@ -113,20 +113,4 @@ val Long.kibibyte get() = this * 1024
 val Long.mebibyte get() = this * 1024 * 1024
 val Long.gibibyte get() = this * 1024 * 1024 * 1024
 
-/**
- * Returns memory alignment for each CPU architecture
- */
-fun alignment(): Int {
-    return when (System.getProperty("os.arch")?.lowercase()) {
-        "x86", "x86_64" -> 4  // 32-bit or 64-bit x86
-        "arm", "armv7l", "aarch64" -> 4  // ARM architectures
-        else -> 8  // Default to 8 bytes alignment for other architectures
-    }
-}
-
-/**
- * Returns how many bytes will be added to reach memory alignment
- */
-fun padding(size: Int): Int = size % alignment() / 8
-
 fun ByteBuffer.putTo(dst: ByteBuffer) { dst.put(this) }

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

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2024 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.graphics.texture
+
+import com.lambda.graphics.buffer.pixel.PixelBuffer
+import com.lambda.util.Communication.logError
+import com.lambda.util.LambdaResource
+import com.lambda.util.stream
+import org.lwjgl.BufferUtils
+import org.lwjgl.opengl.GL11.GL_RGBA
+import org.lwjgl.stb.STBImage
+import java.nio.ByteBuffer
+import kotlin.properties.Delegates
+
+
+class AnimatedTexture(
+    private val path: LambdaResource,
+) : Texture(null) {
+    lateinit var frameDurations: IntArray
+    var width by Delegates.notNull<Int>()
+    var height by Delegates.notNull<Int>()
+    var channels by Delegates.notNull<Int>()
+    var frames by Delegates.notNull<Int>()
+
+    val blockSize: Int
+        get() = width * height * channels
+
+    lateinit var gif: ByteBuffer // Do NOT free this pointer
+    var pbo: PixelBuffer
+
+    var currentFrame = 0
+    var lastUpload = 0L
+
+    override fun bind(slot: Int) {
+        update()
+        super.bind(slot)
+    }
+
+    fun update() {
+        if (System.currentTimeMillis() - lastUpload >= frameDurations[currentFrame]) {
+            val slice = gif
+                .position(blockSize * currentFrame)
+                .limit(blockSize * (currentFrame + 1))
+
+            pbo.upload(slice, offset = 0)
+                ?.let { err -> logError("Error uploading to PBO", err) }
+
+            gif.clear()
+
+            currentFrame = (currentFrame+1) % frames
+            lastUpload = System.currentTimeMillis()
+        }
+    }
+
+    private fun readGif() {
+        val bytes = path.stream.readAllBytes()
+        val buffer = ByteBuffer.allocateDirect(bytes.size)
+
+        buffer.put(bytes)
+        buffer.flip()
+
+        val pDelays = BufferUtils.createPointerBuffer(1)
+        val pWidth = BufferUtils.createIntBuffer(1)
+        val pHeight = BufferUtils.createIntBuffer(1)
+        val pLayers = BufferUtils.createIntBuffer(1)
+        val pChannels = BufferUtils.createIntBuffer(1)
+
+        // The buffer contains packed frames that can be extracted as follows:
+        // limit = width * height * channels * [frame number]
+        gif = STBImage.stbi_load_gif_from_memory(buffer, pDelays, pWidth, pHeight, pLayers, pChannels, 4)!!
+
+        width = pWidth.get()
+        height = pHeight.get()
+        frames = pLayers.get()
+        channels = pChannels.get()
+
+        frameDurations = IntArray(frames)
+        pDelays.getIntBuffer(frames).get(frameDurations)
+    }
+
+    init {
+        readGif()
+        pbo = PixelBuffer(width, height, this@AnimatedTexture, format = GL_RGBA)
+    }
+}

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

@@ -17,7 +17,6 @@
 
 package com.lambda.graphics.texture
 
-import com.lambda.util.LambdaResource
 import com.lambda.util.readImage
 import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap
 import java.awt.image.BufferedImage
@@ -44,4 +43,10 @@ object TextureOwner {
      */
     fun Any.upload(path: String, mipmaps: Int = 1) =
         Texture(path.readImage(), levels = mipmaps).also { textureMap[this@upload] = it }
+
+    /**
+     * Loads a gif and associate it with its owner
+     */
+    fun Any.uploadGif(path: String) =
+        AnimatedTexture(path).also { textureMap[this@uploadGif] = it }
 }

common/src/main/kotlin/com/lambda/module/hud/GifTest.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2024 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.module.hud
+
+import com.lambda.graphics.renderer.gui.TextureRenderer.drawTexture
+import com.lambda.graphics.texture.TextureOwner.uploadGif
+import com.lambda.module.HudModule
+import com.lambda.module.tag.ModuleTag
+
+object GifTest : HudModule(
+    name = "GifTest",
+    defaultTags = setOf(ModuleTag.CLIENT),
+) {
+    val test = uploadGif("chika.gif")
+
+    override val width = 100.0
+    override val height = 100.0
+
+    init {
+        onRender {
+            drawTexture(test, rect)
+        }
+    }
+}

common/src/main/kotlin/com/lambda/module/hud/Watermark.kt

@@ -20,8 +20,10 @@ package com.lambda.module.hud
 import com.lambda.graphics.renderer.gui.TextureRenderer.drawTexture
 import com.lambda.graphics.renderer.gui.TextureRenderer.drawTextureShaded
 import com.lambda.graphics.texture.TextureOwner.upload
+import com.lambda.graphics.texture.TextureOwner.uploadGif
 import com.lambda.module.HudModule
 import com.lambda.module.tag.ModuleTag
+import com.lambda.util.math.Vec2d
 
 object Watermark : HudModule(
     name = "Watermark",