BlockESP, Threading rework

Author: bladekt

common/src/main/kotlin/com/lambda/Lambda.kt

@@ -42,5 +42,9 @@ object Lambda {
         .registerTypeAdapter(GameProfile::class.java, GameProfileSerializer)
         .create()
 
-    fun initialize() = Loader.initialize()
+    fun initialize() {
+        recordRenderCall {
+            Loader.initialize()
+        }
+    }
 }

common/src/main/kotlin/com/lambda/event/events/RenderEvent.kt

@@ -4,39 +4,19 @@ import com.lambda.Lambda.mc
 import com.lambda.event.Event
 import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
-import com.lambda.graphics.renderer.esp.DirectionMask
-import com.lambda.graphics.renderer.esp.EntityEspRenderer
+import com.lambda.graphics.renderer.esp.global.BlockESPRenderer
+import com.lambda.graphics.renderer.esp.global.EntityESPRenderer
 import com.lambda.util.math.Vec2d
-import net.minecraft.entity.Entity
-import java.awt.Color
 
 abstract class RenderEvent : Event {
     class World : RenderEvent()
 
+    class BlockESP : RenderEvent() {
+        val renderer = BlockESPRenderer
+    }
+
     class EntityESP : RenderEvent() {
-        fun build(
-            entity: Entity,
-            filledColor: Color,
-            outlineColor: Color,
-            sides: Int = DirectionMask.ALL,
-            outlineMode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.OR
-        ) {
-            buildFilled(entity, filledColor, sides)
-            buildOutline(entity, outlineColor, sides, outlineMode)
-        }
-
-        fun buildFilled(
-            entity: Entity,
-            color: Color,
-            sides: Int = DirectionMask.ALL
-        ) = EntityEspRenderer.buildFilled(entity, color, sides)
-
-        fun buildOutline(
-            entity: Entity,
-            color: Color,
-            sides: Int = DirectionMask.ALL,
-            outlineMode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.OR
-        ) = EntityEspRenderer.buildOutline(entity, color, sides, outlineMode)
+        val renderer = EntityESPRenderer
     }
 
     abstract class GUI(val scale: Double) : RenderEvent() {

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

@@ -7,7 +7,8 @@ import com.lambda.graphics.gl.GlStateUtils.setupGL
 import com.lambda.graphics.gl.Matrices
 import com.lambda.graphics.gl.Matrices.resetMatrix
 import com.lambda.graphics.gl.Matrices.translate
-import com.lambda.graphics.renderer.esp.EntityEspRenderer
+import com.lambda.graphics.renderer.esp.global.BlockESPRenderer
+import com.lambda.graphics.renderer.esp.global.EntityESPRenderer
 import com.lambda.module.modules.client.GuiSettings
 import com.lambda.util.math.Vec2d
 import com.mojang.blaze3d.systems.RenderSystem.getProjectionMatrix
@@ -41,7 +42,8 @@ object RenderMain {
 
         setupGL {
             RenderEvent.World().post()
-            EntityEspRenderer.render()
+            BlockESPRenderer.render()
+            EntityESPRenderer.render()
         }
     }
 

common/src/main/kotlin/com/lambda/graphics/buffer/vao/VAO.kt

@@ -28,21 +28,20 @@ import java.nio.ByteBuffer
 class VAO(
     private val vertexMode: VertexMode,
     attribGroup: VertexAttrib.Group,
-    private val bufferUsage: BufferUsage = BufferUsage.DYNAMIC,
-    initializeInstantly: Boolean = false
+    private val bufferUsage: BufferUsage = BufferUsage.DYNAMIC
 ) : IRenderContext {
     private var vao = 0
     private var vbo = 0
     private var ibo = 0
 
     private val objectSize: Int
 
-    private lateinit var vertices: ByteBuffer
-    private var verticesPointer = 0L
-    private var verticesPosition = 0L
+    private var vertices: ByteBuffer
+    private var verticesPointer: Long
+    private var verticesPosition: Long
 
-    private lateinit var indices: ByteBuffer
-    private var indicesPointer = 0L
+    private var indices: ByteBuffer
+    private var indicesPointer: Long
     private var indicesCount = 0
     private var uploadedIndices = 0
 
@@ -52,20 +51,9 @@ class VAO(
         val stride = attribGroup.stride
         objectSize = stride * vertexMode.indicesCount
 
-        if (initializeInstantly) {
-            initialize(attribGroup, stride)
-        } else {
-            runGameScheduled {
-                initialize(attribGroup, stride)
-            }
-        }
-    }
-
-    private fun initialize(attribGroup: VertexAttrib.Group, stride: Int) {
         vertices = byteBuffer(objectSize * 256 * 4)
         verticesPointer = address(vertices)
         verticesPosition = verticesPointer
-
         indices = byteBuffer(vertexMode.indicesCount * 512 * 4)
         indicesPointer = address(indices)
 

common/src/main/kotlin/com/lambda/graphics/renderer/esp/ChunkedESP.kt

@@ -5,8 +5,9 @@ import com.lambda.event.events.TickEvent
 import com.lambda.event.events.WorldEvent
 import com.lambda.event.listener.SafeListener.Companion.concurrentListener
 import com.lambda.event.listener.SafeListener.Companion.listener
+import com.lambda.graphics.buffer.vao.vertex.BufferUsage
 import com.lambda.module.modules.client.RenderSettings
-import com.lambda.threading.runGameBlocking
+import com.lambda.threading.awaitMainThread
 import net.minecraft.util.math.ChunkPos
 import net.minecraft.world.WorldView
 import net.minecraft.world.chunk.WorldChunk
@@ -15,17 +16,18 @@ import java.util.concurrent.ConcurrentLinkedDeque
 
 class ChunkedESP private constructor(
     owner: Any,
-    private val update: EspRenderer.(WorldView, Int, Int, Int) -> Unit
+    private val update: ESPRenderer.(WorldView, Int, Int, Int) -> Unit
 ) {
     private val rendererMap = ConcurrentHashMap<Long, EspChunk>()
     private val WorldChunk.renderer get() = rendererMap.getOrPut(pos.toLong()) {
         EspChunk(this, this@ChunkedESP)
     }
-    private var ticks = 0
 
     private val uploadQueue = ConcurrentLinkedDeque<() -> Unit>()
     private val rebuildQueue = ConcurrentLinkedDeque<EspChunk>()
 
+    private var ticks = 0
+
     fun rebuild() {
         rebuildQueue.clear()
         rebuildQueue.addAll(rendererMap.values)
@@ -74,14 +76,15 @@ class ChunkedESP private constructor(
 
     companion object {
         fun Any.newChunkedESP(
-            update: EspRenderer.(WorldView, Int, Int, Int) -> Unit
+            update: ESPRenderer.(WorldView, Int, Int, Int) -> Unit
         ) = ChunkedESP(this, update)
     }
 
     private class EspChunk(val chunk: WorldChunk, val owner: ChunkedESP) {
-        var renderer: EspRenderer? = null
+        var renderer: ESPRenderer? = null
 
         private val chunkOffsets = listOf(1 to 0, 0 to 1, -1 to 0, 0 to -1)
+
         val neighbors = chunkOffsets.map {
             ChunkPos(chunk.pos.x + it.first, chunk.pos.z + it.second)
         }.toTypedArray()
@@ -97,8 +100,8 @@ class ChunkedESP private constructor(
         }
 
         suspend fun rebuild() {
-            val newRenderer = runGameBlocking {
-                EspRenderer()
+            val newRenderer = awaitMainThread {
+                ESPRenderer(BufferUsage.STATIC)
             }
 
             iterateChunk { x, y, z ->

common/src/main/kotlin/com/lambda/graphics/renderer/esp/DirectionMask.kt

@@ -1,6 +1,10 @@
 package com.lambda.graphics.renderer.esp
 
+import com.lambda.util.BlockUtils.blockState
+import net.minecraft.block.BlockState
+import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
+import net.minecraft.world.BlockView
 
 object DirectionMask {
     const val EAST  = 1 // X +
@@ -18,6 +22,16 @@ object DirectionMask {
     fun Int.exclude(dir: Int) = this xor dir
     fun Int.hasDirection(dir: Int) = (this and dir) != 0
 
+    fun buildSideMesh(blockPos: BlockPos, filter: (BlockPos) -> Boolean): Int {
+        var sides = ALL
+
+        Direction.entries
+            .filter { filter(blockPos.offset(it)) }
+            .forEach { sides = sides.exclude(it.mask) }
+
+        return sides
+    }
+
     val Direction.mask get() = when (this) {
         Direction.DOWN -> DOWN
         Direction.UP -> UP

common/src/main/kotlin/com/lambda/graphics/renderer/esp/ESPRenderer.kt

@@ -0,0 +1,71 @@
+package com.lambda.graphics.renderer.esp
+
+import com.lambda.Lambda.mc
+import com.lambda.graphics.buffer.vao.IRenderContext
+import com.lambda.graphics.buffer.vao.VAO
+import com.lambda.graphics.buffer.vao.vertex.BufferUsage
+import com.lambda.graphics.buffer.vao.vertex.VertexAttrib
+import com.lambda.graphics.buffer.vao.vertex.VertexMode
+import com.lambda.graphics.gl.GlStateUtils.withFaceCulling
+import com.lambda.graphics.gl.GlStateUtils.withLineWidth
+import com.lambda.graphics.shader.Shader
+import com.lambda.module.modules.client.RenderSettings
+import java.awt.Color
+import java.util.concurrent.ConcurrentHashMap
+
+open class ESPRenderer(
+    usage: BufferUsage
+) {
+    val faces = VAO(VertexMode.TRIANGLES, VertexAttrib.Group.STATIC_RENDERER, usage)
+    val faceVertices = ConcurrentHashMap<Vertex, Int>()
+
+    val outlines = VAO(VertexMode.LINES, VertexAttrib.Group.STATIC_RENDERER, usage)
+    val outlineVertices = ConcurrentHashMap<Vertex, Int>()
+
+    var updateFaces = false
+    var updateOutlines = false
+
+    fun upload() {
+        if (updateFaces) {
+            updateFaces = false
+            faces.upload()
+        }
+
+        if (updateOutlines) {
+            updateOutlines = false
+            outlines.upload()
+        }
+    }
+
+    fun render() {
+        shader.use()
+        shader["u_CameraPosition"] = mc.gameRenderer.camera.pos
+
+        withFaceCulling(faces::render)
+        withLineWidth(RenderSettings.outlineWidth, outlines::render)
+    }
+
+    fun clear() {
+        faceVertices.clear()
+        outlineVertices.clear()
+
+        faces.clear()
+        outlines.clear()
+    }
+
+    fun IRenderContext.vertex(
+        storage: MutableMap<Vertex, Int>,
+        x: Double, y: Double, z: Double,
+        color: Color
+    ) = lazy {
+        storage.getOrPut(Vertex(x, y, z, color)) {
+            vec3(x, y, z).color(color).end()
+        }
+    }
+
+    data class Vertex(val x: Double, val y: Double, val z: Double, val color: Color)
+
+    companion object {
+        private val shader = Shader("renderer/pos_color", "renderer/box_static")
+    }
+}