Merge W3-polish

core/src/main/java/art/arcane/iris/generation/decoration/IrisDepositGenerator.java

@@ -304,7 +304,12 @@ public class IrisDepositGenerator {
         return new ClumpFootprint(cells.extentX * 2 + 1, cells.minY, false);
     }
 
-    private static void vanillaEllipsoidCells(RNG rng, int size, CellSink sink) {
+    /**
+     * Emits the clump's cells sphere by sphere in x, y, z order, duplicates included. The squared y and z
+     * offsets are computed once per sphere row; the sums keep the per-cell evaluation order, so every cell
+     * test is bit-identical to evaluating {@code nx * nx + ny * ny + nz * nz} in place.
+     */
+    static void vanillaEllipsoidCells(RNG rng, int size, CellSink sink) {
         float angle = rng.nextFloat() * (float) Math.PI;
         float reach = size / 8F;
         double startX = Math.sin(angle) * reach;
@@ -347,6 +352,8 @@ public class IrisDepositGenerator {
             }
         }
 
+        double[] squaredY = new double[16];
+        double[] squaredZ = new double[16];
         for (int i = 0; i < size; i++) {
             double radius = nodes[i * 4 + 3];
             if (radius < 0D) {
@@ -361,21 +368,37 @@ public class IrisDepositGenerator {
             int maxY = Math.max((int) Math.floor(centerY + radius), minY);
             int minZ = (int) Math.floor(centerZ - radius);
             int maxZ = Math.max((int) Math.floor(centerZ + radius), minZ);
+            int spanY = maxY - minY + 1;
+            int spanZ = maxZ - minZ + 1;
+            if (spanY > squaredY.length) {
+                squaredY = new double[spanY];
+            }
+            if (spanZ > squaredZ.length) {
+                squaredZ = new double[spanZ];
+            }
+            for (int y = 0; y < spanY; y++) {
+                double ny = (minY + y + 0.5D - centerY) / radius;
+                squaredY[y] = ny * ny;
+            }
+            for (int z = 0; z < spanZ; z++) {
+                double nz = (minZ + z + 0.5D - centerZ) / radius;
+                squaredZ[z] = nz * nz;
+            }
 
             for (int x = minX; x <= maxX; x++) {
                 double nx = (x + 0.5D - centerX) / radius;
-                if (nx * nx >= 1D) {
+                double squaredX = nx * nx;
+                if (squaredX >= 1D) {
                     continue;
                 }
-                for (int y = minY; y <= maxY; y++) {
-                    double ny = (y + 0.5D - centerY) / radius;
-                    if (nx * nx + ny * ny >= 1D) {
+                for (int y = 0; y < spanY; y++) {
+                    double squaredXY = squaredX + squaredY[y];
+                    if (squaredXY >= 1D) {
                         continue;
                     }
-                    for (int z = minZ; z <= maxZ; z++) {
-                        double nz = (z + 0.5D - centerZ) / radius;
-                        if (nx * nx + ny * ny + nz * nz < 1D) {
-                            sink.add(x, y, z);
+                    for (int z = 0; z < spanZ; z++) {
+                        if (squaredXY + squaredZ[z] < 1D) {
+                            sink.add(x, minY + y, minZ + z);
                         }
                     }
                 }
@@ -601,7 +624,7 @@ public class IrisDepositGenerator {
     }
 
     @FunctionalInterface
-    private interface CellSink {
+    interface CellSink {
         void add(int x, int y, int z);
     }
 

core/src/main/java/art/arcane/iris/generation/hydrology/HydrologyTileCache.java

@@ -537,6 +537,14 @@ public final class HydrologyTileCache implements AutoCloseable {
         chunkColumns(blockX, blockZ);
     }
 
+    /**
+     * Every column of the block's chunk, indexed {@code localZ * 16 + localX}; a column without hydrology
+     * is null. The array is shared with the cache and must not be modified.
+     */
+    public HydrologyColumnSample[] chunkSamples(int blockX, int blockZ) {
+        return chunkColumns(blockX, blockZ).columns();
+    }
+
     /**
      * Whether the column's chunk can be answered without planning: every tile it composes from is
      * already planned. A caller that must not wait (the server thread answering a height or biome

core/src/main/java/art/arcane/iris/generation/hydrology/runtime/IrisHydrologyRuntime.java

@@ -195,6 +195,11 @@ public final class IrisHydrologyRuntime implements AutoCloseable {
         cache.prepareChunkColumns(blockX, blockZ);
     }
 
+    /** The block's chunk columns indexed {@code localZ * 16 + localX}; shared, never modified by callers. */
+    public HydrologyColumnSample[] chunkSamples(int blockX, int blockZ) {
+        return cache.chunkSamples(blockX, blockZ);
+    }
+
     /** Whether the chunk or one of its eight neighbours holds a planned footprint column. */
     public boolean hasColumnsAround(int chunkX, int chunkZ) {
         return cache.hasColumnsAround(chunkX, chunkZ);

core/src/main/java/art/arcane/iris/generation/runtime/IrisComplex.java

@@ -1062,6 +1062,31 @@ public class IrisComplex implements DataProvider {
         return transitionHydrologySample(sample, hydrologyWeight, transitionDisplacement);
     }
 
+    /**
+     * The raw hydrology columns of the chunk holding the block, for a caller that samples every column of
+     * one chunk through {@link #sampleHydrologyColumn(HydrologyColumnSample[], int, int)}; null without
+     * hydrology.
+     */
+    public HydrologyColumnSample[] hydrologyChunkSamples(int x, int z) {
+        return hydrologyRuntime == null ? null : hydrologyRuntime.chunkSamples(x, z);
+    }
+
+    /** {@link #sampleHydrologyColumn(double, double)} for a column of the chunk {@code chunkSamples} came from. */
+    public HydrologyColumnSample sampleHydrologyColumn(HydrologyColumnSample[] chunkSamples, int x, int z) {
+        if (chunkSamples == null) {
+            return null;
+        }
+        HydrologyColumnSample sample = chunkSamples[(z & 15) << 4 | (x & 15)];
+        if (transitionGenerationPlan == null) {
+            return sample;
+        }
+        double hydrologyWeight = transitionHydrologyWeight(x, z);
+        if (sample == null) {
+            return sample;
+        }
+        return transitionHydrologySample(sample, hydrologyWeight, transitionDisplacement);
+    }
+
     private HydrologyColumnSnapshot sampleHydrologySnapshot(int x, int z) {
         if (hydrologyRuntime == null) {
             return HydrologyColumnSnapshot.ready(null);

core/src/main/java/art/arcane/iris/generation/stage/IrisTerrainNormalActuator.java

@@ -154,6 +154,7 @@ public class IrisTerrainNormalActuator extends EngineAssignedActuator<NativeBloc
         private final IrisData data;
         private final IrisComplex complex;
         private final ProceduralStream<Double> riverWaterSurfaceStream;
+        private final HydrologyColumnSample[] hydrologySamples;
         private final boolean bedrockEnabled;
         private final boolean hideOres;
         private final boolean transitionDisplaced;
@@ -186,6 +187,7 @@ public class IrisTerrainNormalActuator extends EngineAssignedActuator<NativeBloc
             data = getData();
             complex = getComplex();
             riverWaterSurfaceStream = complex.getRiverWaterSurfaceStream();
+            hydrologySamples = complex.hydrologyChunkSamples(x, z);
             bedrockEnabled = dimension.isBedrock();
             hideOres = dimension.isHideOresForHiddenOre();
             transitionDisplaced = complex.getTransitionDisplacement() != null;
@@ -226,7 +228,7 @@ public class IrisTerrainNormalActuator extends EngineAssignedActuator<NativeBloc
             }
 
             int topY = Math.min(hf, chunkHeight - 1);
-            HydrologyColumnSample hydrology = complex.sampleHydrologyColumn(realX, realZ);
+            HydrologyColumnSample hydrology = complex.sampleHydrologyColumn(hydrologySamples, realX, realZ);
             HydrologyColumnLayer hydrologyFluid = hydrology == null
                     ? null
                     : hydrology.primarySurfaceFluidLayerOrNull();