[EntityCulling] opt: Grid partition entities

TODO: Huge CPU cache requirement, even slower than not to slice

Author: Rothes

bukkit/version/v1_18/src/main/kotlin/io/github/rothes/esu/bukkit/module/networkthrottle/entityculling/v1_18/RaytraceHandlerImpl.kt

@@ -25,8 +25,10 @@ import io.github.rothes.esu.core.util.UnsafeUtils.usBooleanAccessor
 import io.github.rothes.esu.core.util.extension.math.floorI
 import io.github.rothes.esu.core.util.extension.math.frac
 import io.github.rothes.esu.core.util.extension.math.square
+import it.unimi.dsi.fastutil.Hash
 import it.unimi.dsi.fastutil.ints.Int2ReferenceOpenHashMap
 import it.unimi.dsi.fastutil.ints.IntArrayList
+import it.unimi.dsi.fastutil.longs.Long2ReferenceOpenHashMap
 import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap
 import kotlinx.coroutines.*
 import net.minecraft.server.level.ServerLevel
@@ -59,6 +61,7 @@ import kotlin.time.Duration.Companion.seconds
 object RaytraceHandlerImpl: RaytraceHandler<RaytraceHandlerImpl.RaytraceConfig, EmptyConfiguration>() {
 
     private const val COLLISION_EPSILON = 1E-7
+    private const val GRID_SIZE = 5
     private val INIT_SECTION: Array<LevelChunkSection> = arrayOf()
     private val ENTITY_TYPES: Int
 
@@ -194,7 +197,7 @@ object RaytraceHandlerImpl: RaytraceHandler<RaytraceHandlerImpl.RaytraceConfig,
                     }
                     val entities = entityMap.int2ReferenceEntrySet().map {
                         val squaredRange = (it.intKey + 8).square() // Add extra 8 blocks
-                        SortedEntities(squaredRange, it.value)
+                        SlicedEntities(squaredRange, it.value)
                     }
                     /* Sort entities by tracking range */
 
@@ -268,16 +271,19 @@ object RaytraceHandlerImpl: RaytraceHandler<RaytraceHandlerImpl.RaytraceConfig,
 
     }
 
-    fun tickPlayer(player: ServerPlayer, bukkit: Player, userCullData: UserCullData, level: ServerLevel, entities: List<SortedEntities>) {
+    fun tickPlayer(player: ServerPlayer, bukkit: Player, userCullData: UserCullData, level: ServerLevel, collected: List<SlicedEntities>) {
         val viewDistanceSquared = (bukkit.viewDistance + 1).square() shl 8
 
+        val playerX = player.x
+        val playerZ = player.z
+
         val shouldCull = userCullData.shouldCull
         val predicatedPlayerPos = if (shouldCull && config.predicatePlayerPositon) {
             val velocity = playerVelocityGetter.getPlayerMoveVelocity(player)
             if (velocity.lengthSqr() >= 0.06) { // Threshold for sprinting
-                var x = player.x
+                var x = playerX
                 var y = player.eyeY
-                var z = player.z
+                var z = playerZ
 
                 var vx = velocity.x
                 var vy = velocity.y
@@ -298,26 +304,37 @@ object RaytraceHandlerImpl: RaytraceHandler<RaytraceHandlerImpl.RaytraceConfig,
 
         var tickedEntities = 0
 
-        for ((trackRange, entities) in entities) {
-            val maxRange = min(trackRange, viewDistanceSquared)
-            for (entity in entities) {
-                if (entity === player) continue
-                val dist = (player.x - entity.x).square() + (player.z - entity.z).square()
-                if (dist > maxRange) continue
-
-                tickedEntities++
+        for (sorted in collected) {
+            val range = min(sorted.trackRangeSquared, viewDistanceSquared)
+            val sqrt = sqrt(range.toDouble())
+            val minX = (playerX - sqrt).floorI() shr GRID_SIZE
+            val maxX = (playerX + sqrt).floorI() shr GRID_SIZE
+            val minZ = (playerZ - sqrt).floorI() shr GRID_SIZE
+            val maxZ = (playerZ + sqrt).floorI() shr GRID_SIZE
+            for (x in minX..maxX) {
+                for (z in minZ..maxZ) {
+                    val index = x.toLong() and (z.toLong() shl Int.SIZE_BITS)
+                    val entities = sorted.slices.get(index) ?: continue
+                    for (entity in entities) {
+                        if (entity === player) continue
+                        val dist = (playerX - entity.x).square() + (playerZ - entity.z).square()
+                        if (dist > range) continue
+
+                        tickedEntities++
+
+                        if (
+                            !shouldCull
+                            || entity.isCurrentlyGlowing
+                            || config.visibleEntityTypes.contains(entity.type)
+                            || dist + (player.y - entity.y).square() <= forceVisibleDistanceSquared
+                        ) {
+                            userCullData.setCulled(entity.bukkitEntity, entity.id, false)
+                            continue
+                        }
 
-                if (
-                    !shouldCull
-                    || entity.isCurrentlyGlowing
-                    || config.visibleEntityTypes.contains(entity.type)
-                    || dist + (player.y - entity.y).square() <= forceVisibleDistanceSquared
-                ) {
-                    userCullData.setCulled(entity.bukkitEntity, entity.id, false)
-                    continue
+                        userCullData.setCulled(entity.bukkitEntity, entity.id, raytrace(player, predicatedPlayerPos, entity, level))
+                    }
                 }
-
-                userCullData.setCulled(entity.bukkitEntity, entity.id, raytrace(player, predicatedPlayerPos, entity, level))
             }
         }
         userCullData.shouldCull = tickedEntities >= config.cullThreshold
@@ -605,7 +622,27 @@ object RaytraceHandlerImpl: RaytraceHandler<RaytraceHandlerImpl.RaytraceConfig,
         }
     }
 
-    data class SortedEntities(val trackRangeSquared: Int, val entities: List<Entity>)
+    class SlicedEntities(val trackRangeSquared: Int, entities: List<Entity>) {
+
+        val slices = Long2ReferenceOpenHashMap<MutableList<Entity>>(16, Hash.VERY_FAST_LOAD_FACTOR)
+
+        init {
+            for (entity in entities) {
+                val id = index(entity.x.floorI(), entity.z.floorI())
+                val get = slices.get(id)
+                if (get != null)
+                    get.add(entity)
+                else
+                    slices.put(id, ArrayList<Entity>(16).also { it.add(entity) })
+            }
+        }
+
+        private fun index(x: Int, z: Int): Long {
+            val x = x shr GRID_SIZE
+            val z = z shr GRID_SIZE
+            return x.toLong() and (z.toLong() shl Int.SIZE_BITS)
+        }
+    }
 
     data class RaytraceConfig(
         @Comment("Asynchronous threads used to calculate visibility. More to update faster.")