Fixed 3d, 3d classes

Author: emyfops

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

@@ -26,13 +26,13 @@ import com.lambda.graphics.renderer.esp.ShapeBuilder
 import com.lambda.graphics.renderer.esp.Treed
 
 fun Any.onStaticRender(block: SafeContext.(ShapeBuilder) -> Unit) =
-    listen<RenderEvent.World> { block(ShapeBuilder(Treed.staticFaceBuilder, Treed.staticEdgeBuilder)) }
-
+    listen<RenderEvent.Upload> { block(ShapeBuilder(Treed.Static.faceBuilder, Treed.Static.edgeBuilder)) }
 fun Any.onDynamicRender(block: SafeContext.(ShapeBuilder) -> Unit) =
-    listen<RenderEvent.World> { block(ShapeBuilder(Treed.dynamicFaceBuilder, Treed.dynamicEdgeBuilder)) }
+    listen<RenderEvent.Upload> { block(ShapeBuilder(Treed.Dynamic.faceBuilder, Treed.Dynamic.edgeBuilder)) }
 
 sealed class RenderEvent {
-    class World : Event
+    object Upload : Event
+    object Render : Event
 
     class UpdateTarget : ICancellable by Cancellable()
 }

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

@@ -55,16 +55,22 @@ object RenderMain {
 
             GlStateManager._glBindFramebuffer(GL_FRAMEBUFFER, prevFramebuffer)
 
-            Treed.clear()
-            RenderEvent.World().post()
-            Treed.upload()
-            Treed.render()
+            Treed.Static.render()
+            Treed.Dynamic.render()
+
+            RenderEvent.Render.post()
         }
     }
 
     init {
         listen<TickEvent.Post> {
-            //Treed.clear()
+            Treed.Static.clear()
+            Treed.Dynamic.clear()
+
+            RenderEvent.Upload.post()
+
+            Treed.Static.upload()
+            Treed.Dynamic.upload()
         }
     }
 }

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

@@ -17,11 +17,11 @@
 
 package com.lambda.graphics.renderer.esp
 
+import com.lambda.event.events.RenderEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.events.WorldEvent
 import com.lambda.event.events.onStaticRender
 import com.lambda.event.listener.SafeListener.Companion.listen
-import com.lambda.event.listener.SafeListener.Companion.listenConcurrently
 import com.lambda.module.modules.client.StyleEditor
 import com.lambda.util.world.FastVector
 import com.lambda.util.world.fastVectorOf
