mirrors/Iris
1
0
Fork 0
mirror of https://github.com/VolmitSoftware/Iris.git synced 2026-07-22 06:40:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Studio FIxes

Browse Source
This commit is contained in:
Brian Neumann-Fopiano
2026-04-15 09:45:02 -04:00
parent aa706d027b
commit 9a231b2bcf
9 changed files with 864 additions and 222 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/src/test/java/art/arcane/iris/engine/mantle/components/IrisCaveCarver3DNearParityTest.java
+416 -28
View File
@@ -5,6 +5,7 @@ import art.arcane.iris.engine.framework.Engine;
import art.arcane.iris.engine.framework.EngineMetrics;
import art.arcane.iris.engine.framework.SeedManager;
import art.arcane.iris.engine.mantle.MantleWriter;
import art.arcane.iris.engine.object.IrisCaveFieldModule;
import art.arcane.iris.engine.object.IrisCaveProfile;
import art.arcane.iris.engine.object.IrisDimension;
import art.arcane.iris.engine.object.IrisGeneratorStyle;
@@ -12,8 +13,11 @@ import art.arcane.iris.engine.object.IrisRange;
import art.arcane.iris.engine.object.IrisStyledRange;
import art.arcane.iris.engine.object.IrisWorld;
import art.arcane.iris.engine.object.NoiseStyle;
import art.arcane.iris.util.project.noise.CNG;
import art.arcane.volmlib.util.collection.KList;
import art.arcane.volmlib.util.mantle.runtime.Mantle;
import art.arcane.volmlib.util.mantle.runtime.MantleChunk;
import art.arcane.volmlib.util.math.RNG;
import art.arcane.volmlib.util.matter.Matter;
import art.arcane.volmlib.util.matter.MatterCavern;
import art.arcane.volmlib.util.matter.MatterSlice;
@@ -24,6 +28,8 @@ import org.bukkit.block.data.BlockData;
import org.junit.BeforeClass;
import org.junit.Test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
@@ -41,49 +47,75 @@ import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
public class IrisCaveCarver3DNearParityTest {
private static Method sampleDensityMethod;
private static Field engineField;
private static Field dataField;
private static Field profileField;
private static Field surfaceBreakDensityField;
private static Field thresholdRngField;
private static Field carveAirField;
private static Field carveLavaField;
private static Field carveForcedAirField;
@BeforeClass
public static void setupBukkit() {
if (Bukkit.getServer() != null) {
return;
public static void setupBukkit() throws Exception {
if (Bukkit.getServer() == null) {
Server server = mock(Server.class);
BlockData emptyBlockData = mock(BlockData.class);
doReturn(Logger.getLogger("IrisTest")).when(server).getLogger();
doReturn("IrisTestServer").when(server).getName();
doReturn("1.0").when(server).getVersion();
doReturn("1.0").when(server).getBukkitVersion();
doReturn(emptyBlockData).when(server).createBlockData(any(Material.class));
doReturn(emptyBlockData).when(server).createBlockData(anyString());
Bukkit.setServer(server);
}
Server server = mock(Server.class);
BlockData emptyBlockData = mock(BlockData.class);
doReturn(Logger.getLogger("IrisTest")).when(server).getLogger();
doReturn("IrisTestServer").when(server).getName();
doReturn("1.0").when(server).getVersion();
doReturn("1.0").when(server).getBukkitVersion();
doReturn(emptyBlockData).when(server).createBlockData(any(Material.class));
doReturn(emptyBlockData).when(server).createBlockData(anyString());
Bukkit.setServer(server);
sampleDensityMethod = IrisCaveCarver3D.class.getDeclaredMethod("sampleDensityOptimized", int.class, int.class, int.class);
sampleDensityMethod.setAccessible(true);
engineField = IrisCaveCarver3D.class.getDeclaredField("engine");
engineField.setAccessible(true);
dataField = IrisCaveCarver3D.class.getDeclaredField("data");
dataField.setAccessible(true);
profileField = IrisCaveCarver3D.class.getDeclaredField("profile");
profileField.setAccessible(true);
surfaceBreakDensityField = IrisCaveCarver3D.class.getDeclaredField("surfaceBreakDensity");
surfaceBreakDensityField.setAccessible(true);
thresholdRngField = IrisCaveCarver3D.class.getDeclaredField("thresholdRng");
thresholdRngField.setAccessible(true);
carveAirField = IrisCaveCarver3D.class.getDeclaredField("carveAir");
carveAirField.setAccessible(true);
carveLavaField = IrisCaveCarver3D.class.getDeclaredField("carveLava");
carveLavaField.setAccessible(true);
carveForcedAirField = IrisCaveCarver3D.class.getDeclaredField("carveForcedAir");
carveForcedAirField.setAccessible(true);
}
@Test
public void carvedCellDistributionStableAcrossEquivalentCarvers() {
Engine engine = createEngine(128, 92);
IrisCaveCarver3D firstCarver = new IrisCaveCarver3D(engine, createProfile());
IrisCaveCarver3D firstCarver = new IrisCaveCarver3D(engine, createProfile(true, true));
WriterCapture firstCapture = createWriterCapture(128);
int firstCarved = firstCarver.carve(firstCapture.writer, 7, -3);
IrisCaveCarver3D secondCarver = new IrisCaveCarver3D(engine, createProfile());
IrisCaveCarver3D secondCarver = new IrisCaveCarver3D(engine, createProfile(true, true));
WriterCapture secondCapture = createWriterCapture(128);
int secondCarved = secondCarver.carve(secondCapture.writer, 7, -3);
assertTrue(firstCarved > 0);
assertEquals(firstCarved, secondCarved);
assertEquals(firstCapture.carvedCells, secondCapture.carvedCells);
assertEquals(firstCapture.carvedLiquids, secondCapture.carvedLiquids);
}
@Test
public void latticePathCarvesChunkEdgesAndRespectsWorldHeightClipping() {
public void exactPathCarvesChunkEdgesAndRespectsWorldHeightClipping() {
Engine engine = createEngine(48, 46);
IrisCaveCarver3D carver = new IrisCaveCarver3D(engine, createProfile());
IrisCaveCarver3D carver = new IrisCaveCarver3D(engine, createProfile(true, true));
WriterCapture capture = createWriterCapture(48);
double[] columnWeights = new double[256];
Arrays.fill(columnWeights, 1D);
int[] precomputedSurfaceHeights = new int[256];
Arrays.fill(precomputedSurfaceHeights, 46);
double[] columnWeights = fullWeights();
int[] precomputedSurfaceHeights = filledHeights(46);
int carved = carver.carve(capture.writer, 0, 0, columnWeights, 0D, 0D, new IrisRange(0D, 80D), precomputedSurfaceHeights);
@@ -96,6 +128,293 @@ public class IrisCaveCarver3DNearParityTest {
assertTrue(minY(capture.carvedCells) >= 0);
}
@Test
public void exactPathMatchesNaiveReferenceWithoutWarpOrModules() throws Exception {
assertExactParity(false, false);
}
@Test
public void exactPathMatchesNaiveReferenceWithWarpAndModules() throws Exception {
assertExactParity(true, true);
}
@Test
public void legacySampleStepTwoMatchesExactReference() throws Exception {
Engine engine = createEngine(96, 90);
double[] columnWeights = fullWeights();
int[] precomputedSurfaceHeights = filledHeights(90);
IrisRange worldYRange = new IrisRange(0D, 88D);
IrisCaveProfile exactProfile = createProfile(true, true).setSampleStep(1);
IrisCaveCarver3D exactCarver = new IrisCaveCarver3D(engine, exactProfile);
WriterCapture exactCapture = createWriterCapture(96);
int exactCarved = exactCarver.carve(exactCapture.writer, 5, -1, columnWeights, 0D, 0D, worldYRange, precomputedSurfaceHeights);
IrisCaveProfile legacyProfile = createProfile(true, true).setSampleStep(2);
IrisCaveCarver3D legacyCarver = new IrisCaveCarver3D(engine, legacyProfile);
WriterCapture legacyCapture = createWriterCapture(96);
int legacyCarved = legacyCarver.carve(legacyCapture.writer, 5, -1, columnWeights, 0D, 0D, worldYRange, precomputedSurfaceHeights);
assertEquals(exactCarved, legacyCarved);
assertEquals(exactCapture.carvedCells, legacyCapture.carvedCells);
assertEquals(exactCapture.carvedLiquids, legacyCapture.carvedLiquids);
}
@Test
public void exactPathUsesExpectedLavaAndForcedAirBands() {
Engine engine = createEngine(48, 46);
double[] columnWeights = fullWeights();
int[] precomputedSurfaceHeights = filledHeights(46);
IrisCaveProfile lavaProfile = createProfile(false, false).setAllowLava(true).setAllowWater(false);
IrisCaveCarver3D lavaCarver = new IrisCaveCarver3D(engine, lavaProfile);
WriterCapture lavaCapture = createWriterCapture(48);
lavaCarver.carve(lavaCapture.writer, 0, 0, columnWeights, 0D, 0D, new IrisRange(0D, 80D), precomputedSurfaceHeights);
IrisCaveProfile forcedAirProfile = createProfile(false, false).setAllowLava(false).setAllowWater(false);
IrisCaveCarver3D forcedAirCarver = new IrisCaveCarver3D(engine, forcedAirProfile);
WriterCapture forcedAirCapture = createWriterCapture(48);
forcedAirCarver.carve(forcedAirCapture.writer, 0, 0, columnWeights, 0D, 0D, new IrisRange(0D, 80D), precomputedSurfaceHeights);
assertTrue(containsLiquidInRange(lavaCapture.carvedLiquids, 0, 18, (byte) 2));
assertTrue(containsLiquidInRange(forcedAirCapture.carvedLiquids, 0, 18, (byte) 3));
assertTrue(containsLiquidInRange(lavaCapture.carvedLiquids, 19, 47, (byte) 0));
assertTrue(containsLiquidInRange(forcedAirCapture.carvedLiquids, 19, 47, (byte) 0));
}
@Test
public void optimizedExactPathOutperformsNaiveReference() throws Exception {
Engine engine = createEngine(128, 92);
IrisCaveCarver3D optimizedCarver = new IrisCaveCarver3D(engine, createProfile(true, true));
IrisCaveCarver3D naiveCarver = new IrisCaveCarver3D(engine, createProfile(true, true));
double[] columnWeights = fullWeights();
int[] precomputedSurfaceHeights = filledHeights(92);
IrisRange worldYRange = new IrisRange(0D, 96D);
for (int warmup = 0; warmup < 4; warmup++) {
runOptimizedOnce(optimizedCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128);
runNaiveOnce(naiveCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128);
}
long optimizedTime = 0L;
long naiveTime = 0L;
for (int iteration = 0; iteration < 10; iteration++) {
if ((iteration & 1) == 0) {
optimizedTime += runOptimizedOnce(optimizedCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128);
naiveTime += runNaiveOnce(naiveCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128);
continue;
}
naiveTime += runNaiveOnce(naiveCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128);
optimizedTime += runOptimizedOnce(optimizedCarver, 3, -2, columnWeights, worldYRange, precomputedSurfaceHeights, 128);
}
double speedup = naiveTime / (double) optimizedTime;
assertTrue("expected at least 2.0x speedup but was " + speedup, speedup >= 2D);
}
private void assertExactParity(boolean warp, boolean modules) throws Exception {
Engine engine = createEngine(96, 90);
double[] columnWeights = fullWeights();
int[] precomputedSurfaceHeights = filledHeights(90);
IrisRange worldYRange = new IrisRange(0D, 88D);
IrisCaveCarver3D optimizedCarver = new IrisCaveCarver3D(engine, createProfile(warp, modules));
WriterCapture optimizedCapture = createWriterCapture(96);
int optimizedCarved = optimizedCarver.carve(optimizedCapture.writer, 5, -1, columnWeights, 0D, 0D, worldYRange, precomputedSurfaceHeights);
IrisCaveCarver3D naiveCarver = new IrisCaveCarver3D(engine, createProfile(warp, modules));
WriterCapture naiveCapture = createWriterCapture(96);
int naiveCarved = carveNaiveExact(naiveCarver, naiveCapture.writer, 5, -1, columnWeights, worldYRange, precomputedSurfaceHeights);
assertEquals(optimizedCarved, naiveCarved);
assertEquals(optimizedCapture.carvedCells, naiveCapture.carvedCells);
assertEquals(optimizedCapture.carvedLiquids, naiveCapture.carvedLiquids);
}
private long runOptimizedOnce(IrisCaveCarver3D carver, int chunkX, int chunkZ, double[] columnWeights, IrisRange worldYRange, int[] precomputedSurfaceHeights, int worldHeight) {
WriterCapture capture = createWriterCapture(worldHeight);
long start = System.nanoTime();
carver.carve(capture.writer, chunkX, chunkZ, columnWeights, 0D, 0D, worldYRange, precomputedSurfaceHeights);
long elapsed = System.nanoTime() - start;
assertTrue(!capture.carvedCells.isEmpty());
return elapsed;
}
private long runNaiveOnce(IrisCaveCarver3D carver, int chunkX, int chunkZ, double[] columnWeights, IrisRange worldYRange, int[] precomputedSurfaceHeights, int worldHeight) throws Exception {
WriterCapture capture = createWriterCapture(worldHeight);
long start = System.nanoTime();
int carved = carveNaiveExact(carver, capture.writer, chunkX, chunkZ, columnWeights, worldYRange, precomputedSurfaceHeights);
long elapsed = System.nanoTime() - start;
assertTrue(carved > 0);
return elapsed;
}
private int carveNaiveExact(IrisCaveCarver3D carver, MantleWriter writer, int chunkX, int chunkZ, double[] columnWeights, IrisRange worldYRange, int[] precomputedSurfaceHeights) throws Exception {
Engine engine = (Engine) engineField.get(carver);
IrisData data = (IrisData) dataField.get(carver);
IrisCaveProfile profile = (IrisCaveProfile) profileField.get(carver);
CNG surfaceBreakDensity = (CNG) surfaceBreakDensityField.get(carver);
RNG thresholdRng = (RNG) thresholdRngField.get(carver);
MatterCavern carveAir = (MatterCavern) carveAirField.get(carver);
MatterCavern carveLava = (MatterCavern) carveLavaField.get(carver);
MatterCavern carveForcedAir = (MatterCavern) carveForcedAirField.get(carver);
double[] resolvedWeights = columnWeights;
if (resolvedWeights == null || resolvedWeights.length < 256) {
resolvedWeights = fullWeights();
}
int worldHeight = writer.getMantle().getWorldHeight();
int minY = Math.max(0, (int) Math.floor(profile.getVerticalRange().getMin()));
int maxY = Math.min(worldHeight - 1, (int) Math.ceil(profile.getVerticalRange().getMax()));
if (worldYRange != null) {
int worldMinHeight = engine.getWorld().minHeight();
int rangeMinY = (int) Math.floor(worldYRange.getMin() - worldMinHeight);
int rangeMaxY = (int) Math.ceil(worldYRange.getMax() - worldMinHeight);
minY = Math.max(minY, rangeMinY);
maxY = Math.min(maxY, rangeMaxY);
}
if (maxY < minY) {
return 0;
}
boolean allowSurfaceBreak = profile.isAllowSurfaceBreak();
int surfaceClearance = Math.max(0, profile.getSurfaceClearance());
int surfaceBreakDepth = Math.max(0, profile.getSurfaceBreakDepth());
double surfaceBreakNoiseThreshold = profile.getSurfaceBreakNoiseThreshold();
double surfaceBreakThresholdBoost = Math.max(0D, profile.getSurfaceBreakThresholdBoost());
int[] columnTopY = new int[256];
int[] surfaceBreakFloorY = new int[256];
boolean[] surfaceBreakColumn = new boolean[256];
double[] passThreshold = new double[256];
double[] verticalEdgeFade = computeVerticalEdgeFade(profile, minY, maxY);
MatterCavern[] matterByY = computeMatterByY(engine, profile, carveAir, carveLava, carveForcedAir, minY, maxY);
int x0 = chunkX << 4;
int z0 = chunkZ << 4;
for (int localX = 0; localX < 16; localX++) {
int x = x0 + localX;
for (int localZ = 0; localZ < 16; localZ++) {
int z = z0 + localZ;
int columnIndex = (localX << 4) | localZ;
int columnSurfaceY;
if (precomputedSurfaceHeights != null && precomputedSurfaceHeights.length > columnIndex) {
columnSurfaceY = precomputedSurfaceHeights[columnIndex];
} else {
columnSurfaceY = engine.getHeight(x, z);
}
int clearanceTopY = Math.min(maxY, Math.max(minY, columnSurfaceY - surfaceClearance));
boolean breakColumn = allowSurfaceBreak && signed(surfaceBreakDensity.noiseFast2D(x, z)) >= surfaceBreakNoiseThreshold;
int resolvedTopY = breakColumn ? Math.min(maxY, Math.max(minY, columnSurfaceY)) : clearanceTopY;
columnTopY[columnIndex] = resolvedTopY;
surfaceBreakFloorY[columnIndex] = Math.max(minY, columnSurfaceY - surfaceBreakDepth);
surfaceBreakColumn[columnIndex] = breakColumn;
double columnWeight = clampColumnWeight(resolvedWeights[columnIndex]);
if (columnWeight <= 0D || resolvedTopY < minY) {
passThreshold[columnIndex] = Double.NaN;
continue;
}
passThreshold[columnIndex] = profile.getDensityThreshold().get(thresholdRng, x, z, data) - profile.getThresholdBias();
}
}
@SuppressWarnings("unchecked")
MantleChunk<Matter> chunk = writer.acquireChunk(chunkX, chunkZ);
if (chunk == null) {
return 0;
}
int carved = 0;
for (int localX = 0; localX < 16; localX++) {
int x = x0 + localX;
for (int localZ = 0; localZ < 16; localZ++) {
int z = z0 + localZ;
int columnIndex = (localX << 4) | localZ;
if (Double.isNaN(passThreshold[columnIndex])) {
continue;
}
int topY = columnTopY[columnIndex];
for (int y = minY; y <= topY; y++) {
double localThreshold = passThreshold[columnIndex];
if (surfaceBreakColumn[columnIndex] && y >= surfaceBreakFloorY[columnIndex]) {
localThreshold += surfaceBreakThresholdBoost;
}
localThreshold -= verticalEdgeFade[y - minY];
double density = (double) sampleDensityMethod.invoke(carver, x, y, z);
if (density > localThreshold) {
continue;
}
Matter sectionMatter = chunk.getOrCreate(y >> 4);
MatterSlice<MatterCavern> cavernSlice = sectionMatter.slice(MatterCavern.class);
cavernSlice.set(localX, y & 15, localZ, matterByY[y - minY]);
carved++;
}
}
}
return carved;
}
private double[] computeVerticalEdgeFade(IrisCaveProfile profile, int minY, int maxY) {
int size = Math.max(0, maxY - minY + 1);
double[] verticalEdgeFade = new double[size];
int fadeRange = Math.max(0, profile.getVerticalEdgeFade());
double fadeStrength = Math.max(0D, profile.getVerticalEdgeFadeStrength());
if (size == 0 || fadeRange <= 0 || maxY <= minY || fadeStrength <= 0D) {
return verticalEdgeFade;
}
for (int y = minY; y <= maxY; y++) {
int floorDistance = y - minY;
int ceilingDistance = maxY - y;
int edgeDistance = Math.min(floorDistance, ceilingDistance);
int offsetIndex = y - minY;
if (edgeDistance >= fadeRange) {
continue;
}
double t = Math.max(0D, Math.min(1D, edgeDistance / (double) fadeRange));
double smooth = t * t * (3D - (2D * t));
verticalEdgeFade[offsetIndex] = (1D - smooth) * fadeStrength;
}
return verticalEdgeFade;
}
private MatterCavern[] computeMatterByY(Engine engine, IrisCaveProfile profile, MatterCavern carveAir, MatterCavern carveLava, MatterCavern carveForcedAir, int minY, int maxY) {
MatterCavern[] matterByY = new MatterCavern[Math.max(0, maxY - minY + 1)];
boolean allowLava = profile.isAllowLava();
boolean allowWater = profile.isAllowWater();
int lavaHeight = engine.getDimension().getCaveLavaHeight();
int fluidHeight = engine.getDimension().getFluidHeight();
for (int y = minY; y <= maxY; y++) {
int offset = y - minY;
if (allowLava && y <= lavaHeight) {
matterByY[offset] = carveLava;
continue;
}
if (allowWater && y <= fluidHeight) {
matterByY[offset] = carveAir;
continue;
}
if (!allowLava && y <= lavaHeight) {
matterByY[offset] = carveForcedAir;
continue;
}
matterByY[offset] = carveAir;
}
return matterByY;
}
private Engine createEngine(int worldHeight, int sampledHeight) {
Engine engine = mock(Engine.class);
IrisData data = mock(IrisData.class);
@@ -117,7 +436,7 @@ public class IrisCaveCarver3DNearParityTest {
return engine;
}
private IrisCaveProfile createProfile() {
private IrisCaveProfile createProfile(boolean warp, boolean modules) {
IrisCaveProfile profile = new IrisCaveProfile();
profile.setEnabled(true);
profile.setVerticalRange(new IrisRange(0D, 120D));
@@ -129,10 +448,10 @@ public class IrisCaveCarver3DNearParityTest {
profile.setSurfaceBreakStyle(new IrisGeneratorStyle(NoiseStyle.SIMPLEX).zoomed(0.09D));
profile.setBaseWeight(1D);
profile.setDetailWeight(0.48D);
profile.setWarpStrength(0.37D);
profile.setWarpStrength(warp ? 0.37D : 0D);
profile.setDensityThreshold(new IrisStyledRange(1D, 1D, new IrisGeneratorStyle(NoiseStyle.FLAT)));
profile.setThresholdBias(0D);
profile.setSampleStep(2);
profile.setSampleStep(1);
profile.setMinCarveCells(0);
profile.setRecoveryThresholdBoost(0D);
profile.setSurfaceClearance(5);
@@ -144,6 +463,26 @@ public class IrisCaveCarver3DNearParityTest {
profile.setWaterMinDepthBelowSurface(8);
profile.setWaterRequiresFloor(false);
profile.setAllowLava(true);
if (modules) {
KList<IrisCaveFieldModule> caveModules = new KList<>();
caveModules.add(new IrisCaveFieldModule(
new IrisGeneratorStyle(NoiseStyle.SIMPLEX).zoomed(0.11D),
0.23D,
0.04D,
new IrisRange(0D, 72D),
false
));
caveModules.add(new IrisCaveFieldModule(
new IrisGeneratorStyle(NoiseStyle.SIMPLEX).zoomed(0.19D),
0.17D,
-0.06D,
new IrisRange(24D, 120D),
true
));
profile.setModules(caveModules);
} else {
profile.setModules(new KList<>());
}
return profile;
}
@@ -156,6 +495,7 @@ public class IrisCaveCarver3DNearParityTest {
Map<Integer, Matter> sections = new HashMap<>();
Map<Integer, Map<Integer, MatterCavern>> sectionCells = new HashMap<>();
Set<String> carvedCells = new HashSet<>();
Map<String, Byte> carvedLiquids = new HashMap<>();
doReturn(mantle).when(writer).getMantle();
doReturn(worldHeight).when(mantle).getWorldHeight();
@@ -167,15 +507,15 @@ public class IrisCaveCarver3DNearParityTest {
return section;
}
Matter created = createSection(sectionIndex, sectionCells, carvedCells);
Matter created = createSection(sectionIndex, sectionCells, carvedCells, carvedLiquids);
sections.put(sectionIndex, created);
return created;
}).when(chunk).getOrCreate(anyInt());
return new WriterCapture(writer, carvedCells);
return new WriterCapture(writer, carvedCells, carvedLiquids);
}
private Matter createSection(int sectionIndex, Map<Integer, Map<Integer, MatterCavern>> sectionCells, Set<String> carvedCells) {
private Matter createSection(int sectionIndex, Map<Integer, Map<Integer, MatterCavern>> sectionCells, Set<String> carvedCells, Map<String, Byte> carvedLiquids) {
Matter matter = mock(Matter.class);
@SuppressWarnings("unchecked")
MatterSlice<MatterCavern> slice = mock(MatterSlice.class);
@@ -195,13 +535,44 @@ public class IrisCaveCarver3DNearParityTest {
MatterCavern value = invocation.getArgument(3);
localCells.put(packLocal(localX, localY, localZ), value);
int worldY = (sectionIndex << 4) + localY;
carvedCells.add(cellKey(localX, worldY, localZ));
String cellKey = cellKey(localX, worldY, localZ);
carvedCells.add(cellKey);
carvedLiquids.put(cellKey, value.getLiquid());
return null;
}).when(slice).set(anyInt(), anyInt(), anyInt(), any(MatterCavern.class));
return matter;
}
private double[] fullWeights() {
double[] columnWeights = new double[256];
Arrays.fill(columnWeights, 1D);
return columnWeights;
}
private int[] filledHeights(int height) {
int[] heights = new int[256];
Arrays.fill(heights, height);
return heights;
}
private double clampColumnWeight(double weight) {
if (Double.isNaN(weight) || Double.isInfinite(weight)) {
return 0D;
}
if (weight <= 0D) {
return 0D;
}
if (weight >= 1D) {
return 1D;
}
return weight;
}
private double signed(double value) {
return (value * 2D) - 1D;
}
private int packLocal(int x, int y, int z) {
return (x << 8) | (y << 4) | z;
}
@@ -210,6 +581,21 @@ public class IrisCaveCarver3DNearParityTest {
return x + ":" + y + ":" + z;
}
private boolean containsLiquidInRange(Map<String, Byte> carvedLiquids, int minY, int maxY, byte liquid) {
for (Map.Entry<String, Byte> entry : carvedLiquids.entrySet()) {
if (entry.getValue() != liquid) {
continue;
}
String[] split = entry.getKey().split(":");
int y = Integer.parseInt(split[1]);
if (y >= minY && y <= maxY) {
return true;
}
}
return false;
}
private boolean hasX(Set<String> carvedCells, int x) {
for (String cell : carvedCells) {
String[] split = cell.split(":");
@@ -259,10 +645,12 @@ public class IrisCaveCarver3DNearParityTest {
private static final class WriterCapture {
private final MantleWriter writer;
private final Set<String> carvedCells;
private final Map<String, Byte> carvedLiquids;
private WriterCapture(MantleWriter writer, Set<String> carvedCells) {
private WriterCapture(MantleWriter writer, Set<String> carvedCells, Map<String, Byte> carvedLiquids) {
this.writer = writer;
this.carvedCells = carvedCells;
this.carvedLiquids = carvedLiquids;
}
}
}
core/src/test/java/art/arcane/iris/engine/mantle/components/MantleCarvingComponentTop2BlendTest.java
+16 -24
View File
@@ -17,7 +17,6 @@ import static org.junit.Assert.assertEquals;
public class MantleCarvingComponentTop2BlendTest {
private static Constructor<?> weightedProfileConstructor;
private static Method limitMethod;
private static Method expandTileMethod;
private static Field profileField;
private static Field columnWeightsField;
@@ -28,8 +27,6 @@ public class MantleCarvingComponentTop2BlendTest {
weightedProfileConstructor.setAccessible(true);
limitMethod = MantleCarvingComponent.class.getDeclaredMethod("limitAndMergeBlendedProfiles", List.class, int.class, int.class);
limitMethod.setAccessible(true);
expandTileMethod = MantleCarvingComponent.class.getDeclaredMethod("expandTileWeightsToColumns", double[].class);
expandTileMethod.setAccessible(true);
profileField = weightedProfileClass.getDeclaredField("profile");
profileField.setAccessible(true);
columnWeightsField = weightedProfileClass.getDeclaredField("columnWeights");
@@ -67,21 +64,16 @@ public class MantleCarvingComponentTop2BlendTest {
}
@Test
public void tileWeightsExpandIntoFourColumnsPerTile() throws Exception {
double[] tileWeights = new double[64];
tileWeights[0] = 0.42D;
tileWeights[9] = 0.73D;
double[] expanded = invokeExpand(tileWeights);
public void topTwoMergePreservesIndependentWeightsAtHighColumnIndexes() throws Exception {
WeightedInput input = createWeightedProfiles();
List<?> limited = invokeLimit(input.weightedProfiles(), 2);
assertEquals(0.42D, expanded[(0 << 4) | 0], 0D);
assertEquals(0.42D, expanded[(0 << 4) | 1], 0D);
assertEquals(0.42D, expanded[(1 << 4) | 0], 0D);
assertEquals(0.42D, expanded[(1 << 4) | 1], 0D);
Map<IrisCaveProfile, double[]> byProfile = extractWeightsByProfile(limited);
IrisCaveProfile first = input.profiles().first();
IrisCaveProfile second = input.profiles().second();
assertEquals(0.73D, expanded[(2 << 4) | 2], 0D);
assertEquals(0.73D, expanded[(2 << 4) | 3], 0D);
assertEquals(0.73D, expanded[(3 << 4) | 2], 0D);
assertEquals(0.73D, expanded[(3 << 4) | 3], 0D);
assertEquals(1.0D, byProfile.get(first)[255], 0D);
assertEquals(1.0D, byProfile.get(second)[254], 0D);
}
private WeightedInput createWeightedProfiles() throws Exception {
@@ -90,17 +82,21 @@ public class MantleCarvingComponentTop2BlendTest {
IrisCaveProfile third = new IrisCaveProfile().setEnabled(true).setBaseWeight(0.93D);
Profiles profiles = new Profiles(first, second, third);
double[] firstWeights = new double[64];
double[] firstWeights = new double[256];
firstWeights[0] = 0.2D;
firstWeights[1] = 0.8D;
firstWeights[255] = 0.6D;
double[] secondWeights = new double[64];
double[] secondWeights = new double[256];
secondWeights[0] = 0.7D;
secondWeights[1] = 0.1D;
secondWeights[254] = 0.7D;
double[] thirdWeights = new double[64];
double[] thirdWeights = new double[256];
thirdWeights[0] = 0.3D;
thirdWeights[1] = 0.4D;
thirdWeights[254] = 0.3D;
thirdWeights[255] = 0.4D;
List<Object> weighted = new ArrayList<>();
weighted.add(weightedProfileConstructor.newInstance(first, firstWeights, average(firstWeights), null));
@@ -110,11 +106,7 @@ public class MantleCarvingComponentTop2BlendTest {
}
private List<?> invokeLimit(List<Object> weightedProfiles, int limit) throws Exception {
return (List<?>) limitMethod.invoke(null, weightedProfiles, limit, 64);
}
private double[] invokeExpand(double[] tileWeights) throws Exception {
return (double[]) expandTileMethod.invoke(null, (Object) tileWeights);
return (List<?>) limitMethod.invoke(null, weightedProfiles, limit, 256);
}
private Map<IrisCaveProfile, double[]> extractWeightsByProfile(List<?> weightedProfiles) throws Exception {
core/src/test/java/art/arcane/iris/engine/object/IrisDimensionCarvingResolverParityTest.java
+15 -15
View File
@@ -104,20 +104,20 @@ public class IrisDimensionCarvingResolverParityTest {
}
@Test
public void tileAnchoredChunkPlanResolutionIsStableAcrossRepeatedBuilds() {
public void columnAnchoredChunkPlanResolutionIsStableAcrossRepeatedBuilds() {
Fixture fixture = createMixedDepthFixture();
IrisDimensionCarvingResolver.State state = new IrisDimensionCarvingResolver.State();
IrisDimensionCarvingEntry root = legacyResolveRootEntry(fixture.engine, 80);
for (int chunkX = -24; chunkX <= 24; chunkX += 6) {
for (int chunkZ = -24; chunkZ <= 24; chunkZ += 6) {
IrisDimensionCarvingEntry[] firstPlan = buildTilePlan(fixture.engine, root, chunkX, chunkZ, state);
IrisDimensionCarvingEntry[] secondPlan = buildTilePlan(fixture.engine, root, chunkX, chunkZ, state);
for (int tileIndex = 0; tileIndex < firstPlan.length; tileIndex++) {
IrisDimensionCarvingEntry[] firstPlan = buildColumnPlan(fixture.engine, root, chunkX, chunkZ, state);
IrisDimensionCarvingEntry[] secondPlan = buildColumnPlan(fixture.engine, root, chunkX, chunkZ, state);
for (int columnIndex = 0; columnIndex < firstPlan.length; columnIndex++) {
assertSame(
"tile plan mismatch at chunkX=" + chunkX + " chunkZ=" + chunkZ + " tileIndex=" + tileIndex,
firstPlan[tileIndex],
secondPlan[tileIndex]
"column plan mismatch at chunkX=" + chunkX + " chunkZ=" + chunkZ + " columnIndex=" + columnIndex,
firstPlan[columnIndex],
secondPlan[columnIndex]
);
}
}
@@ -272,14 +272,14 @@ public class IrisDimensionCarvingResolverParityTest {
return new Fixture(engine);
}
private IrisDimensionCarvingEntry[] buildTilePlan(Engine engine, IrisDimensionCarvingEntry rootEntry, int chunkX, int chunkZ, IrisDimensionCarvingResolver.State state) {
IrisDimensionCarvingEntry[] plan = new IrisDimensionCarvingEntry[64];
for (int tileX = 0; tileX < 8; tileX++) {
int worldX = (chunkX << 4) + (tileX << 1);
for (int tileZ = 0; tileZ < 8; tileZ++) {
int worldZ = (chunkZ << 4) + (tileZ << 1);
int tileIndex = (tileX * 8) + tileZ;
plan[tileIndex] = IrisDimensionCarvingResolver.resolveFromRoot(engine, rootEntry, worldX, worldZ, state);
private IrisDimensionCarvingEntry[] buildColumnPlan(Engine engine, IrisDimensionCarvingEntry rootEntry, int chunkX, int chunkZ, IrisDimensionCarvingResolver.State state) {
IrisDimensionCarvingEntry[] plan = new IrisDimensionCarvingEntry[256];
for (int localX = 0; localX < 16; localX++) {
int worldX = (chunkX << 4) + localX;
for (int localZ = 0; localZ < 16; localZ++) {
int worldZ = (chunkZ << 4) + localZ;
int columnIndex = (localX << 4) | localZ;
plan[columnIndex] = IrisDimensionCarvingResolver.resolveFromRoot(engine, rootEntry, worldX, worldZ, state);
}
}
return plan;