Optimizatio

Author: Blade-kt

common/src/main/kotlin/com/lambda/graphics/RenderMain.kt

@@ -28,7 +28,6 @@ import com.lambda.graphics.gl.Matrices.resetMatrices
 import com.lambda.graphics.renderer.esp.global.DynamicESP
 import com.lambda.graphics.renderer.esp.global.StaticESP
 import com.lambda.module.modules.client.GuiSettings
-import com.lambda.util.Communication.info
 import com.lambda.util.math.Vec2d
 import com.mojang.blaze3d.systems.RenderSystem.getProjectionMatrix
 import org.joml.Matrix4f

common/src/main/kotlin/com/lambda/graphics/buffer/Buffer.kt

@@ -36,6 +36,7 @@ abstract class Buffer(
      * Edge case to handle vertex arrays
      */
     val isVertexArray: Boolean = false,
+    val validate: Boolean = true
 ) {
     /**
      * Specifies how the buffers are used
@@ -105,7 +106,19 @@ abstract class Buffer(
     /**
      * Index of the current buffer.
      */
-    var index: Int = 0; private set
+    private var index: Int = 0; private set(value) {
+        if (field == value) return
+        field = value
+        id = bufferIds[value]
+    }
+
+    /**
+     * ID of the current buffer.
+     */
+    var id: Int = 0; get() {
+        if (field == 0) field = bufferIds[0]
+        return field
+    } private set
 
     /**
      * List of all the buffers.
@@ -129,7 +142,7 @@ abstract class Buffer(
     /**
      * Binds current the buffer [index] to the [target].
      */
-    fun bind() = bind(bufferIds[index])
+    fun bind() = bind(id)
 
     /**
      * Swaps the buffer [index] if [buffers] is greater than 1.
@@ -321,6 +334,8 @@ abstract class Buffer(
     abstract fun upload(data: ByteBuffer, offset: Long)
 
     private fun validate() {
+        if (!validate) return
+
         check(usage in GL_STREAM_DRAW..GL_DYNAMIC_COPY)
         { "Usage is invalid, refer to the documentation table." }
 
@@ -363,7 +378,7 @@ abstract class Buffer(
         var lastIbo = 0
         var prevIbo = 0
 
-        fun createPipelineBuffer(bufferTarget: Int) = object : Buffer(buffers = 1) {
+        fun createPipelineBuffer(bufferTarget: Int) = object : Buffer(buffers = 1, validate = false) {
             override val target: Int = bufferTarget
 
             override val usage: Int = GL_STATIC_DRAW

common/src/main/kotlin/com/lambda/graphics/buffer/vertex/VertexArray.kt

@@ -20,20 +20,33 @@ package com.lambda.graphics.buffer.vertex
 import com.lambda.graphics.buffer.Buffer
 import com.lambda.graphics.buffer.vertex.attributes.VertexAttrib
 import com.lambda.graphics.buffer.vertex.attributes.VertexMode
+import com.lambda.graphics.pipeline.PersistentBuffer
 import net.minecraft.client.render.BufferRenderer
 import org.lwjgl.opengl.GL30C.*
 import org.lwjgl.opengl.GL32C.glDrawElementsBaseVertex
 import java.nio.ByteBuffer
 
 class VertexArray(
-    private val vertexMode: VertexMode,
-    private val attributes: VertexAttrib.Group
+    val vertexMode: VertexMode,
+    val attributes: VertexAttrib.Group
 ) : Buffer(isVertexArray = true) {
     override val usage: Int = -1
     override val target: Int = -1
     override val access: Int = -1
 
-    fun render(
+    private var linkedVBO: PersistentBuffer? = null
+
+    fun renderIndices(
+        ibo: PersistentBuffer
+    ) = linkedVBO?.let { vbo ->
+        renderInternal(
+            indicesSize = ibo.byteBuffer.bytesPut - ibo.uploadOffset,
+            indicesPointer = ibo.byteBuffer.pointer + ibo.uploadOffset,
+            verticesOffset = vbo.uploadOffset
+        )
+    } ?: throw IllegalStateException("Unable to use vertex array without having a VBO linked to it.")
+
+    private fun renderInternal(
         indicesSize: Long,
         indicesPointer: Long,
         verticesOffset: Int
@@ -47,6 +60,17 @@ class VertexArray(
             )
         }
 
+    fun linkVbo(vbo: PersistentBuffer, block: VertexArray.() -> Unit = {  }) {
+        linkedVBO = vbo
+
+        bind {
+            vbo.use {
+                attributes.link()
+                block(this@VertexArray)
+            }
+        }
+    }
+
     override fun map(size: Long, offset: Long, block: (ByteBuffer) -> Unit) = throw UnsupportedOperationException()
     override fun upload(data: ByteBuffer, offset: Long) = throw UnsupportedOperationException()
 

common/src/main/kotlin/com/lambda/graphics/buffer/vertex/attributes/VertexAttrib.kt

@@ -21,36 +21,34 @@ import org.lwjgl.opengl.GL11C.GL_FLOAT
 import org.lwjgl.opengl.GL11C.GL_UNSIGNED_BYTE
 import org.lwjgl.opengl.GL20C.glEnableVertexAttribArray
 import org.lwjgl.opengl.GL20C.glVertexAttribPointer
-import org.lwjgl.opengl.GL33.glVertexAttribDivisor
 
 sealed class VertexAttrib(
     private val componentCount: Int,
     componentSize: Int,
     private val normalized: Boolean,
-    private val single: Boolean,
     private val type: Int
 ) {
     open class Float(
-        normalized: Boolean = false, single: Boolean = false
-    ) : VertexAttrib(1, 4, normalized, single, GL_FLOAT) {
+        normalized: Boolean = false
+    ) : VertexAttrib(1, 4, normalized, GL_FLOAT) {
         companion object : Float()
     }
 
     open class Vec2(
-        normalized: Boolean = false, single: Boolean = false
-    ) : VertexAttrib(2, 4, normalized, single, GL_FLOAT) {
+        normalized: Boolean = false
+    ) : VertexAttrib(2, 4, normalized, GL_FLOAT) {
         companion object : Vec2()
     }
 
     open class Vec3(
-        normalized: Boolean = false, single: Boolean = false
-    ) : VertexAttrib(3, 4, normalized, single, GL_FLOAT) {
+        normalized: Boolean = false
+    ) : VertexAttrib(3, 4, normalized, GL_FLOAT) {
         companion object : Vec3()
     }
 
     open class Color(
-        normalized: Boolean = true, single: Boolean = false
-    ) : VertexAttrib(4, 1, normalized, single, GL_UNSIGNED_BYTE) {
+        normalized: Boolean = true
+    ) : VertexAttrib(4, 1, normalized, GL_UNSIGNED_BYTE) {
         companion object : Color()
     }
 
@@ -59,7 +57,6 @@ sealed class VertexAttrib(
     fun link(index: Int, pointer: Long, stride: Int) {
         glEnableVertexAttribArray(index)
         glVertexAttribPointer(index, componentCount, type, normalized, stride, pointer)
-        if (single) glVertexAttribDivisor(index, 1)
     }
 
     @Suppress("ClassName")
@@ -70,15 +67,7 @@ sealed class VertexAttrib(
 
         // GUI
         object FONT : Group(
-            Vec3, Vec2, Color
-        )
-
-        object RECT : Group(
-            Vec3, Vec2, Color
-        )
-
-        object BLUR : Group(
-            Vec2, Vec2
+            Vec2, Vec2, Color
         )
 
         // WORLD

common/src/main/kotlin/com/lambda/graphics/pipeline/PersistentBuffer.kt

@@ -18,32 +18,33 @@
 package com.lambda.graphics.pipeline
 
 import com.lambda.graphics.buffer.Buffer.Companion.createPipelineBuffer
+import com.lambda.graphics.buffer.DynamicByteBuffer
 import com.lambda.graphics.buffer.DynamicByteBuffer.Companion.dynamicByteBuffer
 import com.lambda.graphics.gl.kibibyte
 import org.lwjgl.system.MemoryUtil.memCopy
-import java.nio.ByteBuffer
+import sun.misc.Unsafe
 
 /**
  * Represents a persistent dynamic coherent buffer for fast opengl rendering purposes
  */
 class PersistentBuffer(
-    target: Int, stride: Int
+    target: Int, stride: Int, initialSize: Int = 1.kibibyte
 ) {
     /**
      * Resizable byte buffer that stores all data used last frame
      */
-    val byteBuffer = dynamicByteBuffer(stride * 1.kibibyte)
+    val byteBuffer = dynamicByteBuffer(stride * initialSize)
 
     /**
      * Data that has passed through the buffer within previous frame
      */
     private val snapshot = dynamicByteBuffer(1)
-    private var cacheSize = 0
+    private var snapshotData = 0L
 
     /**
      * Represents a gpu-side buffer
      */
-    private val glBuffer = createPipelineBuffer(target)
+    val glBuffer = createPipelineBuffer(target)
     private var glSize = 0
 
     var uploadOffset = 0
@@ -58,19 +59,12 @@ class PersistentBuffer(
 
             glBuffer.allocate(byteBuffer.data)
             snapshot.realloc(byteBuffer.capacity)
-            cacheSize = 0
+            snapshotData = 0
             return
+        }
 
-            /* TODO:
-                Cache data in range min(snapshot.capacity, byteBuffer.bytesPut)
-                and force upload after byteBuffer.bytesPut
-            */
-        } else if (cacheSize > 0 && snapshot.capacity >= byteBuffer.bytesPut) {
-            // TODO: precise compare-mapping to minimize uploaded data
-            // Split data by chunks of modified regions and upload them only
-            // Might be useful in cases when position updates but uv/color/etc doesn't
-            // Might be not...
-            if (memcmp(snapshot.data, byteBuffer.data, uploadOffset, dataCount.toInt())) return
+        if (snapshotData > 0 && snapshot.capacity >= byteBuffer.bytesPut) {
+            if (memcmp(snapshot, byteBuffer, uploadOffset, dataCount.toInt())) return
         }
 
         glBuffer.update(uploadOffset.toLong(), dataCount, dataStart)
@@ -82,7 +76,7 @@ class PersistentBuffer(
 
     fun sync() {
         memCopy(byteBuffer.pointer, snapshot.pointer, byteBuffer.bytesPut)
-        cacheSize = byteBuffer.bytesPut.toInt()
+        snapshotData = byteBuffer.bytesPut
 
         byteBuffer.resetPosition()
         uploadOffset = 0
@@ -92,17 +86,26 @@ class PersistentBuffer(
         snapshot.resetPosition()
         byteBuffer.resetPosition()
         uploadOffset = 0
-        cacheSize = 0
+        snapshotData = 0
     }
 
     fun use(block: () -> Unit) = glBuffer.bind { block() }
 
-    private fun memcmp(a: ByteBuffer, b: ByteBuffer, pointer: Int, size: Int): Boolean {
-        for (i in pointer..<(pointer + size)) {
-            if (a[i] != b[i]) {
+    private fun memcmp(a: DynamicByteBuffer, b: DynamicByteBuffer, position: Int, size: Int): Boolean {
+        for (i in position..<(position + size)) {
+            if (UNSAFE.getByte(null, a.pointer + i) !=
+                UNSAFE.getByte(null, b.pointer + i)) {
                 return false
             }
         }
         return true
     }
+
+    companion object {
+        private val UNSAFE = run {
+            val unsafeField = Unsafe::class.java.getDeclaredField("theUnsafe")
+            unsafeField.setAccessible(true)
+            unsafeField.get(null) as Unsafe
+        }
+    }
 }

common/src/main/kotlin/com/lambda/graphics/pipeline/VertexBuilder.kt

@@ -29,8 +29,8 @@ import org.joml.Vector4d
 class VertexBuilder(
     private val direct: VertexPipeline? = null
 ) {
-    private val vertices by lazy { mutableListOf<Attribute>() }
-    private val indices by lazy { mutableListOf<Int>() }
+    val vertices by lazy { mutableListOf<Attribute>() }
+    val indices by lazy { mutableListOf<Int>() }
 
     private var verticesCounter = 0
 
@@ -97,9 +97,8 @@ class VertexBuilder(
     fun collect(vararg indices: Int) =
         indices
 
-    fun use(block: VertexBuilder.() -> Unit) {
+    fun use(block: VertexBuilder.() -> Unit) =
         apply(block)
-    }
 
     /**
      * Creates a new vertex with specified attributes
@@ -120,14 +119,19 @@ class VertexBuilder(
             "Builder is already associated with a rendering pipeline. Cannot upload data again."
         }
 
-        /* Upload vertices */
+        uploadVertices(pipeline.vertices)
+        uploadIndices(pipeline.indices)
+    }
+
+    fun uploadVertices(buffer: DynamicByteBuffer) {
         vertices.forEach { attribute ->
-            attribute.upload(pipeline.vertices)
+            attribute.upload(buffer)
         }
+    }
 
-        /* Upload indices */
+    fun uploadIndices(buffer: DynamicByteBuffer) {
         indices.forEach {
-            pipeline.indices.putInt(it)
+            buffer.putInt(it)
         }
     }
 
@@ -264,4 +268,4 @@ class VertexBuilder(
             var color: java.awt.Color
         ) : Attribute({ putColor(color) })
     }
-}
+}