shapedsl

https://youtu.be/efc7njKAfgo

Author: emyfops

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

@@ -17,22 +17,22 @@
 
 package com.lambda.event.events
 
+import com.lambda.context.SafeContext
 import com.lambda.event.Event
 import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
-import com.lambda.graphics.renderer.esp.global.DynamicESP
-import com.lambda.graphics.renderer.esp.global.StaticESP
+import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.graphics.renderer.esp.ShapeBuilder
+import com.lambda.graphics.renderer.esp.Treed
 
-sealed class RenderEvent {
-    class World : Event
+fun Any.onStaticRender(block: SafeContext.(ShapeBuilder) -> Unit) =
+    listen<RenderEvent.World> { block(ShapeBuilder(Treed.staticFaceBuilder, Treed.staticEdgeBuilder)) }
 
-    class StaticESP : Event {
-        val renderer = StaticESP
-    }
+fun Any.onDynamicRender(block: SafeContext.(ShapeBuilder) -> Unit) =
+    listen<RenderEvent.World> { block(ShapeBuilder(Treed.dynamicFaceBuilder, Treed.dynamicEdgeBuilder)) }
 
-    class DynamicESP : Event {
-        val renderer = DynamicESP
-    }
+sealed class RenderEvent {
+    class World : Event
 
     class UpdateTarget : ICancellable by Cancellable()
 }

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

@@ -25,8 +25,7 @@ import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.graphics.gl.GlStateUtils.setupGL
 import com.lambda.graphics.gl.Matrices
 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.graphics.renderer.esp.Treed
 import com.lambda.util.math.Vec2d
 import com.mojang.blaze3d.opengl.GlStateManager
 import com.mojang.blaze3d.systems.RenderSystem
@@ -56,21 +55,16 @@ object RenderMain {
 
             GlStateManager._glBindFramebuffer(GL_FRAMEBUFFER, prevFramebuffer)
 
+            Treed.clear()
             RenderEvent.World().post()
-            StaticESP.render()
-            DynamicESP.render()
+            Treed.upload()
+            Treed.render()
         }
     }
 
     init {
         listen<TickEvent.Post> {
-            StaticESP.clear()
-            RenderEvent.StaticESP().post()
-            StaticESP.upload()
-
-            DynamicESP.clear()
-            RenderEvent.DynamicESP().post()
-            DynamicESP.upload()
+            //Treed.clear()
         }
     }
 }

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

@@ -115,9 +115,6 @@ class VertexBuilder(
     fun collect(vararg indices: Int) =
         indices
 
-    fun use(block: VertexBuilder.() -> Unit) =
-        apply(block)
-
     /**
      * Creates a new vertex with specified attributes
      * @param block Configuration lambda for defining vertex attributes

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

@@ -17,14 +17,14 @@
 
 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.graphics.renderer.esp.impl.StaticESPRenderer
 import com.lambda.module.modules.client.StyleEditor
-import com.lambda.threading.awaitMainThread
+import com.lambda.util.world.FastVector
+import com.lambda.util.world.fastVectorOf
 import net.minecraft.util.math.ChunkPos
 import net.minecraft.world.World
 import net.minecraft.world.chunk.WorldChunk
@@ -33,7 +33,7 @@ import java.util.concurrent.ConcurrentLinkedDeque
 
 class ChunkedESP private constructor(
     owner: Any,
-    private val update: StaticESPRenderer.(World, Int, Int, Int) -> Unit
+    private val update: ShapeBuilder.(World, FastVector) -> Unit
 ) {
     private val rendererMap = ConcurrentHashMap<Long, EspChunk>()
     private val WorldChunk.renderer
@@ -64,12 +64,12 @@ class ChunkedESP private constructor(
             rendererMap.remove(event.chunk.pos.toLong())?.notifyChunks()
         }
 
-        owner.listenConcurrently<TickEvent.Pre> {
+        owner.onStaticRender { builder ->
             if (++ticks % StyleEditor.updateFrequency == 0) {
                 val polls = minOf(StyleEditor.rebuildsPerTick, rebuildQueue.size)
 
                 repeat(polls) {
-                    rebuildQueue.poll()?.rebuild()
+                    rebuildQueue.poll()?.rebuild(builder)
                 }
                 ticks = 0
             }
@@ -84,28 +84,16 @@ class ChunkedESP private constructor(
                 uploadQueue.poll()?.invoke()
             }
         }
-
-        owner.listen<RenderEvent.World> {
-            rendererMap.values.forEach {
-                it.renderer?.render()
-            }
-        }
     }
 
     companion object {
         fun Any.newChunkedESP(
-            update: StaticESPRenderer.(World, Int, Int, Int) -> Unit
-        ) = ChunkedESP(this, update)
+            update: ShapeBuilder.(World, FastVector) -> Unit
+        ) = ChunkedESP(this@newChunkedESP, update)
     }
 
     private class EspChunk(val chunk: WorldChunk, val owner: ChunkedESP) {
-        var renderer: StaticESPRenderer? = 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()
+        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 {
@@ -117,24 +105,14 @@ class ChunkedESP private constructor(
             }
         }
 
-        suspend fun rebuild() {
-            val newRenderer = awaitMainThread { StaticESPRenderer() }
-
-            iterateChunk { x, y, z ->
-                owner.update(newRenderer, chunk.world, x, y, z)
-            }
-
-            owner.uploadQueue.add {
-                newRenderer.upload()
-                renderer = newRenderer
-            }
-        }
+        fun rebuild(builder: ShapeBuilder) =
+            iterateChunk { owner.update(builder, chunk.world, it) }
 
-        private fun iterateChunk(block: (Int, Int, Int) -> Unit) = chunk.apply {
+        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) {
-                        block(x, y, z)
+                        block(fastVectorOf(x, y, z))
                     }
                 }
             }

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

@@ -26,6 +26,8 @@ class DynamicAABB {
     private var prev: Box? = null
     private var curr: Box? = null
 
+    val pair get() = prev?.let { prev -> curr?.let { curr -> prev to curr } }
+
     fun update(box: Box): DynamicAABB {
         prev = curr ?: box
         curr = box
@@ -38,16 +40,6 @@ class DynamicAABB {
         curr = null
     }
 
-    fun getBoxPair(): Pair<Box, Box>? {
-        prev?.let { previous ->
-            curr?.let { current ->
-                return previous to current
-            }
-        }
-
-        return null
-    }
-
     companion object {
         val Entity.dynamicBox
             get() = DynamicAABB().apply {