Patching Cleanup

adapters/bukkit/nms/v26_2_R1/src/main/java/art/arcane/iris/core/nms/v26_2_R1/ImportedFeatureStage.java

@@ -2,6 +2,7 @@ package art.arcane.iris.core.nms.v26_2_R1;
 
 import art.arcane.iris.engine.DimensionStackContext;
 import art.arcane.iris.engine.DimensionStackLayout;
+import art.arcane.iris.nativegen.NativeGenerationWriteGuard;
 import art.arcane.iris.engine.framework.Engine;
 import art.arcane.iris.engine.framework.NativeFeatureGenerationPolicy;
 import art.arcane.iris.engine.object.IrisBiome;
@@ -44,7 +45,6 @@ import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.IntBinaryOperator;
-import java.util.function.Predicate;
 
 /**
  * Bukkit twin of the modded imported-feature stage. Same control, same semantics, same seeds: with
@@ -299,7 +299,7 @@ final class ImportedFeatureStage {
                 surfaceFirstFreeY,
                 floorFirstFreeY,
                 stackContext != null,
-                importedFeatureProtection(staticObjects, stackContext, staticMinY));
+                NativeGenerationWriteGuard.protectedPositions(staticObjects, stackContext, staticMinY));
 
         try {
             for (int stepIndex = 0; stepIndex < steps.size(); stepIndex++) {
@@ -317,30 +317,6 @@ final class ImportedFeatureStage {
         }
     }
 
-    private static Predicate<BlockPos> importedFeatureProtection(
-            IrisStaticObjectLayer staticObjects,
-            DimensionStackContext stackContext,
-            int minimumY
-    ) {
-        Map<Long, DimensionStackLayout> layouts = new ConcurrentHashMap<>();
-        return position -> {
-            if (!staticObjects.isEmpty() && staticObjects.contains(
-                    position.getX(), position.getY() - minimumY, position.getZ())) {
-                return true;
-            }
-            if (stackContext == null) {
-                return false;
-            }
-            long columnKey = ((long) position.getX() << 32)
-                    ^ (position.getZ() & 0xFFFFFFFFL);
-            DimensionStackLayout layout = layouts.computeIfAbsent(
-                    columnKey,
-                    ignored -> stackContext.sample(position.getX(), position.getZ())
-            );
-            return layout.isHostFeatureProtectedY(position.getY() - minimumY);
-        };
-    }
-
     private void placeStep(WorldGenLevel level, FeatureTable table, FeatureSorter.StepFeatureData stepData,
                            Registry<PlacedFeature> featureRegistry, Set<Holder<Biome>> chunkBiomes,
                            ChunkGenerator owner, WorldgenRandom random, long decorationSeed,

adapters/bukkit/nms/v26_2_R1/src/main/java/art/arcane/iris/core/nms/v26_2_R1/IrisChunkGenerator.java

@@ -7,7 +7,6 @@ import java.util.Optional;
 import art.arcane.iris.nativegen.NativeGenerationWriteGuard;
 import java.util.function.LongPredicate;
 import art.arcane.iris.engine.DimensionStackContext;
-import art.arcane.iris.engine.DimensionStackLayout;
 import art.arcane.iris.engine.framework.Engine;
 import art.arcane.iris.engine.framework.EngineLifecycleTasks;
 import art.arcane.iris.engine.framework.GenerationSessionException;
@@ -1125,7 +1124,8 @@ public class IrisChunkGenerator extends CustomChunkGenerator implements LongPred
                     chunkPos.x(), chunkPos.z(), error);
         }
         IrisStaticObjectLayer staticObjects = engine.getDimension().getStaticObjectLayer(engine.getData());
-        Predicate<BlockPos> protectedPosition = nativeStructureProtection(staticObjects);
+        Predicate<BlockPos> protectedPosition = NativeGenerationWriteGuard.protectedPositions(
+                staticObjects, engine.getDimensionStackContext(), engine.getMinHeight());
         WorldGenLevel boundedWorld = NativeStructureWorldgenAccess.create(
                 world, chunkPos, hostWorldgenSurfaceHeight(), hostWorldgenFloorHeight(),
                 engine.getDimensionStackContext() != null,
@@ -1216,8 +1216,9 @@ public class IrisChunkGenerator extends CustomChunkGenerator implements LongPred
                 hostWorldgenSurfaceHeight(),
                 hostWorldgenFloorHeight(),
                 engine.getDimensionStackContext() != null,
-                nativeStructureProtection(
-                        engine.getDimension().getStaticObjectLayer(engine.getData())));
+                NativeGenerationWriteGuard.protectedPositions(
+                        engine.getDimension().getStaticObjectLayer(engine.getData()),
+                        engine.getDimensionStackContext(), engine.getMinHeight()));
         world.setCurrentlyGenerating(() -> "Iris native structure " + structureId);
         try {
             NativeStructurePostProcessor.place(boundedWorld, structureManager, this, random, area, chunkPos,
@@ -1228,28 +1229,6 @@ public class IrisChunkGenerator extends CustomChunkGenerator implements LongPred
         }
     }
 
-    private Predicate<BlockPos> nativeStructureProtection(IrisStaticObjectLayer staticObjects) {
-        DimensionStackContext stackContext = engine.getDimensionStackContext();
-        int minimumY = engine.getMinHeight();
-        Map<Long, DimensionStackLayout> layouts = new ConcurrentHashMap<>();
-        return position -> {
-            if (!staticObjects.isEmpty() && staticObjects.contains(
-                    position.getX(), position.getY() - minimumY, position.getZ())) {
-                return true;
-            }
-            if (stackContext == null) {
-                return false;
-            }
-            long columnKey = ((long) position.getX() << 32)
-                    ^ (position.getZ() & 0xFFFFFFFFL);
-            DimensionStackLayout layout = layouts.computeIfAbsent(
-                    columnKey,
-                    ignored -> stackContext.sample(position.getX(), position.getZ())
-            );
-            return layout.isHostFeatureProtectedY(position.getY() - minimumY);
-        };
-    }
-
     private List<List<Structure>> structuresByStep(Registry<Structure> registry) {
         int runtimeId = engine.getCacheID();
         StructureStepCache cached = structureStepCache;

adapters/bukkit/nms/v26_2_R1/src/test/java/art/arcane/iris/nativegen/NativeGenerationWriteGuardTest.java

@@ -1,13 +1,16 @@
 package art.arcane.iris.nativegen;
 
+import art.arcane.iris.engine.DimensionStackContext;
+import art.arcane.iris.engine.DimensionStackLayout;
 import art.arcane.iris.engine.IrisComplex;
 import art.arcane.iris.engine.IrisEngine;
 import art.arcane.iris.engine.history.GenerationActivation;
 import art.arcane.iris.engine.history.GenerationHistory;
 import art.arcane.iris.engine.history.GenerationHistoryRuntimeRouter;
-import java.util.Optional;
 import art.arcane.iris.engine.framework.Engine;
+import art.arcane.iris.engine.object.IrisStaticObjectLayer;
 import net.minecraft.SharedConstants;
+import net.minecraft.core.BlockPos;
 import net.minecraft.server.Bootstrap;
 import net.minecraft.world.level.ChunkPos;
 import net.minecraft.world.level.WorldGenLevel;
@@ -16,10 +19,17 @@ import net.minecraft.world.level.chunk.status.ChunkStatus;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
+import java.util.Optional;
+import java.util.function.Predicate;
+
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
 
 public final class NativeGenerationWriteGuardTest {
@@ -29,6 +39,42 @@ public final class NativeGenerationWriteGuardTest {
         Bootstrap.bootStrap();
     }
 
+    @Test
+    public void staticObjectsProtectRelativeHeightBeforeStackSampling() {
+        IrisStaticObjectLayer objects = mock(IrisStaticObjectLayer.class);
+        DimensionStackContext stack = mock(DimensionStackContext.class);
+        when(objects.contains(-3, 74, -7)).thenReturn(true);
+
+        Predicate<BlockPos> protectedPositions = NativeGenerationWriteGuard.protectedPositions(objects, stack, -64);
+
+        assertTrue(protectedPositions.test(new BlockPos(-3, 10, -7)));
+        verifyNoInteractions(stack);
+        assertFalse(NativeGenerationWriteGuard.protectedPositions(objects, null, -64)
+                .test(new BlockPos(-3, 11, -7)));
+    }
+
+    @Test
+    public void emptyStaticLayerSkipsContainsAndCachesEachSignedColumn() {
+        IrisStaticObjectLayer objects = mock(IrisStaticObjectLayer.class);
+        DimensionStackContext stack = mock(DimensionStackContext.class);
+        DimensionStackLayout negative = mock(DimensionStackLayout.class);
+        DimensionStackLayout positive = mock(DimensionStackLayout.class);
+        when(objects.isEmpty()).thenReturn(true);
+        when(stack.sample(-1, -1)).thenReturn(negative);
+        when(stack.sample(-1, 1)).thenReturn(positive);
+        when(negative.isHostFeatureProtectedY(64)).thenReturn(true);
+        when(positive.isHostFeatureProtectedY(65)).thenReturn(true);
+
+        Predicate<BlockPos> protectedPositions = NativeGenerationWriteGuard.protectedPositions(objects, stack, -64);
+
+        assertTrue(protectedPositions.test(new BlockPos(-1, 0, -1)));
+        assertFalse(protectedPositions.test(new BlockPos(-1, 1, -1)));
+        assertTrue(protectedPositions.test(new BlockPos(-1, 1, 1)));
+        verify(stack, times(1)).sample(-1, -1);
+        verify(stack, times(1)).sample(-1, 1);
+        verify(objects, never()).contains(anyInt(), anyInt(), anyInt());
+    }
+
     @Test
     public void preTerrainSavedStampDistinguishesEarlierNativeStarts() {
         IrisEngine engine = mock(IrisEngine.class);