Some ChunkESP changes

Author: bladekt

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

@@ -26,27 +26,22 @@ class ChunkedESP private constructor(
     private val uploadQueue = ConcurrentLinkedDeque<() -> Unit>()
     private val rebuildQueue = ConcurrentLinkedDeque<EspChunk>()
 
-    // i completely dont like to listen to enable events
-
     fun rebuild() {
         rebuildQueue.clear()
         rebuildQueue.addAll(rendererMap.values)
     }
 
     init {
         concurrentListener<WorldEvent.BlockUpdate> { event ->
-            world.getWorldChunk(event.pos).renderer.apply {
-                queueRebuild()
-                notifyNeighbors()
-            }
+            world.getWorldChunk(event.pos).renderer.notify()
         }
 
         concurrentListener<WorldEvent.ChunkEvent.Load> { event ->
-            event.chunk.renderer.notifyNeighbors()
+            event.chunk.renderer.notify()
         }
 
         concurrentListener<WorldEvent.ChunkEvent.Unload> { event ->
-            rendererMap.remove(event.chunk.pos.toLong())?.notifyNeighbors()
+            rendererMap.remove(event.chunk.pos.toLong())?.notify()
         }
 
         owner.concurrentListener<TickEvent.Pre> {
@@ -90,18 +85,14 @@ class ChunkedESP private constructor(
         val neighbors = chunkOffsets.map {
             ChunkPos(chunk.pos.x + it.first, chunk.pos.z + it.second)
         }.toTypedArray()
-        val neighborsLoaded get() = neighbors.all { it.isLoaded() }
-
-        fun ChunkPos.isLoaded() = chunk.world.chunkManager.isChunkLoaded(x, z)
 
-        fun queueRebuild() {
-            if (owner.rebuildQueue.contains(this)) return
-            owner.rebuildQueue.add(this)
-        }
-
-        fun notifyNeighbors() {
+        fun notify() {
             neighbors.forEach {
-                owner.rendererMap[it.toLong()]?.queueRebuild()
+                owner.rendererMap[it.toLong()]?.let {
+                    owner.rebuildQueue.apply {
+                        if (!contains(it)) add(it)
+                    }
+                }
             }
         }
 
@@ -114,22 +105,10 @@ class ChunkedESP private constructor(
                 owner.update(newRenderer, chunk.world, x, y, z)
             }
 
-            val upload = {
+            owner.uploadQueue.add {
                 newRenderer.upload()
-                renderer?.clear()
                 renderer = newRenderer
             }
-
-            when (RenderSettings.uploadScheduler) {
-                RenderSettings.UploadScheduler.Instant -> {
-                    runGameBlocking {
-                        upload()
-                    }
-                }
-                RenderSettings.UploadScheduler.Delayed -> {
-                    owner.uploadQueue.add(upload)
-                }
-            }
         }
 
         private fun iterateChunk(block: (Int, Int, Int) -> Unit) = chunk.apply {

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

@@ -19,8 +19,7 @@ object RenderSettings : Module(
     private val lodBiasSetting by setting("Smoothing", 0.0, -10.0..10.0, 0.5) { page == Page.Font }
 
     // ESP
-    val uploadScheduler by setting("Upload Scheduler", UploadScheduler.Instant) { page == Page.ESP }
-    val uploadsPerTick by setting("Uploads", 16, 1..256, 1, unit = " chunk/tick") { page == Page.ESP && uploadScheduler == UploadScheduler.Delayed }
+    val uploadsPerTick by setting("Uploads", 16, 1..256, 1, unit = " chunk/tick") { page == Page.ESP }
     val rebuildsPerTick by setting("Rebuilds", 64, 1..256, 1, unit = " chunk/tick") { page == Page.ESP }
     val vertexMapping by setting("Vertex Mapping", true) { page == Page.ESP }
     val updateFrequency by setting("Update Frequency", 2, 1..10, 1, "Frequency of block updates", unit = " ticks") { page == Page.ESP }
@@ -32,9 +31,4 @@ object RenderSettings : Module(
         Font,
         ESP
     }
-
-    enum class UploadScheduler {
-        Instant,
-        Delayed
-    }
 }