Reject viewer queries outside world bounds

Author: Arbousier1

benchmark/src/main/java/com/loohp/interactionvisualizer/entities/DroppedItemBenchmarkPlugin.java

@@ -83,7 +83,7 @@ private void runBenchmarks() throws IOException {
             benchmarkCramping(world, itemCount, false);
             benchmarkCramping(world, itemCount, true);
         }
-        for (String distribution : List.of("uniform", "hotspot", "no-hit")) {
+        for (String distribution : List.of("uniform", "hotspot", "no-hit", "enclosed-no-hit")) {
             for (int itemCount : List.of(500, 2000, 8000)) {
                 for (int viewerCount : List.of(1, 8, 32, 64, 96, 128, 192, 256, 384, 512, 768, 1024)) {
                     for (int seed = 0; seed < VISIBILITY_SEEDS; seed++) {
@@ -193,6 +193,10 @@ private void benchmarkVisibility(int itemCount, int viewerCount, String distribu
                 items = randomPoints(random, itemCount, 0.0D, 256.0D);
                 viewers = randomPoints(random, viewerCount, 768.0D, 256.0D);
             }
+            case "enclosed-no-hit" -> {
+                items = randomPoints(random, itemCount, 448.0D, 128.0D);
+                viewers = enclosingRingPoints(random, viewerCount);
+            }
             default -> throw new IllegalArgumentException("Unknown visibility distribution: " + distribution);
         }
         LongSupplier linearReference = () -> linearActiveLabels(items, viewers, VIEW_DISTANCE);
@@ -219,9 +223,10 @@ private void reportVisibilityComparison(String benchmark, String baseline, boole
                 "{\"benchmark\":\"%s\",\"distribution\":\"%s\",\"seed\":%d," +
                         "\"items\":%d,\"viewers\":%d," +
                         "\"range\":%.1f,\"baseline\":\"%s\",\"baselineUsesGrid\":%b," +
-                        "\"candidate\":\"production-primitive-viewer-index\"," +
+                        "\"candidate\":\"production-bounded-primitive-viewer-index\"," +
                         "\"candidateStorage\":\"primitive-soa\"," +
                         "\"indexRebuiltPerOperation\":true,\"candidateUsesGrid\":false," +
+                        "\"candidateUsesBounds\":true," +
                         "\"sampleTargetNs\":%d,\"warmupRounds\":%d,\"measurementRounds\":%d," +
                         "\"roundOrder\":\"%s\"," +
                         "\"baselineMedianNs\":%d,\"baselineP95Ns\":%d," +
@@ -265,6 +270,24 @@ private static List<Point> randomPoints(Random random, int count, double offset,
         return points;
     }
 
+    /**
+     * Places viewers around an empty central region. From eight viewers onward the item region is
+     * enclosed by the viewer AABB, while every viewer remains well beyond the visibility radius.
+     * This prevents an outer-bounds fast rejection from disguising worst-case miss scans.
+     */
+    private static List<Point> enclosingRingPoints(Random random, int count) {
+        List<Point> points = new ArrayList<>(count);
+        double phase = random.nextDouble(2.0D * Math.PI);
+        for (int index = 0; index < count; index++) {
+            double angle = phase + 2.0D * Math.PI * index / Math.max(1, count);
+            points.add(new Point(index,
+                    512.0D + Math.cos(angle) * 300.0D,
+                    64.0D + random.nextDouble(32.0D),
+                    512.0D + Math.sin(angle) * 300.0D));
+        }
+        return points;
+    }
+
     private static long linearActiveLabels(List<Point> items, List<Point> viewers, double range) {
         List<Point> viewerSnapshot = new ArrayList<>(viewers.size());
         for (Point viewer : viewers) {

common/src/main/java/com/loohp/interactionvisualizer/entities/DroppedItemSpatialIndex.java

@@ -119,7 +119,8 @@ boolean hasViewerWithin(UUID worldId, double x, double y, double z, double range
             WorldViewerBucket viewers = viewersByWorld == null
                     ? java.util.Objects.equals(singleWorldId, worldId) ? singleWorldViewers : null
                     : viewersByWorld.get(worldId);
-            return viewers != null && viewers.hasViewerWithin(x, y, z, range * range);
+            return viewers != null && !viewers.isOutsideBounds(x, y, z, range)
+                    && viewers.hasViewerWithin(x, y, z, range * range);
         }
 
         private static final class WorldViewerBucket {
@@ -131,6 +132,12 @@ private static final class WorldViewerBucket {
             private double[] xCoordinates = EMPTY;
             private double[] yCoordinates = EMPTY;
             private double[] zCoordinates = EMPTY;
+            private double minimumX = Double.POSITIVE_INFINITY;
+            private double minimumY = Double.POSITIVE_INFINITY;
+            private double minimumZ = Double.POSITIVE_INFINITY;
+            private double maximumX = Double.NEGATIVE_INFINITY;
+            private double maximumY = Double.NEGATIVE_INFINITY;
+            private double maximumZ = Double.NEGATIVE_INFINITY;
             private int size;
 
             private WorldViewerBucket(int initialCapacity) {
@@ -151,9 +158,21 @@ private void add(double x, double y, double z) {
                 xCoordinates[size] = x;
                 yCoordinates[size] = y;
                 zCoordinates[size] = z;
+                minimumX = Math.min(minimumX, x);
+                minimumY = Math.min(minimumY, y);
+                minimumZ = Math.min(minimumZ, z);
+                maximumX = Math.max(maximumX, x);
+                maximumY = Math.max(maximumY, y);
+                maximumZ = Math.max(maximumZ, z);
                 size++;
             }
 
+            private boolean isOutsideBounds(double x, double y, double z, double range) {
+                return x < minimumX - range || x > maximumX + range
+                        || y < minimumY - range || y > maximumY + range
+                        || z < minimumZ - range || z > maximumZ + range;
+            }
+
             private boolean hasViewerWithin(double x, double y, double z, double rangeSquared) {
                 for (int index = 0; index < size; index++) {
                     double deltaX = xCoordinates[index] - x;

common/src/test/java/com/loohp/interactionvisualizer/entities/DroppedItemSpatialIndexTest.java

@@ -74,6 +74,32 @@ void rejectsNegativeExpectedViewerCapacity() {
                 () -> new DroppedItemSpatialIndex.ViewerIndex(-1));
     }
 
+    @Test
+    void viewerBoundsKeepTouchingSphereEdgesExact() {
+        UUID world = UUID.randomUUID();
+        DroppedItemSpatialIndex.ViewerIndex viewers = new DroppedItemSpatialIndex.ViewerIndex(2);
+        viewers.addViewer(world, -10.0D, 64.0D, -10.0D);
+        viewers.addViewer(world, 10.0D, 70.0D, 10.0D);
+
+        assertTrue(viewers.hasViewerWithin(world, 20.0D, 70.0D, 10.0D, 10.0D));
+        assertFalse(viewers.hasViewerWithin(world, 20.0001D, 70.0D, 10.0D, 10.0D));
+        assertTrue(viewers.hasViewerWithin(world, -10.0D, 54.0D, -10.0D, 10.0D));
+        assertFalse(viewers.hasViewerWithin(world, -10.0D, 53.9999D, -10.0D, 10.0D));
+    }
+
+    @Test
+    void viewerBoundsStillRunExactChecksInsideTheBox() {
+        UUID world = UUID.randomUUID();
+        DroppedItemSpatialIndex.ViewerIndex viewers = new DroppedItemSpatialIndex.ViewerIndex(4);
+        viewers.addViewer(world, -100.0D, 64.0D, -100.0D);
+        viewers.addViewer(world, -100.0D, 64.0D, 100.0D);
+        viewers.addViewer(world, 100.0D, 64.0D, -100.0D);
+        viewers.addViewer(world, 100.0D, 64.0D, 100.0D);
+
+        assertFalse(viewers.hasViewerWithin(world, 0.0D, 64.0D, 0.0D, 10.0D));
+        assertTrue(viewers.hasViewerWithin(world, 90.0D, 64.0D, 100.0D, 10.0D));
+    }
+
     @Test
     void upgradesFromSingleWorldFastPathAndKeepsWorldsIsolated() {
         UUID firstWorld = UUID.randomUUID();