Update scheduler

Author: Avanatiker

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

@@ -7,17 +7,15 @@ import com.lambda.event.listener.SafeListener.Companion.concurrentListener
 import com.lambda.event.listener.SafeListener.Companion.listener
 import com.lambda.module.modules.client.RenderSettings
 import com.lambda.threading.runGameBlocking
-import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.ChunkPos
 import net.minecraft.world.BlockView
 import net.minecraft.world.chunk.WorldChunk
-import java.awt.Color
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentLinkedDeque
 
 class ChunkedESP private constructor(
     owner: Any,
-    private val update: EspRenderer.(BlockView, BlockPos) -> Boolean
+    private val update: EspRenderer.(BlockView, Int, Int, Int) -> Unit
 ) {
     private val rendererMap = ConcurrentHashMap<ChunkPos, EspChunk>()
     private val WorldChunk.renderer get() = rendererMap.getOrPut(pos) {
@@ -52,19 +50,23 @@ class ChunkedESP private constructor(
 
         owner.concurrentListener<TickEvent.Pre> {
             if (++ticks % RenderSettings.updateFrequency == 0) {
-                rendererMap.values
-                    .filter { it.neighborsLoaded }
-                    .forEach { it.rebuild() }
+                val polls = minOf(RenderSettings.rebuildsPerTick, rebuildPool.size)
+
+                repeat(polls) {
+                    rebuildPool.poll()?.rebuild()
+                }
                 ticks = 0
             }
         }
 
         owner.listener<TickEvent.Pre> {
             if (uploadPool.isEmpty()) return@listener
 
-            uploadPool
-                .take(RenderSettings.uploadsPerTick)
-                .forEach { it() }
+            val polls = minOf(RenderSettings.uploadsPerTick, uploadPool.size)
+
+            repeat(polls) {
+                uploadPool.poll()?.invoke()
+            }
         }
 
         owner.listener<RenderEvent.World> {
@@ -76,14 +78,12 @@ class ChunkedESP private constructor(
 
     companion object {
         fun Any.newChunkedESP(
-            filter: (BlockView, BlockPos) -> Boolean,
-            painter: (BlockView, BlockPos) -> Pair<Color, Color>
-        ) = ChunkedESP(this, filter, painter)
+            update: EspRenderer.(BlockView, Int, Int, Int) -> Unit
+        ) = ChunkedESP(this, update)
     }
 
     private class EspChunk(val chunk: WorldChunk, val owner: ChunkedESP) {
         var renderer: EspRenderer? = null
-        var outdated = true
 
         private val chunkOffsets = listOf(1 to 0, 0 to 1, -1 to 0, 0 to -1)
         val neighbors = chunkOffsets.map {
@@ -104,14 +104,12 @@ class ChunkedESP private constructor(
         }
 
         suspend fun rebuild() {
-            outdated = false
-
             val newRenderer = runGameBlocking {
                 EspRenderer()
             }
 
             iterateChunk { x, y, z ->
-                draw(newRenderer, BlockPos(x, y, z))
+                owner.update(newRenderer, chunk.world, x, y, z)
             }
 
             val upload = {
@@ -131,10 +129,6 @@ class ChunkedESP private constructor(
             }
         }
 
-        private fun draw(renderer: EspRenderer, x: Int, y: Int, z: Int) {
-            if (!owner.update(chunk, blockPos)) return false
-        }
-
         private fun iterateChunk(block: (Int, Int, Int) -> Unit) = chunk.apply {
             for (x in pos.startX..pos.endX) {
                 for (z in pos.startZ..pos.endZ) {

common/src/main/kotlin/com/lambda/module/modules/client/RenderSettings.kt

@@ -21,6 +21,7 @@ object RenderSettings : Module(
     // ESP
     val uploadScheduler by setting("Upload Scheduler", UploadScheduler.Instant) { page == Page.ESP }
     val uploadsPerTick by setting("Uploads", 8, 1..32, 1, unit = " chunk/tick") { page == Page.ESP && uploadScheduler == UploadScheduler.Delayed }
+    val rebuildsPerTick by setting("Rebuilds", 8, 1..32, 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 }
     val outlineWidth by setting("Outline Width", 1.0, 0.1..5.0, 0.1, "Width of block outlines", unit = "px") { page == Page.ESP }

common/src/main/kotlin/com/lambda/module/modules/render/BlockESP.kt

@@ -1,11 +1,19 @@
 package com.lambda.module.modules.render
 
 import com.lambda.Lambda.mc
+import com.lambda.context.SafeContext
 import com.lambda.graphics.renderer.esp.ChunkedESP.Companion.newChunkedESP
+import com.lambda.graphics.renderer.esp.DirectionMask
+import com.lambda.graphics.renderer.esp.DirectionMask.exclude
+import com.lambda.graphics.renderer.esp.DirectionMask.mask
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
+import com.lambda.util.BlockUtils.blockState
+import net.minecraft.block.Block
 import net.minecraft.block.Blocks
 import net.minecraft.client.render.model.BakedModel
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Direction
 import java.awt.Color
 
 object BlockESP : Module(
@@ -37,6 +45,7 @@ object BlockESP : Module(
             }
         }
     }
+    private val blocks by setting("Blocks", setOf(Blocks.BEDROCK), "Render blocks")
 
     @JvmStatic
     val barrier by setting("Solid Barrier Block", true, "Render barrier blocks")
@@ -48,10 +57,33 @@ object BlockESP : Module(
     @JvmStatic
     val model: BakedModel get() = mc.bakedModelManager.missingModel
 
-    private val esp = newChunkedESP(
-        { view, pos -> view.getBlockState(pos).block == Blocks.BEDROCK },
-        { _, _ -> faceColor to outlineColor }
-    )
+    private val esp = newChunkedESP { view, x, y, z ->
+        val blockPos = BlockPos(x, y, z)
+        val state = view.getBlockState(blockPos)
+        if (state.isAir) return@newChunkedESP
+        if (state.block !in blocks) return@newChunkedESP
+
+        val shape = state.getOutlineShape(view, blockPos)
+        if (shape.isEmpty) return@newChunkedESP
+
+        var sides = DirectionMask.ALL
+
+        Direction.entries
+            .filter { blockPos.offset(it).blockState(view).block in blocks }
+            .forEach { sides = sides.exclude(it.mask) }
+
+        shape.boundingBoxes.forEach { box ->
+            val offsetBox = box.offset(blockPos)
+            if (drawFaces) build(offsetBox, faceColor, outlineColor, sides, DirectionMask.OutlineMode.AND)
+            if (drawOutlines) buildOutline(offsetBox, outlineColor, sides, DirectionMask.OutlineMode.AND)
+        }
+    }
+
+    fun SafeContext.getBlock(x: Int, y: Int, z: Int): Block {
+        val chunk = world.getChunk(x shr 4, z shr 4)
+        val section = chunk.getSection(y shr 4)
+        return section.getBlockState(x and 15, y and 15, z and 15).block
+    }
 
     init {
         onToggle {

common/src/main/kotlin/com/lambda/util/BlockUtils.kt

@@ -11,6 +11,7 @@ import net.minecraft.fluid.FluidState
 import net.minecraft.fluid.Fluids
 import net.minecraft.item.Item
 import net.minecraft.util.math.*
+import net.minecraft.world.BlockView
 import kotlin.math.floor
 
 object BlockUtils {
@@ -97,9 +98,9 @@ object BlockUtils {
 
     val allSigns = signs + wallSigns + hangingSigns + hangingWallSigns
 
-    fun BlockPos.blockState(world: ClientWorld): BlockState = world.getBlockState(this)
-    fun BlockPos.fluidState(world: ClientWorld): FluidState = world.getFluidState(this)
-    fun BlockPos.blockEntity(world: ClientWorld) = world.getBlockEntity(this)
+    fun BlockPos.blockState(world: BlockView): BlockState = world.getBlockState(this)
+    fun BlockPos.fluidState(world: BlockView): FluidState = world.getFluidState(this)
+    fun BlockPos.blockEntity(world: BlockView) = world.getBlockEntity(this)
     fun SafeContext.instantBreakable(blockState: BlockState, blockPos: BlockPos): Boolean {
         val ticksNeeded = 1 / blockState.calcBlockBreakingDelta(player, world, blockPos)
         return (ticksNeeded <= 1 && ticksNeeded != 0f) || player.isCreative