@@ -37,9 +37,7 @@ class ChunkedESP private constructor(
 ) {
     private val rendererMap = ConcurrentHashMap<Long, EspChunk>()
     private val WorldChunk.renderer
-        get() = rendererMap.getOrPut(pos.toLong()) {
-            EspChunk(this, this@ChunkedESP)
-        }
+        get() = rendererMap.getOrPut(pos.toLong()) { EspChunk(this, this@ChunkedESP) }
 
     private val uploadQueue = ConcurrentLinkedDeque<() -> Unit>()
     private val rebuildQueue = ConcurrentLinkedDeque<EspChunk>()
@@ -52,38 +50,29 @@ class ChunkedESP private constructor(
     }
 
     init {
-        listenConcurrently<WorldEvent.BlockUpdate.Client> { event ->
-            world.getWorldChunk(event.pos).renderer.notifyChunks()
-        }
-
-        listenConcurrently<WorldEvent.ChunkEvent.Load> { event ->
-            event.chunk.renderer.notifyChunks()
-        }
+        listen<WorldEvent.BlockUpdate.Client> { world.getWorldChunk(it.pos).renderer.notifyChunks() }
+        listen<WorldEvent.ChunkEvent.Load> { it.chunk.renderer.notifyChunks() }
+        listen<WorldEvent.ChunkEvent.Unload> { rendererMap.remove(it.chunk.pos.toLong())?.notifyChunks() }
 
-        listenConcurrently<WorldEvent.ChunkEvent.Unload> { event ->
-            rendererMap.remove(event.chunk.pos.toLong())?.notifyChunks()
-        }
-
-        owner.onStaticRender { builder ->
+        owner.onStaticRender {
             if (++ticks % StyleEditor.updateFrequency == 0) {
                 val polls = minOf(StyleEditor.rebuildsPerTick, rebuildQueue.size)
 
-                repeat(polls) {
-                    rebuildQueue.poll()?.rebuild(builder)
-                }
+                repeat(polls) { rebuildQueue.poll()?.rebuild() }
+
                 ticks = 0
             }
         }
 
-        owner.listen<TickEvent.Pre> {
+        owner.listen<RenderEvent.Upload> {
             if (uploadQueue.isEmpty()) return@listen
 
             val polls = minOf(StyleEditor.uploadsPerTick, uploadQueue.size)
 
-            repeat(polls) {
-                uploadQueue.poll()?.invoke()
-            }
+            repeat(polls) { uploadQueue.poll()?.invoke() }
         }
+
+        owner.listen<RenderEvent.Render> { rendererMap.values.forEach { it.renderer.render() } }
     }
 
     companion object {
@@ -93,29 +82,35 @@ class ChunkedESP private constructor(
     }
 
     private class EspChunk(val chunk: WorldChunk, val owner: ChunkedESP) {
-        val neighbors = listOf(1 to 0, 0 to 1, -1 to 0, 0 to -1).map { ChunkPos(chunk.pos.x + it.first, chunk.pos.z + it.second) }
+        var renderer = Treed(static = true)
+        private val builder: ShapeBuilder
+            get() = ShapeBuilder(renderer.faceBuilder, renderer.edgeBuilder)
+
+        val neighbors = listOf(1 to 0, 0 to 1, -1 to 0, 0 to -1)
+            .map { ChunkPos(chunk.pos.x + it.first, chunk.pos.z + it.second) }
 
         fun notifyChunks() {
             neighbors.forEach {
                 owner.rendererMap[it.toLong()]?.let {
-                    owner.rebuildQueue.apply {
-                        if (!contains(it)) add(it)
-                    }
+                    if (!owner.rebuildQueue.contains(it))
+                        owner.rebuildQueue.add(it)
                 }
             }
         }
 
-        fun rebuild(builder: ShapeBuilder) =
-            iterateChunk { owner.update(builder, chunk.world, it) }
+        fun rebuild() {
+            renderer = Treed(static = true)
+
+            chunkIterator { owner.update(builder, chunk.world, it) }
 
-        inline fun iterateChunk(crossinline block: (FastVector) -> Unit) = chunk.apply {
-            for (x in pos.startX..pos.endX) {
-                for (z in pos.startZ..pos.endZ) {
-                    for (y in bottomY..height) {
+            owner.uploadQueue.add { renderer.upload() }
+        }
+
+        inline fun chunkIterator(crossinline block: (FastVector) -> Unit) {
+            for (x in chunk.pos.startX..chunk.pos.endX)
+                for (z in chunk.pos.startZ..chunk.pos.endZ)
+                    for (y in chunk.bottomY..chunk.height)
                         block(fastVectorOf(x, y, z))
-                    }
-                }
-            }
         }
     }
 }

src/main/kotlin/com/lambda/graphics/renderer/esp/ShapeDsl.kt

@@ -36,8 +36,8 @@ import java.awt.Color
 annotation class ShapeDsl
 
 class ShapeBuilder(
-    val faces: VertexBuilder,
-    val edges: VertexBuilder,
+    val faces: VertexBuilder = VertexBuilder(),
+    val edges: VertexBuilder = VertexBuilder(),
 ) {
     @ShapeDsl
     fun filled(

src/main/kotlin/com/lambda/graphics/renderer/esp/Treed.kt

@@ -27,53 +27,42 @@ import com.lambda.graphics.shader.Shader.Companion.shader
 import com.lambda.module.modules.client.StyleEditor
 import com.lambda.util.extension.partialTicks
 
-object Treed {
-    val staticShader = shader("renderer/box_static")
-    val dynamicShader = shader("renderer/box_dynamic")
+open class Treed(static: Boolean) {
+    val shader = if (static) staticMode.first else dynamicMode.first
 
-    val staticFaces = VertexPipeline(VertexMode.TRIANGLES, VertexAttrib.Group.STATIC_RENDERER)
-    val staticEdges = VertexPipeline(VertexMode.LINES, VertexAttrib.Group.STATIC_RENDERER)
-    val dynamicFaces = VertexPipeline(VertexMode.TRIANGLES, VertexAttrib.Group.DYNAMIC_RENDERER)
-    val dynamicEdges = VertexPipeline(VertexMode.LINES, VertexAttrib.Group.DYNAMIC_RENDERER)
+    val faces = VertexPipeline(VertexMode.TRIANGLES, if (static) staticMode.second else dynamicMode.second)
+    val edges = VertexPipeline(VertexMode.LINES, if (static) staticMode.second else dynamicMode.second)
 
-    // Vertex builders for shape building
-    var staticFaceBuilder = VertexBuilder(); private set
-    var dynamicFaceBuilder = VertexBuilder(); private set
-    var staticEdgeBuilder = VertexBuilder(); private set
-    var dynamicEdgeBuilder = VertexBuilder(); private set
+    var faceBuilder = VertexBuilder(); private set
+    var edgeBuilder = VertexBuilder(); private set
 
     fun upload() {
-        staticFaces.upload(staticFaceBuilder)
-        staticEdges.upload(staticEdgeBuilder)
-        dynamicFaces.upload(dynamicFaceBuilder)
-        dynamicEdges.upload(dynamicEdgeBuilder)
+        faces.upload(faceBuilder)
+        edges.upload(edgeBuilder)
     }
 
     fun render() {
-        staticShader.use()
-        staticShader["u_TickDelta"] = Lambda.mc.partialTicks
-        staticShader["u_CameraPosition"] = Lambda.mc.gameRenderer.camera.pos
+        shader.use()
+        shader["u_TickDelta"] = Lambda.mc.partialTicks
+        shader["u_CameraPosition"] = Lambda.mc.gameRenderer.camera.pos
 
-        GlStateUtils.withFaceCulling(staticFaces::render)
-        GlStateUtils.withLineWidth(StyleEditor.outlineWidth, staticEdges::render)
+        GlStateUtils.withFaceCulling(faces::render)
+        GlStateUtils.withLineWidth(StyleEditor.outlineWidth, edges::render)
+    }
 
-        dynamicShader.use()
-        dynamicShader["u_TickDelta"] = Lambda.mc.partialTicks
-        dynamicShader["u_CameraPosition"] = Lambda.mc.gameRenderer.camera.pos
+    fun clear() {
+        faces.clear()
+        edges.clear()
 
-        GlStateUtils.withFaceCulling(dynamicFaces::render)
-        GlStateUtils.withLineWidth(StyleEditor.outlineWidth, dynamicEdges::render)
+        faceBuilder = VertexBuilder()
+        edgeBuilder = VertexBuilder()
     }
 
-    fun clear() {
-        staticFaces.clear()
-        staticEdges.clear()
-        dynamicFaces.clear()
-        dynamicEdges.clear()
+    object Static : Treed(true)
+    object Dynamic : Treed(false)
 
-        staticFaceBuilder = VertexBuilder()
-        staticEdgeBuilder = VertexBuilder()
-        dynamicFaceBuilder = VertexBuilder()
-        dynamicEdgeBuilder = VertexBuilder()
+    companion object {
+        private val staticMode = shader("renderer/box_static") to VertexAttrib.Group.STATIC_RENDERER
+        private val dynamicMode = shader("renderer/box_dynamic") to VertexAttrib.Group.DYNAMIC_RENDERER
     }
 }

src/main/kotlin/com/lambda/module/modules/combat/CrystalAura.kt

@@ -180,7 +180,7 @@ object CrystalAura : Module(
             updatesThisFrame = 0
         }
 
-        listen<RenderEvent.World> {
+        listen<RenderEvent.Upload> {
             if (!debug) return@listen
 
             Matrices.push {

src/main/kotlin/com/lambda/module/modules/movement/Blink.kt

@@ -58,7 +58,7 @@ object Blink : Module(
     private var lastBox = Box(BlockPos.ORIGIN)
 
     init {
-        listen<RenderEvent.World> {
+        listen<RenderEvent.Upload> {
             val time = System.currentTimeMillis()
 
             if (isActive && time - lastUpdate < delay) return@listen

src/main/kotlin/com/lambda/module/modules/network/PacketDelay.kt

@@ -51,7 +51,7 @@ object PacketDelay : Module(
     private var inboundLastUpdate = 0L
 
     init {
-        listen<RenderEvent.World> {
+        listen<RenderEvent.Upload> {
             if (mode != Mode.STATIC) return@listen
 
             flushPools(System.currentTimeMillis())