depth test / block outline start / immediate region esp where you update vertices each frame

Author: beanbag44

src/main/kotlin/com/lambda/graphics/esp/RegionESP.kt

@@ -21,18 +21,18 @@ import com.lambda.Lambda.mc
 import com.lambda.graphics.mc.LambdaRenderPipelines
 import com.lambda.graphics.mc.RegionRenderer
 import com.lambda.graphics.mc.RenderRegion
-import com.lambda.util.extension.tickDelta
+import com.lambda.util.extension.tickDeltaF
 import com.mojang.blaze3d.systems.RenderSystem
-import java.util.concurrent.ConcurrentHashMap
-import kotlin.math.floor
 import org.joml.Matrix4f
 import org.joml.Vector3f
 import org.joml.Vector4f
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.floor
 
 /**
  * Base class for region-based ESP systems. Provides unified rendering logic and region management.
  */
-abstract class RegionESP(val name: String, val depthTest: Boolean) {
+abstract class RegionESP(val name: String, var depthTest: Boolean) {
     protected val renderers = ConcurrentHashMap<Long, RegionRenderer>()
 
     /** Get or create a ShapeScope for a specific world position. */
@@ -53,9 +53,9 @@ abstract class RegionESP(val name: String, val depthTest: Boolean) {
 
     /**
      * Render all active regions.
-     * @param tickDelta Progress within current tick (used for interpolation)
+     * @param tickDeltaF Progress within current tick (used for interpolation)
      */
-    open fun render(tickDelta: Float = mc.tickDelta) {
+    fun render() {
         val camera = mc.gameRenderer?.camera ?: return
         val cameraPos = camera.pos
 
@@ -78,7 +78,7 @@ abstract class RegionESP(val name: String, val depthTest: Boolean) {
         }
 
         // Render Faces
-        RegionRenderer.createRenderPass("$name Faces")?.use { pass ->
+        RegionRenderer.createRenderPass("$name Faces", depthTest)?.use { pass ->
             val pipeline =
                     if (depthTest) LambdaRenderPipelines.ESP_QUADS
                     else LambdaRenderPipelines.ESP_QUADS_THROUGH
@@ -91,7 +91,7 @@ abstract class RegionESP(val name: String, val depthTest: Boolean) {
         }
 
         // Render Edges
-        RegionRenderer.createRenderPass("$name Edges")?.use { pass ->
+        RegionRenderer.createRenderPass("$name Edges", depthTest)?.use { pass ->
             val pipeline =
                     if (depthTest) LambdaRenderPipelines.ESP_LINES
                     else LambdaRenderPipelines.ESP_LINES_THROUGH

src/main/kotlin/com/lambda/graphics/mc/ImmediateRegionESP.kt

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2026 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.graphics.mc
+
+import com.lambda.graphics.esp.RegionESP
+import com.lambda.graphics.esp.ShapeScope
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.floor
+
+/**
+ * Interpolated region-based ESP system for smooth entity rendering.
+ *
+ * This system rebuilds and uploads vertices every frame. Callers are responsible for providing
+ * interpolated positions (e.g., using entity.prevX/x with tickDelta). The tick() method swaps
+ * builders to allow smooth transitions between frames.
+ */
+class ImmediateRegionESP(name: String, depthTest: Boolean = false) : RegionESP(name, depthTest) {
+	// Current frame builders (being populated this tick)
+	private val currBuilders = ConcurrentHashMap<Long, ShapeScope>()
+
+	override fun shapes(x: Double, y: Double, z: Double, block: ShapeScope.() -> Unit) {
+		val key = getRegionKey(x, y, z)
+		val scope =
+			currBuilders.getOrPut(key) {
+				val size = RenderRegion.REGION_SIZE
+				val rx = (size * floor(x / size)).toInt()
+				val ry = (size * floor(y / size)).toInt()
+				val rz = (size * floor(z / size)).toInt()
+				ShapeScope(RenderRegion(rx, ry, rz))
+			}
+		scope.apply(block)
+	}
+
+	override fun clear() {
+		currBuilders.clear()
+	}
+
+	fun tick() {
+		currBuilders.clear()
+	}
+
+	override fun upload() {
+		val activeKeys = currBuilders.keys.toSet()
+
+		currBuilders.forEach { (key, scope) ->
+			val renderer = renderers.getOrPut(key) { RegionRenderer(scope.region) }
+			renderer.upload(scope.builder.collector)
+		}
+
+		renderers.forEach { (key, renderer) ->
+			if (key !in activeKeys) {
+				renderer.clearData()
+			}
+		}
+	}
+}

src/main/kotlin/com/lambda/graphics/mc/InterpolatedRegionESP.kt

@@ -126,14 +126,24 @@ class RegionRenderer(val region: RenderRegion) {
 	companion object {
 		/** Helper to create a render pass targeting the main framebuffer. */
 		fun createRenderPass(label: String): RenderPass? {
+			return createRenderPass(label, useDepth = true)
+		}
+
+		/**
+		 * Helper to create a render pass targeting the main framebuffer.
+		 * @param label Debug label for the render pass
+		 * @param useDepth Whether to attach the depth buffer for depth testing
+		 */
+		fun createRenderPass(label: String, useDepth: Boolean): RenderPass? {
 			val framebuffer = mc.framebuffer ?: return null
+			val depthView = if (useDepth) framebuffer.depthAttachmentView else null
 			return RenderSystem.getDevice()
 				.createCommandEncoder()
 				.createRenderPass(
 					{ label },
 					framebuffer.colorAttachmentView,
 					OptionalInt.empty(),
-					framebuffer.depthAttachmentView,
+					depthView,
 					OptionalDouble.empty()
 				)
 		}

src/main/kotlin/com/lambda/graphics/mc/RegionRenderer.kt

@@ -24,7 +24,7 @@ import com.lambda.graphics.renderer.esp.DynamicAABB
 import com.lambda.module.modules.client.StyleEditor
 import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils.blockState
-import com.lambda.util.extension.partialTicks
+import com.lambda.util.extension.tickDelta
 import net.minecraft.block.BlockState
 import net.minecraft.block.entity.BlockEntity
 import net.minecraft.entity.Entity
@@ -35,7 +35,6 @@ import net.minecraft.util.math.Vec3d
 import net.minecraft.util.shape.VoxelShape
 import java.awt.Color
 import kotlin.math.min
-import kotlin.math.sqrt
 
 /**
  * Shape builder for region-based rendering. All coordinates are automatically converted to
@@ -138,7 +137,7 @@ class RegionShapeBuilder(val region: RenderRegion) {
 		val pair = box.pair ?: return
 		val prev = pair.first
 		val curr = pair.second
-		val tickDelta = mc.partialTicks
+		val tickDelta = mc.tickDelta
 		val interpolated = Box(
 			lerp(tickDelta, prev.minX, curr.minX),
 			lerp(tickDelta, prev.minY, curr.minY),
@@ -231,7 +230,7 @@ class RegionShapeBuilder(val region: RenderRegion) {
 		val pair = box.pair ?: return
 		val prev = pair.first
 		val curr = pair.second
-		val tickDelta = mc.partialTicks
+		val tickDelta = mc.tickDelta
 		val interpolated = Box(
 			lerp(tickDelta, prev.minX, curr.minX),
 			lerp(tickDelta, prev.minY, curr.minY),

src/main/kotlin/com/lambda/graphics/mc/RegionShapeBuilder.kt

@@ -77,7 +77,7 @@ import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
 import com.lambda.util.BlockUtils.isEmpty
 import com.lambda.util.BlockUtils.isNotBroken
 import com.lambda.util.BlockUtils.isNotEmpty
-import com.lambda.util.extension.partialTicks
+import com.lambda.util.extension.tickDelta
 import com.lambda.util.item.ItemUtils.block
 import com.lambda.util.math.lerp
 import com.lambda.util.player.gamemode
@@ -248,7 +248,7 @@ object BreakManager : Manager<BreakRequest>(
 
                     val currentProgress = currentDelta / adjustedThreshold
                     val nextTicksProgress = (currentDelta + breakDelta) / adjustedThreshold
-                    val interpolatedProgress = lerp(mc.partialTicks, currentProgress, nextTicksProgress)
+                    val interpolatedProgress = lerp(mc.tickDelta, currentProgress, nextTicksProgress)
 
                     val fillColor = if (config.dynamicFillColor) lerp(
                         interpolatedProgress,

src/main/kotlin/com/lambda/interaction/managers/breaking/BreakManager.kt

@@ -31,7 +31,7 @@ import com.lambda.util.Formatting.format
 import com.lambda.util.combat.CombatUtils.hasDeadlyCrystal
 import com.lambda.util.combat.DamageUtils.isFallDeadly
 import com.lambda.util.extension.fullHealth
-import com.lambda.util.extension.tickDelta
+import com.lambda.util.extension.tickDeltaF
 import com.lambda.util.player.SlotUtils.allStacks
 import com.lambda.util.text.buildText
 import com.lambda.util.text.color
@@ -219,7 +219,7 @@ object AutoDisconnect : Module(
         }),
         Creeper({ creeper }, {
             fastEntitySearch<CreeperEntity>(15.0).find {
-                it.getLerpedFuseTime(mc.tickDelta) > 0.0
+                it.getLerpedFuseTime(mc.tickDeltaF) > 0.0
                         && it.pos.distanceTo(player.pos) <= 5.0
             }?.let { creeper ->
                 buildText {

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

@@ -31,7 +31,7 @@ import com.lambda.util.NamedEnum
 import com.lambda.util.combat.CombatUtils.hasDeadlyCrystal
 import com.lambda.util.combat.DamageUtils.isFallDeadly
 import com.lambda.util.extension.fullHealth
-import com.lambda.util.extension.tickDelta
+import com.lambda.util.extension.tickDeltaF
 import com.lambda.util.world.fastEntitySearch
 import net.minecraft.entity.mob.CreeperEntity
 import net.minecraft.entity.player.PlayerEntity
@@ -85,7 +85,7 @@ object AutoTotem : Module(
     enum class Reason(val check: SafeContext.() -> Boolean) {
         Health({ player.fullHealth < minimumHealth }),
         Creeper({ creeper && fastEntitySearch<CreeperEntity>(15.0).any {
-            it.getLerpedFuseTime(mc.tickDelta) > 0.0
+            it.getLerpedFuseTime(mc.tickDeltaF) > 0.0
                     && it.pos.distanceTo(player.pos) <= 5.0
         } }),
         Player({ players && fastEntitySearch<PlayerEntity>(minPlayerDistance.toDouble()).any { otherPlayer ->