fixed esp, still has caching issues

Author: emyfops

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

@@ -20,15 +20,13 @@ 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.Module
 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
 import java.util.concurrent.ConcurrentHashMap
@@ -53,36 +51,30 @@ class ChunkedESP private constructor(
     }
 
     init {
-        //listen<WorldEvent.BlockUpdate.Client> { rebuildQueue.add(rendererMap[ChunkPos.toLong(it.pos)] ?: return@listen) }
-        listen<WorldEvent.ChunkEvent.Load> {
-            if (!owner.isEnabled) return@listen
-            it.chunk.renderer.notifyChunks()
+        listen<WorldEvent.BlockUpdate.Client> { event ->
+            world.getWorldChunk(event.pos).renderer.notifyChunks()
         }
 
-        listen<WorldEvent.ChunkEvent.Unload> {
-            if (!owner.isEnabled) return@listen
-            rendererMap.remove(it.chunk.pos.toLong())?.notifyChunks()
+        listen<WorldEvent.ChunkEvent.Load> { event ->
+            event.chunk.renderer.notifyChunks()
         }
 
-        listenConcurrently<TickEvent.Post> {
-            if (!owner.isEnabled) return@listenConcurrently
-            if (++ticks % StyleEditor.updateFrequency == 0) {
-                val polls = minOf(StyleEditor.rebuildsPerTick, rebuildQueue.size)
-
-                repeat(polls) { rebuildQueue.poll()?.rebuild() }
+        listen<WorldEvent.ChunkEvent.Unload> {
+            val pos = it.chunk.pos.toLong()
+            rendererMap.remove(pos)?.notifyChunks()
+        }
 
-                ticks = 0
-            }
+        owner.listenConcurrently<TickEvent.Pre> {
+            val polls = minOf(StyleEditor.rebuildsPerTick, rebuildQueue.size)
+            repeat(polls) { rebuildQueue.poll()?.rebuild() }
         }
 
-        owner.onStaticRender {
-            if (!owner.isEnabled || uploadQueue.isEmpty()) return@onStaticRender
+        owner.listen<TickEvent.Pre>  {
             val polls = minOf(StyleEditor.uploadsPerTick, uploadQueue.size)
             repeat(polls) { uploadQueue.poll()?.invoke() }
         }
 
         owner.listen<RenderEvent.Render> {
-            if (!owner.isEnabled) return@listen
             rendererMap.values.forEach { it.renderer.render() }
         }
     }
@@ -98,19 +90,18 @@ class ChunkedESP private constructor(
         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) }
+        /*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 { chunkPos ->
-                owner.rendererMap[chunkPos.toLong()]?.let {
-                    if (!owner.rebuildQueue.contains(it))
-                        owner.rebuildQueue.add(it)
-                }
+            owner.rendererMap[chunk.pos.toLong()]?.let {
+                if (!owner.rebuildQueue.contains(it))
+                    owner.rebuildQueue.add(it)
             }
         }
 
         suspend fun rebuild() {
+            renderer.clear()
             renderer = awaitMainThread { Treed(static = true) }
 
             for (x in chunk.pos.startX..chunk.pos.endX)