ref: huge blockpos memory allocation

emyfops · emyfops · commit a2c7d40ef760 · 2024-10-26T21:08:11.000-04:00
diff --git a/common/src/main/kotlin/com/lambda/graphics/renderer/esp/ChunkedESP.kt b/common/src/main/kotlin/com/lambda/graphics/renderer/esp/ChunkedESP.kt
@@ -22,20 +22,19 @@ import com.lambda.event.events.TickEvent
 import com.lambda.event.events.WorldEvent
 import com.lambda.event.listener.SafeListener.Companion.concurrentListener
 import com.lambda.event.listener.SafeListener.Companion.listener
-import com.lambda.graphics.buffer.BufferUsage
 import com.lambda.graphics.renderer.esp.impl.ESPRenderer
 import com.lambda.graphics.renderer.esp.impl.StaticESPRenderer
 import com.lambda.module.modules.client.RenderSettings
 import com.lambda.threading.awaitMainThread
 import net.minecraft.util.math.ChunkPos
-import net.minecraft.world.WorldView
+import net.minecraft.world.World
 import net.minecraft.world.chunk.WorldChunk
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentLinkedDeque
 
 class ChunkedESP private constructor(
     owner: Any,
-    private val update: StaticESPRenderer.(WorldView, Int, Int, Int) -> Unit
+    private val update: StaticESPRenderer.(World, Int, Int, Int) -> Unit
 ) {
     private val rendererMap = ConcurrentHashMap<Long, EspChunk>()
     private val WorldChunk.renderer
@@ -96,7 +95,7 @@ class ChunkedESP private constructor(
 
     companion object {
         fun Any.newChunkedESP(
-            update: StaticESPRenderer.(WorldView, Int, Int, Int) -> Unit
+            update: StaticESPRenderer.(World, Int, Int, Int) -> Unit
         ) = ChunkedESP(this, update)
     }
 
@@ -120,9 +119,7 @@ class ChunkedESP private constructor(
         }
 
         suspend fun rebuild() {
-            val newRenderer = awaitMainThread {
-                StaticESPRenderer(BufferUsage.STATIC)
-            }
+            val newRenderer = awaitMainThread { StaticESPRenderer() }
 
             iterateChunk { x, y, z ->
                 owner.update(newRenderer, chunk.world, x, y, z)
diff --git a/common/src/main/kotlin/com/lambda/graphics/renderer/esp/DirectionMask.kt b/common/src/main/kotlin/com/lambda/graphics/renderer/esp/DirectionMask.kt
@@ -17,6 +17,8 @@
 
 package com.lambda.graphics.renderer.esp
 
+import com.lambda.util.world.FastVector
+import com.lambda.util.world.offset
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 
@@ -39,11 +41,11 @@ object DirectionMask {
     fun Int.exclude(direction: Direction) = exclude(direction.mask)
     fun Int.hasDirection(dir: Int) = (this and dir) != 0
 
-    fun buildSideMesh(blockPos: BlockPos, filter: (BlockPos) -> Boolean): Int {
+    fun buildSideMesh(position: FastVector, filter: (FastVector) -> Boolean): Int {
         var sides = ALL
 
         Direction.entries
-            .filter { filter(blockPos.offset(it)) }
+            .filter { filter(position.offset(it)) }
             .forEach { sides = sides.exclude(it.mask) }
 
         return sides
diff --git a/common/src/main/kotlin/com/lambda/module/modules/player/Scaffold.kt b/common/src/main/kotlin/com/lambda/module/modules/player/Scaffold.kt
@@ -52,6 +52,7 @@ import com.lambda.util.player.MovementUtils.newMovementInput
 import com.lambda.util.player.MovementUtils.roundedForward
 import com.lambda.util.player.MovementUtils.roundedStrafing
 import com.lambda.util.world.raycast.RayCastUtils.blockResult
+import com.lambda.util.world.toFastVec
 import net.minecraft.util.Hand
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
@@ -313,11 +314,11 @@ object Scaffold : Module(
         renderInfo.removeIf {
             val (info, time) = it
 
-            val pos = info.placedPos
+            val pos = info.placedPos.toFastVec()
             val seconds = (currentTime - time) / 1000.0
 
             val sides = buildSideMesh(pos) { meshPos ->
-                renderInfo.any { it.first.placedPos == meshPos }
+                renderInfo.any { it.first.placedPos.toFastVec() == meshPos }
             }
 
             val box = Box(info.placedPos)
diff --git a/common/src/main/kotlin/com/lambda/module/modules/render/BlockESP.kt b/common/src/main/kotlin/com/lambda/module/modules/render/BlockESP.kt
@@ -26,11 +26,11 @@ import com.lambda.graphics.renderer.esp.builders.buildOutline
 import com.lambda.graphics.renderer.esp.impl.StaticESPRenderer
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
-import com.lambda.util.BlockUtils.blockState
+import com.lambda.util.extension.getBlockState
+import com.lambda.util.world.fastVectorOf
 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.Box
 import java.awt.Color
 
@@ -93,18 +93,22 @@ object BlockESP : Module(
         }
     }
 
-    private val esp = newChunkedESP { view, x, y, z ->
-        val blockPos = BlockPos(x, y, z)
-        val state = view.getBlockState(blockPos)
+    private val esp = newChunkedESP { world, x, y, z ->
+        val position = fastVectorOf(x, y, z)
+        val state = world.getBlockState(position)
         if (state.block !in blocks) return@newChunkedESP
 
         val sides = if (mesh) {
-            buildSideMesh(blockPos) {
-                it.blockState(view).block in blocks
+            buildSideMesh(position) {
+                world.getBlockState(it).block in blocks
             }
         } else DirectionMask.ALL
 
-        build(Box(blockPos), sides)
+        build(
+            // big hack
+            Box(x.toDouble(), y.toDouble(), z.toDouble(), x.toDouble()+1, y.toDouble()+1, z.toDouble()+1),
+            sides
+        )
     }
 
     private fun StaticESPRenderer.build(
diff --git a/common/src/main/kotlin/com/lambda/util/world/Position.kt b/common/src/main/kotlin/com/lambda/util/world/Position.kt
@@ -18,6 +18,7 @@
 package com.lambda.util.world
 
 import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Direction
 import net.minecraft.util.math.Vec3d
 import net.minecraft.util.math.Vec3i
 
@@ -131,13 +132,11 @@ infix fun FastVector.plus(vec: FastVector): FastVector = fastVectorOf(x + vec.x,
 
 /**
  * Adds the given vector to the position.
- * @return The new position.
  */
 infix fun FastVector.plus(vec: Vec3i): FastVector = fastVectorOf(x + vec.x, y + vec.y, z + vec.z)
 
 /**
  * Adds the given vector to the position.
- * @return The new position.
  */
 infix fun FastVector.plus(vec: Vec3d): FastVector =
     fastVectorOf(x + vec.x.toLong(), y + vec.y.toLong(), z + vec.z.toLong())
@@ -149,13 +148,11 @@ infix fun FastVector.minus(vec: FastVector): FastVector = fastVectorOf(x - vec.x
 
 /**
  * Subtracts the given vector from the position.
- * @return The new position.
  */
 infix fun FastVector.minus(vec: Vec3i): FastVector = fastVectorOf(x - vec.x, y - vec.y, z - vec.z)
 
 /**
  * Subtracts the given vector from the position.
- * @return The new position.
  */
 infix fun FastVector.minus(vec: Vec3d): FastVector =
     fastVectorOf(x - vec.x.toLong(), y - vec.y.toLong(), z - vec.z.toLong())
@@ -223,15 +220,19 @@ infix fun FastVector.distSq(other: Vec3d): Double {
     return (dx * dx + dy * dy + dz * dz).toDouble()
 }
 
+/**
+ * Adds a [net.minecraft.util.math.Direction] offset to the fast vector
+ */
+fun FastVector.offset(dir: Direction) =
+    fastVectorOf(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ)
+
 /**
  * Converts a [Vec3i] to a [FastVector].
- * @return The encoded position.
  */
 fun Vec3i.toFastVec(): FastVector = fastVectorOf(x.toLong(), y.toLong(), z.toLong())
 
 /**
  * Converts a [Vec3d] to a [FastVector].
- * @return The encoded position.
  */
 fun Vec3d.toFastVec(): FastVector = fastVectorOf(x.toLong(), y.toLong(), z.toLong())
 
