Merged carve noise batching

- Compiled cave density fields with batched per-pass lattices and shared warp fields

core/src/test/java/art/arcane/iris/generation/mantle/IrisCaveCarver3DCellKernelTest.java

@@ -83,6 +83,11 @@ public class IrisCaveCarver3DCellKernelTest {
         assertScenario(Scenario.FLOOR_FLUID_LAYERED, 0xb4c0fb23e071617dL, 68747);
     }
 
+    @Test
+    public void packStyleProfilesSharingFieldsMatchGoldenWriteSequence() throws Exception {
+        assertScenario(Scenario.PACK_SHARED, 0xdbe20a1ca87f9cc7L, 269035);
+    }
+
     @Test
     public void cellKernelDecidesCellsWithoutColumnEvaluation() throws Exception {
         IrisCaveCarver3D.CellCounters before = IrisCaveCarver3D.cellCounters();
@@ -196,7 +201,31 @@ public class IrisCaveCarver3DCellKernelTest {
         return profile;
     }
 
+    private static IrisCaveProfile packProfile(NoiseStyle warp, double warpZoom, double warpStrength, NoiseStyle base,
+                                               double baseZoom, double threshold, IrisCaveFieldModule... modules) {
+        IrisCaveProfile profile = baseProfile(true, false);
+        profile.setWarpStyle(new IrisGeneratorStyle(warp).zoomed(warpZoom));
+        profile.setWarpStrength(warpStrength);
+        profile.setBaseDensityStyle(new IrisGeneratorStyle(base).zoomed(baseZoom));
+        profile.setDetailDensityStyle(new IrisGeneratorStyle(NoiseStyle.SIMPLEX).zoomed(0.5D));
+        profile.setBaseWeight(0.82D);
+        profile.setDetailWeight(0.15D);
+        profile.setDensityThreshold(new IrisStyledRange(threshold - 0.06D, threshold + 0.05D,
+                new IrisGeneratorStyle(NoiseStyle.SIMPLEX).zoomed(0.78D)));
+        profile.setThresholdBias(0.12D);
+        profile.setSampleStep(2);
+        profile.setModules(new KList<>(modules));
+        return profile;
+    }
+
+    private static IrisCaveFieldModule packModule(NoiseStyle style, double zoom, double weight, double threshold,
+                                                  double minY, double maxY, boolean invert) {
+        return new IrisCaveFieldModule(new IrisGeneratorStyle(style).zoomed(zoom), weight, threshold,
+                new IrisRange(minY, maxY), invert);
+    }
+
     private enum Scenario {
+        PACK_SHARED,
         WARP_MODULES,
         WARP_TERRAIN,
         STYLED_BLEND,
@@ -207,6 +236,20 @@ public class IrisCaveCarver3DCellKernelTest {
         FLOOR_FLUID_LAYERED;
 
         IrisCaveProfile[] profiles() {
+            if (this == PACK_SHARED) {
+                return new IrisCaveProfile[]{
+                        packProfile(NoiseStyle.FRACTAL_WATER, 0.44D, 3.2D, NoiseStyle.PERLIN_IRIS, 0.72D, -0.02D,
+                                packModule(NoiseStyle.FRACTAL_FBM_SIMPLEX, 0.24D, 0.08D, 0.03D, 10D, 140D, false),
+                                packModule(NoiseStyle.SIMPLEX_VASCULAR, 1.02D, 0.05D, 0.07D, 4D, 90D, true)),
+                        packProfile(NoiseStyle.FRACTAL_WATER, 0.44D, 3.2D, NoiseStyle.FRACTAL_BILLOW_SIMPLEX, 0.656D, 0.01D,
+                                packModule(NoiseStyle.CELLULAR_BILINEAR, 1.32D, 0.06D, 0.02D, 20D, 150D, false)),
+                        packProfile(NoiseStyle.FRACTAL_WATER, 0.44D, 3.2D, NoiseStyle.PERLIN_IRIS, 0.72D, 0.04D,
+                                packModule(NoiseStyle.FRACTAL_FBM_SIMPLEX, 0.24D, 0.08D, 0.03D, 10D, 140D, false),
+                                packModule(NoiseStyle.SIMPLEX_VASCULAR, 1.02D, 0.05D, 0.07D, 4D, 90D, true)),
+                        packProfile(NoiseStyle.PERLIN_IRIS, 0.35D, 2.4D, NoiseStyle.IRIS_DOUBLE, 0.68D, -0.04D,
+                                packModule(NoiseStyle.VASCULAR_THIN, 1.28D, 0.04D, 0.05D, 8D, 120D, false))
+                };
+            }
             if (this == FLOOR_FLUID_LAYERED) {
                 return new IrisCaveProfile[]{
                         baseProfile(true, true).setAllowFluid(true).setFluidRequiresFloor(true).setFluidMinDepthBelowSurface(4),
@@ -228,7 +271,7 @@ public class IrisCaveCarver3DCellKernelTest {
                         .setFluidMinDepthBelowSurface(6).setAllowLava(false);
                 case NO_WARP_MODULES -> baseProfile(false, true);
                 case LATTICE -> baseProfile(true, true).setSampleStep(3);
-                case FLOOR_FLUID_LAYERED -> baseProfile(true, true);
+                case FLOOR_FLUID_LAYERED, PACK_SHARED -> baseProfile(true, true);
             };
         }
 
@@ -239,6 +282,7 @@ public class IrisCaveCarver3DCellKernelTest {
                 int worldZ = (chunkZ << 4) + (index & 15);
                 double blend = 0.5D + 0.6D * Math.sin(worldX * 0.11D) * Math.cos(worldZ * 0.07D);
                 weights[index] = switch (this) {
+                    case PACK_SHARED -> 0.5D + 0.6D * Math.sin(worldX * 0.13D + layer * 1.7D) * Math.cos(worldZ * 0.09D - layer);
                     case STYLED_BLEND, FLUID_BOUNDARY -> blend;
                     case FLOOR_FLUID_LAYERED -> layer == 0 ? blend : 1D - blend;
                     default -> 1D;

core/src/test/java/art/arcane/iris/generation/mantle/IrisCaveCarver3DLatticeTest.java

@@ -0,0 +1,163 @@
+package art.arcane.iris.generation.mantle;
+
+import art.arcane.iris.generation.cave.IrisCaveFieldModule;
+import art.arcane.iris.generation.cave.IrisCaveProfile;
+import art.arcane.iris.generation.noise.IrisGeneratorStyle;
+import art.arcane.iris.generation.noise.IrisStyledRange;
+import art.arcane.iris.generation.noise.NoiseStyle;
+import art.arcane.iris.generation.runtime.Engine;
+import art.arcane.iris.generation.runtime.EngineMetrics;
+import art.arcane.iris.generation.runtime.SeedManager;
+import art.arcane.iris.generation.terrain.IrisDimension;
+import art.arcane.iris.pack.loading.IrisData;
+import art.arcane.iris.pack.value.IrisRange;
+import art.arcane.iris.world.IrisWorld;
+import art.arcane.volmlib.util.collection.KList;
+import org.junit.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Random;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.withSettings;
+
+public class IrisCaveCarver3DLatticeTest {
+    private static final long CARVE_SEED = 7_340_119_802_557L;
+    private static final int WORLD_HEIGHT = 384;
+
+    @Test
+    public void batchedLatticeColumnsMatchScalarPlaneDensityBitForBit() throws Exception {
+        Engine engine = createEngine();
+        CaveDensityGrid grid = new CaveDensityGrid(256);
+        IrisCaveProfile[] profiles = {
+                profile(NoiseStyle.FRACTAL_WATER, 0.44D, 3.2D, NoiseStyle.PERLIN_IRIS, 0.72D,
+                        module(NoiseStyle.FRACTAL_FBM_SIMPLEX, 0.24D, 10D, 140D, false),
+                        module(NoiseStyle.CELLULAR_BILINEAR, 1.32D, 4D, 300D, true)),
+                profile(NoiseStyle.PERLIN_IRIS, 0.35D, 2.4D, NoiseStyle.IRIS_DOUBLE, 0.68D,
+                        module(NoiseStyle.VASCULAR_THIN, 1.28D, 8D, 220D, false)),
+                profile(NoiseStyle.SIMPLEX, 0.5D, 0D, NoiseStyle.FRACTAL_BILLOW_SIMPLEX, 0.656D)
+        };
+        Method sampleLatticeColumn = IrisCaveCarver3D.class.getDeclaredMethod("sampleLatticeColumn",
+                CaveCarveScratch.class, CaveDensityGrid.Column.class, int.class, int.class, int.class);
+        sampleLatticeColumn.setAccessible(true);
+        Method samplePlaneDensity = IrisCaveCarver3D.class.getDeclaredMethod("samplePlaneDensity",
+                CaveCarveScratch.class, int.class, int.class, int.class);
+        samplePlaneDensity.setAccessible(true);
+        Field warpOwnerField = IrisCaveCarver3D.class.getDeclaredField("warpOwner");
+        warpOwnerField.setAccessible(true);
+        Random random = new Random(91_337L);
+        for (IrisCaveProfile profile : profiles) {
+            IrisCaveCarver3D carver = new IrisCaveCarver3D(engine, profile, grid);
+            CaveDensityGrid.Owner warpOwner = (CaveDensityGrid.Owner) warpOwnerField.get(carver);
+            CaveCarveScratch batch = new CaveCarveScratch();
+            CaveCarveScratch reference = new CaveCarveScratch();
+            for (int trial = 0; trial < 48; trial++) {
+                int latticeX = random.nextInt(4001) - 2000;
+                int latticeZ = random.nextInt(4001) - 2000;
+                int x = latticeX << CaveDensityGrid.LATTICE_SHIFT;
+                int z = latticeZ << CaveDensityGrid.LATTICE_SHIFT;
+                int count = selectRows(random, batch);
+                CaveDensityGrid.Column warpColumn = trial % 3 == 0 ? null
+                        : grid.warpColumn(warpOwner, WORLD_HEIGHT + 1, latticeX, latticeZ);
+                for (int pass = 0; pass < 2; pass++) {
+                    sampleLatticeColumn.invoke(carver, batch, warpColumn, x, z, count);
+                    for (int index = 0; index < count; index++) {
+                        int y = batch.latticeY[index];
+                        double expected = (double) samplePlaneDensity.invoke(carver, reference, x, y, z);
+                        assertEquals("x=" + x + " y=" + y + " z=" + z + " pass=" + pass,
+                                Double.doubleToRawLongBits(expected), Double.doubleToRawLongBits(batch.latticeDensity[index]));
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    public void identicalFieldsShareGridOwnersAcrossProfiles() throws Exception {
+        Engine engine = createEngine();
+        CaveDensityGrid grid = new CaveDensityGrid(256);
+        Field densityOwnerField = IrisCaveCarver3D.class.getDeclaredField("densityOwner");
+        densityOwnerField.setAccessible(true);
+        Field warpOwnerField = IrisCaveCarver3D.class.getDeclaredField("warpOwner");
+        warpOwnerField.setAccessible(true);
+        IrisCaveCarver3D first = new IrisCaveCarver3D(engine, profile(NoiseStyle.FRACTAL_WATER, 0.44D, 3.2D,
+                NoiseStyle.PERLIN_IRIS, 0.72D, module(NoiseStyle.SIMPLEX_VASCULAR, 1.02D, 4D, 90D, true)), grid);
+        IrisCaveCarver3D sameDensity = new IrisCaveCarver3D(engine, profile(NoiseStyle.FRACTAL_WATER, 0.44D, 3.2D,
+                NoiseStyle.PERLIN_IRIS, 0.72D, module(NoiseStyle.SIMPLEX_VASCULAR, 1.02D, 4D, 90D, true))
+                .setDensityThreshold(new IrisStyledRange(0.2D, 0.2D, new IrisGeneratorStyle(NoiseStyle.FLAT))), grid);
+        IrisCaveCarver3D sameWarp = new IrisCaveCarver3D(engine, profile(NoiseStyle.FRACTAL_WATER, 0.44D, 1.7D,
+                NoiseStyle.FRACTAL_BILLOW_SIMPLEX, 0.656D), grid);
+        IrisCaveCarver3D otherWarp = new IrisCaveCarver3D(engine, profile(NoiseStyle.FRACTAL_WATER, 0.46D, 3.2D,
+                NoiseStyle.PERLIN_IRIS, 0.72D, module(NoiseStyle.SIMPLEX_VASCULAR, 1.02D, 4D, 90D, true)), grid);
+        IrisCaveCarver3D otherModule = new IrisCaveCarver3D(engine, profile(NoiseStyle.FRACTAL_WATER, 0.44D, 3.2D,
+                NoiseStyle.PERLIN_IRIS, 0.72D, module(NoiseStyle.SIMPLEX_VASCULAR, 1.02D, 4D, 91D, true)), grid);
+        assertSame(densityOwnerField.get(first), densityOwnerField.get(sameDensity));
+        assertSame(warpOwnerField.get(first), warpOwnerField.get(sameDensity));
+        assertSame(warpOwnerField.get(first), warpOwnerField.get(sameWarp));
+        assertSame(warpOwnerField.get(first), warpOwnerField.get(otherModule));
+        assertNotSame(densityOwnerField.get(first), densityOwnerField.get(sameWarp));
+        assertNotSame(densityOwnerField.get(first), densityOwnerField.get(otherModule));
+        assertNotSame(densityOwnerField.get(first), densityOwnerField.get(otherWarp));
+        assertNotSame(warpOwnerField.get(first), warpOwnerField.get(otherWarp));
+    }
+
+    private static int selectRows(Random random, CaveCarveScratch scratch) {
+        int start = random.nextInt(40);
+        int end = start + 20 + random.nextInt(WORLD_HEIGHT - start - 20);
+        scratch.ensureLatticeBatch(end - start + 1);
+        int count = 0;
+        for (int y = start; y <= end; y++) {
+            if (random.nextInt(5) != 0) {
+                scratch.latticeY[count++] = y;
+            }
+        }
+        return count;
+    }
+
+    private static IrisCaveProfile profile(NoiseStyle warp, double warpZoom, double warpStrength, NoiseStyle base,
+                                           double baseZoom, IrisCaveFieldModule... modules) {
+        IrisCaveProfile profile = new IrisCaveProfile();
+        profile.setEnabled(true);
+        profile.setVerticalRange(new IrisRange(4D, 360D));
+        profile.setWarpStyle(new IrisGeneratorStyle(warp).zoomed(warpZoom));
+        profile.setWarpStrength(warpStrength);
+        profile.setBaseDensityStyle(new IrisGeneratorStyle(base).zoomed(baseZoom));
+        profile.setDetailDensityStyle(new IrisGeneratorStyle(NoiseStyle.SIMPLEX).zoomed(0.5D));
+        profile.setSurfaceBreakStyle(new IrisGeneratorStyle(NoiseStyle.SIMPLEX).zoomed(0.82D));
+        profile.setBaseWeight(0.82D);
+        profile.setDetailWeight(0.15D);
+        profile.setDensityThreshold(new IrisStyledRange(-0.1D, 0.02D, new IrisGeneratorStyle(NoiseStyle.SIMPLEX).zoomed(0.78D)));
+        profile.setSampleStep(2);
+        profile.setModules(new KList<>(modules));
+        return profile;
+    }
+
+    private static IrisCaveFieldModule module(NoiseStyle style, double zoom, double minY, double maxY, boolean invert) {
+        return new IrisCaveFieldModule(new IrisGeneratorStyle(style).zoomed(zoom), 0.07D, 0.04D, new IrisRange(minY, maxY), invert);
+    }
+
+    private static Engine createEngine() {
+        Engine engine = mock(Engine.class, withSettings().stubOnly());
+        IrisData data = mock(IrisData.class, withSettings().stubOnly());
+        IrisDimension dimension = mock(IrisDimension.class, withSettings().stubOnly());
+        SeedManager seedManager = mock(SeedManager.class, withSettings().stubOnly());
+        doReturn(data).when(engine).getData();
+        doReturn(dimension).when(engine).getDimension();
+        doReturn(seedManager).when(engine).getSeedManager();
+        doReturn(CARVE_SEED).when(seedManager).getCarve();
+        doReturn(new EngineMetrics(16)).when(engine).getMetrics();
+        doReturn(IrisWorld.builder().minHeight(-64).maxHeight(WORLD_HEIGHT - 64).build()).when(engine).getWorld();
+        doReturn(WORLD_HEIGHT).when(engine).getHeight();
+        doReturn(200).when(engine).getHeight(anyInt(), anyInt());
+        doReturn(20).when(dimension).getCaveLavaHeight();
+        doReturn(64).when(dimension).getFluidHeight();
+        doReturn(1).when(dimension).getCaveDensitySamplingStep();
+        return engine;
+    }
+}

core/src/test/java/art/arcane/iris/generation/mantle/IrisCaveCarver3DNearParityTest.java

@@ -13,6 +13,7 @@ import art.arcane.iris.generation.noise.IrisStyledRange;
 import art.arcane.iris.world.IrisWorld;
 import art.arcane.iris.generation.noise.NoiseStyle;
 import art.arcane.volmlib.util.noise.CNG;
+import art.arcane.volmlib.util.noise.program.NoiseProgram;
 import art.arcane.volmlib.util.collection.KList;
 import art.arcane.volmlib.util.mantle.runtime.Mantle;
 import art.arcane.volmlib.util.mantle.runtime.MantleChunk;
@@ -148,7 +149,7 @@ public class IrisCaveCarver3DNearParityTest {
             sampledY.add((int) y);
             return x * 0.0001D + y * 0.01D + z * 0.0002D;
         }).when(density).noiseFastSigned3D(anyDouble(), anyDouble(), anyDouble());
-        baseDensityField.set(carver, density);
+        baseDensityField.set(carver, NoiseProgram.compileSigned3D(density));
         Method prepare = IrisCaveCarver3D.class.getDeclaredMethod("prepareVerticalDensityPlane",
                 CaveCarveScratch.class, int.class, int.class, int.class);
         prepare.setAccessible(true);
@@ -168,7 +169,7 @@ public class IrisCaveCarver3DNearParityTest {
         doReturn(1).when(dimension).getCaveDensitySamplingStep();
         IrisCaveCarver3D scalar = new IrisCaveCarver3D(engine,
                 createProfile(false, false).setDetailWeight(0D).setAllowFluid(false));
-        baseDensityField.set(scalar, density);
+        baseDensityField.set(scalar, NoiseProgram.compileSigned3D(density));
         CaveCarveScratch scalarScratch = new CaveCarveScratch();
         for (int index = 0; index < 256; index++) {
             scalarScratch.planeColumnIndices[index] = index;
@@ -292,10 +293,10 @@ public class IrisCaveCarver3DNearParityTest {
             IrisCaveCarver3D carver = new IrisCaveCarver3D(engine, profile);
             CNG base = mock(CNG.class, withSettings().stubOnly());
             doReturn(1D).when(base).noiseFastSigned3D(anyDouble(), anyDouble(), anyDouble());
-            baseDensityField.set(carver, base);
+            baseDensityField.set(carver, NoiseProgram.compileSigned3D(base));
             CNG module = mock(CNG.class, withSettings().stubOnly());
             doReturn(-1D).when(module).noiseFastSigned3D(anyDouble(), anyDouble(), anyDouble());
-            moduleDensityField.set(((CaveFieldModuleState[]) modulesField.get(carver))[0], module);
+            moduleDensityField.set(((CaveFieldModuleState[]) modulesField.get(carver))[0], NoiseProgram.compileSigned3D(module));
             WriterCapture capture = createWriterCapture(128);
             carver.carve(capture.writer, -1, 2, fullWeights(), 0D, 0D, null, filledHeights(110));
             assertEquals(512, capture.carvedCells.size());
@@ -364,13 +365,13 @@ public class IrisCaveCarver3DNearParityTest {
                     }
                     return -1D;
                 }).when(density).noiseFastSigned3D(anyDouble(), anyDouble(), anyDouble());
-                baseDensityField.set(carver, density);
+                baseDensityField.set(carver, NoiseProgram.compileSigned3D(density));
                 assertThrows(IllegalStateException.class, () -> carver.carve(capture.writer, 0, 0,
                         fullWeights(), 0D, 0D, null, filledHeights(110)));
             } else {
                 carver.carve(capture.writer, 0, 0, fullWeights(), 0D, 0D, null, filledHeights(110));
+                assertFalse(capture.carvedCells.isEmpty());
             }
-            assertFalse(capture.carvedCells.isEmpty());
             Field scratchField = IrisCaveCarver3D.class.getDeclaredField("scratchCache");
             scratchField.setAccessible(true);
             ThreadLocal<?> scratchCache = (ThreadLocal<?>) scratchField.get(carver);
@@ -385,6 +386,12 @@ public class IrisCaveCarver3DNearParityTest {
             for (CaveDensityGrid.Column column : scratch.densityColumns) {
                 assertNull(column);
             }
+            for (CaveDensityGrid.Column column : scratch.cellLattice.densityColumns) {
+                assertNull(column);
+            }
+            for (CaveDensityGrid.Column column : scratch.cellLattice.warpColumns) {
+                assertNull(column);
+            }
         }
     }
 
@@ -439,7 +446,7 @@ public class IrisCaveCarver3DNearParityTest {
         }).when(detail).noiseFastSigned3D(anyDouble(), anyDouble(), anyDouble());
         Field detailField = IrisCaveCarver3D.class.getDeclaredField("detailDensity");
         detailField.setAccessible(true);
-        detailField.set(carver, detail);
+        detailField.set(carver, NoiseProgram.compileSigned3D(detail));
         WriterCapture capture = createWriterCapture(128);
         try (ForkJoinPool pool = new ForkJoinPool(4)) {
             assertEquals(0, pool.submit(() -> carver.carve(capture.writer, 0, 0, fullWeights(),
@@ -772,7 +779,7 @@ public class IrisCaveCarver3DNearParityTest {
         rejectedDensity.put("11:10:10", -1D);
         rejectedDensity.put("9:10:10", -1D);
         CoordinateDensityCNG rejectedNoise = new CoordinateDensityCNG(rejectedDensity);
-        baseDensityField.set(carver, rejectedNoise);
+        baseDensityField.set(carver, NoiseProgram.compileSigned3D(rejectedNoise));
 
         boolean rejected = (boolean) aquiferCupSupportMethod.invoke(
                 carver, new CaveCarveScratch(), 10, 10, 10, 0D);
@@ -781,7 +788,7 @@ public class IrisCaveCarver3DNearParityTest {
         assertEquals(List.of("10:9:10", "10:8:10", "11:10:10", "9:10:10"), rejectedNoise.sampledCoordinates);
 
         CoordinateDensityCNG acceptedNoise = new CoordinateDensityCNG(Map.of());
-        baseDensityField.set(carver, acceptedNoise);
+        baseDensityField.set(carver, NoiseProgram.compileSigned3D(acceptedNoise));
 
         boolean accepted = (boolean) aquiferCupSupportMethod.invoke(
                 carver, new CaveCarveScratch(), 10, 10, 10, 0D);
@@ -1100,7 +1107,7 @@ public class IrisCaveCarver3DNearParityTest {
                 AtomicLong isolatedSamples = new AtomicLong();
                 IrisCaveCarver3D shared = new IrisCaveCarver3D(engine,
                         createProfile(warp, modules).setAdaptiveSampling(true), new CaveDensityGrid(4096));
-                baseDensityField.set(shared, new CountingCNG((CNG) baseDensityField.get(shared), sharedSamples));
+                baseDensityField.set(shared, NoiseProgram.compileSigned3D(new CountingCNG((NoiseProgram) baseDensityField.get(shared), sharedSamples)));
                 for (int chunkX = -1; chunkX <= 1; chunkX++) {
                     for (int chunkZ = -1; chunkZ <= 1; chunkZ++) {
                         WriterCapture sharedCapture = createWriterCapture(96);
@@ -1108,7 +1115,7 @@ public class IrisCaveCarver3DNearParityTest {
                                 null, filledHeights(90));
                         IrisCaveCarver3D isolated = new IrisCaveCarver3D(engine,
                                 createProfile(warp, modules).setAdaptiveSampling(true));
-                        baseDensityField.set(isolated, new CountingCNG((CNG) baseDensityField.get(isolated), isolatedSamples));
+                        baseDensityField.set(isolated, NoiseProgram.compileSigned3D(new CountingCNG((NoiseProgram) baseDensityField.get(isolated), isolatedSamples)));
                         WriterCapture isolatedCapture = createWriterCapture(96);
                         int isolatedCarved = isolated.carve(isolatedCapture.writer, chunkX, chunkZ, fullWeights(), 0D, 0D,
                                 null, filledHeights(90));
@@ -1241,7 +1248,7 @@ public class IrisCaveCarver3DNearParityTest {
         new IrisCaveCarver3D(engine, profile).carve(expected.writer, -1, 2,
                 fullWeights(), 0D, 0D, null, filledHeights(110));
         IrisCaveCarver3D carver = new IrisCaveCarver3D(engine, profile);
-        CNG original = (CNG) baseDensityField.get(carver);
+        NoiseProgram original = (NoiseProgram) baseDensityField.get(carver);
         CNG density = mock(CNG.class, withSettings().stubOnly());
         AtomicBoolean entered = new AtomicBoolean();
         WriterCapture nested = createWriterCapture(128);
@@ -1252,9 +1259,9 @@ public class IrisCaveCarver3DNearParityTest {
             double x = invocation.getArgument(0);
             double y = invocation.getArgument(1);
             double z = invocation.getArgument(2);
-            return original.noiseFastSigned3D(x, y, z);
+            return original.sampleSigned3D(x, y, z);
         }).when(density).noiseFastSigned3D(anyDouble(), anyDouble(), anyDouble());
-        baseDensityField.set(carver, density);
+        baseDensityField.set(carver, NoiseProgram.compileSigned3D(density));
         WriterCapture actual = createWriterCapture(128);
         carver.carve(actual.writer, -1, 2, fullWeights(), 0D, 0D, null, filledHeights(110));
         assertTrue(entered.get());
@@ -1268,7 +1275,7 @@ public class IrisCaveCarver3DNearParityTest {
         doAnswer(invocation -> {
             lookups.incrementAndGet();
             return invocation.callRealMethod();
-        }).when(grid).column(any(), anyInt(), anyInt(), anyInt(), anyInt());
+        }).when(grid).column(any(), anyInt(), anyInt(), anyInt());
         return grid;
     }
 
@@ -1292,10 +1299,10 @@ public class IrisCaveCarver3DNearParityTest {
     }
 
     private void countSkippableSamples(IrisCaveCarver3D carver, AtomicLong samples) throws Exception {
-        detailDensityField.set(carver, new CountingCNG((CNG) detailDensityField.get(carver), samples));
+        detailDensityField.set(carver, NoiseProgram.compileSigned3D(new CountingCNG((NoiseProgram) detailDensityField.get(carver), samples)));
         CaveFieldModuleState[] modules = (CaveFieldModuleState[]) modulesField.get(carver);
         for (CaveFieldModuleState module : modules) {
-            moduleDensityField.set(module, new CountingCNG((CNG) moduleDensityField.get(module), samples));
+            moduleDensityField.set(module, NoiseProgram.compileSigned3D(new CountingCNG((NoiseProgram) moduleDensityField.get(module), samples)));
         }
     }
 
@@ -1893,10 +1900,10 @@ public class IrisCaveCarver3DNearParityTest {
     }
 
     private static final class CountingCNG extends CNG {
-        private final CNG delegate;
+        private final NoiseProgram delegate;
         private final AtomicLong samples;
 
-        private CountingCNG(CNG delegate, AtomicLong samples) {
+        private CountingCNG(NoiseProgram delegate, AtomicLong samples) {
             super(new RNG(41_117L));
             this.delegate = delegate;
             this.samples = samples;
@@ -1905,7 +1912,7 @@ public class IrisCaveCarver3DNearParityTest {
         @Override
         public double noiseFastSigned3D(double x, double y, double z) {
             samples.incrementAndGet();
-            return delegate.noiseFastSigned3D(x, y, z);
+            return delegate.sampleSigned3D(x, y, z);
         }
     }